Seminar Flask Intensivseminar – APIs, Authentifizierung und Sicherheit

Dieses Intensivformat bündelt die Spezialthemen API-Entwicklung, Benutzeridentität, Autorisierung, Anwendungssicherheit und dienstübergreifende Integration. Es richtet sich an Teams, die in einer Woche einen zusammenhängenden Sicherheits- und Schnittstellenpfad erarbeiten müssen.

Die Inhalte werden bewusst verdichtet: vom Ressourcenvertrag über OpenAPI und Zugriffsschutz bis zu Bedrohungsmodell, Microservice-Kommunikation und Vertragstests. Alle Schutzmaßnahmen werden als überprüfbare Regeln umgesetzt.

Inhaltsübersicht

1. Ressourcenmodell und HTTP-Semantik
2. JSON-Validierung und Serialisierung
3. Fehlerformat, Versionierung und Kompatibilität
4. OpenAPI-Beschreibung und Schnittstellendokumentation
5. API-Authentifizierung, Autorisierung und Missbrauchsschutz
6. Benutzerkonten, Kennwörter und Anmeldung
7. Sitzungsverwaltung und Kontosicherheit
8. Rollen, Rechte und Autorisierungsregeln
9. Externe Identitätsanbieter und OpenID Connect
10. Authentifizierungs- und Autorisierungstests
11. Bedrohungsmodell und Sicherheitsgrenzen
12. Eingaben, Ausgaben und Injection-Schutz
13. CSRF, Cookies und Sitzungsabsicherung
14. Sicherheitsheader und Ressourcenbegrenzung
15. Secrets, Abhängigkeiten und sichere Bereitstellung
16. Servicegrenzen und API-Verträge
17. Synchrone Kommunikation und Resilienz
18. Ereignisse, Konsistenz und Nachrichtenverarbeitung
19. Identität und Berechtigungen über Dienstgrenzen
20. Retries, Idempotenz und Fehlerpfade
21. Verteilte Nachvollziehbarkeit und Betrieb
22. API-, Vertrags- und Integrationstests
23. Sicherheitstests und Härtungsprüfung
24. Praxisprojekt und Wissenssicherung

Lernziele

• APIs als stabile, dokumentierte Verträge entwickeln.
• Benutzer-, Sitzungs- und Tokenverfahren sicher integrieren.
• Rollen, Ressourcenrechte und Mandantengrenzen durchsetzen.
• Anwendungs- und API-Angriffsflächen systematisch härten.
• Servicekommunikation, Ereignisse und verteilte Identität absichern.
• Verträge und Sicherheitsannahmen automatisiert prüfen.

Zielgruppe

Erfahrene Flask- und Backend-Entwickler, Architekten, Integrations- und Security-Teams mit Verantwortung für öffentliche oder interne Schnittstellen.

Voraussetzungen

Sehr gute Python- und Flask-Kenntnisse, sichere HTTP-Grundlagen sowie Erfahrung mit Datenbanken und automatisierten Tests.

Seminarinhalte

1. Ressourcenmodell und HTTP-Semantik

API-Endpunkte werden aus fachlichen Ressourcen und stabilen HTTP-Kontrakten abgeleitet.

1. Schritt 1: Ressourcen, Identitäten und Beziehungen aus Anwendungsfällen bestimmen.
2. Schritt 2: Methoden, Statuscodes und Idempotenz pro Operation festlegen.
3. Schritt 3: Filter, Sortierung, Pagination und Feldselektion konsistent definieren.
4. Schritt 4: Beispielrequests und -responses als überprüfbare Verträge formulieren.

2. JSON-Validierung und Serialisierung

Eingaben und Ausgaben werden über explizite Schemas kontrolliert, damit interne Modelle nicht ungefiltert nach außen gelangen.

1. Schritt 1: Content-Type und JSON-Struktur vor fachlicher Verarbeitung prüfen.
2. Schritt 2: Pflichtfelder, Typen, Formate und verschachtelte Objekte in Schemas festlegen.
3. Schritt 3: Eingabe-, Domänen- und Ausgabemodelle voneinander trennen.
4. Schritt 4: Unbekannte Felder, Nullwerte und Versionsunterschiede automatisiert testen.

3. Fehlerformat, Versionierung und Kompatibilität

Fehlerantworten und Änderungsregeln werden als Teil des öffentlichen API-Vertrags behandelt.

1. Schritt 1: Einheitliches Fehlerobjekt mit Code, Meldung, Details und Korrelationskennung definieren.
2. Schritt 2: Validierungs-, Authentifizierungs-, Konflikt- und Serverfehler eindeutig abbilden.
3. Schritt 3: Versionierungsstrategie für Pfad, Header oder Medienformat anhand der Produktanforderungen wählen.
4. Schritt 4: Abwärtskompatibilität und Deprecation-Verhalten mit Vertragstests absichern.

