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