Verkenning

De cartograaf met een laptoptas

In 1569 publiceerde Gerardus Mercator – een Vlaming, laten we dat even vaststellen – zijn beroemde wereldkaart. Het was een meesterwerk van wiskunde en verbeelding, maar vooral van geduld. Mercator had nooit zelf de kusten van Afrika bevaren of de Stille Oceaan overgestoken. Hij werkte met verslagen van zeelieden, met schetsmatige portulaankaarten, met verhalen die na vijf keer doorvertellen nauwelijks meer op de werkelijkheid leken dan een gemiddelde vacatureomschrijving. Toch produceerde hij iets bruikbaars. Iets waarmee je ergens kon komen zonder op de rotsen te lopen.

De pentester is, in wezen, een cartograaf. Voordat er ook maar een enkele exploit wordt afgevuurd, voordat er een wachtwoord wordt gekraakt of een shell wordt verkregen, moet het landschap in kaart worden gebracht. Welke systemen staan er? Welke poorten zijn open? Welke software draait erachter? Wie beheert het? Wie heeft zes jaar geleden een domeinnaam geregistreerd met zijn persoonlijke Gmail-adres en is dat vervolgens totaal vergeten?

Dit proces – verkenning, reconnaissance, recon – is het fundament waarop elk assessment rust. Sla het over, en je bent een ontdekkings- reiziger die zonder kaart of kompas de oceaan op vaart. Je kunt geluk hebben. Maar waarschijnlijk vaar je gewoon in cirkels rond en eindig je op dezelfde plek waar je begon, alleen dan met minder tijd en meer frustratie.

En laten we eerlijk zijn: de meeste organisaties maken het je niet moeilijk. Ze laten hun infrastructuur rondslingeren als iemand die net verhuisd is en de dozen nog niet heeft uitgepakt. Drie jaar later staan die dozen er nog. Niemand weet meer wat erin zit, maar niemand durft ze weg te gooien. Dat is ongeveer hoe de gemiddelde IT-omgeving eruitziet. En het is precies waarom verkenning zo effectief is.

Passieve verkenning: kijken zonder aan te raken

De kunst van het gluren

Er is een fundamenteel verschil tussen iemands voordeur intrappen en door het raam naar binnen kijken. Passieve verkenning is het tweede. Je verstuurt geen enkel pakket naar het doelwit. Je raakt niets aan. Je kijkt alleen naar informatie die al publiekelijk beschikbaar is – openbare registers, zoekmachines, certificaatdatabases, sociale media. Het is het equivalent van het lezen van iemands LinkedIn-profiel: je leert een hoop, en de ander heeft geen idee.

Dit is waar OSINT begint – Open Source Intelligence. Een term die klinkt alsof hij uit een Tom Clancy-roman komt, maar in de praktijk vooral neerkomt op: heel goed googelen.

Whois: het kadaster van het internet

Elke domeinnaam heeft een registratie. Net als een huis in het kadaster staat geregistreerd met een eigenaar, een adres, en een datum, heeft een domein een whois-record. En net als bij het kadaster zijn die gegevens vaak verrassend informatief.

whois target.com
whois TARGET_IP

Een whois-lookup vertelt je wie het domein heeft geregistreerd, wanneer, via welke registrar, en soms zelfs met welk e-mailadres en telefoonnummer. Veel organisaties gebruiken tegenwoordig privacy-services om deze gegevens af te schermen, maar je zou versteld staan van hoeveel dat niet doen. Of die het wel doen voor hun hoofddomein, maar vergeten voor die ene testomgeving die ze in 2019 hebben opgezet.

Het IP-adres whois geeft je informatie over het netblok – welke organisatie het IP-bereik bezit, welke ASN erbij hoort, en vaak een abuse-contactadres. Handig om de omvang van het doelwit te begrijpen.

DNS records: het telefoonboek

DNS is het telefoonboek van het internet, en net als een telefoonboek vertelt het je meer dan alleen telefoonnummers. Een organisatie kan haar website beveiligen als Fort Knox, maar als haar DNS-records publiekelijk haar interne structuur onthullen, is dat alsof je de kluisdeur vergrendelt maar de bouwtekeningen op straat legt.

De basisrecords die je wilt opvragen:

host target.com
host -t MX target.com
host -t TXT target.com
host -t NS target.com
host -t AAAA target.com

MX-records vertellen je welke mailserver het bedrijf gebruikt (Google Workspace? Microsoft 365? Een eigen server die al drie patchcycli achterloopt?). TXT-records bevatten vaak SPF-configuratie, DKIM-keys, en soms domeinverificatierecords voor allerlei cloudservices – een soort openbare boodschappenlijst van welke diensten de organisatie gebruikt. NS-records vertellen je wie de DNS beheert, wat op zichzelf al een aanwijzing is over de technische volwassenheid van het bedrijf.

Certificaat transparantie: de onbedoelde inventaris

Certificate Transparency logs zijn een van de mooiste cadeaus die het internet aan pentesters heeft gegeven. Elke keer dat een organisatie een TLS-certificaat aanvraagt, wordt dat geregistreerd in publiekelijk doorzoekbare logs. En omdat organisaties certificaten aanvragen voor al hun domeinen en subdomeinen – inclusief die interne testomgeving, die staging-server, en dat vergeten Jenkins-dashboard – krijg je een gratis inventaris van hun gehele webinfrastructuur.

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

Het percentage-teken (%25, URL-encoded %) is een wildcard. Het resultaat is vaak een ontnuchterend lange lijst van subdomeinen waarvan de helft niet eens zou moeten bestaan. staging.target.com, dev-old.target.com, jenkins-test.target.com, api-v1-deprecated.target.com.

Het is alsof je in iemands laatje met oude sleutels kijkt. Ze weten zelf niet meer waar de helft van die sleutels op past, maar elk van die sleutels opent ergens een deur.

