OAuth 2.0 en OpenID Connect worden vaak samen gebruikt, maar lossen verschillende problemen op: toegang verlenen tot een dienst en vaststellen wie er inlogt. Je leest hoe de rollen, tokens en beveiligingskeuzes werken, en waar het in de praktijk mis kan gaan.

OAuth 2.0 geeft toegang, maar bewijst niet wie iemand is

OAuth 2.0 draait om toestemming. Je gebruikt het als je een app toegang wilt geven tot iets van een andere dienst, zonder volledige inloggegevens door te geven. Voorbeeld: een agenda-app mag jouw afspraken ophalen. Die agenda deelt niet direct al jouw identiteit met de app, maar geeft een access token dat vastlegt welke actie de app namens jou mag uitvoeren. Zo’n token is dus géén inlogsleutel: het geeft alleen toestemming voor een bepaald doel, niet per se bewijs wie jij bent.

En dat is een belangrijk verschil. Als je een access token krijgt, weet de ontvangende API eigenlijk alleen dat iemand toestemming heeft gegeven. Het token zelf zegt niet automatisch wie dat was of waarvoor het gebruikt mag worden. Elke ontvangende API moet dus goed weten: wie heeft dit token uitgegeven, waar is het voor bedoeld, en welke rechten horen erbij?

OpenID Connect (OIDC) pakt het anders aan. Het bouwt voort op OAuth 2.0, maar voegt een standaardmanier toe om je identiteit door te geven. Daarvoor wordt een ID-token gebruikt, waarin rechtstreeks staat wie je bent, plus extra details over de soort login. Gebruik OAuth als je een API wilt aanspreken namens iemand anders; OIDC als je wilt dat iemand inlogt en je zeker wilt weten wie het is. Zie je een knop 'Inloggen met...' van een externe partij, dan zit daar meestal OIDC achter, ook al wordt de techniek van OAuth gebruikt.

Behandel OAuth niet automatisch als een veilig inlogsysteem. Bewaar geen access tokens als bewijs wie iemand is. Fouten hierin zorgen er soms voor dat accounts per ongeluk gekoppeld raken, of dat vertrouwelijke gegevens worden blootgelegd aan de verkeerde partij. Maak je dus een systeem dat beide afhandelt (autorisatie en authenticatie), hou deze strikt uit elkaar.

De rollen in OAuth 2.0 en OpenID Connect

Elke OAuth-implementatie bestaat uit vaste rollen. Je hebt altijd een resource owner: meestal is dat gewoon jij, de gebruiker. De client is de applicatie (bijvoorbeeld een webshop of app) die toegang wil tot gegevens of functies. De authorization server is de partij die je authenticatie afhandelt en de tokens uitgeeft. De resource server biedt de API die de beschermde gegevens levert. Soms beheert een enkele partij zowel de authorization server als de resource server, maar dat zijn nog steeds gescheiden rollen, met ieder zijn taak.

Bij OIDC komt de rol relying party erbij: dat is de app die vertrouwt op de identiteitsverklaring van de OpenID Provider. Die provider bedenkt, controleert en tekent het ID-token. De client controleert daarna dat token, handtekening, doel, geldigheidsduur, al dat soort checks, en gebruikt de claims om lokaal een sessie op te bouwen. De resource server (de API dus) kijkt alleen naar het access token, niet naar het ID-token: tokens zijn per rol bedoeld.

Je doet er goed aan om expliciet vast te leggen wie in je systeem welke rol heeft. Veel gemaakte fout: een webapplicatie stuurt een access token rechtstreeks door naar een backend die daar eigenlijk niets mee mag doen. Of een API accepteert tokens alleen omdat ze door een bekende partij zijn uitgegeven, zonder te controleren of ze wel daadwerkelijk voor die specifieke API bedoeld zijn.

Check bij elk token: wie heeft het uitgegeven, voor wie, waarvoor, en wie mag het controleren? Haal niet in één discussie inloggen en bijvoorbeeld voorraadbeheer of klantgegevens ophalen door elkaar: verschillende autorisatiemodellen, verschillende vertrouwensrelaties, andere logica.

