Het implementeren van aangepaste authenticatiemiddleware in Flask met JSON Web Tokens (JWT) vereist een gestructureerde aanpak voor veilige gebruikerssessiebeheer en toegangscontrole. Hieronder volgt een overzicht van hoe je dit kunt aanpakken, inclusief best practices: 1. Middleware-implementatie in Flask: - Gebruik een decorator of een before_request-handler om de JWT-token te controleren voor beveiligde routes. - Bijvoorbeeld: ```python from functools import wraps from flask import request, jsonify def jwt_required(f): @wraps(f) def decorated_function(*args, **kwargs): token = None # Zoek token in Authorization-header auth_header = request.headers.get('Authorization', None) if auth_header: parts = auth_header.split() if len(parts) == 2 and parts[0].lower() == 'bearer': token = parts[1] if not token: return jsonify({'message': 'Token ontbreekt'}), 401 try: # Verifieer en decodeer de token payload = jwt.decode(token, SECRET_KEY, algorithms=['HS256']) # Voeg gebruikersgegevens toe aan request context request.user = payload['user_id'] except jwt.ExpiredSignatureError: return jsonify({'message': 'Token is verlopen'}), 401 except jwt.InvalidTokenError: return jsonify({'message': 'Ongeldig token'}), 401 return f(*args, **kwargs) return decorated_function ``` 2. Gebruikerssessies beheren: - Bij succesvolle login genereer je een JWT met gebruikersinformatie en een vervaltijd (`exp` claim). - Bewaar geen sessiegegevens op de server; vertrouw op de JWT voor stateloze sessiebeheer. - Voor extra veiligheid kun je token-invalideringslijsten of zwarte lijsten implementeren indien nodig. 3. Veilige toegang tot routes: - Gebruik de `@jwt_required` decorator op alle routes die authenticatie vereisen. - Bijvoorbeeld: ```python @app.route('/beveiligd') @jwt_required def beveiligde_route(): return jsonify({'message': f'Welkom gebruiker {request.user}'}) ``` 4. Best practices voor sessie-integriteit en mislukte authenticatie: - Gebruik sterke geheime sleutels (`SECRET_KEY`) en veilige algoritmen zoals HS256. - Implementeer korte vervaltijden voor tokens en refresh tokens indien nodig. - Bij mislukte authenticatie: geef geen details prijs over waarom het misging; houd de respons algemeen. - Log mislukte pogingen voor auditdoeleinden. - Zorg voor HTTPS om token-diefstal te voorkomen. - Overweeg extra beveiligingsmaatregelen zoals IP-beperking of gebruikersagentcontrole. Kort samengevat: - Gebruik een decorator voor JWT-validatie. - Verifieer tokens bij elke beveiligde route. - Genereer en stuur JWT's bij login. - Behandel mislukte authenticaties met duidelijke, veilige foutmeldingen en log deze pogingen. - Behoud sessie-integriteit door sterke geheime sleutels, korte vervaltijden en veilige transportlagen. Op deze wijze zorg je voor een efficiënte, veilige en schaalbare gebruikersauthenticatie in je Flask-applicatie.