Google Dorks: de zoekmachine als wapen

Google indexeert alles. Dat is letterlijk haar bestaansreden. En soms indexeert ze dingen die niet geindexeerd hadden moeten worden. Google dorking is de kunst van het gebruik van geavanceerde zoekoperators om precies die dingen te vinden.

# Bestanden die niet openbaar horen te zijn
# site:target.com filetype:pdf
# site:target.com filetype:xlsx
# site:target.com ext:sql | ext:db | ext:bak

# Admin pagina's en login portals
# site:target.com ext:php inurl:admin
# site:target.com inurl:login

# Directory listings (altijd een slecht teken)
# site:target.com intitle:"index of" "parent directory"

Die laatste – intitle:"index of" – is bijzonder vermakelijk. Een directory listing betekent dat een webserver de inhoud van een map gewoon toont, als een soort digitale etalage. Soms vind je er configuratiebestanden, database-backups, of een bestand genaamd passwords.txt dat – en dit is het mooie – inderdaad wachtwoorden bevat.

Het is de digitale equivalent van een bedrijf dat zijn kluissleutel aan een haakje bij de receptie hangt. Met een labeltje eraan. Waarop “kluissleutel” staat.

Shodan: de zoekmachine voor alles met een IP-adres

Waar Google het web indexeert, indexeert Shodan het internet. Elke server, elke webcam, elke industriele controller, elke printer die iemand per ongeluk aan het internet heeft gehangen. Shodan scant constant het hele IPv4-bereik en slaat de banners op die services terugsturen.

# Zoek op hostname
shodan search hostname:target.com

# Bekijk een specifiek IP
shodan host TARGET_IP

# Zoek op software in een netrange
shodan search "Apache" net:TARGET_RANGE/24

Shodan laat je zoeken op software, versienummers, locatie, en organisatie. Je kunt ermee vinden welke Apache-versies een bedrijf draait, of ze ergens een MySQL-server open hebben staan, of er een onbeveiligde Elasticsearch-instance is die de volledige klantendatabase serveert aan iedereen die ernaar vraagt.

theHarvester: de stofzuiger

theHarvester combineert meerdere bronnen – zoekmachines, PGP-servers, LinkedIn, DNS – om e-mailadressen, subdomeinen en IP-adressen te verzamelen die bij een domein horen.

# Zoek met meerdere bronnen
theHarvester -d target.com -b google,bing,linkedin -l 500

# Of gewoon alles
theHarvester -d target.com -b all

E-mailadressen zijn goud waard. Ze vertellen je de naamconventie van het bedrijf (j.jansen@target.com? jan.jansen@target.com? jjansen@target.com?), waarmee je vervolgens een lijst van geldige gebruikersnamen kunt genereren. En die gebruikersnamen zijn weer bruikbaar voor wachtwoordaanvallen, Kerberos-enumeratie, en social engineering.

Recon-ng: het framework

Voor wie zijn verkenning wat gestructureerder wil aanpakken, is recon-ng een modulair framework dat verschillende OSINT-bronnen combineert in een werkbare omgeving.

recon-ng
# 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

Het werkt als een soort Metasploit voor OSINT – je installeert modules, configureert opties, en laat ze los op je doelwit. Het verschil is dat je hier niets breekt; je verzamelt alleen informatie.

En mocht je denken dat dit allemaal overdreven is – dat geen enkel bedrijf zoveel informatie lekt via publieke bronnen – dan heb je duidelijk nog nooit een pentest gedaan. De hoeveelheid informatie die organisaties vrijwillig op internet pleuren is ronduit ontroerend. Het is alsof ze het je makkelijk willen maken. Alsof er ergens een ongeschreven regel bestaat die zegt: “Maak het de aanvaller zo comfortabel mogelijk.”

DNS enumeratie: dieper graven

Zone transfers: het grote cadeau

Passieve verkenning vertelt je veel, maar op een gegeven moment wil je dieper graven. DNS-enumeratie is de brug tussen passief en actief – je praat direct met nameservers, maar je scant geen systemen en je probeert geen exploits.

De heilige graal van DNS-enumeratie is de zone transfer. Een zone transfer (AXFR) is een mechanisme waarmee een secundaire nameserver een complete kopie van een DNS-zone opvraagt bij de primaire server. Het is bedoeld voor replicatie tussen nameservers. Het is niet bedoeld voor willekeurige mensen op internet.

Maar – en hier wordt het leuk – veel nameservers zijn zo geconfigureerd dat ze zone transfers aan iedereen toestaan.

# Zone transfer proberen
host -l target.com ns1.target.com
dig axfr target.com @ns1.target.com

# Met dnsrecon
dnsrecon -d target.com -t axfr

Als een zone transfer lukt, krijg je alles. Elk A-record, elk CNAME-record, elk intern hostname dat de beheerder heeft aangemaakt. dc01.internal.target.com. backup-nas.target.com. test-database-do-not-expose.target.com. Het is alsof je de complete plattegrond van een gebouw krijgt, inclusief de nooduitgangen en het kamertje waar de sysadmin zijn middagdutje doet.

Zijn zone transfers zeldzaam? Ja, steeds zeldzamer. Maar ze komen nog steeds voor. En als ze werken, dan heb je net in dertig seconden meer informatie vergaard dan in een uur googelen.

Subdomain bruteforce: de methodische aanpak

Als zone transfers niet werken – en dat is tegenwoordig vaker wel dan niet het geval – is subdomain bruteforce je volgende optie. Het concept is simpel: je neemt een woordenlijst met veelvoorkomende subdomeinnamen en probeert ze een voor een.

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

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

De -t 50 flag bij gobuster zet het aantal threads – hoeveel gelijktijdige verzoeken er worden gedaan. Vijftig is een redelijk getal; hoog genoeg om snel te zijn, laag genoeg om de nameserver niet plat te leggen. Hoewel, als je de nameserver van het doelwit plat legt met een subdomain-bruteforce, dan hadden ze grotere problemen dan jij.

