Help me een uitgebreid JWT-beveiligingstrainingprogramma te maken voor mijn ontwikkelingsteam
description
Door een uitgebreid JWT-beveiligingstrainingprogramma te maken, zal je ontwikkelingsteam beter uitgerust zijn om veilige authenticatiemethoden te implementeren, kwetsbaarheden te verminderen en de algehele systeembeveiliging te verbeteren.
prompt
try_prompt
Ik wil een trainingsprogramma ontwerpen gericht op JWT-beveiligingsbest practices voor mijn ontwikkelingsteam. De belangrijkste onderwerpen die ik wil behandelen zijn: {{topics}}. Welke materialen, bronnen en praktische oefeningen kan ... more
generate_helper
...
ai_answers
provider: openai
model: gpt-4.1-nano
Hier is een gestructureerd trainingsprogramma gericht op JWT-beveiligingsbest practices, inclusief materialen, bronnen, praktische oefeningen en beoordelingsmethoden:
1. Introductie tot JWT en Beveiligingsrisico’s
- Materialen:
- Artikel: "JSON Web Tokens (JWT) Introduction and Security Best Practices" (bijvoorbeeld op Auth0 of OWASP)
- Video: Introductie tot JWT-beveiliging
- Doel: Begrip van wat JWT is, veelvoorkomende beveiligingsproblemen en het belang van goede praktijken
2. Beste Praktijken voor Tokenlooptijden
- Materiaal:
- Documentatie van JWT-implementaties (bijv. RFC 7519, specifieke framework-documentatie)
- Artikel: "Setting Token Expiration Times for Security"
- Praktische oefeningen:
- Configureren van verschillende tokenlooptijden in een testomgeving
- Simuleren van tokenverlopen en hernieuwingsprocessen
- Tips:
- Gebruik korte expiratie voor gevoelige acties
- Implementeer refresh tokens voor langere sessies
3. Veilig Instellen van Token Claims en Handtekeningen
- Materiaal:
- Best practices voor claims (iss, aud, sub, exp)
- Documentatie over HMAC en RSA handtekeningen
- Praktische oefeningen:
- Implementeren van juiste claims
- Verifiëren van handtekeningen en claims in code
4. Beveiligingsmaatregelen en Implementatie
- Materiaal:
- OWASP JWT Security Cheat Sheet
- Artikel over veilige opslag van geheime sleutels
- Praktische oefeningen:
- Beveiligde opslag van geheime sleutels
- Implementatie van token invalidatie en blacklisting
5. Realistische Scenario’s en Best Practices
- Cases:
- Scenario’s waarbij tokens worden gestolen of vervalst
- Implementatie van extra beveiligingslagen zoals PKI
- Praktische oefeningen:
- Detectie van verdachte tokens
- Respons op beveiligingsincidenten
**Kennisbeoordeling en Toepassing:**
- **Korte Quizzen:** Na elke module enkele multiple-choice of open vragen om begrip te toetsen.
- **Code Review Sessies:** Laat teamleden JWT-implementaties beoordelen en verbeteren.
- **Praktijkproject:** Laat ze een klein project opzetten waarin ze JWT volgens de best practices gebruiken.
- **Scenario-gebaseerde Tests:** Simuleer beveiligingsincidenten en vraag hoe ze zouden reageren.
- **Feedback en Discussie:** Organiseer sessies waarin teamleden hun ervaringen delen en vragen stellen.
**Extra bronnen:**
- OWASP JWT Cheat Sheet: https://cheatsheetseries.owasp.org/cheatsheets/JSON_Web_Token_Cheat_Sheet.html
- Auth0 JWT Best Practices: https://auth0.com/docs/security/tokens/json-web-tokens
- RFC 7519 (JWT standaard): https://tools.ietf.org/html/rfc7519
Door deze combinatie van theorie, praktische oefeningen en evaluaties zorg je ervoor dat je team niet alleen de kennis opdoet, maar deze ook effectief kan toepassen in de praktijk.
provider: deepseek
model: deepseek-chat
Zeker, hier is een gedetailleerd trainingsprogramma voor JWT-beveiligingsbest practices in het Nederlands:
### **JWT Beveiligingstraining: Programma-overzicht**
**Doelstelling:** Het ontwikkelteam equipen met de kennis en vaardigheden om JWT's op een veilige, robuuste manier te implementeren, met focus op praktische toepassing en reële scenario's.
---
### **Kernmodule 1: JWT Fundamenten & Looptijden (Token Expiry)**
**Theorie:**
1. **Wat is een JWT?** Opfrisser: structuur (header, payload, signature), hoe signing/verificatie werkt.
2. **Waarom Looptijden Cruciaal Zijn:** Het beperken van het aanvalsvenster. Een token dat nooit verloopt is een permanent toegangsticket voor een aanvaller.
3. **Soorten Tokens en hun Looptijden:**
* **Access Token:** Korte levensduur (**bijv. 5 - 15 minuten**). Dit is de belangrijkste beveiligingsmaatregel. Leg uit dat dit de "blast radius" beperkt bij diefstal.
* **Refresh Token:** Langere levensduur (**bijv. 7 dagen, 30 dagen**), maar opgeslagen veilig (HTTP-only Cookie) en onderhevig aan intrekking (meer hierover later).
**Beste Praktijken voor Looptijden:**
* **Gebruik korte Access Token looptijden.** Stel een maximum in van 15 minuten voor hoogwaardige applicaties.
* **Implementeer een Refresh Token flow.** Dit biedt een goede gebruikerservaring zonder in te leveren op veiligheid.
* **Vermijd te lange Refresh Token looptijden.** Overweeg een "Remember Me" functionaliteit voor langere sessies, in plaats van alle refresh tokens extreem lang geldig te houden.
* **Stel de `exp` (expiration) claim altijd in.** Vertrouw niet alleen op andere mechanismen.
**Materialen & Bronnen:**
* **Leesmateriaal:** [JWT.io Introduction](https://jwt.io/introduction) (gebruik de vertaler van je browser indien nodig).
* **Artikel:** ["Stop using JWT for sessions"](http://cryto.net/~joepie91/blog/2016/06/13/stop-using-jwt-for-sessions/) (als discussiestuk over de valkuilen).
* **Handige Tool:** [JWT.io Debugger](https://jwt.io/) om tokens live te decoderen en te inspecteren.
**Praktische Oefening:**
* **Oefening:** Laat het team een eenvoudige login-API bouwen (bijv. met Node.js/Express of Python/Flask) die twee endpoints heeft:
1. `/login`: Retourneert een JWT Access Token (geldig 5 minuten) en een Refresh Token (opgeslagen in een database, gekoppeld aan de gebruiker en geldig 24 uur).
2. `/refresh`: Accepteert een geldige Refresh Token en geeft een *nieuw* Access Token terug.
---
### **Kernmodule 2: Veilige Implementatie & Opslag**
**Theorie:**
1. **Token Opslag aan Client-side:**
* **Access Token:** Opslaan in **geheugen** (bijv. JavaScript variabele/state) is het veiligst. Als opslag nodig is, gebruik dan `sessionStorage` (vervalt bij tab sluiten).
* **Vermijd `localStorage`.** Dit is gevoelig voor XSS-aanvallen.
* **Refresh Token:** Stuur deze altijd terug in een **HTTP-only, Secure, SameSite=Strict Cookie**. Dit beschermt tegen XSS.
2. **Signeren en Verifiëren:**
* **Gebruik een sterk algoritme:** **RS256** (asymmetrisch) verdient de voorkeur boven HS256 (symmetrisch). Hierbij heeft alleen de auth-server de private key om te signeren, terwijl resource-servers alleen de publieke key nodig hebben om te verifiëren.
* **Houd je private key VEILIG!** Nooit in code of repositories.
**Materialen & Bronnen:**
* **Handleiding:** [OWASP JWT Cheat Sheet](https://cheatsheetseries.owasp.org/cheatsheets/JSON_Web_Token_for_Java_Cheat_Sheet.html) (de concepten zijn universeel).
* **Video:** Een tutorial over het genereren van RSA-sleutelparen.
**Praktische Oefening:**
* **Oefening:** Pas de login-API aan van Module 1.
* Genereer een RSA-sleutelpaar. Laat de teamleden de JWT signeren met de private key en verifiëren met de publieke key in een andere "mock" resource-server.
* Implementeer de Refresh Token als een HTTP-only cookie.
---
### **Kernmodule 3: Gevorderde Beveiligingsmechanismen**
**Theorie:**
1. **Token Intrekking (Revocation):**
* **Waarom?** Een gestolen Refresh Token moet ongeldig gemaakt kunnen worden.
* **Hoe?** Door een "blocklist" (meestal in de database of cache) bij te houden van ingetrokken Refresh Token IDs (`jti` claim) of gebruikers die zijn uitgelogd vóór de expiratie van hun token.
2. **Beveiligingsclaims in de Payload:**
* **`iss` (Issuer):** Wie heeft het token uitgegeven?
* **`aud` (Audience):** Voor wie is het token bedoeld?
* **`jti` (JWT ID):** Unieke identifier voor het token, essentieel voor intrekking.
* Controleer deze claims altijd op de resource-server!
**Praktische Oefening:**
* **Oefening:** Breid de API verder uit.
* Voeg een `jti` claim toe aan elke Refresh Token en sla deze op in de database.
* Maak een `/logout` endpoint dat de bijbehorende Refresh Token invalideert in de database.
* Pas de `/refresh` endpoint aan zodat het alleen werkt met een Refresh Token dat niet in de "blocklist" staat.
---
### **Kennisassessie & Toepassing in de Praktijk**
**1. Theoretische Toets (Voor en Na):**
* **Pre-training Quiz:** Een korte multiple-choice quiz over JWT-basisprincipes en veelgemaakte fouten. Dit meet de beginsituatie.
* **Post-training Quiz:** Dezelfde of vergelijkbare quiz om de vooruitgang in theoretische kennis te meten.
**2. "Capture The Flag" (CTF) - Praktische Beoordeling:**
Dit is de belangrijkste beoordeling. Creëer een eenvoudige, opzettelijk kwetsbare applicatie (bijv. een "Secure Notes" app) en geef het team de opdracht om deze te beveiligen en bepaalde "flags" te vinden.
* **Scenario's (Flags):**
* **Flag 1 - Zwakke Signatuur:** De app gebruikt het geheim "geheim". Vind de key en genereer een admin-token.
* **Flag 2 - Geen Expiratie:** Een token verloopt nooit. Maak een token aan en gebruik het oneindig.
* **Flag 3 - Algoritme Omwisseling:** De app accepteert het 'none' algoritme. Omzeil de signatuur.
* **Flag 4 - Onveilige Opslag:** De Access Token is opgeslagen in `localStorage`. Steel hem via een geïnjecteerd script (simulatie van XSS).
* **Flag 5 - Geen Intrekking:** Log uit, maar gebruik de oude Refresh Token nog steeds om een nieuw Access Token aan te vragen.
Het team moet de kwetsbaarheden identificeren, de bijbehorende flag "vangen", en **de code repareren** om de kwetsbaarheid te dichten.
**3. Code Review Sessie:**
* **Oefening:** Laat teamleden in paren elkaars code reviewen van de praktische oefeningen. Geef ze een checklist met criteria:
* [ ] Zijn de token looptijden kort?
* [ ] Worden refresh tokens veilig opgeslagen (HTTP-only cookie)?
* [ ] Wordt er gecontroleerd op de `exp`, `iss`, `aud` claims?
* [ ] Is er een mechanisme voor intrekking?
* [ ] Wordt een sterk signatuuralgoritme gebruikt (RS256)?
**4. Real-World Scenario Rollenspel:**
* **Oefening:** Verdeel de rollen: "Aanvaller" en "Verdediger".
* De "Aanvaller" probeert een van de kwetsbaarheden uit de CTF uit te buiten in een live demo-omgeving.
* De "Verdediger" moet de aanval detecteren (door logs te controleren, foutmeldingen te analyseren) en uitleggen welk beveiligingsmechanisme faalde en hoe het had moeten worden voorkomen.
### **Aanvullende Tips voor Succes**
* **Tooling:** Introduceer tools zoals [`jsonwebtoken`](https://github.com/auth0/node-jsonwebtoken) voor Node.js of [`PyJWT`](https://pyjwt.readthedocs.io/) voor Python, en bespreek hun veilige configuratie.
* **Beveiliging door de Stack:** Benadruk dat JWT-beveiliging slechts één onderdeel is. Het moet worden aangevuld met andere praktijken zoals HTTPS overal, input validatie, en CORS-beleid.
* **Herhaling:** Plan over 3-6 maanden een korte "opfris"-sessie om de concepten levend te houden en nieuwe bedreigingen te bespreken.
Met dit programma leg je een sterke basis, test je de kennis op een praktische manier en zorg je ervoor dat je team de theorie kan vertalen naar veiligere code. Veel succes!