Zo verloopt inloggen met de authorization code flow

De authorization code flow is de gangbare aanpak voor moderne webapps. Gebruiker start bij de client, wordt doorgestuurd naar de authorization server (waar onder andere de client_id, redirect URI, gewenste rechten en een random state worden meegegeven). Zit je bij OIDC, dan komt in de scopes duidelijk openid voorbij. Na inloggen, soms met expliciete toestemming, krijg je een tijdelijke code terug naar de opgegeven redirect URI.

De client wisselt die code om voor tokens. Bij een serverapp gebeurt dat meestal veilig op de backend zelf. In het geval van een publieke client zoals een mobiele app, wordt PKCE ingezet. Je maakt dan een willekeurige code_verifier; daarvan stuur je een afgeleide code_challenge mee bij het eerste verzoek. Zo voorkom je dat een onderschepte code gebruikt kan worden door een kwaadwillende.

State is belangrijk: je koppelt hiermee het oorspronkelijke verzoek aan de terugkeer van de gebruiker, helpt tegen cross-site aanvallen. OIDC gebruikt daarbovenop een nonce, speciaal voor het ID-token. Die waarden zijn niet inwisselbaar, dus check beide apart, op de juiste plek.

Laat implicit flow links liggen. Die flow stuurt tokens in de URL mee; dat betekent blootstelling in browsergeschiedenis, logs of via referrers. Codeflow minimaliseert dat risico, doordat tokens alleen via een gecontroleerd kanaal terugkomen. Let na de callback op foutcodes, verlopen codes en verkeerde redirects, automatische login zonder validatie is geen goede praktijk.

ID-tokens en access tokens hebben verschillende doelen

Je gebruikt een ID-token om te bewijzen dat iemand is ingelogd: het is een formele verklaring, bedoeld voor de client, niet voor de API. Hier staan zaken in als wie uitgaf, voor welke client, wanneer uitgegeven, en met welk subject. Het access token is er juist voor de resource server, die mag er een API mee aanspreken. Soms is dat access token als JWT leesbaar, soms krijg je alleen een opaak tekentje dat je alleen bij de authorization server kunt controleren. Je kunt dus niet aannemen dat elk access token gewoon te lezen is.

Als client moet je elk ID-token checken: de handtekening, maar ook details zoals issuer en audience. Let op de nonce in OIDC: die moet kloppen met je eigen nonce. Alleen tokens met correcte handtekening, audience en interval zijn bruikbaar. Bij sleutelrotatie gebruikt de client de actueel bekende sleutels uit de provider-metadata. Een onbekende of ingetrokken sleutel betekent: geen toegang, niet tóch doorlaten.

De API controleert een access token op haar eigen manier. Bij JWT’s bekijkt ze handtekening, issuer, audience, scopes, soms rollen. Is het token opaak, dan gebruikt de API introspectie bij de authorization server om status en rechten op te vragen. JWT-validering is lokaal handig en snel; introspectie signaleert direct intrekking, maar betekent wel een extra afhankelijkheid.

Nooit een ID-token als toegangstoken gebruiken, ook al lijkt het technisch mogelijk. Een API moet een access token eisen, niets anders. Spreid verwerking: ID-token alleen gebruiken voor identificatie bij het inloggen, access token voor bijbehorende API-actie, je eigen sessie voor browsertoegang tot de site zelf.

Scopes en toestemming beperken de toegang

Scopes specificeren welk niveau van toegang de applicatie opvraagt, zoals alleen ‘profiel lezen’ of ‘agenda beheren’. De scope-naam geeft géén beveiliging: de authorization server beslist of de client het mag aanvragen; de resource server checkt of het token die scope bezit. Een API die niet controleert op scopes, maakt elke toestemming betekenisloos.