Hier is een gedetailleerde uitleg voor het implementeren van aangepaste JWT-authenticatiemiddleware in Flask: ## 1. Basis Middleware Structuur ```python from flask import Flask, request, jsonify, g from functools import wraps import jwt from datetime import datetime, timedelta import secrets app = Flask(__name__) app.config['SECRET_KEY'] = secrets.token_hex(32) # Gebruik een veilige secret key class AuthMiddleware: @staticmethod def generate_token(user_id, username, roles=[]): """Genereer JWT token voor gebruiker""" payload = { 'user_id': user_id, 'username': username, 'roles': roles, 'exp': datetime.utcnow() + timedelta(hours=24), # Token verloopt na 24 uur 'iat': datetime.utcnow() } return jwt.encode(payload, app.config['SECRET_KEY'], algorithm='HS256') @staticmethod def verify_token(token): """Verifieer JWT token""" try: payload = jwt.decode(token, app.config['SECRET_KEY'], algorithms=['HS256']) return payload except jwt.ExpiredSignatureError: return None # Token is verlopen except jwt.InvalidTokenError: return None # Ongeldig token ``` ## 2. Decorator voor Route Bescherming ```python def token_required(f): @wraps(f) def decorated(*args, **kwargs): token = None # Check voor token in headers if 'Authorization' in request.headers: auth_header = request.headers['Authorization'] if auth_header.startswith('Bearer '): token = auth_header.split(' ')[1] if not token: return jsonify({'message': 'Token is ontbreekt'}), 401 # Verifieer token payload = AuthMiddleware.verify_token(token) if not payload: return jsonify({'message': 'Ongeldig of verlopen token'}), 401 # Sla gebruiker op in Flask's g object voor toegang in routes g.user = payload return f(*args, **kwargs) return decorated def roles_required(*required_roles): def decorator(f): @wraps(f) @token_required def decorated(*args, **kwargs): user_roles = g.user.get('roles', []) # Check of gebruiker minstens één van de vereiste rollen heeft if not any(role in user_roles for role in required_roles): return jsonify({'message': 'Onvoldoende rechten'}), 403 return f(*args, **kwargs) return decorated return decorator ``` ## 3. Gebruik in Routes ```python @app.route('/login', methods=['POST']) def login(): data = request.get_json() username = data.get('username') password = data.get('password') # Verifieer gebruikerscredentials (vereenvoudigd voorbeeld) user = authenticate_user(username, password) if user: token = AuthMiddleware.generate_token( user_id=user['id'], username=user['username'], roles=user.get('roles', ['user']) ) return jsonify({ 'token': token, 'expires_in': 24 * 60 * 60 # 24 uur in seconden }) return jsonify({'message': 'Ongeldige credentials'}), 401 @app.route('/protected') @token_required def protected_route(): return jsonify({ 'message': 'Dit is een beschermde route', 'user': g.user['username'] }) @app.route('/admin') @roles_required('admin', 'moderator') def admin_route(): return jsonify({'message': 'Alleen toegankelijk voor admins/moderators'}) ``` ## 4. Sessie Beheer en Veiligheid ```python class SessionManager: def __init__(self): self.blacklisted_tokens = set() def blacklist_token(self, token): """Voeg token toe aan blacklist bij uitloggen""" self.blacklisted_tokens.add(token) def is_token_blacklisted(self, token): """Check of token geblacklist is""" return token in self.blacklisted_tokens # Uitgebreide token verificatie met blacklist check def enhanced_token_required(f): @wraps(f) def decorated(*args, **kwargs): token = None if 'Authorization' in request.headers: auth_header = request.headers['Authorization'] if auth_header.startswith('Bearer '): token = auth_header.split(' ')[1] if not token: return jsonify({'message': 'Token ontbreekt'}), 401 # Check blacklist if session_manager.is_token_blacklisted(token): return jsonify({'message': 'Token is ingetrokken'}), 401 payload = AuthMiddleware.verify_token(token) if not payload: return jsonify({'message': 'Ongeldig token'}), 401 g.user = payload return f(*args, **kwargs) return decorated @app.route('/logout', methods=['POST']) @token_required def logout(): token = request.headers['Authorization'].split(' ')[1] session_manager.blacklist_token(token) return jsonify({'message': 'Succesvol uitgelogd'}) ``` ## 5. Beste Praktijken en Beveiliging ```python # Configuratie voor extra veiligheid app.config.update( JWT_ALGORITHM='HS256', JWT_ACCESS_TOKEN_EXPIRES=timedelta(hours=1), # Kortere levensduur voor betere veiligheid JWT_REFRESH_TOKEN_EXPIRES=timedelta(days=7) # Refresh tokens voor langere sessies ) # Rate limiting voor authenticatie endpoints from flask_limiter import Limiter from flask_limiter.util import get_remote_address limiter = Limiter( app, key_func=get_remote_address, default_limits=["200 per day", "50 per hour"] ) @app.route('/login', methods=['POST']) @limiter.limit("5 per minute") # Max 5 login pogingen per minuut def login(): # Login implementatie... # Refresh token mechanisme @app.route('/refresh', methods=['POST']) @token_required def refresh_token(): current_user = g.user # Genereer nieuw token met dezelfde claims new_token = AuthMiddleware.generate_token( user_id=current_user['user_id'], username=current_user['username'], roles=current_user['roles'] ) return jsonify({'token': new_token}) ``` ## 6. Foutafhandeling ```python @app.errorhandler(401) def unauthorized(error): return jsonify({ 'message': 'Authenticatie vereist', 'error': 'unauthorized' }), 401 @app.errorhandler(403) def forbidden(error): return jsonify({ 'message': 'Onvoldoende rechten', 'error': 'forbidden' }), 403 # Globale exception handler voor JWT errors @app.errorhandler(jwt.InvalidTokenError) def handle_invalid_token(error): return jsonify({ 'message': 'Ongeldig token', 'error': 'invalid_token' }), 401 ``` ## Belangrijkste Beveiligingstips: 1. **Gebruik HTTPS** voor alle communicatie 2. **Korte token levensduur** (1-24 uur) 3. **Implementeer refresh tokens** voor langere sessies 4. **Blacklist ingetrokken tokens** 5. **Rate limiting** op login endpoints 6. **Veilige secret key** (minimaal 32 bytes) 7. **Valideer alle gebruikersinvoer** 8. **Log authenticatiepogingen** voor monitoring Deze implementatie biedt een robuuste authenticatielaag voor je Flask-applicatie met goede beveiliging en flexibiliteit voor verschillende gebruikersrollen.