4. OpenAPI-Beschreibung und Schnittstellendokumentation

Die maschinenlesbare Beschreibung wird aus realen Verträgen aufgebaut und gegen die Implementierung geprüft.

1. Schritt 1: Operationen, Parameter, Schemas und Antwortvarianten vollständig modellieren.
2. Schritt 2: Sicherheitsverfahren, Beispiele und Fehlerobjekte in der Spezifikation ergänzen.
3. Schritt 3: Dokumentation aus der Spezifikation bereitstellen, ohne interne Verwaltungsendpunkte offenzulegen.
4. Schritt 4: Spezifikation linten und Abweichungen zur Laufzeit in der CI erkennen.

5. API-Authentifizierung, Autorisierung und Missbrauchsschutz

Zugriffsschutz wird pro Ressource und Operation durchgesetzt und gegen automatisierten Missbrauch ergänzt.

1. Schritt 1: Sitzungs-, Token- und föderierte Verfahren nach Clienttyp auswählen.
2. Schritt 2: Berechtigungen in Services prüfen und nicht allein auf ausgeblendete Routen vertrauen.
3. Schritt 3: Ratenbegrenzung, Größenlimits und Schutz vor wiederholten Fehlversuchen planen.
4. Schritt 4: Fehlende, abgelaufene und manipulierte Zugangsdaten mit Negativtests prüfen.

6. Benutzerkonten, Kennwörter und Anmeldung

Lokale Konten werden mit sicheren Kennwortableitungen, eindeutigen Identitäten und kontrollierten Fehlversuchen verwaltet.

1. Schritt 1: Benutzeridentität, Status und eindeutige Anmeldeattribute modellieren.
2. Schritt 2: Kennwörter ausschließlich mit geeigneter Hashfunktion und individuellen Salts speichern.
3. Schritt 3: Login, Logout und generische Fehlermeldungen ohne Benutzererkennung umsetzen.
4. Schritt 4: Fehlversuche, deaktivierte Konten und Kennwortänderung mit Tests abdecken.

7. Sitzungsverwaltung und Kontosicherheit

Anmeldesitzungen werden erneuert, begrenzt und bei sicherheitsrelevanten Änderungen widerrufen.

1. Schritt 1: Sitzungskennung beim Login wechseln und alte Daten vollständig entfernen.
2. Schritt 2: Absolute und inaktive Ablaufzeit sowie Remember-me-Verhalten festlegen.
3. Schritt 3: Cookie-Schutzattribute, HTTPS-Pflicht und erneute Authentifizierung für kritische Aktionen konfigurieren.
4. Schritt 4: Session-Fixation, Replay und parallele Sitzungen in Sicherheitstests prüfen.

8. Rollen, Rechte und Autorisierungsregeln

Zugriffsentscheidungen werden zentral, testbar und unabhängig von der Darstellung getroffen.

1. Schritt 1: Rollen, Rechte und Ressourcenaktionen aus Fachanforderungen ableiten.
2. Schritt 2: Autorisierung als Service oder Policy statt verteilter If-Abfragen implementieren.
3. Schritt 3: Mandanten- und Eigentumsprüfungen zusätzlich zu globalen Rollen berücksichtigen.
4. Schritt 4: Positiv- und Negativmatrix aller kritischen Aktionen automatisiert testen.

9. Externe Identitätsanbieter und OpenID Connect

Föderierte Anmeldung wird mit klarer Vertrauensgrenze, sicherer Rückleitung und kontrollierter Kontozuordnung integriert.

1. Schritt 1: Client, Redirect-URI, Scopes und Vertrauenswürdigkeit des Providers konfigurieren.
2. Schritt 2: State, Nonce und PKCE entsprechend dem verwendeten Flow einsetzen.
3. Schritt 3: Externe Claims auf interne Identität und Berechtigungen abbilden.
4. Schritt 4: Abgelaufene Tokens, Providerausfall und geänderte Kontenbindung testen.

10. Authentifizierungs- und Autorisierungstests

Sicherheitskritische Zustandsübergänge und Berechtigungsgrenzen werden systematisch als Negativfälle geprüft.

1. Schritt 1: Fixtures für anonyme, aktive, gesperrte und unterschiedlich berechtigte Konten anlegen.
2. Schritt 2: Login, Logout, Ablauf, Kennwortwechsel und Sitzungswiderruf testen.
3. Schritt 3: Direkte URL-Aufrufe und manipulierte Objektkennungen gegen Berechtigungslecks prüfen.
4. Schritt 4: Testmatrix in die kontinuierliche Integration aufnehmen und bei Regeländerungen aktualisieren.