De kwaliteit van je resultaten staat of valt met je woordenlijst. SecLists – de culinaire bijbel van de pentester – bevat diverse lijsten, van de top 5000 meest voorkomende subdomeinen tot lijsten met meer dan een miljoen entries. Begin klein, escaleer als nodig.

Specifieke DNS records opvragen

Soms wil je niet bruteforcen maar chirurgisch te werk gaan. dig is je scalpel:

# Alle records opvragen
dig target.com ANY

# Specifieke types
dig target.com MX
dig target.com TXT

# Expliciet via een specifieke nameserver
dig @ns1.target.com target.com AXFR

Reverse DNS sweep

Een slimme truc: als je het IP-bereik van een organisatie kent (via whois), kun je een reverse DNS sweep doen – elk IP-adres opvragen en kijken of er een hostname aan gekoppeld is.

# Met dnsrecon
dnsrecon -r TARGET_RANGE/24

# Of handmatig (de brute-force methode)
for ip in $(seq 1 254); do host 10.0.0.$ip; done | grep -v "not found"

Die handmatige one-liner is niet elegant, maar hij werkt. En soms is dat alles wat telt.

Volledige DNS enumeratie

Het gereedschap dnsenum combineert veel van het bovenstaande in een enkele tool:

# Standaard enumeratie
dnsenum target.com

# Met een specifieke nameserver
dnsenum --dnsserver ns1.target.com target.com

dnsenum probeert zone transfers, doet reverse lookups, bruteforced subdomeinen, en zoekt naar delegatierecords – allemaal automatisch. Het is de Zwitserse legermessen onder de DNS-tools.

Service fingerprinting: wat draait daar?

Banner grabbing: de eerste indruk

Je hebt nu een lijst met IP-adressen, hostnamen, en subdomeinen. De volgende vraag is: wat draait er op die systemen? Welke software, welke versies, welke configuratie?

Banner grabbing is de meest directe manier om dat te achterhalen. Veel services sturen bij het openen van een verbinding een banner – een begroetingsbericht dat vertelt welke software het is en welke versie.

# Netcat voor handmatig banner grabbing
nc -nv TARGET_IP 80
nc -nv TARGET_IP 22
nc -nv TARGET_IP 25
nc -nv TARGET_IP 21

Bij poort 80 typ je vervolgens HEAD / HTTP/1.0 gevolgd door twee enters, en de webserver vertelt je keurig dat het Apache 2.4.49 is. Of nginx 1.18. Of IIS 10.0. Soms zelfs met het besturingssysteem erbij. Het is alsof je bij een bedrijf aanklopt en de receptionist je spontaan vertelt welk alarmmodel ze gebruiken, wie de sleutels heeft, en om hoe laat de nachtbewaker pauze heeft.

Dit zou grappig zijn als het niet zo waar was.

HTTP headers analyseren

Webservers zijn bijzonder spraakzaam. De HTTP-headers die ze terugsturen bevatten een schat aan informatie:

# Bekijk de headers
curl -I https://target.com

De Server-header vertelt je de webserversoftware. X-Powered-By onthult vaak de backend-technologie (PHP, ASP.NET, Express). De Set-Cookie-header kan frameworks onthullen – een cookie genaamd JSESSIONID schreeuwt “Java!”, PHPSESSID schreeuwt “PHP!”, en ASP.NET_SessionId schreeuwt “We hebben in 2008 een architecturale keuze gemaakt en sindsdien niet meer achteromgekeken!”

Headers als X-AspNet-Version, X-AspNetMvc-Version, en X-Generator zijn soms letterlijk de versienummers die je nodig hebt om een CVE te zoeken. Het is informatie die standaard wordt meegestuurd tenzij iemand de moeite neemt om het uit te zetten. En het uitvinden van wie die moeite neemt: dat is onderdeel van je assessment.

Technologie detectie: WhatWeb en Wappalyzer

Voor een uitgebreidere analyse heb je geautomatiseerde tools:

# WhatWeb
whatweb target.com
whatweb -a 3 target.com  # Aggressief

# Nmap service versie detectie
nmap -sV -p 80,443,8080 target.com

WhatWeb probeert de gebruikte technologieen te identificeren door naar specifieke patronen te kijken – HTML-structuren, JavaScript- bibliotheken, CSS-frameworks, CMS-vingerafdrukken. Het vertelt je niet alleen dat er een webserver draait, maar dat het een WordPress 5.8 site is met het Divi-thema, jQuery 3.6, en Google Analytics.

Wappalyzer doet hetzelfde maar als browser-extensie, wat handig is voor passieve analyse terwijl je door de site navigeert.

IB’s scan.sh script integreert WhatWeb automatisch:

# Uit scan.sh: voor elke host met HTTP
whatweb ${yolo} > raw/recon/whatweb-${yolo}.txt

Elk resultaat wordt opgeslagen in raw/recon/ en is vervolgens zichtbaar in de Output viewer – maar daarover later meer.

Nmap service scanning

Nmap blijft de gouden standaard voor service-identificatie:

# Service en versie detectie met web-specifieke scripts
nmap -p80,443,8080 -sV \
    --script=http-enum,http-methods,http-title target

Het http-enum script probeert bekende paden te vinden (admin panels, configuratiebestanden), http-methods controleert welke HTTP-methoden zijn toegestaan (PUT en DELETE op een webserver is zelden een goed teken), en http-title haalt de paginatitel op.

Directory en bestand fuzzing: het doorzoeken van de kast

Waarom fuzzing werkt

Stel je voor dat je een gebouw binnenwandelt. De receptie verwijst je naar de vergaderruimte. Maar jij bent niet geinteresseerd in de vergaderruimte. Jij wilt weten welke andere kamers er zijn. De server- ruimte. Het archief. Het kantoor van de directeur waar die ene laptop staat met de onversleutelde database.

