Het ontwerpen van een OAuth 2.0 authenticatie- en autorisatiestroom met automatische scope-toewijzing op basis van vooraf gedefinieerde API-toegangsniveaus vereist een gestructureerde aanpak. Hieronder beschrijf ik een stapsgewijze aanpak, inclusief definities, implementatie en best practices. 1. Definieer Toegangsniveaus en Scope-toewijzingen a. Toegangsniveaus: - Lezen (read): Toegang tot het ophalen van gegevens. - Schrijven (write): Toegang tot het wijzigen of toevoegen van gegevens. - Beheerder (admin): Volledige controle, inclusief het beheren van gebruikers en instellingen. b. Scope-toewijzingen: - Lezen = api.read - Schrijven = api.write - Beheerder = api.admin 2. Implementatie van de Structuur a. Scope-beheer: - Bewaar scope-definities in een centrale configuratie of database. - Koppel elke scope aan een specifiek toegangsniveau. b. Clientregistratie: - Bij registratie van clients (apps), definieer welke toegangsniveaus en scopes ze mogen verkrijgen. - Gebruik client- of gebruikersrollen om te bepalen welke scopes zij kunnen aanvragen. c. Authorization Server: - Tijdens het toestaan van autorisatie, ken automatisch scopes toe op basis van de toegangsniveaus die de gebruiker of client heeft. - Bij het verkrijgen van een access token, genereer het token met de relevante scopes. 3. Dynamische Scope Toewijzing a. Bij authenticatie: - Controleer de toegestane toegangsniveaus van de gebruiker of client. - Wijs automatisch de scopes toe die horen bij die niveaus. b. Tijdens token-issuance: - Voeg de scopes toe aan het access token op basis van het toegestane toegangsniveau. 4. Beveiliging en Scope-beperking a. Tokenvalidatie: - Valideer de access token bij elke API-aanroep. - Controleer de geldigheid, integriteit en scope-toegang. b. Scope-beperking op endpoints: - Configureer je API zodat elk endpoint alleen toegankelijk is voor tokens met de juiste scopes. - Bijvoorbeeld: - `/data/read` vereist `api.read` - `/data/write` vereist `api.write` - `/admin` vereist `api.admin` 5. Implementatievoorbeeld a. Scope-filtering in API: ```python def authorize_request(token_scopes, required_scope): if required_scope not in token_scopes: raise UnauthorizedError("Ontbrekende scope") ``` b. Scope toewijzing bij token-uitgifte: ```python def generate_access_token(user, client, user_levels): scopes = [] if 'lezen' in user_levels: scopes.append('api.read') if 'schrijven' in user_levels: scopes.append('api.write') if 'beheerder' in user_levels: scopes.append('api.admin') return create_token(scopes=scopes) ``` 6. Best Practices - **Centraliseer scope-beheer**: Houd scopes en toegangsniveaus in één centrale configuratie. - **Gebruik rollen en claims**: Koppel toegangsniveaus aan gebruikers- of clientrollen. - **Minimaliseer scopes**: Geef alleen de minimaal benodigde scopes aan clients/users. - **Automatiseer scope-toewijzing**: Gebruik scripts of policies om scopes dynamisch toe te wijzen op basis van rollen. - **Monitoring en auditing**: Log scope-gebruik en token-verificaties voor audits. - **Schaling**: Voeg geleidelijk nieuwe toegangsniveaus en scopes toe en test uitgebreid. Door deze structuur te implementeren, zorg je voor een flexibele, veilige en schaalbare manier om toegangsniveaus en scopes te beheren binnen je OAuth 2.0-infrastructuur.

