nexarch/internal/oidc/provider_test.go

package oidc

import (
	"context"
	"crypto/ed25519"
	"encoding/base64"
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"net/url"
	"os"
	"strings"
	"testing"

	"github.com/golang-jwt/jwt/v5"
	"github.com/jackc/pgx/v5/pgxpool"

	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
	"gitea.perlbach24.de/scripte/nexarch/internal/moduletrust"
)

// newProviderTestSetup baut Tenant-DB-Schema (users, oidc_clients,
// oidc_auth_codes) direkt gegen TEST_ADMIN_DSN auf, analog zum Muster in
// internal/tenant/lifecycle_test.go — braucht kein volles Tenant-Provisioning,
// nur eine isolierte Datenbank fuer diesen Testlauf.
func newProviderTestSetup(t *testing.T) (*Handler, *pgxpool.Pool, func()) {
	t.Helper()
	adminDSN := os.Getenv("TEST_ADMIN_DSN")
	if adminDSN == "" {
		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
	}
	ctx := context.Background()

	pool, err := pgxpool.New(ctx, adminDSN)
	if err != nil {
		t.Fatalf("pool: %v", err)
	}

	if _, err := pool.Exec(ctx, `
		CREATE EXTENSION IF NOT EXISTS pgcrypto;
		CREATE TABLE IF NOT EXISTS users (
			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
			email TEXT NOT NULL UNIQUE,
			name TEXT NOT NULL,
			status TEXT NOT NULL DEFAULT 'active',
			created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
			updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
		);
		CREATE TABLE IF NOT EXISTS oidc_clients (
			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
			name TEXT NOT NULL,
			client_id TEXT NOT NULL UNIQUE,
			secret_hash BYTEA NOT NULL,
			redirect_uris TEXT[] NOT NULL,
			allowed_scopes TEXT[] NOT NULL,
			created_at TIMESTAMPTZ NOT NULL DEFAULT now()
		);
		CREATE TABLE IF NOT EXISTS oidc_auth_codes (
			code_hash BYTEA PRIMARY KEY,
			client_id TEXT NOT NULL REFERENCES oidc_clients(client_id),
			user_id UUID NOT NULL REFERENCES users(id),
			redirect_uri TEXT NOT NULL,
			scopes TEXT[] NOT NULL,
			created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
			expires_at TIMESTAMPTZ NOT NULL,
			used_at TIMESTAMPTZ
		);
	`); err != nil {
		t.Fatalf("schema: %v", err)
	}

	keys, err := moduletrust.NewKeyManager()
	if err != nil {
		t.Fatalf("keymanager: %v", err)
	}

	clients := NewClientStore(pool)
	authCodes := NewAuthCodeStore(pool)
	handler := NewHandler(clients, authCodes, keys, "https://core.test.nexarch.example")

	cleanup := func() {
		ctx := context.Background()
		_, _ = pool.Exec(ctx, `DROP TABLE IF EXISTS oidc_auth_codes, oidc_clients, users CASCADE`)
		pool.Close()
	}
	return handler, pool, cleanup
}

func createTestUser(t *testing.T, pool *pgxpool.Pool, email string) string {
	t.Helper()
	var id string
	err := pool.QueryRow(context.Background(), `
		INSERT INTO users (email, name) VALUES ($1, $2) RETURNING id
	`, email, "Test Nutzer").Scan(&id)
	if err != nil {
		t.Fatalf("testnutzer anlegen: %v", err)
	}
	return id
}

