fix(archieui): a sign-in provider outage is a health issue, not a startup failure

This commit is contained in:
sam committed 2026-10-04 18:12:23 +11:00
1 parent 90399f5025
commit 56f2bf8a5d
8 files changed
+196 -73

No files matched your search

+17 -15
View File
@@ -10,20 +10,23 @@ import (
"github.com/samcharles93/archie-core/internal/infrastructure/oidc"
)
// dashboardAuthenticator builds the OIDC credential check, or nil when no
// provider is configured.
func dashboardAuthenticator(ctx context.Context, opts Options, subjects identity.SubjectResolver, log *slog.Logger) (func(context.Context, string) (identity.Identity, error), error) {
// signInProvider returns the configured identity provider, or nil when none
// is. It does not contact the provider: an outage is a health issue, not a
// reason to stop serving.
func signInProvider(opts Options) (*oidc.Provider, error) {
if strings.TrimSpace(opts.OidcIssuer) == "" {
return nil, nil
}
verifier, err := oidc.New(ctx, oidc.Config{Issuer: opts.OidcIssuer, Audience: opts.OidcAudience})
if err != nil {
// Failing here rather than serving anyway: a dashboard that cannot verify
// a credential would silently fall back to a gate that names nobody, and
// an operator who configured a provider must not get the unauthenticated
// behaviour instead.
return nil, err
return oidc.NewProvider(oidc.Config{Issuer: opts.OidcIssuer, Audience: opts.OidcAudience})
}
// dashboardAuthenticator builds the credential check, or nil when no provider
// is configured.
func dashboardAuthenticator(provider *oidc.Provider, opts Options, subjects identity.SubjectResolver, log *slog.Logger) func(context.Context, string) (identity.Identity, error) {
if provider == nil {
return nil
}
verifier := oidc.NewVerifier(provider)
log.Info("dashboard authenticates provider credentials", "issuer", opts.OidcIssuer, "audience", opts.OidcAudience)
return func(ctx context.Context, credential string) (identity.Identity, error) {
// A personal token is bound in the State Store, not issued by the
@@ -33,19 +36,18 @@ func dashboardAuthenticator(ctx context.Context, opts Options, subjects identity
}
value, _, err := identity.Authenticate(ctx, subjects, verifier, credential)
return value, err
}, nil
}
}
// dashboardLoginFlow builds the browser sign-in flow, or nil when not
// configured. The client secret is read from the named env var.
func dashboardLoginFlow(ctx context.Context, opts Options) (identity.LoginFlow, error) {
if strings.TrimSpace(opts.OidcIssuer) == "" || strings.TrimSpace(opts.OidcClientID) == "" {
func dashboardLoginFlow(provider *oidc.Provider, opts Options) (identity.LoginFlow, error) {
if provider == nil || strings.TrimSpace(opts.OidcClientID) == "" {
return nil, nil
}
secret := ""
if name := strings.TrimSpace(opts.OidcClientSecretEnv); name != "" {
secret = os.Getenv(name)
}
return oidc.NewFlow(ctx, oidc.Config{Issuer: opts.OidcIssuer, Audience: opts.OidcAudience},
opts.OidcClientID, secret, opts.OidcRedirectURL)
return oidc.NewFlow(provider, opts.OidcClientID, secret, opts.OidcRedirectURL)
}
+10 -5
View File
@@ -10,13 +10,14 @@ import (
"github.com/samcharles93/archie-core/internal/domain/messaging"
"github.com/samcharles93/archie-core/internal/domain/storecontract"
infraaccess "github.com/samcharles93/archie-core/internal/infrastructure/access"
"github.com/samcharles93/archie-core/internal/infrastructure/oidc"
"github.com/samcharles93/archie-core/internal/infrastructure/readiness"
)
// newReadinessRegistry builds the readiness probes for the Gateway and State
// Store.
func newReadinessRegistry(o Options, tasks storecontract.TaskStore, chat messaging.ChatContract, chain *infraaccess.Live) *health.Registry {
return health.NewRegistry(
// newReadinessRegistry builds the readiness probes for the Gateway, the State
// Store and, when one is configured, the sign-in provider.
func newReadinessRegistry(o Options, tasks storecontract.TaskStore, chat messaging.ChatContract, chain *infraaccess.Live, provider *oidc.Provider) *health.Registry {
probes := []health.Probe{
readiness.NewProblemProbe("access_policies", problemSource(chain)),
captureRefusalProbe{store: refusalStore(tasks)},
readiness.NewContractProbe("state_db", o.DependencyTimeout, func(ctx context.Context) error {
@@ -27,7 +28,11 @@ func newReadinessRegistry(o Options, tasks storecontract.TaskStore, chat messagi
_, err := chat.Snapshot(ctx)
return err
}),
)
}
if provider != nil {
probes = append(probes, readiness.NewContractProbe("sign_in_provider", o.DependencyTimeout, provider.Check))
}
return health.NewRegistry(probes...)
}
// problemSource keeps a missing chain a nil source, which the probe reports
+4 -3
View File
@@ -72,11 +72,12 @@ func Run(ctx context.Context, options Options) error {
return err
}
authenticate, err := dashboardAuthenticator(ctx, opts, tasks, log)
provider, err := signInProvider(opts)
if err != nil {
return err
}
login, err := dashboardLoginFlow(ctx, opts)
authenticate := dashboardAuthenticator(provider, opts, tasks, log)
login, err := dashboardLoginFlow(provider, opts)
if err != nil {
return err
}
@@ -86,7 +87,7 @@ func Run(ctx context.Context, options Options) error {
Log: log,
Store: tasks,
Chat: chat,
Health: newReadinessRegistry(opts, tasks, chat, chain),
Health: newReadinessRegistry(opts, tasks, chat, chain, provider),
ControlPlane: tasks.ControlPlane(),
Identities: tasks,
Authenticate: authenticate,
+4 -1
View File
@@ -55,7 +55,7 @@ type SubjectBinding interface {
type LoginFlow interface {
// AuthCodeURL returns the provider URL for a sign-in and the PKCE verifier the
// callback must present with the code.
AuthCodeURL(state string) (string, string)
AuthCodeURL(ctx context.Context, state string) (string, string, error)
// Exchange completes the flow and returns what the provider proved. It
// verifies through the same path a presented token takes, so a token obtained
// by browser cannot be accepted on terms a presented token would be refused on.
@@ -88,6 +88,9 @@ var (
// verify: wrong signature, expired, wrong issuer, wrong audience, or
// malformed. It never means the credential was merely unrecognised.
ErrCredentialRejected = errors.New("credential rejected")
// ErrProviderUnavailable means the identity provider could not be reached,
// so a credential could be neither accepted nor refused.
ErrProviderUnavailable = errors.New("identity provider unavailable")
// ErrSubjectUnbound means a verified subject has no identity bound to it.
// The provider authenticated someone archie does not know.
ErrSubjectUnbound = errors.New("credential subject is not bound to an identity")
+40 -35
View File
@@ -16,57 +16,58 @@ import (
// password, holding a session, or writing any of the protocol itself: discovery,
// the code exchange, PKCE and token verification are the libraries'.
type Flow struct {
verifier *Verifier
oauth oauth2.Config
audience string
provider *Provider
verifier *Verifier
clientID string
clientSecret string
redirectURL string
}
// NewFlow discovers the provider and builds the browser flow. ClientID and the
// secret are the provider's registration for this dashboard; the secret is read
// from wherever the operator keeps it and is never logged or stored.
func NewFlow(ctx context.Context, cfg Config, clientID, clientSecret, redirectURL string) (*Flow, error) {
issuer := strings.TrimSpace(cfg.Issuer)
audience := strings.TrimSpace(cfg.Audience)
if issuer == "" {
return nil, fmt.Errorf("oidc: issuer is required")
}
if audience == "" {
return nil, fmt.Errorf("oidc: audience is required")
}
// NewFlow builds the browser flow over provider. ClientID and the secret are
// the provider's registration for this dashboard; the secret is read from
// wherever the operator keeps it and is never logged or stored.
func NewFlow(provider *Provider, clientID, clientSecret, redirectURL string) (*Flow, error) {
if strings.TrimSpace(clientID) == "" {
return nil, fmt.Errorf("oidc: client id is required for the browser flow")
}
if strings.TrimSpace(redirectURL) == "" {
return nil, fmt.Errorf("oidc: redirect URL is required for the browser flow")
}
provider, err := gooidc.NewProvider(ctx, issuer)
if err != nil {
return nil, fmt.Errorf("oidc: discover %q: %w", issuer, err)
}
return &Flow{
verifier: &Verifier{verifier: provider.Verifier(&gooidc.Config{ClientID: audience})},
oauth: oauth2.Config{
ClientID: clientID,
ClientSecret: clientSecret,
Endpoint: provider.Endpoint(),
RedirectURL: redirectURL,
// openid is what makes the provider return a subject at all; profile
// and email are what make a name available for a display.
Scopes: []string{gooidc.ScopeOpenID, "profile", "email"},
},
audience: audience,
provider: provider, verifier: NewVerifier(provider),
clientID: clientID, clientSecret: clientSecret, redirectURL: redirectURL,
}, nil
}
func (f *Flow) oauth(ctx context.Context) (oauth2.Config, error) {
discovered, err := f.provider.get(ctx)
if err != nil {
return oauth2.Config{}, err
}
return oauth2.Config{
ClientID: f.clientID,
ClientSecret: f.clientSecret,
Endpoint: discovered.Endpoint(),
RedirectURL: f.redirectURL,
// openid is what makes the provider return a subject at all; profile
// and email are what make a name available for a display.
Scopes: []string{gooidc.ScopeOpenID, "profile", "email"},
}, nil
}
// AuthCodeURL returns the provider URL to send a browser to, with the
// audience requested, and the PKCE verifier.
func (f *Flow) AuthCodeURL(state string) (string, string) {
func (f *Flow) AuthCodeURL(ctx context.Context, state string) (string, string, error) {
config, err := f.oauth(ctx)
if err != nil {
return "", "", err
}
codeVerifier := oauth2.GenerateVerifier()
url := f.oauth.AuthCodeURL(state,
url := config.AuthCodeURL(state,
oauth2.S256ChallengeOption(codeVerifier),
oauth2.SetAuthURLParam("audience", f.audience),
oauth2.SetAuthURLParam("audience", f.provider.audience),
)
return url, codeVerifier
return url, codeVerifier, nil
}
// Exchange completes the flow: it trades the code for the provider's tokens and
@@ -74,7 +75,11 @@ func (f *Flow) AuthCodeURL(state string) (string, string) {
// through. There is no second verification path here, so a token obtained by the
// browser cannot be accepted on terms a presented token would be refused on.
func (f *Flow) Exchange(ctx context.Context, code, codeVerifier string) (identity.ProviderSession, error) {
token, err := f.oauth.Exchange(ctx, strings.TrimSpace(code), oauth2.VerifierOption(codeVerifier))
config, err := f.oauth(ctx)
if err != nil {
return identity.ProviderSession{}, err
}
token, err := config.Exchange(ctx, strings.TrimSpace(code), oauth2.VerifierOption(codeVerifier))
if err != nil {
return identity.ProviderSession{}, fmt.Errorf("oidc: exchange code: %w", err)
}
+52 -13
View File
@@ -7,6 +7,7 @@ import (
"context"
"fmt"
"strings"
"sync"
gooidc "github.com/coreos/go-oidc/v3/oidc"
@@ -22,15 +23,19 @@ type Config struct {
Audience string
}
// Verifier validates tokens against the provider's published signing keys.
type Verifier struct {
verifier *gooidc.IDTokenVerifier
// Provider discovers the identity provider on first use and keeps the result.
// A provider that is down at startup does not stop the dashboard: discovery
// is retried on the next request, and Check reports the outage as health.
type Provider struct {
issuer string
audience string
mu sync.Mutex
discovered *gooidc.Provider
}
// New discovers the provider and builds a verifier from its published keys.
// Discovery happens once, at construction: an unreachable provider is a
// startup failure the operator sees, not a request-time surprise.
func New(ctx context.Context, cfg Config) (*Verifier, error) {
// NewProvider validates cfg without contacting the provider.
func NewProvider(cfg Config) (*Provider, error) {
issuer := strings.TrimSpace(cfg.Issuer)
audience := strings.TrimSpace(cfg.Audience)
if issuer == "" {
@@ -39,21 +44,55 @@ func New(ctx context.Context, cfg Config) (*Verifier, error) {
if audience == "" {
return nil, fmt.Errorf("oidc: audience is required")
}
provider, err := gooidc.NewProvider(ctx, issuer)
if err != nil {
return nil, fmt.Errorf("oidc: discover %q: %w", issuer, err)
return &Provider{issuer: issuer, audience: audience}, nil
}
// get returns the discovered provider, discovering it now if no earlier
// attempt succeeded.
func (p *Provider) get(ctx context.Context) (*gooidc.Provider, error) {
p.mu.Lock()
defer p.mu.Unlock()
if p.discovered != nil {
return p.discovered, nil
}
return &Verifier{verifier: provider.Verifier(&gooidc.Config{ClientID: audience})}, nil
discovered, err := gooidc.NewProvider(ctx, p.issuer)
if err != nil {
return nil, fmt.Errorf("%w: discover %q: %w", identity.ErrProviderUnavailable, p.issuer, err)
}
p.discovered = discovered
return discovered, nil
}
// Check fetches the provider's discovery document afresh, so an outage after
// startup shows as well as one before it.
func (p *Provider) Check(ctx context.Context) error {
_, err := gooidc.NewProvider(ctx, p.issuer)
return err
}
// Verifier validates tokens against the provider's published signing keys.
type Verifier struct {
provider *Provider
}
// NewVerifier returns a verifier for provider's tokens.
func NewVerifier(provider *Provider) *Verifier {
return &Verifier{provider: provider}
}
// Verify checks the token's signature, issuer, audience and expiry against the
// provider's keys, and returns what it proved. Every check is the library's:
// signature comparison, claim validation and key rotation are not archie's code.
func (v *Verifier) Verify(ctx context.Context, rawToken string) (identity.Credential, error) {
if v == nil || v.verifier == nil {
if v == nil || v.provider == nil {
return identity.Credential{}, fmt.Errorf("oidc: no verifier is configured")
}
token, err := v.verifier.Verify(ctx, strings.TrimSpace(rawToken))
discovered, err := v.provider.get(ctx)
if err != nil {
return identity.Credential{}, err
}
verifier := discovered.Verifier(&gooidc.Config{ClientID: v.provider.audience})
token, err := verifier.Verify(ctx, strings.TrimSpace(rawToken))
if err != nil {
return identity.Credential{}, fmt.Errorf("oidc: verify: %w", err)
}
@@ -0,0 +1,60 @@
package oidc
import (
"context"
"encoding/json"
"errors"
"net/http"
"net/http/httptest"
"sync/atomic"
"testing"
"github.com/samcharles93/archie-core/internal/domain/identity"
)
// TestProviderOutageIsUnavailableThenRecovers pins that a provider down at
// startup neither stops the dashboard nor refuses credentials as invalid, and
// that sign-in works once it returns.
func TestProviderOutageIsUnavailableThenRecovers(t *testing.T) {
var up atomic.Bool
var server *httptest.Server
server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if !up.Load() {
http.Error(w, "down", http.StatusServiceUnavailable)
return
}
_ = json.NewEncoder(w).Encode(map[string]string{
"issuer": server.URL, "authorization_endpoint": server.URL + "/auth",
"token_endpoint": server.URL + "/token", "jwks_uri": server.URL + "/keys",
})
}))
defer server.Close()
provider, err := NewProvider(Config{Issuer: server.URL, Audience: "archie"})
if err != nil {
t.Fatalf("a down provider must not fail construction: %v", err)
}
verifier := NewVerifier(provider)
ctx := context.Background()
tests := []struct {
name string
up bool
wantUnavailable bool
}{
{"down is unavailable, not rejected", false, true},
{"back up is a normal verification", true, false},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
up.Store(tt.up)
_, err := verifier.Verify(ctx, "not-a-jwt")
if err == nil || errors.Is(err, identity.ErrProviderUnavailable) != tt.wantUnavailable {
t.Fatalf("verify err %v, want unavailable %v", err, tt.wantUnavailable)
}
if checkErr := provider.Check(ctx); (checkErr != nil) != tt.wantUnavailable {
t.Fatalf("check err %v, want failure %v", checkErr, tt.wantUnavailable)
}
})
}
}
+9 -1
View File
@@ -206,7 +206,11 @@ func (s *Server) handleLogin(w http.ResponseWriter, r *http.Request) {
http.Error(w, "could not start sign-in", http.StatusInternalServerError)
return
}
url, verifier := s.Login.AuthCodeURL(state)
url, verifier, err := s.Login.AuthCodeURL(r.Context(), state)
if err != nil {
s.refuseUnidentified(w, r, err)
return
}
setFlowCookie(w, r, loginStateCookie, state)
setFlowCookie(w, r, loginVerifierCookie, verifier)
http.Redirect(w, r, url, http.StatusSeeOther)
@@ -286,6 +290,10 @@ func (s *Server) refuseUnidentified(w http.ResponseWriter, r *http.Request, err
status := http.StatusUnauthorized
reason := "That credential was not accepted."
switch {
case errors.Is(err, identity.ErrProviderUnavailable):
// Signing in again cannot help until the provider is back.
http.Error(w, "The sign-in provider is unavailable. Try again shortly.", http.StatusServiceUnavailable)
return
case errors.Is(err, identity.ErrIdentityInactive):
status, reason = http.StatusForbidden, "That identity may not act."
case errors.Is(err, identity.ErrSubjectUnbound):