Beperk aangevraagde scopes tot het strikt noodzakelijke. Vraagt een app alleen voorraadstanden op, dan is toestemming om klantgegevens aan te passen niet nodig. Het principe van minimaal benodigde rechten beschermt je gegevens én houdt toestemmingsvragen helder. Scopes creëren voor de zekerheid ‘voor later’ leidt snel tot teveel toegang en terughoudende gebruikers.

Scopes vervangen interne autorisatie niet. Een scope kan aangeven ‘deze client mag API-functie X aanroepen’, maar de API moet zelf bepalen of deze gebruiker bijvoorbeeld toegang krijgt tot klant A of dossier B. Gebruik scopes als aanvulling, niet als vervanging.

Leg vast wie scopes mag toekennen, intrekken of wijzigen. Soms vraagt een gebruiker toestemming, soms zijn rechten vooraf geregeld tussen organisaties. Blijf helder over wie de baas is over die rechten. Test negatieve gevallen: geen toestemming, geen toegang; niet stiekem toch beperkte data leveren.

Veilig inloggen met redirect URI, state en nonce

Redirect URI’s sturen de browser na login of toestemming terug naar de juiste plek in je app. Leg voor elk domein expliciet geldige redirectadressen vast, dus aparte URI’s voor test, acceptatie en productie. Geen wildcards: dat nodigt aanvallers uit tokens door te sluizen naar eigen domeinen. Je app moet de redirect URI uit het verzoek exact matchen met de geregistreerde waarden. Gebruik HTTPS, tenzij je lokaal ontwikkelt.

State koppelt je loginverzoek aan de terugkeer en hoort altijd onvoorspelbaar te zijn, veilig bewaard (serverkant, of in een cliënt die dat kan) en maar één keer te gebruiken. Check state vóór je de code of tokens verwerkt. Als je niet valideert, loopt een kwaadwillende zo een onbedoelde login in op jouw account.

OIDC voegt de nonce toe: deze bind je aan de ID-token, als extra check dat het token in deze sessie is uitgegeven. Iedere losse waarde (state en nonce) heeft zijn eigen doel en moet je apart controleren.

Verzamel of log tokens, codes en gevoelige info nooit in applicatielogs, analytics of foutberichten. Strip tijdelijke gegevens zodra verwerkt. Laat callbackpagina’s geen externe scripts toegang geven tot URL’s met gevoelige info. Gaat er iets mis, toon een neutrale foutmelding en log alleen minimale technische details voor onderzoek (zonder geheimen).

Sessies, accountkoppeling en gebruikersidentiteit

Is login via OIDC geslaagd, dan bouwt de website een eigen sessie op. Dat is iets anders dan je ID-token bewaren en bij ieder verzoek weer uitlezen. Voor veiligheid hoort je sessie meestal op de server, zichtbaar als cookie (met Secure, HttpOnly, en een passende SameSite en korte waarde). Stel die cookie opnieuw in na login om sessiediefstal te voorkomen. Bescherm gevoelige acties met extra controles: wachtwoord of tweede factor waar het moet.

Koppel een account niet alleen op e-mailadres. E-mail verandert of raakt opnieuw uitgegeven, en verificatie ontbreekt soms. Combinatie van issuer en subject is stabieler. Noteer ook wie precies de identiteit heeft gecontroleerd, en wanneer, zodat je later kunt reageren op wijzigingen.

Accounts samenvoegen puur op overeenkomstig e-mailadres is riskant, want wie de juiste e-mail kent, kan zomaar toegang krijgen tot andersmans gegevens. Beter: laat een gebruiker zich inloggen, daarna expliciet een extra externe identiteit koppelen. Is een externe identiteit al verbonden aan een ander account, behandel dat als conflict, nooit automatisch samenvoegen.

Denk na over de gevolgen van intrekken van toegang bij de aanbieder, of als het externe account wordt opgeruimd. Je lokale sessie blijft bestaan tot je eigen instellingen daar verandering in brengen. Houd grip op sessieduur, her-authenticatie bij gevoelige acties, en het loskoppelen van externe accounts. Externe authenticatie geldt als momentopname: die zegt niets over toekomstige geldigheid van een sessie.

