Ontwerp een aangepaste OAuth 2.0 flow met specifieke scopes
description
Met deze prompt kan ik een op maat gemaakte OAuth 2.0 flow ontwerpen die specifiek afgestemd is op mijn API-vereisten. Het helpt me om duidelijke scopes te definiëren en te begrijpen hoe ik deze veilig kan toepassen, wat resulteert in betere toegangscontrole en beveiliging dan standaard implementaties.
prompt
Help me een OAuth 2.0 authenticatie flow te ontwerpen die gebruikmaakt van de volgende scopes: <geef de gewenste scopes op>. Beschrij ...
try_prompt
generate_helper
disclaimerOnPageApi
tags
ai_answers
provider: openai
model: gpt-4.1-nano
Natuurlijk! Hier is een overzicht van het ontwerpen van een OAuth 2.0 authenticatieflow met de scopes `read:user` en `write:data`, inclusief definities, toepassing en beveiligingsmaatregelen:
1. Scope-definitie:
- `read:user`: Toegang verlenen tot het lezen van gebruikersinformatie.
- `write:data`: Toegang toestaan tot het schrijven of wijzigen van data binnen de API.
2. Configuratie in OAuth-server:
- Registreer deze scopes bij je OAuth 2.0 autorisatieserver.
- Zorg dat de scopes duidelijk benoemd en beperkt blijven tot de noodzakelijke rechten.
3. Toepassing in de API-integratie:
- Bij het aanvragen van een toegangstoken via de OAuth 2.0 Authorization Code Flow:
- Vraag expliciet de scopes aan, bijvoorbeeld: `scope=read:user write:data`.
- Bij het verkrijgen van het access token:
- Zorg dat het token de juiste scopes bevat en dat de resource server deze controleert.
- In je API endpoints:
- Controleer het access token op de aanwezigheid van de juiste scopes voordat je de gevraagde acties toestaat.
4. Beveiligingsmaatregelen:
- Gebruik HTTPS voor alle communicatie om man-in-the-middle aanvallen te voorkomen.
- Implementeer token-validatie en controleer de scopes en vervaldatum van tokens.
- Beperk de levensduur van access tokens en gebruik refresh tokens indien nodig.
- Implementeer strikte client-authenticatie en registreer clients correct.
- Zorg voor logging en monitoring van toegangspogingen en gebruik van scopes.
- Overweeg het gebruik van PKCE (Proof Key for Code Exchange) bij public clients voor extra beveiliging.
Door deze stappen te volgen, definieer je duidelijk welke rechten gebruikers of clients krijgen, en zorg je voor een veilige en gecontroleerde API-integratie.
provider: deepseek
model: deepseek-chat
Zeker, hier is een ontwerp voor een OAuth 2.0-authenticatieflow met de gevraagde scopes, volledig in het Nederlands:
---
### **Ontwerp OAuth 2.0 Flow met Scopes `read:user` en `write:data`**
#### **1. Scope-definitie**
Definieer de scopes in je autorisatieserver (bijv. in configuratie of database):
- **`read:user`**: Toestemming om gebruikersgegevens (zoals profiel, e-mail) te lezen.
- **`write:data`**: Toestemming om gegevens namens de gebruiker te wijzigen of toe te voegen.
Voorbeeld (pseudo-configuratie):
```json
{
"scopes": {
"read:user": {
"description": "Leestoegang tot gebruikersgegevens"
},
"write:data": {
"description": "Schrijftoegang om gegevens te bewerken"
}
}
}
```
#### **2. Flow-stappen (Authorization Code Flow)**
1. **Autorisatieverzoek**:
- Redirect gebruiker naar autorisatie-endpoint met parameters:
```
/auth?client_id=JOUW_CLIENT_ID&redirect_uri=JOUW_REDIRECT_URI&response_type=code&scope=read:user+write:data
```
- Toon de gebruiker een consent-scherm met de gevraagde rechten.
2. **Tokenuitwisseling**:
- Na goedkeuring wissel de ontvangen `authorization_code` in voor een access token via het token-endpoint:
```
POST /token
Body: client_id=...&client_secret=...&code=...&grant_type=authorization_code
```
3. **API-toegang**:
- Gebruik het access token in API-requests via de `Authorization: Bearer <token>` header.
- Valideer het token en controleer scopes voor elke request.
#### **3. Scope-toepassing in API**
- **Endpoint-beveiliging**: Koppel endpoints aan vereiste scopes:
- `GET /user/profile` → Vereist `read:user`
- `POST /data/upload` → Vereist `write:data`
- **Implementatie**: Controleer scopes in middleware of autorisatielaag:
```python
# Voorbeeld (pseudocode)
if not token.has_scope("write:data"):
return HTTP_403_FORBIDDEN
```
#### **4. Kritieke Beveiligingsmaatregelen**
1. **HTTPS everywhere**: Gebruik TLS voor alle communicatie.
2. **Client Authenticatie**: Bewaar `client_secret` veilig (nooit in frontend).
3. **Token Validation**: Valideer JWT-signature, issuer (`iss`), audience (`aud`), en expiry.
4. **Scope Minimalisatie**: Vraag alleen noodzakelijke scopes aan (principle of least privilege).
5. **CSRF-bescherming**: Gebruik `state`-parameter in autorisatieverzoek.
6. **Token Storage**: Bewaar tokens veilig (bijv. httpOnly cookies of secure storage).
7. **Introspectie-endpoint**: Overweeg een token introspectie-endpoint voor validatie.
8. **Rate Limiting**: Beperk mislukte inlogpogingen en token-requests.
#### **5. Aanvullende Tips**
- Log alle autorisatiepogingen voor auditing.
- Implementeer token revocation (bijv. via refresh token invalidation).
- Overweeg PKCE (Proof Key for Code Exchange) voor extra beveiliging (met name voor native apps).
---
### **Voorbeeld Scope-check in Practice**
```python
# Middleware voor scope-validatie
def require_scope(scope):
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
token = get_token_from_request()
if scope not in token.scopes:
return {"error": "Onvoldoende rechten"}, 403
return func(*args, **kwargs)
return wrapper
return decorator
# Gebruik in API
@app.route("/data", methods=["POST"])
@require_scope("write:data")
def upload_data():
# Verwerk data
pass
```
Laat me weten als je specifieke details nodig hebt voor je techstack (bijv. Node.js, Spring, etc.)!