Zeker, ik help je graag een OAuth 2.0-stroom te ontwerpen met automatische scope-toewijzing. Hier is een complete implementatiegids in het Nederlands. ## 1. Toegangsniveaus en Scope-Definitie ### Toegangsniveau Definitie ```json { "niveaus": { "lezen": { "scopes": ["api.read"], "beschrijving": "Alleen-lezen toegang tot API resources" }, "schrijven": { "scopes": ["api.read", "api.write"], "beschrijving": "Lezen en schrijven toegang" }, "beheerder": { "scopes": ["api.read", "api.write", "api.admin"], "beschrijving": "Volledige beheerdersrechten" } } } ``` ## 2. OAuth 2.0 Autorization Server Implementatie ### Scope Management Service ```javascript class ScopeManager { constructor() { this.niveauMapping = { 'lezen': ['api.read'], 'schrijven': ['api.read', 'api.write'], 'beheerder': ['api.read', 'api.write', 'api.admin'] }; } // Automatische scope-toewijzing op basis van toegangsniveau getScopesVoorNiveau(toegangsniveau) { return this.niveauMapping[toegangsniveau] || []; } // Valideer of gebruiker het gevraagde niveau mag hebben valideerToegangsniveau(gebruikerId, gevraagdNiveau) { // Implementeer je bedrijfslogica hier const gebruikerNiveau = this.getGebruikerNiveau(gebruikerId); return this.isNiveauToegestaan(gebruikerNiveau, gevraagdNiveau); } } ``` ### Token Endpoint Implementatie ```javascript app.post('/oauth/token', async (req, res) => { const { grant_type, toegangsniveau, client_id } = req.body; // Valideer client credentials const client = await validateClient(client_id); if (!client) return res.status(401).json({ error: 'invalid_client' }); // Automatische scope-toewijzing const scopeManager = new ScopeManager(); const scopes = scopeManager.getScopesVoorNiveau(toegangsniveau); // Genereer access token met automatisch toegewezen scopes const accessToken = await generateAccessToken({ client_id, scopes, toegangsniveau }); res.json({ access_token: accessToken, token_type: 'Bearer', expires_in: 3600, scope: scopes.join(' ') }); }); ``` ## 3. API Resource Server Implementatie ### Middleware voor Token Validatie en Scope Checks ```javascript const authenticateToken = (vereisteScopes = []) => { return async (req, res, next) => { const authHeader = req.headers['authorization']; const token = authHeader && authHeader.split(' ')[1]; if (!token) { return res.status(401).json({ error: 'Access token vereist' }); } try { // Token validatie const decoded = await verifyToken(token); req.user = decoded; // Scope validatie if (vereisteScopes.length > 0) { const heeftToegang = vereisteScopes.some(scope => decoded.scopes.includes(scope) ); if (!heeftToegang) { return res.status(403).json({ error: 'Onvoldoende rechten' }); } } next(); } catch (error) { return res.status(403).json({ error: 'Ongeldig token' }); } }; }; ``` ### Endpoint Beveiliging ```javascript // Alleen lezen endpoints app.get('/api/data', authenticateToken(['api.read']), (req, res) => { // Lees operaties }); // Schrijf endpoints app.post('/api/data', authenticateToken(['api.write']), (req, res) => { // Schrijf operaties }); // Beheerder endpoints app.delete('/api/data/:id', authenticateToken(['api.admin']), (req, res) => { // Beheerder-only operaties }); ``` ## 4. Dynamische Scope Management ### Database Schema voor Flexibel Beheer ```sql CREATE TABLE toegangsniveaus ( id SERIAL PRIMARY KEY, naam VARCHAR(50) UNIQUE NOT NULL, beschrijving TEXT ); CREATE TABLE scopes ( id SERIAL PRIMARY KEY, naam VARCHAR(100) UNIQUE NOT NULL, beschrijving TEXT ); CREATE TABLE niveau_scopes ( niveau_id INTEGER REFERENCES toegangsniveaus(id), scope_id INTEGER REFERENCES scopes(id), PRIMARY KEY (niveau_id, scope_id) ); CREATE TABLE gebruiker_niveaus ( gebruiker_id VARCHAR(255) NOT NULL, niveau_id INTEGER REFERENCES toegangsniveaus(id), PRIMARY KEY (gebruiker_id, niveau_id) ); ``` ## 5. Best Practices voor Implementatie ### 1. Security Best Practices - **Token Validatie**: Implementeer JWT signing met sterke algoritmes (RS256) - **Scope Minimalisatie**: Verleen altijd minimale benodigde scopes - **Token Expiratie**: Korte access token levensduur (max 1 uur) - **Refresh Tokens**: Gebruik voor langdurige sessies met propere revocation ### 2. Scope Management Schaalbaarheid ```javascript // Centrale scope registry voor schaalbaarheid class ScopeRegistry { constructor() { this.registry = new Map(); this.initialiseerStandaardScopes(); } initialiseerStandaardScopes() { this.registry.set('api.read', { beschrijving: 'Leestoegang API', endpoints: ['GET /api/*'], riskLevel: 'laag' }); this.registry.set('api.write', { beschrijving: 'Schrijftoegang API', endpoints: ['POST /api/*', 'PUT /api/*', 'PATCH /api/*'], riskLevel: 'medium' }); this.registry.set('api.admin', { beschrijving: 'Beheerdersrechten', endpoints: ['DELETE /api/*', 'POST /api/admin/*'], riskLevel: 'hoog' }); } // Dynamisch nieuwe scopes toevoegen registreerScope(naam, config) { this.registry.set(naam, config); } } ``` ### 3. Monitoring en Audit - **Log alle scope-toewijzingen** voor audit doeleinden - **Monitor ongebruikte scopes** voor opruiming - **Implementeer scope-usage analytics** om patronen te identificeren ### 4. Automatische Escalatie Preventie ```javascript class ToegangsControle { static preventEscalatie(huidigNiveau, gevraagdNiveau) { const niveauVolgorde = ['lezen', 'schrijven', 'beheerder']; const huidigIndex = niveauVolgorde.indexOf(huidigNiveau); const gevraagdIndex = niveauVolgorde.indexOf(gevraagdNiveau); // Voorkom dat gebruikers zichzelf hogere rechten kunnen geven return gevraagdIndex <= huidigIndex; } } ``` ## 6. Uitbreidingsmogelijkheden ### Conditionele Scopes ```javascript // Dynamische scope-toewijzing op basis van context const getConditioneleScopes = (gebruiker, context) => { const basisScopes = scopeManager.getScopesVoorNiveau(gebruiker.toegangsniveau); // Voeg conditionele scopes toe if (context.requireMfa && gebruiker.mfaEnabled) { basisScopes.push('api.mfa_verified'); } return basisScopes; }; ``` ### Scope Deprecation Strategy ```javascript // Gestructureerde scope deprecation class ScopeDeprecationManager { deprecateScope(scopeNaam, vervangendeScope, deprecationDatum) { // Markeer scope als deprecated // Stuur notificaties naar clients // Plan automatische migratie } } ``` Deze architectuur biedt een schaalbare, veilige basis voor OAuth 2.0 implementatie met automatische scope-toewijzing. Het centrale concept is dat toegangsniveaus als abstractie laag fungeren, waardoor je scopes centraal kunt beheren zonder client-configuraties te hoeven aanpassen.