Directory fuzzing doet precies dat. Je probeert systematisch URL-paden om te ontdekken welke pagina’s, mappen, en bestanden er op een webserver staan die niet gelinkt zijn vanuit de navigatie. Verborgen admin-panels. Backup-bestanden. Configuratiebestanden. API-endpoints die niemand heeft gedocumenteerd maar die wel gewoon antwoorden.

Gobuster: snel en doeltreffend

Gobuster is de arbeidspaard van directory fuzzing – snel, simpel, en effectief:

# Basis directory bruteforce
gobuster dir -u http://target \
    -w /usr/share/wordlists/dirb/common.txt \
    -t 50 \
    -b 301,302

# Met extensies (essentieel!)
gobuster dir -u http://target \
    -w /usr/share/wordlists/dirb/common.txt \
    -x php,html,txt,bak \
    -t 50

Die -x flag is cruciaal. Zonder extensies zoek je alleen naar directories. Met -x php,html,txt,bak zoek je naar elke entry in je woordenlijst plus elke entry met elk van die extensies. Dus admin wordt admin, admin.php, admin.html, admin.txt, en admin.bak. Die laatste – .bak – is de reden dat pentesters goede wijn kunnen kopen. Het aantal keren dat een ontwikkelaar een backup van een configuratiebestand maakt door er .bak achter te plakken en het dan op de webserver laat staan, is… ontmoedigend.

De -b 301,302 flag filtert redirects uit de resultaten. Soms wil je die zien (een redirect kan interessant zijn), soms niet. Experimenteer.

Gobuster voor subdomeinen en virtual hosts

Gobuster kan meer dan directories:

# Subdomain bruteforce via DNS
gobuster dns -d target.com \
    -w /usr/share/seclists/Discovery/DNS/subdomains-top1million-5000.txt

# Virtual host bruteforce
gobuster vhost -u http://target \
    -w /usr/share/seclists/Discovery/DNS/subdomains-top1million-5000.txt

VHOST-bruteforce is bijzonder handig wanneer meerdere websites op hetzelfde IP-adres draaien (shared hosting, reverse proxies). De server reageert anders afhankelijk van welke Host-header je meestuurt – en gobuster probeert ze allemaal.

Wfuzz: de flexibele optie

Wfuzz is flexibeler dan gobuster en kan naast directories ook parameters en waarden fuzzen:

# Directory fuzzing
wfuzz -c -z file,/usr/share/seclists/Discovery/Web-Content/raft-medium-files.txt \
    --hc 301,404,403 http://target/FUZZ

# Parameter discovery (welke parameters accepteert een pagina?)
wfuzz -c -z file,/usr/share/seclists/Discovery/Web-Content/burp-parameter-names.txt \
    --hc 404 "http://target/page?FUZZ=test"

# Parameter value fuzzing
wfuzz -c -z file,wordlist.txt --hc 404 "http://target/page?param=FUZZ"

# POST data fuzzing (login bruteforce)
wfuzz -c -z file,wordlist.txt --hc 404 \
    -d "user=admin&pass=FUZZ" http://target/login

De kracht van wfuzz zit in het FUZZ-keyword. Overal waar je FUZZ plaatst, wordt elke entry uit je woordenlijst geprobeerd. URL-pad? FUZZ. Parameternaam? FUZZ. Parameterwaarde? FUZZ. Cookie? FUZZ. Het is als een universele sleutel die in elk slot wordt geprobeerd.

De --hc flag verbergt specifieke HTTP-statuscodes. --hc 404 verbergt “Not Found”-responses, zodat je alleen de hits ziet. Andersom kun je --sc 200,301 gebruiken om alleen specifieke codes te tonen.

IB’s scan.sh integreert wfuzz in de geautomatiseerde workflow:

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

Merk op dat scan.sh de --sc (show codes) variant gebruikt in plaats van --hc (hide codes) – het toont alleen de interessante statuscodes. De output gaat rechtstreeks naar raw/recon/, waar de Output viewer het oppikt.

Custom woordenlijsten met CeWL

Generieke woordenlijsten zijn goed, maar custom woordenlijsten zijn beter. CeWL (Custom Word List generator) crawlt een website en extraheert woorden om een op maat gemaakte woordenlijst te genereren:

# Crawl 2 niveaus diep, woorden van minimaal 5 tekens
cewl -d 2 -m 5 -w custom_wordlist.txt http://target

Als een bedrijf het over “ProjectPhoenix” heeft op hun website, is de kans groot dat er ergens een /projectphoenix/-directory of een projectphoenix-admin-subdomein bestaat. CeWL vindt die termen en je kunt ze toevoegen aan je fuzzing-woordenlijst.

Hakrawler: de spin

Hakrawler combineert webcrawling met Wayback Machine-data:

# Crawl de site
echo "http://target" | hakrawler

# Inclusief historische data van Wayback Machine
echo "http://target" | hakrawler -s wayback

De Wayback Machine is de digitale schoenendoos met oude foto’s van het internet. Pagina’s die al lang zijn verwijderd, staan er vaak nog. En als een bedrijf drie jaar geleden een admin-panel had op /admin dat ze sindsdien hebben verwijderd… tja, misschien hebben ze het verwijderd uit de navigatie maar niet van de server. Hakrawler helpt je die historische paden te vinden.

Woordenlijsten kiezen en aanpassen

De keuze van woordenlijst bepaalt het succes van je fuzzing. Een paar richtlijnen:

Begin altijd klein en escaleer. common.txt bevat ~4600 entries en is in seconden klaar. directory-list-2.3-medium.txt bevat ~220.000 entries en kan minuten tot uren duren, afhankelijk van de snelheid van de server en je threadcount.

CMS scanning: WordPress en de rest

WordPress: het internet’s populairste doelwit

