Files
patrickandClaude Sonnet 5 a4d4119d55
CI / backend-tests (push) Successful in 3m57s
CI / frontend-build (push) Successful in 24s
feat(auth): FOUND-016 API-Token für Entwicklungs-/Tooling-Zugriff
Rollenbasiertes, langlebiges Token neben dem normalen JWT-Login-Flow -
für automatisierte Zugriffe/Skripte. Admin wählt bei Erzeugung eine oder
mehrere Rollen, Klartext wird einmalig gezeigt (wie ein Passwort), Token
ist jederzeit deaktivierbar/reaktivierbar.

Architektur: jedes Token bekommt einen Begleit-"Dienstkonto"-Benutzer
(Benutzer.ist_dienstkonto=True, kein echter Login), der die Rollen über
die bestehende benutzer_rolle-Tabelle trägt - dadurch funktionieren
require_roles()/require_permission() und alle Audit-FKs unverändert,
keine bestehende Endpunkt-Dependency musste angepasst werden.
get_current_user() erkennt ein Token am Präfix mabea_pat_ und löst es
über den Hash (SHA-256, kein bcrypt - Token ist bereits hochentropisch)
auf den Begleit-Benutzer auf. Dienstkonten sind aus GET /benutzer
ausgeblendet, damit sie keine Auswahl-Dropdowns verunreinigen.

Neuer Admin-Tab "API-Tokens" (Gruppe System, nur Administration).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01VDMvneg6wKfXdXvTYNd3dN
2026-09-17 01:23:21 +02:00

96 lines
3.5 KiB
Python

import secrets
import uuid
from datetime import datetime, timezone
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
from app.core.security import erzeuge_api_token, hash_password, hashe_api_token
from app.models.api_token import ApiToken
from app.models.auth import Benutzer, BenutzerRolle, RolleTyp
class ApiTokenNichtGefundenError(Exception):
pass
async def erstelle_token(
db: AsyncSession, *, name: str, rollen: list[RolleTyp], erstellt_von_benutzer_id: int
) -> tuple[ApiToken, str]:
"""FOUND-016: legt einen Begleit-Benutzer an (kein echter Login - Passwort
ist ein unverwendbarer Zufallswert, siehe Docstring ApiToken), der die
übergebenen Rollen über die bestehende benutzer_rolle-Tabelle trägt.
Gibt das Klartext-Token zusätzlich zurück - der Aufrufer (Endpoint) MUSS
es dem Admin einmalig zeigen, es ist danach nirgends mehr abrufbar."""
dienstkonto = Benutzer(
name=f"API-Token: {name}",
login=f"api-token:{uuid.uuid4()}",
passwort_hash=hash_password(secrets_urlsafe_unbenutzbar()),
aktiv=True,
ist_dienstkonto=True,
)
db.add(dienstkonto)
await db.flush()
for rolle in rollen:
db.add(BenutzerRolle(benutzer_id=dienstkonto.id, rolle=rolle))
klartext, token_hash = erzeuge_api_token()
token = ApiToken(
name=name,
token_hash=token_hash,
benutzer_id=dienstkonto.id,
aktiv=True,
erstellt_am=datetime.now(timezone.utc),
erstellt_von_benutzer_id=erstellt_von_benutzer_id,
)
db.add(token)
await db.flush()
return token, klartext
def secrets_urlsafe_unbenutzbar() -> str:
"""Eigene, benannte Hilfsfunktion statt `secrets.token_urlsafe()` inline -
macht an der Aufrufstelle klar, dass dieses "Passwort" bewusst nie
irgendwo eingegeben werden soll (Dienstkonto authentifiziert sich nur
über das API-Token, nie über Login/Passwort)."""
return secrets.token_urlsafe(32)
async def hole_benutzer_fuer_token(db: AsyncSession, klartext_token: str) -> Benutzer | None:
"""Zentrale Auth-Fallback-Funktion (app/api/deps.py): löst ein
API-Token-Klartext auf den zugehörigen Dienstkonto-Benutzer auf, sofern
Token UND Dienstkonto aktiv sind. Aktualisiert `letzte_verwendung_am`
bei jeder erfolgreichen Verwendung (Audit/Aufräum-Hinweis, welche Tokens
noch genutzt werden)."""
token_hash = hashe_api_token(klartext_token)
result = await db.execute(select(ApiToken).where(ApiToken.token_hash == token_hash))
token = result.scalar_one_or_none()
if token is None or not token.aktiv:
return None
benutzer = await db.get(Benutzer, token.benutzer_id)
if benutzer is None or not benutzer.aktiv:
return None
token.letzte_verwendung_am = datetime.now(timezone.utc)
await db.flush()
return benutzer
async def liste_tokens(db: AsyncSession) -> list[ApiToken]:
result = await db.execute(select(ApiToken).order_by(ApiToken.erstellt_am.desc()))
return list(result.scalars().all())
async def rollen_fuer_token(db: AsyncSession, token: ApiToken) -> list[RolleTyp]:
result = await db.execute(select(BenutzerRolle.rolle).where(BenutzerRolle.benutzer_id == token.benutzer_id))
return [row[0] for row in result.all()]
async def setze_aktiv(db: AsyncSession, token_id: uuid.UUID, aktiv: bool) -> ApiToken:
token = await db.get(ApiToken, token_id)
if token is None:
raise ApiTokenNichtGefundenError
token.aktiv = aktiv
await db.flush()
return token