# Python/Flask-Backend

Fügen Sie einer Python-Flask-App die Anmeldung hinzu, mit der Bibliothek Authlib und dem Authorization Code Flow mit PKCE.

Diese Anleitung fügt einer Flask-App die OIDC-Anmeldung hinzu, mit [Authlib](https://docs.authlib.org/en/latest/client/flask.html), das Discovery, PKCE und Token-Validierung übernimmt. Sie geht von einem **Confidential Client** aus (einem Backend, das ein Secret geheim halten kann).

Falls Sie noch keine Anwendung registriert haben, siehe [Bevor Sie beginnen](https://dts-identity.com/de/docs/quickstarts.md#before-you-start). Zum zugrunde liegenden Protokoll siehe [OpenID Connect (Authorization Code + PKCE)](https://dts-identity.com/de/docs/quickstarts/oidc-authorization-code.md).

## 1. Abhängigkeiten installieren

```bash
pip install flask authlib requests
```

## 2. Client konfigurieren

```python
import os

from authlib.integrations.flask_client import OAuth
from flask import Flask, redirect, session, url_for

app = Flask(__name__)
app.secret_key = os.environ["SESSION_SECRET"]

oauth = OAuth(app)
oauth.register(
    "idp",
    client_id=os.environ["OIDC_CLIENT_ID"],
    client_secret=os.environ["OIDC_CLIENT_SECRET"],
    # Your instance's login domain (issuer). Authlib reads the discovery
    # document and configures all endpoints from it.
    server_metadata_url="https://<your-domain>/.well-known/openid-configuration",
    client_kwargs={
        "scope": "openid profile email offline_access",
        "code_challenge_method": "S256",  # send a PKCE challenge as well
    },
)
```

Halten Sie `OIDC_CLIENT_ID` und `OIDC_CLIENT_SECRET` in der Umgebung, niemals in der Versionsverwaltung.

## 3. Anmeldung starten

Authlib baut die Autorisierungs-URL mit einer PKCE-Challenge und einem `state`, merkt sich beides in der Session und leitet den Browser weiter:

```python
@app.route("/login")
def login():
    redirect_uri = url_for("callback", _external=True)  # e.g. https://app.example.com/callback
    return oauth.idp.authorize_redirect(redirect_uri)
```

Die `redirect_uri` muss exakt einem an der Anwendung registrierten Wert entsprechen.

## 4. Callback verarbeiten

Tauschen Sie den Code gegen Tokens. Authlib validiert die Antwort, den `state`, den PKCE-Verifier und das ID-Token.

```python
@app.route("/callback")
def callback():
    tokens = oauth.idp.authorize_access_token()

    claims = tokens["userinfo"]  # validated ID-token claims
    session["user"] = {"sub": claims["sub"], "name": claims.get("name"), "email": claims.get("email")}
    session["id_token"] = tokens["id_token"]

    # Optional: fetch additional claims from UserInfo
    # userinfo = oauth.idp.userinfo(token=tokens)

    return redirect("/")
```

## 5. Abmelden

Schicken Sie den Benutzer an den End-Session-Endpunkt und löschen Sie anschließend Ihre eigene Session.

```python
from urllib.parse import urlencode

@app.route("/logout")
def logout():
    metadata = oauth.idp.load_server_metadata()
    params = urlencode({
        "id_token_hint": session.get("id_token", ""),
        "post_logout_redirect_uri": "https://app.example.com/",
    })
    session.clear()
    return redirect(f"{metadata['end_session_endpoint']}?{params}")
```

Registrieren Sie `https://app.example.com/` als Post-Logout-Redirect-URI an der Anwendung, auf dieselbe Weise wie eine Redirect-URI.

## Fehlerbehebung

- **Der Discovery-Aufruf schlägt fehl.** Stellen Sie sicher, dass `https://<your-domain>/.well-known/openid-configuration` von Ihrem Server aus erreichbar ist und die Domain der Login-Host Ihrer Instanz ist.
- **`mismatching_state` beim Callback.** Die Session, die die Anmeldung gestartet hat, muss dieselbe sein, die den Callback verarbeitet. Stellen Sie sicher, dass Session-Cookies den Redirect überleben (korrektes `SameSite` und in Produktion `secure`-Cookies über HTTPS) und dass `secret_key` über alle Worker hinweg identisch ist; ein zufälliger Schlüssel pro Worker macht die Session bei jedem Redirect stillschweigend kaputt.
- **Es wird nie ein Refresh-Token zurückgegeben.** Nehmen Sie `offline_access` in den Scope auf und prüfen Sie, dass die Anwendung so konfiguriert ist, dass sie Refresh-Tokens erhält.

## Nächste Schritte

- [React-Single-Page-App](https://dts-identity.com/de/docs/quickstarts/react-spa.md) für einen reinen Browser-Client.
- [Eine API schützen](https://dts-identity.com/de/docs/quickstarts/protect-an-api.md), um Access Token in der eigenen Python-API zu validieren.
- [Anwendungen](https://dts-identity.com/de/docs/integrations/applications.md), um Token-Laufzeiten und weitere Client-Einstellungen zu prüfen.