WordPress drijft ruwweg 43% van alle websites op het internet. Dat is een ongelooflijk getal. Het betekent ook dat als je een pentest doet, de kans bijna een op twee is dat je ergens een WordPress-site tegenkomt. En WordPress-sites zijn… hoe zeg je dat beleefd… vaak niet goed onderhouden.

Het probleem zit niet in WordPress zelf – de core is redelijk veilig. Het probleem zit in plugins. WordPress heeft meer dan 60.000 plugins, en de kwaliteit varieert van “professioneel geschreven door een team van senior developers” tot “in een weekend in elkaar gehackt door iemand die net zijn eerste PHP-tutorial heeft gevolgd.” En het zijn die laatste plugins die op productiesites draaien, drie jaar zonder update, met bekende kwetsbaarheden die je kunt googelen.

WPScan: de WordPress-specialist

WPScan is de tool voor WordPress-security:

# Basis scan: enumerate alles
wpscan --url http://TARGET --enumerate ap,at,cb,dbe

# Gebruikers enumereren
wpscan --url http://TARGET --enumerate u

# Agressieve plugin detectie
wpscan --url http://TARGET --enumerate ap --plugins-detection aggressive

# Thema enumeratie
wpscan --url http://TARGET --enumerate at

De --enumerate flags bepalen wat er wordt gescand: - ap – alle plugins - at – alle thema’s - cb – config backups - dbe – database exports - u – gebruikers - vp – kwetsbare plugins (vereist API-token) - vt – kwetsbare thema’s (vereist API-token)

WPScan met API-token

De gratis versie van WPScan vindt plugins en thema’s, maar om te weten of ze kwetsbaar zijn, heb je een API-token nodig:

# Met API-token: vulnerability database
wpscan --url http://TARGET --api-token YOUR_TOKEN --enumerate vp,vt

De API-token koppelt je scan aan de WPVulnDB-database, die CVE-details en exploit-informatie bevat voor bekende WordPress-kwetsbaarheden. De gratis tier biedt 25 scans per dag, wat voor de meeste assessments ruim voldoende is.

Password brute force via WPScan

WPScan kan ook wachtwoorden bruteforcen:

# Enkele gebruiker
wpscan --url http://TARGET -U admin \
    -P /usr/share/wordlists/rockyou.txt

# Meerdere gebruikers via XML-RPC
wpscan --url http://TARGET -U users.txt \
    -P /usr/share/wordlists/rockyou.txt \
    --password-attack xmlrpc

De --password-attack xmlrpc optie is slimmer dan een standaard login-bruteforce. XML-RPC staat het toe om meerdere wachtwoorden per verzoek te proberen, wat sneller is en minder opvalt in logs. Althans, het zou minder opvallen als beheerders hun logs zouden lezen.

Handmatige WordPress checks

Soms is handmatig werk sneller:

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

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

# XML-RPC beschikbaar?
curl -s http://TARGET/xmlrpc.php

# Bekende paden
# http://TARGET/wp-login.php
# http://TARGET/wp-admin/

Die REST API voor gebruikers is een klassieker. Standaard geeft WordPress een JSON-lijst van alle gebruikers terug als je /wp-json/wp/v2/users opvraagt. Met namen. En slugs. En avatar-URLs. Het is alsof je bij een bedrijf aanklopt en de receptionist je een organigram overhandigt met alle namen, functies, en pasfoto’s erbij.

En hier is de kicker: na het vinden van geldige gebruikersnamen, en na het kraken van het wachtwoord van een admin-account, is het pad naar een webshell verbazingwekkend kort:

Appearance -> Theme Editor -> 404.php -> [plak je PHP-shell]

Dat is het. Drie klikken en je hebt code-executie op de server. WordPress maakt het zo makkelijk om een themabestand te bewerken dat het bijna een feature is in plaats van een kwetsbaarheid.

Andere CMS-scanners

WordPress is niet het enige CMS. Voor andere platforms:

Het patroon is hetzelfde: identificeer het CMS, gebruik de gespecialiseerde scanner, zoek naar bekende kwetsbaarheden en misconfiguraties.

De IB Task Runner: scans vanuit het dashboard

Waarom klikken als je ook kunt klikken?

Tot nu toe hebben we tools besproken die je vanuit de terminal uitvoert. Dat werkt prima, maar IB biedt een elegantere optie: de Task Runner. Het is een webinterface waarmee je voorgedefinieerde taken kunt starten, monitoren, en de output kunt bekijken – allemaal vanuit je browser.

Nu denk je misschien: “Waarom zou ik een webinterface gebruiken als ik een terminal heb?” Goeie vraag. Het antwoord is drieledig:

1. Parallellisme. Je kunt meerdere scans tegelijk starten en ze allemaal monitoren in een enkel dashboard.
2. Persistentie. De output wordt opgeslagen en is later terug te vinden via de Output viewer.
3. Reproduceerbaarheid. De taken zijn voorgedefinieerd met gevalideerde parameters, dus je krijgt consistente resultaten.

Hoe de Task Runner werkt

De Task Runner is gebouwd als een Flask Blueprint in tasks.py. Het hart is een Python dictionary genaamd _TASKS die elke beschikbare taak definieert:

_TASKS = {
    "scan": {
        "label": "Network scan (nmap)",
        "group": "recon",
        "desc": "Nmap TCP/UDP scan, nuclei, whatweb, wfuzz",
        "cmd": ["bash", "scan.sh"],
        "args": [
            {
                "name": "interface",
                "label": "Interface / IP",
                "placeholder": "eth0, tun0 of 10.0.0.1",
                "required": True,
                "pattern": "ip_or_iface",
            },
            {
                "name": "naam",
                "label": "Scan naam",
                "placeholder": "engagement-name",
                "required": True,
                "pattern": "safe_name",
            },
            {
                "name": "hosts",
                "label": "Hosts / range",
                "placeholder": "10.1.2.0/24",
                "required": True,
                "pattern": "ip_or_iface",
            },
        ],
    },
    # ...meer taken...
}

