IAM-06: sso-anmeldung-ueber-oidc

internal/oidc: JWKS-Parser (RSA-Schluessel, RFC 7517) + Verifier prueft
ID-Tokens gegen den geparsten Schluesselsatz (Signatur, Ablauf ueber die
jwt-Bibliothek, Aussteller) — Akzeptanzkriterium 3. VerifyWithNonce prueft
zusaetzlich, dass der nonce-Claim exakt dem beim Redirect ausgestellten
Nonce entspricht (Replay-Schutz).

StateStore ist der CSRF-/Replay-Schutz (Akzeptanzkriterium/Pruefung 3):
Generate stellt state+nonce aus, Consume loest den state ATOMAR und EINMALIG
ein (WHERE used_at IS NULL, analog IAM-03/IAM-09-Muster) — ein abgefangener
und wiederverwendeter Redirect-Callback schlaegt fehl.

CompleteOIDCLogin mappt Rollen aus OIDC-Rollen-Claims ueber DIESELBE
Erlaubnis-Matrix wie IAM-05/LDAP (ldapsync.RoleMappingStore.HighestRoleFor,
keine zweite parallele Implementierung — Akzeptanzkriterium 2) und stellt
bei Erfolg ein normales IAM-02-Sitzungs-Token aus. Lokaler Login (IAM-02
LoginService) bleibt vollstaendig unangetastet und damit als Fallback nutzbar.

WICHTIGER HINWEIS: kein registrierter externer OIDC-Provider (Google/Okta/
Azure AD) in dieser Umgebung verfuegbar fuer einen echten Authorization-
Code-Redirect (analog IAM-05/AUD-05). ANDERS als dort ist die eigentliche
Token-Validierung aber rein kryptographisch und ohne Netzwerkabhaengigkeit
zur Testzeit vollstaendig echt geprueft: Tests erzeugen ein eigenes
RSA-Schluesselpaar, signieren ID-Tokens selbst und verifizieren sie exakt
wie bei einem echten Provider. Nur der Live-Redirect zu einem realen
externen IdP bleibt ungeprueft.

Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS):
1. Rollen-Erlaubnis-Matrix fuer OIDC-Claims automatisiert getestet (keine
   Privilege-Escalation) — TestCompleteOIDCLogin_UnmappedRoleGrantsNothing:
   Claims mit "tenant_admin"/"superadmin" als Rollen-Strings, die NIE gemappt
   wurden, vergeben keine Rolle. PASS.
2. Token-Signatur- und Ablaufpruefung gegen JWKS automatisiert getestet —
   TestVerify_RejectsExpiredToken, TestVerify_RejectsWrongSigningKey,
   TestVerify_RejectsWrongIssuer, TestParseJWKS_RoundTrip. PASS.
3. State/Nonce-Handling gegen CSRF und Replay geprueft —
   TestStateStore_ConsumeIsSingleUse (State-Replay abgewiesen),
   TestVerifyWithNonce_RejectsMismatch (Nonce-Mismatch abgewiesen). PASS.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

internal/oidc/verify.go

@@ -0,0 +1,70 @@
+package oidc
+
+import (
+	"crypto/rsa"
+	"errors"
+	"fmt"
+
+	"github.com/golang-jwt/jwt/v5"
+)
+
+var ErrInvalidToken = errors.New("oidc: id-token ungueltig, abgelaufen oder falscher aussteller")
+
+// Claims sind die fuer NEXARCH relevanten OIDC-ID-Token-Claims.
+type Claims struct {
+	Subject string   `json:"sub"`
+	Email   string   `json:"email"`
+	Nonce   string   `json:"nonce"`
+	Roles   []string `json:"roles"` // providerabhaengiger Claim-Name, hier vereinfacht fest "roles"
+	jwt.RegisteredClaims
+}
+
+// Verifier prueft ID-Tokens gegen den JWKS-Schluesselsatz eines konfigurierten
+// Providers (Akzeptanzkriterium 3: fehlerhafte/abgelaufene Tokens werden
+// abgewiesen).
+type Verifier struct {
+	keys   map[string]*rsa.PublicKey
+	issuer string
+}
+
+func NewVerifier(keys map[string]*rsa.PublicKey, issuer string) *Verifier {
+	return &Verifier{keys: keys, issuer: issuer}
+}
+
+// Verify prueft Signatur (gegen JWKS), Ablauf (jwt-Bibliothek lehnt
+// abgelaufene Tokens automatisch ab) und Aussteller.
+func (v *Verifier) Verify(idToken string) (*Claims, error) {
+	claims := &Claims{}
+	token, err := jwt.ParseWithClaims(idToken, claims, func(t *jwt.Token) (interface{}, error) {
+		if _, ok := t.Method.(*jwt.SigningMethodRSA); !ok {
+			return nil, ErrInvalidToken
+		}
+		kid, _ := t.Header["kid"].(string)
+		key, ok := v.keys[kid]
+		if !ok {
+			return nil, ErrInvalidToken
+		}
+		return key, nil
+	})
+	if err != nil || !token.Valid {
+		return nil, ErrInvalidToken
+	}
+	if claims.Issuer != v.issuer {
+		return nil, fmt.Errorf("%w: unerwarteter aussteller %q", ErrInvalidToken, claims.Issuer)
+	}
+	return claims, nil
+}
+
+// VerifyWithNonce prueft zusaetzlich, dass der nonce-Claim im Token exakt
+// dem bei der Anfrage ausgestellten Nonce entspricht — verhindert Replay
+// eines fremden, gueltigen ID-Tokens (Akzeptanzkriterium/Pruefung 3).
+func (v *Verifier) VerifyWithNonce(idToken, expectedNonce string) (*Claims, error) {
+	claims, err := v.Verify(idToken)
+	if err != nil {
+		return nil, err
+	}
+	if claims.Nonce == "" || claims.Nonce != expectedNonce {
+		return nil, fmt.Errorf("%w: nonce stimmt nicht ueberein", ErrInvalidToken)
+	}
+	return claims, nil
+}