jcoffey-dev
17fdc212c2
Ingest tenant-awareness was named "undesigned, not just unbuilt" across CLAUDE.md/threat-model.md/the runbook since early Phase 4 -- the last major standing gap. Scoping was agreed via AskUserQuestion: a config-supplied tenant_id + shared-secret token ingest validates (smaller real implementation, no new PKI), over per-tenant mTLS certs. This change builds that identity mechanism end to end and attaches it to every record at the point it enters the system; it deliberately does NOT build per-tenant write-routing for ClickHouse or Tantivy -- that's real, separately-scoped follow-up work, disclosed explicitly everywhere this was previously called undesigned, not silently left half-done. New pieces: - metadata/migrations/0034 + enterprise/internal/rbacstore/ ingest_credentials.go: a per-tenant bearer credential, only its SHA-256 hash ever persisted (same reasoning a password gets hashed, not stored raw) -- CreateIngestCredential returns the plaintext exactly once, ValidateIngestCredential/RevokeIngestCredential/ ListIngestCredentialsForTenant round it out. - enterprise-auth gains -create-ingest-credential-tenant/ -list-ingest-credentials-tenant/-revoke-ingest-credential (same offline-operator-flag shape as every other credential-minting flag in this binary) and a new POST /internal/authorize-ingest endpoint (internal/authhandler) validating a presented token and resolving its tenant -- a genuinely different credential type from session-backed /internal/authorize, so it doesn't touch session.Manager at all. - ingest (AGPL core) gains an optional TenantResolver (internal/grpcserver, nil by default) and its HTTP client implementation (internal/tenantresolver.HTTPResolver) -- a plain HTTP call to enterprise-auth's new endpoint, never an enterprise/ import, same "network boundary, not import boundary" shape api/authz.HTTPAuthorizer already uses for the query path. PushBatch now requires an `authorization: Bearer <token>` gRPC metadata entry once a resolver is configured, fails the whole batch closed on a missing/invalid credential (never falls back to "no tenant"), and attaches the resolved tenant ID to every record as a `tenant_id` Kafka message header before producing it. Verified with real round trips at every layer, no Docker needed: rbacstore's credential CRUD (skip-gated on live Postgres, same as every other rbacstore integration test this phase), authhandler's new endpoint (real HTTP via httptest, including the regression test that a session token must not validate as an ingest credential), tenantresolver (real HTTP client against httptest, same pattern as authz.HTTPAuthorizer's own tests), and grpcserver's PushBatch (fake resolver/producer -- no resolver leaves messages unchanged, a configured resolver attaches the right header or fails closed on a bad/missing token). Helm: ingest.requireTenantCredential (default false) is a deliberate, separate opt-in from enterprise.enabled -- turning ENTERPRISE_AUTH_URL on for ingest requires every agent to already hold a credential or be refused outright, so it must not default on just because enterprise.enabled does (same reasoning api.yaml's ENTERPRISE_AUTH_URL isn't tied to enterprise.enabled directly either). docker-compose.yml leaves it unset, same as ever. Docs updated everywhere this was called "undesigned": CLAUDE.md, docs/architecture.md, docs/security/threat-model.md (including its summary table, now split into "identity: built" vs "write-routing: not yet"), docs/phase-4-runbook.md (new §13), enterprise/README.md.
276 lines
8.5 KiB
Go
276 lines
8.5 KiB
Go
package authhandler
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"io"
|
|
"log/slog"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"testing"
|
|
|
|
"github.com/sentry/sentry/enterprise/internal/session"
|
|
)
|
|
|
|
// fakeIngestCredentialValidator is an in-memory stand-in for
|
|
// *rbacstore.Store's ValidateIngestCredential, keyed by token.
|
|
type fakeIngestCredentialValidator struct {
|
|
tenantByToken map[string]string
|
|
}
|
|
|
|
func newFakeIngestCredentialValidator() *fakeIngestCredentialValidator {
|
|
return &fakeIngestCredentialValidator{tenantByToken: map[string]string{}}
|
|
}
|
|
|
|
func (f *fakeIngestCredentialValidator) ValidateIngestCredential(_ context.Context, token string) (string, error) {
|
|
tenantID, ok := f.tenantByToken[token]
|
|
if !ok {
|
|
return "", errNotFound
|
|
}
|
|
return tenantID, nil
|
|
}
|
|
|
|
var errNotFound = &fakeNotFoundError{}
|
|
|
|
type fakeNotFoundError struct{}
|
|
|
|
func (*fakeNotFoundError) Error() string { return "not found" }
|
|
|
|
func testHandler(t *testing.T) (*Handler, *session.Manager) {
|
|
t.Helper()
|
|
m, err := session.NewManager([]byte("this-is-a-32-byte-test-signing-key!"))
|
|
if err != nil {
|
|
t.Fatalf("session.NewManager: %v", err)
|
|
}
|
|
return New(slog.New(slog.NewTextHandler(io.Discard, nil)), m, Features{}, newFakeIngestCredentialValidator()), m
|
|
}
|
|
|
|
func doAuthorize(t *testing.T, h *Handler, mutate func(*http.Request)) *httptest.ResponseRecorder {
|
|
t.Helper()
|
|
mux := http.NewServeMux()
|
|
h.RegisterRoutes(mux)
|
|
req := httptest.NewRequest(http.MethodPost, "/internal/authorize", nil)
|
|
if mutate != nil {
|
|
mutate(req)
|
|
}
|
|
rec := httptest.NewRecorder()
|
|
mux.ServeHTTP(rec, req)
|
|
return rec
|
|
}
|
|
|
|
func TestAuthorizeViaServiceToken(t *testing.T) {
|
|
h, m := testHandler(t)
|
|
token, err := m.IssueServiceToken("alerting")
|
|
if err != nil {
|
|
t.Fatalf("IssueServiceToken: %v", err)
|
|
}
|
|
rec := doAuthorize(t, h, func(r *http.Request) {
|
|
r.Header.Set("Authorization", "Bearer "+token)
|
|
})
|
|
if rec.Code != http.StatusOK {
|
|
t.Fatalf("status = %d, body = %s", rec.Code, rec.Body.String())
|
|
}
|
|
var body authorizeResponse
|
|
if err := json.NewDecoder(rec.Body).Decode(&body); err != nil {
|
|
t.Fatalf("decoding response: %v", err)
|
|
}
|
|
if body.Role != "service" || body.TenantID != "" || body.UserID != "" {
|
|
t.Fatalf("unexpected response: %+v", body)
|
|
}
|
|
}
|
|
|
|
func TestAuthorizeViaSessionCookie(t *testing.T) {
|
|
h, m := testHandler(t)
|
|
token, err := m.IssueUserSession("acme", "u1", "editor")
|
|
if err != nil {
|
|
t.Fatalf("IssueUserSession: %v", err)
|
|
}
|
|
rec := doAuthorize(t, h, func(r *http.Request) {
|
|
r.AddCookie(&http.Cookie{Name: SessionCookieName, Value: token})
|
|
})
|
|
if rec.Code != http.StatusOK {
|
|
t.Fatalf("status = %d, body = %s", rec.Code, rec.Body.String())
|
|
}
|
|
var body authorizeResponse
|
|
if err := json.NewDecoder(rec.Body).Decode(&body); err != nil {
|
|
t.Fatalf("decoding response: %v", err)
|
|
}
|
|
if body.TenantID != "acme" || body.UserID != "u1" || body.Role != "editor" {
|
|
t.Fatalf("unexpected response: %+v", body)
|
|
}
|
|
}
|
|
|
|
func TestAuthorizeBearerTakesPrecedenceOverCookie(t *testing.T) {
|
|
h, m := testHandler(t)
|
|
serviceToken, err := m.IssueServiceToken("alerting")
|
|
if err != nil {
|
|
t.Fatalf("IssueServiceToken: %v", err)
|
|
}
|
|
sessionToken, err := m.IssueUserSession("acme", "u1", "viewer")
|
|
if err != nil {
|
|
t.Fatalf("IssueUserSession: %v", err)
|
|
}
|
|
rec := doAuthorize(t, h, func(r *http.Request) {
|
|
r.Header.Set("Authorization", "Bearer "+serviceToken)
|
|
r.AddCookie(&http.Cookie{Name: SessionCookieName, Value: sessionToken})
|
|
})
|
|
var body authorizeResponse
|
|
if err := json.NewDecoder(rec.Body).Decode(&body); err != nil {
|
|
t.Fatalf("decoding response: %v", err)
|
|
}
|
|
if body.Role != "service" {
|
|
t.Fatalf("expected the Bearer service token to win, got role %q", body.Role)
|
|
}
|
|
}
|
|
|
|
func TestAuthorizeNoCredentialsIsUnauthorized(t *testing.T) {
|
|
h, _ := testHandler(t)
|
|
rec := doAuthorize(t, h, nil)
|
|
if rec.Code != http.StatusUnauthorized {
|
|
t.Fatalf("status = %d, want 401", rec.Code)
|
|
}
|
|
}
|
|
|
|
func TestAuthorizeInvalidTokenIsUnauthorized(t *testing.T) {
|
|
h, _ := testHandler(t)
|
|
rec := doAuthorize(t, h, func(r *http.Request) {
|
|
r.Header.Set("Authorization", "Bearer not-a-real-token")
|
|
})
|
|
if rec.Code != http.StatusUnauthorized {
|
|
t.Fatalf("status = %d, want 401", rec.Code)
|
|
}
|
|
}
|
|
|
|
func TestFeaturesReflectsConfiguredMechanisms(t *testing.T) {
|
|
m, err := session.NewManager([]byte("this-is-a-32-byte-test-signing-key!"))
|
|
if err != nil {
|
|
t.Fatalf("session.NewManager: %v", err)
|
|
}
|
|
h := New(slog.New(slog.NewTextHandler(io.Discard, nil)), m, Features{OIDCEnabled: true, SAMLEnabled: false}, newFakeIngestCredentialValidator())
|
|
|
|
mux := http.NewServeMux()
|
|
h.RegisterRoutes(mux)
|
|
rec := httptest.NewRecorder()
|
|
mux.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/auth/features", nil))
|
|
|
|
if rec.Code != http.StatusOK {
|
|
t.Fatalf("status = %d, body = %s", rec.Code, rec.Body.String())
|
|
}
|
|
var body featuresResponse
|
|
if err := json.NewDecoder(rec.Body).Decode(&body); err != nil {
|
|
t.Fatalf("decoding response: %v", err)
|
|
}
|
|
if !body.SSOConfigured || !body.OIDCEnabled || body.SAMLEnabled {
|
|
t.Fatalf("unexpected features response: %+v", body)
|
|
}
|
|
}
|
|
|
|
func TestFeaturesAllFalseWhenNothingConfigured(t *testing.T) {
|
|
h, _ := testHandler(t)
|
|
mux := http.NewServeMux()
|
|
h.RegisterRoutes(mux)
|
|
rec := httptest.NewRecorder()
|
|
mux.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/auth/features", nil))
|
|
|
|
var body featuresResponse
|
|
if err := json.NewDecoder(rec.Body).Decode(&body); err != nil {
|
|
t.Fatalf("decoding response: %v", err)
|
|
}
|
|
if body.SSOConfigured || body.OIDCEnabled || body.SAMLEnabled {
|
|
t.Fatalf("expected all-false features when nothing is configured, got %+v", body)
|
|
}
|
|
}
|
|
|
|
func TestAuthorizeTokenFromWrongManagerIsUnauthorized(t *testing.T) {
|
|
h, _ := testHandler(t)
|
|
otherManager, err := session.NewManager([]byte("a-completely-different-32-byte-key!"))
|
|
if err != nil {
|
|
t.Fatalf("session.NewManager: %v", err)
|
|
}
|
|
token, err := otherManager.IssueServiceToken("alerting")
|
|
if err != nil {
|
|
t.Fatalf("IssueServiceToken: %v", err)
|
|
}
|
|
rec := doAuthorize(t, h, func(r *http.Request) {
|
|
r.Header.Set("Authorization", "Bearer "+token)
|
|
})
|
|
if rec.Code != http.StatusUnauthorized {
|
|
t.Fatalf("status = %d, want 401", rec.Code)
|
|
}
|
|
}
|
|
|
|
func doAuthorizeIngest(t *testing.T, h *Handler, mutate func(*http.Request)) *httptest.ResponseRecorder {
|
|
t.Helper()
|
|
mux := http.NewServeMux()
|
|
h.RegisterRoutes(mux)
|
|
req := httptest.NewRequest(http.MethodPost, "/internal/authorize-ingest", nil)
|
|
if mutate != nil {
|
|
mutate(req)
|
|
}
|
|
rec := httptest.NewRecorder()
|
|
mux.ServeHTTP(rec, req)
|
|
return rec
|
|
}
|
|
|
|
func TestAuthorizeIngestResolvesTenant(t *testing.T) {
|
|
m, err := session.NewManager([]byte("this-is-a-32-byte-test-signing-key!"))
|
|
if err != nil {
|
|
t.Fatalf("session.NewManager: %v", err)
|
|
}
|
|
validator := newFakeIngestCredentialValidator()
|
|
validator.tenantByToken["real-token"] = "acme"
|
|
h := New(slog.New(slog.NewTextHandler(io.Discard, nil)), m, Features{}, validator)
|
|
|
|
rec := doAuthorizeIngest(t, h, func(r *http.Request) {
|
|
r.Header.Set("Authorization", "Bearer real-token")
|
|
})
|
|
if rec.Code != http.StatusOK {
|
|
t.Fatalf("status = %d, body = %s", rec.Code, rec.Body.String())
|
|
}
|
|
var body authorizeIngestResponse
|
|
if err := json.NewDecoder(rec.Body).Decode(&body); err != nil {
|
|
t.Fatalf("decoding response: %v", err)
|
|
}
|
|
if body.TenantID != "acme" {
|
|
t.Fatalf("TenantID = %q, want acme", body.TenantID)
|
|
}
|
|
}
|
|
|
|
func TestAuthorizeIngestNoCredentialsIsUnauthorized(t *testing.T) {
|
|
h, _ := testHandler(t)
|
|
rec := doAuthorizeIngest(t, h, nil)
|
|
if rec.Code != http.StatusUnauthorized {
|
|
t.Fatalf("status = %d, want 401", rec.Code)
|
|
}
|
|
}
|
|
|
|
func TestAuthorizeIngestUnknownTokenIsUnauthorized(t *testing.T) {
|
|
h, _ := testHandler(t)
|
|
rec := doAuthorizeIngest(t, h, func(r *http.Request) {
|
|
r.Header.Set("Authorization", "Bearer not-a-real-token")
|
|
})
|
|
if rec.Code != http.StatusUnauthorized {
|
|
t.Fatalf("status = %d, want 401", rec.Code)
|
|
}
|
|
}
|
|
|
|
// TestAuthorizeIngestRejectsSessionToken is the regression test for the
|
|
// two /internal/authorize* endpoints validating genuinely different
|
|
// credential types: a real session.Manager-signed token (a service
|
|
// token or human session) must not work as an ingest credential, since
|
|
// it was never checked against rbacstore.ValidateIngestCredential --
|
|
// this endpoint doesn't call session.Manager.Validate at all.
|
|
func TestAuthorizeIngestRejectsSessionToken(t *testing.T) {
|
|
h, m := testHandler(t)
|
|
sessionToken, err := m.IssueServiceToken("alerting")
|
|
if err != nil {
|
|
t.Fatalf("IssueServiceToken: %v", err)
|
|
}
|
|
rec := doAuthorizeIngest(t, h, func(r *http.Request) {
|
|
r.Header.Set("Authorization", "Bearer "+sessionToken)
|
|
})
|
|
if rec.Code != http.StatusUnauthorized {
|
|
t.Fatalf("status = %d, want 401 (a session token must not validate as an ingest credential)", rec.Code)
|
|
}
|
|
}
|