fix(kiosk): NFC-Login verlangt Pflicht-PIN als Zweitfaktor (Security-Audit K-3)

Bisher genügte die reine NFC-UID zum Einstempeln. Getestete Reader-Hardware
(günstiger USB-HID-RFID-Leser, EM4100 125kHz) liefert nur eine unverschlüsselte,
trivial klonbare Chip-ID - identisch zum in security_audit_kiosk_qr_nfc_2026_05_26
(K-3) beschriebenen Risiko, das bisher offen war.

- login_nfc() verlangt jetzt PIN, nutzt denselben Brute-Force-Lockout wie
  login_pin (keyed auf nfc_uid statt Personalnummer)
- Neuer Endpunkt POST /users/{id}/kiosk-nfc (Admin/HR) zum Zuordnen einer
  Karte zu einem Mitarbeiter - existierte bisher gar nicht, kiosk_nfc_uid
  war nur im Model vorhanden, nirgends setzbar
- Company-interner Unique-Check (eine Karte = ein Mitarbeiter)

Kein bestehendes Frontend nutzt NFC-Login bisher, daher kein Breaking Change.
Höhere Sicherheitsstufe (NTAG424 SUN, klon-resistent) bleibt vorgemerkt für
späteren Hardware-Wechsel (aktueller Reader kann keine Kryptografie).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Gis16MnuwkYcivLrSxK1pD

backend/app/routers/kiosk.py