Elke taak heeft een label, een groep (voor categorisatie in de UI), een beschrijving, een commando, en optioneel argumenten. Argumenten worden gevalideerd tegen regex-patronen voordat ze aan het commando worden toegevoegd. Geen shell injection hier – shell=False in de subprocess-aanroep, en argumenten worden als aparte list-elementen doorgegeven.

De veiligheidslaag

Dit is een belangrijk punt, dus laten we er even bij stilstaan. De Task Runner voert alleen taken uit die in de _TASKS-dictionary staan. Je kunt niet willekeurig commando’s invoeren. Je kunt geen pijpen gebruiken, geen command substitution, geen shell-trucs. De argumenten worden gevalideerd tegen patronen:

_RE_SAFE_NAME = re.compile(r"^[a-zA-Z0-9_\-]+$")
_RE_IP_OR_IFACE = re.compile(r"^[a-zA-Z0-9._:/%\-]+$")
_RE_SEARCH_TERM = re.compile(r"^[a-zA-Z0-9._:\-/]+$")

Een scannaam mag alleen letters, cijfers, underscores en streepjes bevatten. Een IP-adres of interface mag geen puntkomma’s of backticks bevatten. Path traversal (..) wordt expliciet geblokkeerd. Het is een allowlist-benadering in plaats van een denylist – als het niet op de lijst staat, mag het niet.

Ironisch genoeg is dit precies de benadering die de systemen die we testen zouden moeten gebruiken.

Taken starten

Via de webinterface (/dashboard/tasks) selecteer je een taak, vul je de parameters in, en klik je op “Run”. Achter de schermen wordt een POST-request gestuurd naar /api/tasks/run:

{
    "task": "scan",
    "args": {
        "interface": "tun0",
        "naam": "acme-corp",
        "hosts": "10.1.2.0/24"
    }
}

De Task Runner start het commando in een achtergrondthread, kent er een uniek run_id aan toe, en begint de output te bufferen. Elke taak heeft een maximum runtime van 600 seconden (10 minuten) – als een scan langer duurt, wordt het proces netjes beindigd.

Status volgen

Terwijl een taak draait, kun je de status en output opvragen:

# API call (of via de web UI)
GET /api/tasks/runs/{run_id}

De response bevat de status (running, success, failed), de starttijd, de return code, en de output – de laatste 500 regels, opgeslagen in een deque met maximale grootte:

_MAX_OUTPUT_LINES = 500

Die limiet van 500 regels voorkomt dat een verbose scan je geheugen opeet. Voor de volledige output kijk je naar de bestanden in raw/.

Beschikbare recon-taken

De Task Runner biedt de volgende reconnaissance-taken:

Zoeken in scanresultaten

Na een scan wil je snel specifieke hosts vinden. De search-taak is hiervoor gebouwd:

# Achter de schermen: search.sh
# Zoek alle hosts met HTTP in de nmap results
bash search.sh acme-corp http

# Zoek alle hosts met SSH
bash search.sh acme-corp ssh

# Zoek alle hosts met poort 3389 (RDP)
bash search.sh acme-corp 3389

Het script doorzoekt de .gnmap-output (greppable nmap format) en retourneert een schone lijst van IP-adressen. Simpel, effectief, en exact wat je nodig hebt om je volgende stap te plannen.

De Output viewer: alles terug te vinden

Waar gaan de resultaten heen?

Een scan produceert bestanden. Nmap schrijft .nmap, .gnmap, en .xml. WhatWeb schrijft tekstrapporten. Wfuzz schrijft resultaten. Nuclei schrijft bevindingen. Al die bestanden belanden in subdirectories onder raw/:

raw/
  nmap/           # Nmap scan output
  recon/          # WhatWeb, wfuzz, nuclei, etc.
  local/          # Lokale configuratie (ifconfig, id, etc.)
  loot/           # Geexfiltreerde data per client-IP
  exploits/       # Exploit output
  tls/            # TLS scan resultaten
  debug/          # Debug output
  mirror/         # Website mirrors
  spider/         # Spider output
  route/          # Routing informatie
  tooling/        # Overige tool output

De Output viewer (/dashboard/outputs) indexeert al deze directories en presenteert de bestanden in een doorzoekbare interface.

Hoe de Output viewer werkt

De implementatie in output_view.py is elegant in haar eenvoud. Bij elk verzoek wordt de lijst van _ALLOWED_BASES doorzocht:

_ALLOWED_BASES = [
    Path("raw/local"),
    Path("raw/nmap"),
    Path("raw/recon"),
    Path("raw/loot"),
    Path("raw/exploits"),
    Path("raw/tls"),
    Path("raw/debug"),
    Path("raw/mirror"),
    Path("raw/spider"),
    Path("raw/route"),
    Path("raw/tooling"),
    Path("raw/wget"),
]

Alleen bestanden in deze directories worden getoond, en alleen bestanden met toegestane extensies:

_ALLOWED_SUFFIXES = {
    ".txt", ".nmap", ".gnmap", ".xml", ".csv", ".log",
    ".md", ".json", ".html", ".htm", ".conf", ".cfg",
    ".ini", ".yaml", ".yml"
}

Geen binaire bestanden, geen executables, geen willekeurige bestandstypes. En elk bestand wordt gelezen tot maximaal 120KB (_MAX_READ_BYTES = 120_000) – groot genoeg voor de meeste scanresultaten, klein genoeg om de browser niet te laten vastlopen op een nmap-scan van een /16 netwerk.

De path resolution bevat een expliciete check tegen path traversal:

def _resolve_output(output_id):
    rel = output_id.replace("__", "/")
    path = Path(rel)
    # ... existence check ...
    normalized = path.resolve()
    for base in _ALLOWED_BASES:
        if normalized.is_relative_to(base.resolve()):
            return normalized
    return None

