Sollte ich JWT oder OAuth nutzen?

Für die meisten: OAuth. JWT wenn du Stateless brauchst.

Wie checke ich meine API auf Vulnerabilities?

Mit Tools wie Burp Suite, Postman, oder OWASP ZAP.

Sollte ich API-Keys in der URL haben?

Nein, immer im Authorization Header.

IT-Sicherheit

API Security – Wie du deine REST API absicherst

Kevin KrögerIT-Sicherheit

APIs sind ein großes Ziel für Hacker. Eine unsichere API kann bedeuten: Alle deine Daten sind weg. Alle deine Funktionen können manipuliert werden. Wir zeigen, wie du APIs sicher machst.

Die Grundlagen: Authentication

Jede API braucht Authentication. Benutzer / Services müssen sich identifizieren. API Keys: Die einfachste Methode. Der Client bekommt einen Key und sendet ihn mit jeder Request: ``` GET /api/users Authorization: Bearer sk_live_abc123def456 ``` Pro: Einfach. Con: Wenn der Key geleakt wird, ist alles kompromittiert. OAuth 2.0: Der Standard für moderne APIs. Der User loggt sich bei einem Identity Provider ein (Google, GitHub, etc.) und bekommt einen Token. Pro: Sicher, da der User sein Passwort nicht direkt shared. Con: Komplexer zu implementieren. JWT (JSON Web Tokens): Ein Token mit signierter Information: ``` Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9... ``` Pro: Stateless (du brauchst keine Session DB). Con: Wenn der Key geleakt wird, ist der Token nicht stoppbar. Für die meisten: JWT oder OAuth 2.0.

Authorization: Kann dieser User das tun?

Nach Authentication kommt Authorization. Nur weil ein User sich identified hat, bedeutet das nicht, dass er alle Daten sehen kann. ```python @app.route('/api/users/<user_id>') def get_user(user_id): current_user = get_current_user() # Authorization Check: if current_user.id != user_id and not current_user.is_admin: return {"error": "Forbidden"}, 403 return get_user_data(user_id) ```

Rate Limiting

Ohne Rate Limiting kann ein Attacker deine API mit Requests bombardieren (DDoS). Mit Rate Limiting limitierst du Requests pro IP oder User: ``` GET /api/search?q=test Response Headers: X-RateLimit-Limit: 100 X-RateLimit-Remaining: 99 X-RateLimit-Reset: 1234567890 ``` Wenn das Limit überschritten wird: 429 Too Many Requests.

CORS (Cross-Origin Resource Sharing)

Wenn deine API von einer anderen Domain called wird (z.B. von einem Frontend), brauchst du CORS-Headers: ``` Access-Control-Allow-Origin: https://frontend.example.com Access-Control-Allow-Methods: GET, POST, PUT, DELETE Access-Control-Allow-Headers: Authorization, Content-Type ``` Aber: Default zu "Allow Nothing". Sei explizit welche Origins erlaubt sind.

Input Validation

Auch APIs brauchen Input Validation. Lass mich nicht einfach beliebige Daten hochladen: ```python @app.route('/api/users', methods=['POST']) def create_user(): data = request.json # Validation: if not data.get('email') or '@' not in data['email']: return {"error": "Invalid email"}, 400 if len(data.get('password', '')) < 8: return {"error": "Password too short"}, 400 ```

HTTPS (TLS/SSL)

Immer HTTPS verwenden. Nie HTTP. Jede Request wird verschlüsselt. Das ist ein Muss. Kein Aber.

Versioning

Alte API-Versionen sollten deprecated werden. Aber: Gib Benutzern Zeit zu upgraden: ``` GET /api/v2/users Aber v1 wird noch supported für die nächsten 6 Monate. ```

Logging und Monitoring

Log alle API-Requests, speziell falsche. Monitore auf verdächtige Patterns: ```python logger.info(f"API Request: {method} {path} from {ip_address}") logger.warning(f"Authentication failed for user {username}") logger.error(f"Database error: {error}") ```

Gemeinsame API-Fehler

1. Zu viel Information in Error Messages: Gib nicht weg welches Feld falsch ist (kann brute force helfen) 2. No Rate Limiting: Attacker bombardiert deine API 3. Sensitive Data in Logs: Logge keine Passwörter oder Tokens 4. Version 1 nicht weggeworfen: Alte Versionen mit Vulnerabilities sind noch aktiv

Fazit

API Security ist nicht kompliziert. Authentication + Authorization + Rate Limiting + HTTPS + Logging = Sichere API. Das ist es.

Unsere Leistung