@@ -172,6 +172,7 @@ async def kiosk_login_nfc(
     """NFC-Login: NFC-UID der Karte."""
     user, session_token = await kiosk_auth_service.login_nfc(
         nfc_uid=data.nfc_uid,
+        pin=data.pin,
         company_id=device.company_id,
         device_id=device.id,
         db=db,

backend/app/routers/users.py

@@ -14,6 +14,7 @@ from app.schemas.user import (
     NextPersonnelNumberResponse,
     NotificationPrefsUpdate,
     NotificationTypeOut,
+    SetKioskNfcUidRequest,
     SetKioskPinRequest,
     UserImportResult,
     UserImportRowResult,
@@ -283,3 +284,19 @@ async def set_kiosk_pin(
     user = await user_service.get_by_id(user_id, current_user.company_id, db)
     await user_service.set_kiosk_pin(user, data.pin, db)
     return MessageResponse(message="Kiosk PIN updated")
+
+
+@router.post("/{user_id}/kiosk-nfc", response_model=MessageResponse)
+async def set_kiosk_nfc(
+    user_id: UUID,
+    data: SetKioskNfcUidRequest,
+    current_user: CurrentUser,
+    db: AsyncSession = Depends(get_db),
+):
+    """NFC-Karte einem Mitarbeiter zuordnen. Nur Admin/HR - die Karte allein ist
+    kein Geheimnis (klonbare UID), daher darf sie nicht selbst zugewiesen werden."""
+    if not current_user.is_admin_or_above():
+        raise HTTPException(status_code=403, detail="Not allowed")
+    user = await user_service.get_by_id(user_id, current_user.company_id, db)
+    await user_service.set_kiosk_nfc_uid(user, data.nfc_uid, db)
+    return MessageResponse(message="Kiosk NFC-UID updated")

backend/app/schemas/kiosk_auth.py

@@ -10,8 +10,9 @@ class KioskPinLoginRequest(BaseModel):
 
 
 class KioskNfcLoginRequest(BaseModel):
-    """Login via NFC-UID."""
+    """Login via NFC-UID + Pflicht-PIN (Zweitfaktor, da UID allein klonbar ist)."""
     nfc_uid: str = Field(..., min_length=1, max_length=64)
+    pin: str = Field(..., min_length=4, max_length=16)
 
 
 class KioskQrLoginRequest(BaseModel):

backend/app/schemas/user.py

@@ -102,6 +102,13 @@ class SetKioskPinRequest(BaseModel):
     pin: str = Field(min_length=4, max_length=6, pattern=r"^\d+$")
 
 
+class SetKioskNfcUidRequest(BaseModel):
+    """UID des NFC-Chips (roh, wie vom Reader geliefert - z.B. dezimale EM4100-ID
+    oder Mifare-Hex-UID). Nur Admin/HR - Mitarbeiter setzen ihre eigene Karte nicht
+    selbst, da sonst jeder eine fremde UID eintragen könnte."""
+    nfc_uid: str | None = Field(None, min_length=1, max_length=64)
+
+
 class NextPersonnelNumberResponse(BaseModel):
     next: str
 

backend/app/services/kiosk_auth_service.py

@@ -3,7 +3,7 @@ Kiosk-User-Auth Service.
 
 Unterstützte Methoden:
   PIN  → User über Personalnummer suchen, bcrypt-PIN prüfen
-  NFC  → User über kiosk_nfc_uid suchen
+  NFC  → User über kiosk_nfc_uid suchen, PIN als Pflicht-Zweitfaktor (K-3-Fix)
   QR   → QR-Token ist ein kurzlebiger Redis-Key (5 min, einmalig)
   List → Kein Passwort, User wählt sich aus Liste (für vertrauenswürdige Umgebungen)
 """
@@ -181,20 +181,51 @@ class KioskAuthService:
     async def login_nfc(
         self,
         nfc_uid: str,
+        pin: str,
         company_id: uuid.UUID,
         device_id: uuid.UUID,
         db: AsyncSession,
     ) -> tuple[User, str]:
-        """Authentifizierung per NFC-UID."""
-        user = await db.scalar(
-            select(User).where(
-                User.company_id == company_id,
-                User.kiosk_nfc_uid == nfc_uid,
-                User.is_active == True,
+        """Authentifizierung per NFC-UID + Pflicht-PIN als Zweitfaktor.
+
+        Reine NFC-UIDs (MIFARE Classic/NTAG213 o.ä. wie sie günstige
+        HID-Keyboard-Reader liefern) sind trivial klonbar (Security-Audit
+        2026-05-26, K-3) – die Karte allein ist daher kein ausreichender
+        Auth-Faktor. PIN-Pflicht macht aus "Karte kopiert" allein noch keinen
+        gültigen Login. Nutzt denselben Lockout-Mechanismus wie login_pin,
+        keyed auf die NFC-UID statt Personalnummer.
+        """
+        import redis.asyncio as aioredis
+        from app.core.config import settings
+
+        redis_client = aioredis.from_url(settings.redis_url, decode_responses=True)
+        try:
+            await self._check_pin_lockout(device_id, nfc_uid, redis_client)
+
+            user = await db.scalar(
+                select(User).where(
+                    User.company_id == company_id,
+                    User.kiosk_nfc_uid == nfc_uid,
+                    User.is_active == True,
+                )
             )
-        )
-        if user is None:
-            raise HTTPException(status_code=401, detail="NFC-Karte nicht registriert.")
+            if user is None:
+                await self._record_pin_failure(device_id, nfc_uid, redis_client)
+                raise HTTPException(status_code=401, detail="NFC-Karte nicht registriert.")
+
+            if not user.kiosk_pin_hash:
+                raise HTTPException(
+                    status_code=401,
+                    detail="Kein PIN gesetzt. Bitte in den Profileinstellungen einen PIN vergeben.",
+                )
+
+            if not bcrypt.checkpw(pin.encode(), user.kiosk_pin_hash.encode()):
+                await self._record_pin_failure(device_id, nfc_uid, redis_client)
+                raise HTTPException(status_code=401, detail="Falscher PIN.")
+
+            await self._clear_pin_failures(device_id, nfc_uid, redis_client)
+        finally:
+            await redis_client.aclose()
 
         session_token = await kiosk_session_service.create_session(
             user_id=user.id,

backend/app/services/user_service.py

@@ -396,5 +396,21 @@ class UserService:
             return False
         return verify_password(pin, user.kiosk_pin_hash)
 
+    async def set_kiosk_nfc_uid(self, user: User, nfc_uid: str | None, db: AsyncSession) -> None:
+        if nfc_uid:
+            existing = await db.scalar(
+                select(User).where(
+                    User.company_id == user.company_id,
+                    User.kiosk_nfc_uid == nfc_uid,
+                    User.id != user.id,
+                )
+            )
+            if existing is not None:
+                raise HTTPException(
+                    status_code=409,
+                    detail="Diese NFC-Karte ist bereits einem anderen Mitarbeiter zugeordnet.",
+                )
+        user.kiosk_nfc_uid = nfc_uid
+
 
 user_service = UserService()