Als het geresolvede pad niet binnen een van de toegestane bases valt, wordt None geretourneerd en krijg je een 404. Geen ../../etc/passwd hier.

Praktisch voorbeeld: een volledige recon-workflow

Laten we het allemaal samenvoegen in een praktisch voorbeeld. Je hebt een pentest-opdracht voor Acme Corp, met scope 10.1.2.0/24.

Stap 1: Passieve verkenning (buiten IB)

# Whois
whois acme-corp.com

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

# theHarvester
theHarvester -d acme-corp.com -b all

Stap 2: Netwerkscan via de Task Runner

Open /dashboard/tasks, selecteer “Network scan (nmap)”: - Interface: tun0 (je VPN-interface) - Scan naam: acme-corp - Hosts: 10.1.2.0/24

Klik “Run”. IB start scan.sh met die parameters. Het script: 1. Maakt de directory-structuur aan (raw/nmap/, raw/recon/, etc.) 2. Logt je lokale configuratie 3. Draait een TCP-poortscan 4. Draait een UDP-poortscan 5. Converteert output naar CSV 6. Start een full scan op elke gevonden host (in screen-sessies) 7. Draait WhatWeb, Wfuzz, en Nuclei op elke host met HTTP

Stap 3: Resultaten doorzoeken

Na de scan, gebruik de search-taak: - Scan naam: acme-corp - Zoekterm: http

Je krijgt een lijst van alle hosts met webservers. Herhaal met ssh, ftp, smb, rdp, 3389, et cetera.

Stap 4: Resultaten bekijken in de Output viewer

Open /dashboard/outputs. Je ziet nu: - raw/nmap/acme-corp_quick_scan_tcp.nmap – TCP-scanresultaten - raw/nmap/acme-corp_quick_scan_udp.nmap – UDP-scanresultaten - raw/nmap/acme-corp_tcp-poorten.txt – Poorten in CSV - raw/nmap/acme-corp_tcp-versies.txt – Service-versies in CSV - raw/recon/whatweb-10.1.2.15:80.txt – WhatWeb voor elke host - raw/recon/wfuzz-10.1.2.15:80.txt – Wfuzz voor elke host - raw/recon/nuclei-10.1.2.15:80.txt – Nuclei voor elke host

Klik op een bestand om de inhoud te bekijken. Alles op een plek, doorzoekbaar, opgeslagen voor je rapport.

Stap 5: Gerichte vervolgstappen

Met de scanresultaten plan je je volgende acties: - WordPress gevonden? Open recon_wpscan uit de Command Library - FTP open? Start de ftp_anon-taak - SMTP? Open recon_smtp - SNMP? Open recon_snmp - NFS? Open recon_nfs

Overige protocollen: de vergeten diensten

SMTP enumeratie: het e-mail verhoor

E-mailservers zijn als praatgrage portiers. Als je ze de juiste vragen stelt, vertellen ze je welke bewoners er in het gebouw wonen. SMTP heeft drie commando’s die hiervoor misbruikt kunnen worden: VRFY (verify), EXPN (expand), en RCPT TO.

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

# EXPN voor mailinglijst-leden
# EXPN all-users

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

VRFY vraagt aan de server: “Bestaat deze gebruiker?” De server antwoordt met 250 (ja) of 550 (nee). Het is alsof je bij een bedrijf belt en vraagt: “Werkt Jan Jansen bij u?” En de receptionist antwoordt eerlijk.

De meeste beheerders schakelen VRFY uit. De slimme beheerders schakelen ook EXPN uit. Maar RCPT TO – dat kun je niet uitzetten, want dat is hoe e-mail werkt. Je stuurt een mail naar een adres, en de server vertelt je of dat adres bestaat.

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

smtp-user-enum -M RCPT -U users.txt -D target.com -t TARGET_IP

smtp-user-enum -M EXPN -U users.txt -t TARGET_IP

Nmap SMTP scripts

Nmap heeft specifieke scripts voor SMTP-analyse:

# User enumeratie
nmap -p 25 --script smtp-enum-users TARGET_IP

# Beschikbare commando's
nmap -p 25 --script smtp-commands TARGET_IP

# Open relay check (kan de server mail relayen voor willekeurige afzenders?)
nmap -p 25 --script smtp-open-relay TARGET_IP

Een open relay is een SMTP-server die mail doorstuurt namens willekeurige afzenders. In de jaren negentig was dit normaal. Nu is het een teken dat iemand zijn mailserver heeft geconfigureerd in de jaren negentig en er sindsdien niet meer naar heeft omgekeken.

SNMP: het protocol dat nooit had mogen bestaan

Simple Network Management Protocol. “Simple” in de zin van “simpel te misbruiken.” SNMP is ontworpen in een tijdperk waarin het internet bestond uit een paar universiteiten die elkaar vertrouwden. De authenticatie in SNMP v1 en v2c bestaat uit een “community string” – wat een deftig woord is voor een wachtwoord dat in plaintext over het netwerk wordt gestuurd.

En de meestgebruikte community strings? “public” voor leestoegang. “private” voor schrijftoegang.

Laat dat even tot je doordringen. Het protocol dat wordt gebruikt om routers, switches, servers, en printers te beheren – om ze te configureren, te monitoren, en zelfs te herstarten – gebruikt standaard het wachtwoord “public.” Het is alsof de beveiliging van een kerncentrale bestaat uit een deur met een slot waarvan de code “1234” is. En er hangt een bordje naast: “De code is 1234.”

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

# Of met nmap
nmap -sU -p 161 --script snmp-brute TARGET_IP

SNMP Walk: de complete inventaris

Als je een geldige community string hebt gevonden (en dat heb je, want het is bijna altijd “public”), kun je een SNMP walk doen. Dat is het equivalent van het openen van elke lade en kast in een kantoor en alles fotograferen wat erin zit.

