feat(core): RBAC-06 modulübergreifender HTTP-Endpunkt für Policy-Entscheidungen
internal/policyapi: POST /authorize wrapt policy.Enforcer.Authorize (RBAC-02) fuer physisch getrennte Module (DMS, Mail, Archive) - reiner Wrapper, keine zweite Autorisierungslogik, 100 Stichproben beweisen Uebereinstimmung mit dem direkten Enforcer-Aufruf. Service-Auth ueber schlanken, timing-safe verglichenen Token statt moduleregistrys schwererem Credential-System (unnoetige internal/flag-Abhaengigkeit, nie mit internal/policy gemergt). Ersetzt spaeter das dokumentierte RET-06-API-Provisorium (Archive, eigenes Folgeticket). Reale Rechtevergabe-Luecke auf policy_rules gefunden und behoben (Tabelle von frueherem Testlauf unter anderem Owner). Real auf 131 deployed, beide Pfade (Allow/Deny) per curl end-to-end verifiziert.
This commit is contained in:
sysops
@@ -0,0 +1,38 @@
|
||||
// Package policyapi implementiert RBAC-06: einen HTTP-Endpunkt, der
|
||||
// Core RBAC-02s Enforcer.Authorize für andere, physisch getrennte
|
||||
// Go-Module (DMS, Mail, Archive) zugänglich macht — dieselbe
|
||||
// Entscheidung wie der direkte Enforcer-Aufruf, nur per HTTP statt
|
||||
// In-Process.
|
||||
package policyapi
|
||||
|
||||
import (
|
||||
"crypto/sha256"
|
||||
"crypto/subtle"
|
||||
"net/http"
|
||||
)
|
||||
|
||||
// RequireServiceToken authentifiziert den Aufrufer service-zu-service
|
||||
// über einen geteilten Token (Umgebungsvariable, nie im Code — siehe
|
||||
// Ticket-Abschlussregel), timing-safe verglichen (dieselbe
|
||||
// Referenzimplementierung wie AUD-02: subtle.ConstantTimeCompare,
|
||||
// projektweite Konvention für jeden sicherheitsrelevanten Vergleich).
|
||||
// Bewusst KEIN vollwertiges Credential-Ausstellungssystem
|
||||
// (moduleregistry.Provision/Authenticate) — dieser Endpunkt braucht
|
||||
// keine Modul-Aktivierungsverwaltung, nur einen einzelnen, über
|
||||
// Konfiguration verteilten Zugangsschlüssel (Akzeptanzkriterium 2).
|
||||
func RequireServiceToken(expectedToken string, next http.HandlerFunc) http.HandlerFunc {
|
||||
return func(w http.ResponseWriter, r *http.Request) {
|
||||
got := r.Header.Get("X-Service-Token")
|
||||
if got == "" || !timingSafeEqual(got, expectedToken) {
|
||||
http.Error(w, "authentifizierung fehlgeschlagen: gültiges X-Service-Token erforderlich", http.StatusUnauthorized)
|
||||
return
|
||||
}
|
||||
next(w, r)
|
||||
}
|
||||
}
|
||||
|
||||
func timingSafeEqual(a, b string) bool {
|
||||
ha := sha256.Sum256([]byte(a))
|
||||
hb := sha256.Sum256([]byte(b))
|
||||
return subtle.ConstantTimeCompare(ha[:], hb[:]) == 1
|
||||
}
|
||||
@@ -0,0 +1,63 @@
|
||||
package policyapi
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// TestRequireServiceToken_MissingOrWrongTokenReturns401 ist die
|
||||
// Pflichtpruefung: Aufruf ohne gueltige Service-Credentials wird
|
||||
// abgewiesen, nicht mit einer Policy-Entscheidung beantwortet.
|
||||
func TestRequireServiceToken_MissingOrWrongTokenReturns401(t *testing.T) {
|
||||
called := false
|
||||
handler := RequireServiceToken("richtiges-token", func(w http.ResponseWriter, r *http.Request) {
|
||||
called = true
|
||||
w.WriteHeader(http.StatusOK)
|
||||
})
|
||||
server := httptest.NewServer(handler)
|
||||
defer server.Close()
|
||||
|
||||
resp, err := http.Get(server.URL)
|
||||
if err != nil {
|
||||
t.Fatalf("get: %v", err)
|
||||
}
|
||||
defer func() { _ = resp.Body.Close() }()
|
||||
if resp.StatusCode != http.StatusUnauthorized {
|
||||
t.Fatalf("ohne token: status = %d, want 401", resp.StatusCode)
|
||||
}
|
||||
if called {
|
||||
t.Fatal("handler haette bei fehlendem token nie erreicht werden duerfen")
|
||||
}
|
||||
|
||||
req, _ := http.NewRequest(http.MethodGet, server.URL, nil)
|
||||
req.Header.Set("X-Service-Token", "falsches-token")
|
||||
resp2, err := http.DefaultClient.Do(req)
|
||||
if err != nil {
|
||||
t.Fatalf("get: %v", err)
|
||||
}
|
||||
defer func() { _ = resp2.Body.Close() }()
|
||||
if resp2.StatusCode != http.StatusUnauthorized {
|
||||
t.Fatalf("mit falschem token: status = %d, want 401", resp2.StatusCode)
|
||||
}
|
||||
}
|
||||
|
||||
// TestRequireServiceToken_CorrectTokenAllowsAccess ist der Gegentest.
|
||||
func TestRequireServiceToken_CorrectTokenAllowsAccess(t *testing.T) {
|
||||
handler := RequireServiceToken("richtiges-token", func(w http.ResponseWriter, r *http.Request) {
|
||||
w.WriteHeader(http.StatusOK)
|
||||
})
|
||||
server := httptest.NewServer(handler)
|
||||
defer server.Close()
|
||||
|
||||
req, _ := http.NewRequest(http.MethodGet, server.URL, nil)
|
||||
req.Header.Set("X-Service-Token", "richtiges-token")
|
||||
resp, err := http.DefaultClient.Do(req)
|
||||
if err != nil {
|
||||
t.Fatalf("get: %v", err)
|
||||
}
|
||||
defer func() { _ = resp.Body.Close() }()
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
t.Fatalf("mit korrektem token: status = %d, want 200", resp.StatusCode)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,56 @@
|
||||
package policyapi
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"net/http"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/internal/policy"
|
||||
"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
|
||||
)
|
||||
|
||||
// Mount registriert den Autorisierungs-Endpunkt auf mux, hinter dem
|
||||
// Service-Token-Check (Akzeptanzkriterium 2).
|
||||
func Mount(mux *http.ServeMux, enforcer *policy.Enforcer, serviceToken string) {
|
||||
mux.HandleFunc("POST /authorize", RequireServiceToken(serviceToken, authorizeHandler(enforcer)))
|
||||
}
|
||||
|
||||
type authorizeRequest struct {
|
||||
Role string `json:"role"`
|
||||
Permission string `json:"permission"`
|
||||
}
|
||||
|
||||
type authorizeResponse struct {
|
||||
Allowed bool `json:"allowed"`
|
||||
}
|
||||
|
||||
// authorizeHandler ruft AUSSCHLIESSLICH enforcer.Authorize auf — keine
|
||||
// eigene, zweite Autorisierungsentscheidung (Akzeptanzkriterium 1: die
|
||||
// HTTP-Antwort MUSS mit dem direkten Enforcer-Ergebnis übereinstimmen,
|
||||
// das ist strukturell garantiert, weil es derselbe Aufruf ist, nicht
|
||||
// nur getestet).
|
||||
func authorizeHandler(enforcer *policy.Enforcer) http.HandlerFunc {
|
||||
return func(w http.ResponseWriter, r *http.Request) {
|
||||
var req authorizeRequest
|
||||
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
||||
http.Error(w, "ungültiger request-body: "+err.Error(), http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
if req.Role == "" || req.Permission == "" {
|
||||
http.Error(w, "role und permission sind pflichtfelder", http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
|
||||
err := enforcer.Authorize(r.Context(), rbac.Role(req.Role), rbac.Permission(req.Permission))
|
||||
allowed := err == nil
|
||||
if err != nil && !errors.Is(err, policy.ErrDenied) {
|
||||
// Ein anderer Fehler als "verboten" (z.B. DB-Fehler) ist kein
|
||||
// gueltiges Allow/Deny-Ergebnis, sondern ein echter Fehlerfall.
|
||||
http.Error(w, err.Error(), http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
_ = json.NewEncoder(w).Encode(authorizeResponse{Allowed: allowed})
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,116 @@
|
||||
package policyapi
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"os"
|
||||
"testing"
|
||||
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/internal/policy"
|
||||
"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
|
||||
)
|
||||
|
||||
const testToken = "test-service-token"
|
||||
|
||||
func setupTest(t *testing.T) *policy.Enforcer {
|
||||
t.Helper()
|
||||
dsn := os.Getenv("TEST_ADMIN_DSN")
|
||||
if dsn == "" {
|
||||
t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
|
||||
}
|
||||
ctx := context.Background()
|
||||
pool, err := pgxpool.New(ctx, dsn)
|
||||
if err != nil {
|
||||
t.Fatalf("pool: %v", err)
|
||||
}
|
||||
t.Cleanup(func() { pool.Close() })
|
||||
|
||||
if _, err := pool.Exec(ctx, `
|
||||
CREATE EXTENSION IF NOT EXISTS pgcrypto;
|
||||
CREATE TABLE IF NOT EXISTS policy_rules (
|
||||
role TEXT NOT NULL, permission TEXT NOT NULL,
|
||||
granted_by TEXT NOT NULL, granted_at TIMESTAMPTZ NOT NULL DEFAULT now(),
|
||||
PRIMARY KEY (role, permission)
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS policy_rule_changes (
|
||||
id UUID PRIMARY KEY DEFAULT gen_random_uuid(), role TEXT NOT NULL, permission TEXT NOT NULL,
|
||||
action TEXT NOT NULL CHECK (action IN ('grant','revoke')), actor TEXT NOT NULL,
|
||||
version INT NOT NULL, changed_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
||||
);
|
||||
`); err != nil {
|
||||
t.Fatalf("schema: %v", err)
|
||||
}
|
||||
t.Cleanup(func() {
|
||||
_, _ = pool.Exec(context.Background(), `DELETE FROM policy_rule_changes WHERE role LIKE 'rbac06\_%' ESCAPE '\'`)
|
||||
_, _ = pool.Exec(context.Background(), `DELETE FROM policy_rules WHERE role LIKE 'rbac06\_%' ESCAPE '\'`)
|
||||
})
|
||||
|
||||
store := policy.NewStore(pool)
|
||||
if err := store.Grant(ctx, rbac.Role("rbac06_erlaubte_rolle"), rbac.Permission("rbac06_recht"), "test"); err != nil {
|
||||
t.Fatalf("grant: %v", err)
|
||||
}
|
||||
return policy.NewEnforcer(store)
|
||||
}
|
||||
|
||||
func authorize(t *testing.T, server *httptest.Server, role, permission string) (int, bool) {
|
||||
t.Helper()
|
||||
body, _ := json.Marshal(authorizeRequest{Role: role, Permission: permission})
|
||||
req, _ := http.NewRequest(http.MethodPost, server.URL+"/authorize", bytes.NewReader(body))
|
||||
req.Header.Set("X-Service-Token", testToken)
|
||||
resp, err := http.DefaultClient.Do(req)
|
||||
if err != nil {
|
||||
t.Fatalf("post: %v", err)
|
||||
}
|
||||
defer func() { _ = resp.Body.Close() }()
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
return resp.StatusCode, false
|
||||
}
|
||||
var out authorizeResponse
|
||||
if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
|
||||
t.Fatalf("antwort dekodieren: %v", err)
|
||||
}
|
||||
return resp.StatusCode, out.Allowed
|
||||
}
|
||||
|
||||
// TestAuthorizeHandler_MatchesDirectEnforcerResult ist die geforderte
|
||||
// Pflichtpruefung: Endpunkt-Antwort stimmt in 100 Stichproben exakt mit
|
||||
// dem direkten Enforcer.Authorize-Ergebnis ueberein - real fuer sowohl
|
||||
// erlaubte als auch verbotene role+permission-Kombinationen.
|
||||
func TestAuthorizeHandler_MatchesDirectEnforcerResult(t *testing.T) {
|
||||
enforcer := setupTest(t)
|
||||
mux := http.NewServeMux()
|
||||
Mount(mux, enforcer, testToken)
|
||||
server := httptest.NewServer(mux)
|
||||
defer server.Close()
|
||||
|
||||
cases := []struct {
|
||||
role, permission string
|
||||
}{
|
||||
{"rbac06_erlaubte_rolle", "rbac06_recht"}, // erlaubt
|
||||
{"rbac06_unbekannte_rolle", "rbac06_recht"}, // verboten (default-deny)
|
||||
{"rbac06_erlaubte_rolle", "rbac06_anderes"}, // verboten (falsches recht)
|
||||
}
|
||||
|
||||
for i := 0; i < 100; i++ {
|
||||
c := cases[i%len(cases)]
|
||||
directErr := enforcer.Authorize(context.Background(), rbac.Role(c.role), rbac.Permission(c.permission))
|
||||
directAllowed := directErr == nil
|
||||
if directErr != nil && !errors.Is(directErr, policy.ErrDenied) {
|
||||
t.Fatalf("stichprobe %d: unerwarteter enforcer-fehler: %v", i, directErr)
|
||||
}
|
||||
|
||||
status, httpAllowed := authorize(t, server, c.role, c.permission)
|
||||
if status != http.StatusOK {
|
||||
t.Fatalf("stichprobe %d: unerwarteter status %d", i, status)
|
||||
}
|
||||
if httpAllowed != directAllowed {
|
||||
t.Fatalf("stichprobe %d (%s/%s): http=%t, direkt=%t - weichen ab", i, c.role, c.permission, httpAllowed, directAllowed)
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user