11. Bedrohungsmodell und Sicherheitsgrenzen

Schutzmaßnahmen werden aus Datenwert, Angreifern, Eintrittspunkten und Vertrauensgrenzen abgeleitet.

1. Schritt 1: Schützenswerte Daten, Funktionen und Betriebsgeheimnisse inventarisieren.
2. Schritt 2: Browser, API, Proxy, Datenbank, Queue und Fremdsysteme als Vertrauensgrenzen markieren.
3. Schritt 3: Missbrauchsfälle für Identität, Eingaben, Dateien und Ressourcenverbrauch priorisieren.
4. Schritt 4: Maßnahmen, verbleibendes Risiko und Prüfnachweis in einer Sicherheitsmatrix festhalten.

12. Eingaben, Ausgaben und Injection-Schutz

Alle externen Daten werden validiert und kontextgerecht kodiert, bevor sie Datenbank, Template oder Betriebssystem erreichen.

1. Schritt 1: Eingabegrenzen für Länge, Typ, Format und Anzahl zentral setzen.
2. Schritt 2: Parametrisierte Datenbankzugriffe und ORM statt zusammengesetzter SQL-Zeichenketten verwenden.
3. Schritt 3: Jinja-Autoescaping beibehalten und sichere Markierung nur für kontrollierte Inhalte einsetzen.
4. Schritt 4: XSS-, SQL-Injection-, Pfad- und Header-Manipulation mit Negativtests prüfen.

13. CSRF, Cookies und Sitzungsabsicherung

Browserbasierte Zustandsänderungen und Sitzungen werden gegen fremde Ursprünge und Diebstahl geschützt.

1. Schritt 1: CSRF-Schutz für alle cookieauthentifizierten verändernden Requests aktivieren.
2. Schritt 2: Secure, HttpOnly, SameSite und kurze Lebensdauer für Sitzungscookies konfigurieren.
3. Schritt 3: Session-Fixation durch Erneuerung und session.clear bei Identitätswechsel verhindern.
4. Schritt 4: Cross-Site- und Replay-Szenarien mit realistischen Requests testen.

14. Sicherheitsheader und Ressourcenbegrenzung

Browserkontrollen und Request-Limits werden als Teil der Produktionskonfiguration umgesetzt.

1. Schritt 1: HSTS, Content Security Policy, X-Content-Type-Options und Frame-Schutz festlegen.
2. Schritt 2: MAX_CONTENT_LENGTH sowie Formulargrößen und Teilezahl begrenzen.
3. Schritt 3: Host- und Proxy-Vertrauen gegen Header-Spoofing absichern.
4. Schritt 4: Große Requests, viele Formularfelder und unerwartete Hosts unter Last testen.

15. Secrets, Abhängigkeiten und sichere Bereitstellung

Sicherheitsniveau umfasst Quellcode, Pakete, Konfiguration und Betriebsweg gemeinsam.

1. Schritt 1: Secrets aus Repository und Image entfernen und Rotation vorbereiten.
2. Schritt 2: Abhängigkeiten sperren, regelmäßig prüfen und Sicherheitsupdates priorisiert einspielen.
3. Schritt 3: Debug-Modus und Entwicklungsserver in Produktion technisch ausschließen.
4. Schritt 4: Build-Artefakt, Konfiguration und Laufzeitrechte in der CI kontrollieren.

16. Servicegrenzen und API-Verträge

Ein Microservice wird nur dort gebildet, wo fachliche Autonomie und unabhängiger Betrieb den Zusatzaufwand rechtfertigen.

1. Schritt 1: Domänenfähigkeiten, Datenverantwortung und Änderungsrhythmus analysieren.
2. Schritt 2: Schnittstellen und Eigentümerschaft vor der technischen Zerlegung festlegen.
3. Schritt 3: Synchrone und asynchrone Verträge mit klaren Fehler- und Zeitregeln definieren.
4. Schritt 4: Grenzen durch Vertragstests und unabhängige Deploymentfähigkeit überprüfen.

17. Synchrone Kommunikation und Resilienz

HTTP-Aufrufe zwischen Diensten werden mit Timeouts, begrenzten Wiederholungen und klaren Fehlerbildern umgesetzt.

1. Schritt 1: Client mit expliziten Verbindungs- und Antwortzeitlimits konfigurieren.
2. Schritt 2: Nur sichere beziehungsweise idempotente Operationen kontrolliert wiederholen.
3. Schritt 3: Circuit-Breaker-, Bulkhead- und Fallback-Strategien nach Kritikalität bewerten.
4. Schritt 4: Langsame, fehlerhafte und nicht erreichbare Partnerdienste in Tests simulieren.