# Alles opvragen
snmpwalk -c public -v1 -t 10 TARGET_IP

Maar SNMP is georganiseerd in een hierarchische structuur van OIDs (Object Identifiers). Je kunt gericht informatie opvragen:

# Windows gebruikers
snmpwalk -c public -v1 TARGET_IP 1.3.6.1.4.1.77.1.2.25

# Draaiende processen
snmpwalk -c public -v1 TARGET_IP 1.3.6.1.2.1.25.4.2.1.2

# Open TCP poorten
snmpwalk -c public -v1 TARGET_IP 1.3.6.1.2.1.6.13.1.3

# Geinstalleerde software
snmpwalk -c public -v1 TARGET_IP 1.3.6.1.2.1.25.6.3.1.2

# Systeem beschrijving
snmpwalk -c public -v1 TARGET_IP 1.3.6.1.2.1.1.1

# Hostnaam
snmpwalk -c public -v1 TARGET_IP 1.3.6.1.2.1.1.5

# Network interfaces
snmpwalk -c public -v1 TARGET_IP 1.3.6.1.2.1.2.2.1.2

Kijk eens naar die lijst. Gebruikersnamen. Draaiende processen. Open poorten. Geinstalleerde software. Via een protocol dat authenticert met het woord “public.” Dit is geen kwetsbaarheid die je ontdekt – dit is een feature die je exploiteert.

snmp-check: alles in een keer

Voor wie geen zin heeft om OIDs te onthouden:

snmp-check TARGET_IP -c public

snmp-check vraagt alle relevante informatie op en presenteert het in een leesbaar formaat. Systeeminformatie, gebruikers, processen, poorten, shares, software – alles in een keer.

NFS: het netwerkbestandssysteem dat te veel deelt

Network File System is een protocol voor het delen van bestanden over een netwerk. Het stamt uit 1984 – het jaar van Orwell, en blijkbaar ook het jaar waarin niemand zich zorgen maakte over toegangscontrole.

NFS-exports kunnen zo worden geconfigureerd dat ze toegankelijk zijn voor specifieke hosts, maar in de praktijk staan ze vaak open voor iedereen. En “iedereen” omvat “de pentester die net je netwerk heeft gescand.”

# Ontdek NFS exports
nmap -sV -p 111 --script=rpcinfo TARGET_IP
nmap -p 111 --script nfs* TARGET_IP
showmount -e TARGET_IP

showmount -e is de sleutel. Het toont welke directories worden geexporteerd en naar wie. Als daar een * staat (iedereen), dan is het kerstmis.

NFS shares mounten

# Mount de share
mkdir /mnt/nfs
mount -o nolock TARGET_IP:/share /mnt/nfs

# Met specifieke NFS-versie (als versie 4 niet werkt)
mount -t nfs -o vers=3,nolock TARGET_IP:/share /mnt/nfs
mount -t nfs -o vers=2,nolock TARGET_IP:/share /mnt/nfs

Na het mounten kun je de bestanden gewoon benaderen alsof ze lokaal zijn:

# Zoek naar interessante bestanden
ls -la /mnt/nfs/
find /mnt/nfs/ -type f \
    -name "*.txt" -o -name "*.conf" -o -name "id_rsa" 2>/dev/null

Die id_rsa in het find-commando is geen toeval. SSH-private keys op NFS-shares komen vaker voor dan je zou denken. En met een private key heb je SSH-toegang zonder wachtwoord.

UID spoofing

NFS v3 vertrouwt op de client om de gebruikers-ID (UID) te rapporteren. Als je een bestand ziet dat eigendom is van UID 1000, kun je lokaal een gebruiker aanmaken met datzelfde UID en het bestand lezen:

# Als bestanden eigendom zijn van UID 1000
useradd -u 1000 fakeuser
su fakeuser
cat /mnt/nfs/secret.txt

Dit werkt tenzij root_squash is ingeschakeld – een instelling die voorkomt dat root op de client zich voordoet als root op de server. Maar als je no_root_squash ziet in de exports… dan ben je root. Op de server. Via een gemounte share.

# Check RPC services
rpcinfo -p TARGET_IP

De moraal van het verhaal

Verkenning is niet glamoureus. Het is geen Hollywood-moment met groene tekst op een zwart scherm terwijl dramatische muziek speelt. Het is geduldig zoeken, methodisch documenteren, en verbanden leggen tussen losse stukjes informatie. Het is het lezen van DNS-records tot je ogen tranen. Het is het doorploegen van woordenlijsten die groter zijn dan de gemiddelde Tolstoj-roman.

Maar het is het fundament van alles wat volgt.

En wat de organisaties betreft die we testen: het fascinerende is niet dat ze kwetsbaar zijn. Kwetsbaarheden zijn onvermijdelijk in complexe systemen. Het fascinerende is hoeveel van die kwetsbaar- heden neer te voeren zijn op pure nalatigheid. Zone transfers die openstaan omdat niemand ze heeft uitgeschakeld. SNMP met “public” als community string omdat dat de standaard was en niemand hem heeft veranderd. NFS-exports naar de hele wereld omdat * minder typewerk is dan een specifiek IP-adres.

Het is niet dat deze organisaties niet weten dat ze dit moeten beveiligen. Ze hebben security policies. Ze hebben compliance frameworks. Ze hebben jaarlijkse awareness-trainingen waarin een consultant met een PowerPoint uitlegt waarom je niet op links in e-mails moet klikken. Maar als het aankomt op het daadwerkelijk configureren van hun systemen – het monotone, onzichtbare werk van het dichtdraaien van overbodige diensten en het veranderen van standaardwachtwoorden – dan is er ineens niemand thuis.

Dat is de waarde van een pentest. Niet het vinden van obscure zero-days of geavanceerde exploits. Maar het aantonen dat de voordeur al die tijd open heeft gestaan.

Referentietabel