// Akzeptanzkriterium 1 (Client-Registrierung) + 2 (voller Flow) + 3 (JWKS-
// Verifikation, Scope-Einschraenkung). Deckt Pruefungen 1-3 ab.
func TestFullAuthorizationCodeFlow(t *testing.T) {
	handler, pool, cleanup := newProviderTestSetup(t)
	defer cleanup()
	ctx := context.Background()
	userID := createTestUser(t, pool, "nutzer@acme.example")

	// Pruefung 1 / Akzeptanzkriterium 1: Client registriert sich.
	clientID, clientSecret, err := handler.clients.Register(ctx, "Test-Drittanwendung",
		[]string{"https://app.example.com/callback"},
		[]string{"openid", "profile"}, // erlaubte Scopes: KEIN "admin"
	)
	if err != nil {
		t.Fatalf("register: %v", err)
	}

	// Session-Cookie fuer den Authorize-Aufruf ausstellen, exakt wie ein
	// echter Browser ihn haette — RequireAuth uebernimmt die Verifikation,
	// dieselbe Middleware wie in Produktion (nicht simuliert).
	issuer := auth.NewTokenIssuer("test-session-secret")
	sessionToken, err := issuer.Issue(userID, "acme")
	if err != nil {
		t.Fatalf("session-token ausstellen: %v", err)
	}

	authorizeURL := "/oidc/authorize?" + url.Values{
		"response_type": {"code"},
		"client_id":     {clientID},
		"redirect_uri":  {"https://app.example.com/callback"},
		// admin wird angefragt, ist aber NICHT erlaubt -> muss herausgefiltert werden.
		"scope": {"openid profile admin"},
		"state": {"xyz123"},
	}.Encode()

	req := httptest.NewRequest(http.MethodGet, authorizeURL, nil)
	req.AddCookie(&http.Cookie{Name: auth.CookieName, Value: sessionToken})
	rec := httptest.NewRecorder()

	protected := auth.RequireAuth(issuer, handler.Authorize)
	protected(rec, req)

	if rec.Code != http.StatusFound {
		t.Fatalf("authorize: status = %d, want %d, body: %s", rec.Code, http.StatusFound, rec.Body.String())
	}
	loc, err := url.Parse(rec.Header().Get("Location"))
	if err != nil {
		t.Fatalf("redirect-location parsen: %v", err)
	}
	if loc.Query().Get("state") != "xyz123" {
		t.Fatalf("state = %q, want xyz123 (muss unveraendert durchgereicht werden)", loc.Query().Get("state"))
	}
	code := loc.Query().Get("code")
	if code == "" {
		t.Fatal("erwartet gesetzten code-Parameter in der redirect-URL")
	}

	// Pruefung 1 / Akzeptanzkriterium 2: Code gegen Token tauschen.
	tokenForm := url.Values{
		"grant_type":    {"authorization_code"},
		"code":          {code},
		"redirect_uri":  {"https://app.example.com/callback"},
		"client_id":     {clientID},
		"client_secret": {clientSecret},
	}
	tokenReq := httptest.NewRequest(http.MethodPost, "/oidc/token", strings.NewReader(tokenForm.Encode()))
	tokenReq.Header.Set("Content-Type", "application/x-www-form-urlencoded")
	tokenRec := httptest.NewRecorder()
	handler.Token(tokenRec, tokenReq)

	if tokenRec.Code != http.StatusOK {
		t.Fatalf("token: status = %d, want 200, body: %s", tokenRec.Code, tokenRec.Body.String())
	}

	var tokenResp struct {
		IDToken string `json:"id_token"`
		Scope   string `json:"scope"`
	}
	if err := decodeJSON(tokenRec.Body.Bytes(), &tokenResp); err != nil {
		t.Fatalf("token-response dekodieren: %v", err)
	}

	// Akzeptanzkriterium 3 / Pruefung 3: "admin" wurde herausgefiltert.
	grantedScopes := strings.Fields(tokenResp.Scope)
	for _, s := range grantedScopes {
		if s == "admin" {
			t.Fatal("nicht erlaubter scope 'admin' wurde dennoch gewaehrt")
		}
	}
	if !containsAll(grantedScopes, "openid", "profile") {
		t.Fatalf("erwartete scopes openid+profile, habe %v", grantedScopes)
	}

	// Pruefung 2 / Akzeptanzkriterium 3: ausgestelltes Token gegen JWKS verifizieren.
	jwksRec := httptest.NewRecorder()
	handler.JWKS(jwksRec, httptest.NewRequest(http.MethodGet, "/oidc/jwks.json", nil))

	var jwks idpJWKSet
	if err := decodeJSON(jwksRec.Body.Bytes(), &jwks); err != nil {
		t.Fatalf("jwks dekodieren: %v", err)
	}
	if len(jwks.Keys) == 0 {
		t.Fatal("jwks enthaelt keine schluessel")
	}

	parsedToken, err := jwt.ParseWithClaims(tokenResp.IDToken, &IDTokenClaims{}, func(tok *jwt.Token) (interface{}, error) {
		kid, _ := tok.Header["kid"].(string)
		for _, k := range jwks.Keys {
			if k.Kid == kid {
				pub, err := decodeBase64URLEd25519(k.X)
				if err != nil {
					return nil, err
				}
				return ed25519.PublicKey(pub), nil
			}
		}
		return nil, jwt.ErrTokenUnverifiable
	})
	if err != nil || !parsedToken.Valid {
		t.Fatalf("id-token gegen jwks verifizieren: %v (valid=%v)", err, parsedToken != nil && parsedToken.Valid)
	}

	claims := parsedToken.Claims.(*IDTokenClaims)
	if claims.Subject != userID {
		t.Fatalf("sub = %q, want %q", claims.Subject, userID)
	}
	if len(claims.Audience) != 1 || claims.Audience[0] != clientID {
		t.Fatalf("aud = %v, want [%q]", claims.Audience, clientID)
	}
}