Refresh tokens beheren en toegang intrekken

Access tokens blijven niet eeuwig geldig. Voor langdurige toegang heb je een refresh token nodig; daarmee vraag je stilletjes een nieuw access token aan, zodat de gebruiker niet telkens hoeft in te loggen. Maar: een refresh token is extra gevoelig. Wie het in handen krijgt, kan steeds opnieuw toegang aanvragen. Dus: sla het bij voorkeur alleen server-side, versleuteld en afgeschermd, op. Nooit in browser localStorage of in logs bewaren.

In een serverapplicatie is een refresh token alleen toegankelijk voor de backend die het echt nodig heeft. Gebruikt een publieke app het, volg dan streng de mogelijkheden van het platform. Mobiel? Gebruik de voorzieningen voor veilige opslag van het besturingssysteem. Met een backend-for-frontend bewaar je tokens buiten de browser en werkt de front-end alleen via een sterke sessiecookie, met wat extra beheer voor sessies als bijkomend aandachtspunt.

Ondersteunt je provider refresh-tokenrotatie, gebruik dat dan verstandig. Na elke verversing krijg je een nieuw refresh token, hergebruik van een oude betekent mogelijk token diefstal. Zorg dus dat je met parallelle verversingspogingen goed omgaat: dubbele requests kunnen anders tokens onbruikbaar maken. Intrekken bij de provider (revoken) en lokaal uitloggen speel je altijd apart klaar: één actie wist niet alles op alle plekken.

De houdbaarheid van access en refresh tokens stem je af op wat nodig is: meer gemak betekent langer toegang, maar ook meer risico als een token lekt. Voor gevoelige functies kan extra authenticatie nodig zijn, los van je reguliere sessie. Bereid je voor op verlopen of ingetrokken tokens, tijdelijke netwerkproblemen en duidelijke herstelroutes waarmee je bijvoorbeeld infinite redirects voorkomt.

OAuth gebruiken voor koppelingen met externe API’s

Bouw je een koppeling met een externe API, denk dan als eerste na wie waarvoor verantwoordelijk is. Bijvoorbeeld: haalt je webshop voorraad op met een eigen applicatietoken, of namens een specifieke medewerker na diens login bij de leverancier? Dat verschil bepaalt het autorisatiescenario. Zet voor jezelf op een rij: toegang via gebruikersautoriteit of via de applicatie zelf, wie mag de koppeling beheren, en welke data zijn precies nodig.

Is er geen gebruikerslogin nodig (denk aan server-naar-server communicatie), dan kun je meestal uit met een client credentials-achtige flow. Je applicatie logt zelf in, ontvangt een token en krijgt toegang tot vooraf afgesproken functies. Gebruik deze flow niet als je namens een specifieke gebruiker gevoelige data nodig hebt. Die scenario’s vragen om een gewone authorization code flow, interactief, met duidelijke toestemming. Check steeds wat de provider toelaat en vereist.

API-fouten, afwijzingen of uitval zijn normaal. De API kan een request weigeren, scopes kunnen ontbreken, of de dienst ligt er even uit. Vraag niet eindeloos nieuwe tokens aan na een foutmelding: na een echte weigering hoort jouw koppeling stilgelegd te worden tot je nieuwe toestemming hebt. Gebruik beperkte retries met wachttijd en maak onderscheid tussen herstelbare en niet-herstelbare situaties.

Bewaar alleen wat echt nodig is na een API-call. Een geldig token is geen reden om vergaarde data permanent op te slaan. Leg vast: hoe lang bewaar je data van een externe dienst, wie mag daarbij, en hoe wordt alles verwijderd na beëindiging van de koppeling? Test samenwerkingen in aparte omgevingen per fase, en monitor alleen het nodige als status, latency en foutklasse. Bewaar dus nergens tokens of volledige headers met gevoelige info.