18. Ereignisse, Konsistenz und Nachrichtenverarbeitung

Asynchrone Integration wird mit eindeutigen Ereignissen, Idempotenz und nachvollziehbarer Zustandsfortschreibung aufgebaut.

1. Schritt 1: Ereignisname, Version, Schlüssel und unveränderliche Nutzdaten definieren.
2. Schritt 2: Outbox- oder vergleichbares Muster für zuverlässige Veröffentlichung einsetzen.
3. Schritt 3: Konsumenten idempotent gestalten und Reihenfolgeanforderungen explizit machen.
4. Schritt 4: Duplikate, verspätete Ereignisse und Schemaentwicklung testen.

19. Identität und Berechtigungen über Dienstgrenzen

Authentifizierungsnachweise werden validiert, während fachliche Autorisierung beim zuständigen Dienst verbleibt.

1. Schritt 1: Vertrauenswürdigen Token-Aussteller und Schlüsselrotation konfigurieren.
2. Schritt 2: Audience, Issuer, Ablauf und Signatur bei jedem Dienst prüfen.
3. Schritt 3: Benutzer-, Dienst- und Mandantenidentität eindeutig trennen.
4. Schritt 4: Tokenmissbrauch, fehlende Scopes und widerrufene Konten in Integrationstests abdecken.

20. Retries, Idempotenz und Fehlerpfade

Wiederholungen werden gezielt auf vorübergehende Fehler begrenzt und verursachen keine doppelten Seiteneffekte.

1. Schritt 1: Temporäre, dauerhafte und fachliche Fehler in getrennte Kategorien einordnen.
2. Schritt 2: Exponentielles Backoff, Jitter und maximale Versuche konfigurieren.
3. Schritt 3: Idempotenzschlüssel oder Zustandsprüfungen für verändernde Tasks implementieren.
4. Schritt 4: Doppelte Zustellung, Workerabbruch und erschöpfte Retries automatisiert prüfen.

21. Verteilte Nachvollziehbarkeit und Betrieb

Logs, Metriken und Traces werden über Prozess- und Dienstgrenzen hinweg korreliert.

1. Schritt 1: Korrelations- und Trace-Kontext bei eingehenden und ausgehenden Aufrufen übernehmen.
2. Schritt 2: Dienstname, Version und Deploymentkennung als Telemetrieattribute ergänzen.
3. Schritt 3: Service-Level-Indikatoren pro Vertrag und Nutzerpfad definieren.
4. Schritt 4: Fehlerkette in einer simulierten Störung vom Gateway bis zur Datenbank nachvollziehen.

22. API-, Vertrags- und Integrationstests

Schnittstellen werden gegen Statuscodes, Schemas, Nebenwirkungen und Kompatibilitätsregeln getestet.

1. Schritt 1: Test-Client mit wiederverwendbaren Authentifizierungs- und Daten-Fixtures konfigurieren.
2. Schritt 2: Erfolgs-, Validierungs-, Konflikt- und Berechtigungsfälle tabellarisch abdecken.
3. Schritt 3: Response-Schemas und OpenAPI-Beispiele automatisiert vergleichen.
4. Schritt 4: Datenbank-, Queue- und Fremdsystemintegrationen in getrennten Teststufen prüfen.

23. Sicherheitstests und Härtungsprüfung

Die wichtigsten Schutzannahmen werden als wiederholbare Tests und Betriebschecks festgehalten.

1. Schritt 1: Negativtests für Authentifizierung, Autorisierung, CSRF und Eingabegrenzen erstellen.
2. Schritt 2: Sicherheitsheader, Cookie-Attribute und Fehlerausgaben automatisiert prüfen.
3. Schritt 3: Abhängigkeits- und statische Analyse in die CI integrieren.
4. Schritt 4: Härtungscheckliste vor Veröffentlichung und nach Infrastrukturänderungen ausführen.

Praxisprojekt

Eine geschützte Fach-API wird entworfen, dokumentiert und getestet. Ergänzend entstehen Login- und Rollenfunktionen, ein externer Identitätsfluss, eine Ereignisintegration sowie ein vollständiger Katalog aus Vertrags- und Sicherheitstests.

Methodik

Kurze fachliche Einordnungen wechseln mit Demonstrationen, geführten Umsetzungen, Fehleranalysen und eigenständigen Übungen. Jede größere Änderung wird durch einen Test, eine Diagnose oder eine betriebliche Prüfroutine abgesichert. Die Arbeitsstände werden schrittweise zu einem durchgängigen Beispielprojekt zusammengeführt.