// Pruefung 3 (dediziert): Client, der einen Scope anfragt, den er bei der
// Registrierung nicht erhalten hat, bekommt ihn unter keinen Umstaenden.
func TestGrantedScopes_NeverExceedsAllowed(t *testing.T) {
	c := Client{AllowedScopes: []string{"openid", "profile"}}
	granted := c.GrantedScopes([]string{"openid", "admin", "profile", "billing"})
	if !containsAll(granted, "openid", "profile") || len(granted) != 2 {
		t.Fatalf("granted = %v, want genau [openid profile]", granted)
	}
}

func TestValidateRedirectURI_RejectsUnregistered(t *testing.T) {
	c := Client{RedirectURIs: []string{"https://app.example.com/callback"}}
	if err := c.ValidateRedirectURI("https://boese-seite.example.com/callback"); err == nil {
		t.Fatal("erwartet fehler fuer nicht registrierte redirect_uri")
	}
	if err := c.ValidateRedirectURI("https://app.example.com/callback"); err != nil {
		t.Fatalf("registrierte redirect_uri sollte akzeptiert werden: %v", err)
	}
}

func TestAuthCodeStore_CannotBeConsumedTwice(t *testing.T) {
	handler, pool, cleanup := newProviderTestSetup(t)
	defer cleanup()
	ctx := context.Background()
	userID := createTestUser(t, pool, "einmalig@acme.example")
	clientID, _, err := handler.clients.Register(ctx, "Einmal-Client", []string{"https://a.example/cb"}, []string{"openid"})
	if err != nil {
		t.Fatalf("register: %v", err)
	}

	code, err := handler.authCodes.Issue(ctx, clientID, userID, "https://a.example/cb", []string{"openid"})
	if err != nil {
		t.Fatalf("issue: %v", err)
	}

	if _, err := handler.authCodes.Consume(ctx, code, clientID, "https://a.example/cb"); err != nil {
		t.Fatalf("erster consume sollte funktionieren: %v", err)
	}
	if _, err := handler.authCodes.Consume(ctx, code, clientID, "https://a.example/cb"); err == nil {
		t.Fatal("zweiter consume desselben codes haette fehlschlagen muessen")
	}
}

func containsAll(haystack []string, needles ...string) bool {
	set := make(map[string]bool, len(haystack))
	for _, h := range haystack {
		set[h] = true
	}
	for _, n := range needles {
		if !set[n] {
			return false
		}
	}
	return true
}

func decodeJSON(data []byte, v any) error {
	return json.Unmarshal(data, v)
}

func decodeBase64URLEd25519(s string) ([]byte, error) {
	return base64.RawURLEncoding.DecodeString(s)
}