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
96 lines
3.5 KiB
Python
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
|