Wanneer een applicatie een URL namens een gebruiker opvraagt, kan die server onbedoeld toegang geven tot interne systemen of cloudvoorzieningen. Lees hoe SSRF ontstaat en welke controles op invoer, DNS, redirects en netwerkverkeer het risico beperken.
Hoe SSRF ontstaat wanneer een server URL’s opvraagt
Bij Server-Side Request Forgery (SSRF) draait het om een aanvaller die je applicatie een verzoek laat uitvoeren naar een adres dat hij zelf kiest. Niet met de rechten of het netwerk van de gebruiker, maar op het account van je server. Zelfs iets simpels zoals een afbeelding ophalen, een document importeren of een webhook controleren, kan daarvoor al een ingang vormen. Vaak bereik je zo interne bestemmingen die normaal gesproken helemaal niet openstaan voor het internet.
Hier schuift de vertrouwensgrens: wat als gewone URL binnenkomt, bepaalt ineens waar de server heen belt. Je verwacht bijvoorbeeld dat iemand een externe URL opgeeft, maar het wordt een intern IP-adres, loopback-domein of een hostnaam die stiekem intern routeert. Die request pakt dan ineens interne API’s, cloudmetadata-adressen of een managementinterface mee. Soms krijgt de aanvaller zelf geen antwoord te zien, maar via responstijd, statuscode of foutmelding lek je toch informatie.
Dit risico beperkt zich niet tot eenvoudige HTTP-clients. Bedenk dat bibliotheken voor afbeeldingen, PDF-omzetting, XML-verwerking of zelfs documentimport ook URL’s ophalen. Dus zolang iemand vrij adres mag opgeven, of als het verzoek anders wordt geïnterpreteerd dan gecheckt, houd je een kwetsbaarheid open. Ook maatwerk in WordPress vraagt daarom om veilige verwerking van externe URL’s.
Risicovolle URL-invoer herkennen in applicatiefuncties
Zoek naar plekken waar een gebruiker zelf een adres kan opgeven of via omwegen kan laten opslaan. Denk aan velden voor een afbeeldings-URL, importfuncties voor nieuwsfeeds, previews van webpagina’s, het ophalen van avatars via externe hosts en integraties die callback-URL’s accepteren. Een URL kan onzichtbaar verstopt zitten in een bestand, in API-verzoeken of zelfs in velden die niet direct als URL opvallen. Het is dus niet nodig dat er letterlijk een URL-veld getoond wordt voor een mogelijk SSRF-risico. Ook een WordPress-plug-in die externe URL’s verwerkt, hoort in die inventarisatie.
Per functie is het nuttig te bekijken: welke applicatiecomponent verwerkt de URL, welke code of library voert het verzoek uit, welke protocollen zijn toegestaan en wat gebeurt er met de response? Zelfs als je alleen wat metadata nodig hebt, kan de applicatie een compleet HTTP-verzoek uitvoeren of doorgestuurd worden naar een andere bestemming. Soms werkt een preview-service zo dat hij na het laden van de HTML opnieuw bestanden gaat ophalen, elk met hun eigen netwerkverzoek. Zo kan elke stap extra risico introduceren.
Let op wie welke delen van de URL bepaalt. Dat een URL deels door de applicatie is opgebouwd, zegt weinig als gebruikers de host, het pad of querystrings kunnen beïnvloeden. Ook belangrijk: gebeurt het verzoek direct tijdens een webactie of via een achtergrondtaak? Dit bepaalt welke netwerkmachtigingen gelden, welke logging er is en welke netwerkbeperkingen van kracht zijn.
URL-validatie met allowlists en consistente parsing
Wil je een URL echt afvangen, koppel je validatie dan aan dezelfde parser als je HTTP-client gebruikt. Kijk altijd naar protocol (schema), host, poort en wie er als gebruiker in de URL staat. De meeste apps kunnen simpelweg een allowlist instellen: bijvoorbeeld alleen HTTPS naar vooraf goedgekeurde domeinen. Een allowlist is overzichtelijker te beoordelen dan een blacklist die intern verkeer uitsluit, want een blacklist moet alle denkbare schrijfwijzen en routes blijven blokkeren.
Normaliseer de URL voor je controle doet, maar bouw geen eigen routines vol tekstvervanging. Parsers kunnen verschillend omgaan met hoofdletters, percent codes, IPv6-vormen, een extra punt bij de hostname of met vreemde karakters. Als je validatiehost niet overeenkomt met die van je netwerkclient, stelt je controle niets voor. Accepteer alleen geldige, eenduidige URL’s en corrigeer ze niet stiekem in de achtergrond. Afwijzen werkt helderder.
Kijk kritisch naar de allowlist. Heeft een functie enkel bestanden van een bepaald domein nodig? Sta dan alleen dat domein toe, liefst inclusief restricties op subdomeinen en poorten. Een wildcard is onveiliger als derden subdomeinen kunnen uitgeven. Kijk ook goed naar pad en query als die toegang tot gevoelige functies regelen. Denk eraan: validatie van URL’s is beleid, het is geen alternatief voor netwerkafscherming.
DNS-resolutie en DNS-rebinding beheersen
Een hostnaam verwijst makkelijk naar verschillende IP’s, waaronder private, localhost of link-local adressen. Je vangt dus niet zomaar alles af door te kijken of er een intern IP-adres letterlijk in de URL staat. De applicatie moet daarom eerst zelf de hostnaam vertalen (resolven) en alle uitkomsten checken volgens het eigen beleid. Vergeet niet dat er IPv4 en IPv6 kunnen langskomen, net als andere speciale adressen die niet bedoeld zijn voor internet.
DNS-rebinding is een sluipweg. Hier laat een aanvaller het DNS-antwoord wisselen zodat je validatie een publiek adres ziet, maar de connectie zelf eindigt op een intern IP. Dit risico ontstaat als je validatie en verbindingsopbouw los van elkaar gebruikt. Je krijgt meer grip door de validatieresolutie en de feitelijke netwerkopbouw te koppelen, of een netwerklaag te benutten die gewoon alle verbindingen naar verboden reeksen blokkeert. Of dat lukt, hangt af van de gebruikte HTTP-bibliotheek en infrastructuur.
Kijk altijd naar alle IP’s die de resolver teruggeeft en neem niet blind de eerste. Caching is relevant: een cache kan oude antwoorden vasthouden, maar een korte TTL geeft ruimte voor DNS-trucs. Log welke hostnaam en eindadres je uiteindelijk gebruikt, zodat je afwijkingen later kunt onderzoeken. Wie DNS via een proxy laat lopen, moet bepalen: doet de applicatie de naamoplossing of doet de proxy dat? Jouw validatie moet aansluiten op het deel dat de connectie daadwerkelijk bouwt.
Redirects en protocollen beperken bij externe verzoeken
Ook als de eerste bestemming veilig lijkt, kan een redirect alsnog een intern adres bereiken. Een externe URL die een HTTP 3xx bevat naar een intern IP, wordt standaard vaak automatisch gevolgd. Zet dat automatische redirectvolgen uit als het niet nodig is. Is het toch vereist, behandel dan elke redirect stap als een nieuwe bestemming: parse opnieuw, check opnieuw met de allowlist, resolve opnieuw en beperk het aantal redirects.
Let erop of een redirect van HTTPS naar HTTP zomaar is toegestaan (dat maakt de verbinding kwetsbaarder). Een redirect naar een ander domein kan domeinchecks ondermijnen. Verder: sommige clients sturen headers, cookies of authenticaties mee bij vervolgbezoeken. Zorg dat er geen geheimen meegaan naar een onbekende bestemming of dat een eerder geweigerde host alsnog bereikbaar wordt na een redirect.
Laat alleen protocols toe die een functie daadwerkelijk nodig heeft: vaak alleen HTTP of HTTPS. Sommige bibliotheken ondersteunen bijvoorbeeld ook file:// of andere schema’s, soms onbedoeld. Kun je het schema beïnvloeden, dan zijn interne bestanden of lokale diensten soms ineens bereikbaar. Kijk daarom niet alleen naar validatie, maar ook naar instellingen van clients, proxy’s en libraries. Bij een update kan het standaardgedrag ineens wijzigen, dus leg deze controls vast in tests.
Uitgaand netwerkverkeer beperken met egressregels
Applicatiecontroles stellen teleur bij fouten of als iemand een onverwachte parser of DNS-variant weet te gebruiken. Netwerkblokkades zijn daarom onmisbaar als extra verdediging. Laat processen die externe URL’s moeten ophalen alleen netwerkroutes open die ze echt nodig hebben. Blokkeer toegang tot interne, loopback, link-local en vergelijkbare netwerken waar dat kan. Een firewall die slechts vertrouwd op een veld in de applicatie mist doel als het onderliggende proces vrij naar buiten mag bellen.
Hoe je dit inricht, verschilt per omgeving. In een cloudomgeving kun je denken aan security groups, netwerkrichtlijnen of het verplichten van egress-proxy’s. Containerplatforms kunnen netwerkregels per taak afdwingen. Een proxy kan aanvragen centraal filteren en loggen, mits de applicatie er niet omheen kan verbinden. Vergeet DNS en IPv6 niet: beperk dus niet alleen op IPv4, anders is de achterdeur open via een alternatief pad.
Netwerkisolatie heeft altijd een functioneel effect. Als je dienst legitiem bestanden van meerdere externe domeinen moet kunnen halen, betekent strikte netwerkbeperking dat je soms moet gaan splitsen: zo scheid je risico’s tussen hoofdapp en aparte taak. Test foutscenario's ook, bijvoorbeeld als een proxydienst even niet bereikbaar is: valt de client terug op een directe verbinding, dan is je beveiliging zo doorbroken.
Cloudmetadata en interne diensten als SSRF-doelwit
SSRF is extra risicovol wanneer een server gevoelige interne diensten kan bereiken die hun vertrouwen baseren op netwerktoegang in plaats van stevige authenticatie. Met cloudmetadata-endpoints kun je informatie over je cloudomgeving of tijdelijke inlogsleutels weggeven. Interne beheerpanelen, service-discovery-systemen en API’s zijn via de server misschien wel benaderbaar, ook als die nooit bedoeld zijn als publieke dienst. De impact wordt bepaald door je netwerkarchitectuur en de rechten van het proces dat geraakt wordt.
Pak daarom niet alleen de URL-invoer aan, maar maak het behalen van toegang minder waardevol. Gebruik waar je kunt metadata-oplossingen die extra bescherming bieden en voorkom dat applicaties zonder noodzaak toegang hebben tot metadata interne endpoints. Wijs iedere workload een eigen identiteit en minimale privileges toe, zo kan een gelekte credential niet meteen alles in je netwerk. Interne API’s hebben ijzersterke authenticatie en autorisatie nodig, niet alleen vertrouwen op netwerkpositie.
Besef dat de inhoud van de response niet altijd direct bij de aanvaller terecht hoeft te komen. Misschien wordt er alleen een error getoond, een deel opgeslagen of alleen een signaaltje afgegeven. Blind SSRF wordt vaak gebruikt om beschikbare interne hosts te peilen of diensten indirect in beweging te krijgen. Beperk daarom beide dingen: welke interne adressen bereikbaar zijn, plus hoeveel response-info een gebruiker mag terugzien. Foutmeldingen mogen nooit interne adressen, headers of gevoelige inhoud prijsgeven.
Externe integraties ontwerpen zonder open URL-proxy
Voor integraties als webhooks, previews of imports gelden allemaal andere vertrouwensvragen. Bij webhooks registreer je een adres waar de app straks iets heen stuurt, bij imports haalt de applicatie zelf data op. Het type verbinding bepaalt het risico. Bied je een functie aan waar gebruikers vrije URL’s kunnen aanmelden en alle responses ongefilterd terugkrijgen, dan heb je in feite een open proxy gemaakt. Daarmee stel je je interne netwerk bloot of werkt je server (onbedoeld) als doorgeefluik.
Beperk integratiefuncties dus tot wat strikt nodig is. Voor een preview kun je denken aan een aparte service die alleen HTML ophaalt, zonder cookies of logins, met maximale grootte per response en minimale verwerking. Bij een import kun je bestandstype, grootte en toegestane domeinen strak afbakenen. Webhooks vragen extra om controle op uitgaande adressen, redirectbeleid en bescherming van headers. Sla ingevoerde webhookadressen niet als definitief veilig op: DNS of het adres zelf kan daarna wijzigen.
Laat een achtergrondtaak een eerder gevalideerde URL niet zomaar zonder nieuwe controle gebruiken. Er kan tijdens opslag of tussen registratie en uitvoer van alles veranderd zijn, van DNS-wijzigingen tot aangepaste configuraties. Sla eventueel een gecontroleerde versie op, voer controles vlak voor de verbinding uit en log wie of wat het verzoek oorspronkelijk heeft aangevraagd. Dit helpt om bevoegdheden en bestemming terug te vinden als er onverwacht netwerkverkeer uitgaat.
SSRF-tests, logging en foutafhandeling in de praktijk
Test SSRF-beveiliging over de hele keten, van het invulveld tot de uiteindelijke netwerkverbinding. In je testomgeving kun je specifiek gecontroleerde adressen en DNS-antwoorden inzetten, zodat je alle variaties nabootst: publiek, intern, loopback, IPv6, rare schrijfwijzen, redirects, meerdere DNS-antwoorden. Kijk hoe de app reageert, volledige afwijzing, verkeerde host, time-outs, grote responses, of blokkades die alsnog te omzeilen zijn via workers die vastlopen.
Een geslaagde test toont dat de aanvraag wordt afgeketst en dat er geen connectie is gelegd naar de verboden bestemming. Gebruik logging of netwerkmonitoring in tests om dat te checken. Maak regressietests bij updates van libraries, proxy’s of servers: nieuw gedrag rond DNS, redirects of protocollen kan je bestaande controles ondergraven. Test altijd met de live configuratie, niet alleen een losse validatiefunctie. Bij maatwerk in PHP kun je de URL-verwerking en netwerkcontroles gericht laten beoordelen.
Log genoeg om incidenten terug te zoeken: wie vroeg het aan, wat was de host, welk resolved IP, welke redirect en wat was het resultaat? Sla niet klakkeloos alle querystrings of responses op als daar tokens of persoonsgegevens in kunnen staan. Geef gebruikers een veilige (niet te informatieve) foutmelding, details hou je afgeschermd voor onderzoek. Limieten op tijd, grootte en aantal redirects beschermen je applicatie bovendien tegen misbruik, ook als het doeladres zelf geen risico lijkt te zijn.
Veelgestelde vragen
Hoe test ik een applicatie veilig op SSRF?
Test alleen op SSRF als je toestemming hebt en werk altijd met een gecontroleerd doeladres waar je zeggenschap over hebt. Doe dit idealiter altijd in een testomgeving om geen echte interne systemen of productiegegevens te raken. Zet een unieke URL of token op je eigen domein, zo kun je controleren of jouw server het verzoek uitvoert zonder bij gevoelige doelen uit te komen.
- Bepaal vooraf de scope en het testmoment.
- Gebruik nooit cloudmetadata of zomaar interne IP's als doel voor je test.
- Merk je dat je ineens toegang krijgt tot interne data of systemen? Stop meteen en leg het vast volgens het afgesproken proces.
Welke signalen wijzen op een SSRF-aanval in serverlogs?
Onverwachte uitgaande verbindingen naar interne, lokale of vreemde adressen zijn een aanwijzing voor SSRF, maar daarmee ben je er niet. Vergelijk webapplicatielogs met DNS-, proxy- en netwerklogs om te zien welke invoer er aan zo’n verbinding voorafging. Herhaalde verzoeken naar steeds andere hosts, vreemde schemas of veranderde foutmeldingen en responstijden bij een bepaald adres, kunnen verder helpen bij het herkennen van pogingen.
- Waar mogelijk: log het aangeleverde adres, de hostname na parsing, het echte bestemmingsadres.
- Zoek naar afwijkingen in uitgaand verkeer en onverwachte redirectroutes.
- Baken gevoelige data in logs af, stel meldingen in voor verkeer richting onbekende adressen.
Wat moet ik doen als ik vermoed dat SSRF is misbruikt?
Stop eerst het uitgaande verkeer waar het misging en kijk direct na welke adressen je app benaderd heeft. Sla alle relevante logs op rond applicatie, DNS, proxies en netwerk, voordat tijdelijke oplossing maatregelen gegevens overschrijven. Behandel eventuele credentials of tokens die meegegaan zijn als geschaad: trek ze in of roteer ze, controleer welke acties er mee zijn uitgevoerd.
- Isoleer zo nodig de getroffen taak of schakel de risicovolle functie tijdelijk uit.
- Kijk of cloud- of interne diensten verdachte verzoeken of wijzigingen laten zien.
- Herstel de oorzaak en check je nieuwe controls voordat je de functionaliteit opnieuw openzet.
Wat is het verschil tussen SSRF en CSRF?
Het verschil: Bij SSRF laat een aanvaller een server van je applicatie een verzoek uitvoeren, bij CSRF is het juist de browser van een ingelogde gebruiker die een ongewenste actie doet. SSRF raakt vooral interne of interne-achtige doelen die alleen via je server bereikbaar zijn; CSRF richt zich op de sessie en rechten van iemand in diens eigen browser. De namen lijken, de aanvalsvector is fundamenteel anders.
- Beperk bij SSRF de bestemmingen die je server mag benaderen en verfijn netwerktoegang.
- CSRF pak je aan met CSRF-tokens en slimme cookie-instellingen.
Kan een WAF SSRF-aanvallen blokkeren?
Een Web Application Firewall (WAF) herkent soms verdachte input, maar is niet betrouwbaar als afdoende SSRF-beveiliging. Veel SSRF-aanvallen gaan via gekke URL-syntax, redirects of DNS-trucs die pas na de WAF passeren. Een WAF ziet bovendien vaak niet welk IP-adres jouw server uiteindelijk daadwerkelijk opzoekt. Zie een WAF als hulpmiddel: hij kan een aanval signaleren of blokkeren, maar vormt geen sluitende oplossing.
- Voer bestemmingscontrole uit in de applicatie zelf, precies zoals je HTTP-client de URL uitleest.
- Beperk uitgaand verkeer direct op netwerk- of proxyniveau.
- Test of verboden adressen echt onbereikbaar zijn, ook als ze je WAF passeren.
Foto: Erik Mclean