Files
archie/internal/infrastructure/oidc/oidc.go
T

160 lines
5.2 KiB
Go

// Package oidc verifies identity-provider tokens. It is a resource server: it
// validates a token the provider issued and never issues one, holds no client
// secret, and mints no session.
package oidc
import (
"context"
"fmt"
"strings"
"sync"
gooidc "github.com/coreos/go-oidc/v3/oidc"
"github.com/samcharles93/archie-core/internal/domain/identity"
)
// Config identifies the provider and the audience archie accepts tokens for.
// Audience is required rather than optional: without it a token the provider
// minted for a different service would authenticate here, which is the
// confused-deputy failure this boundary exists to prevent.
type Config struct {
Issuer string
Audience string
}
// 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
}
// 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 == "" {
return nil, fmt.Errorf("oidc: issuer is required")
}
if audience == "" {
return nil, fmt.Errorf("oidc: audience is required")
}
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
}
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
audience string
}
// 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.provider == nil {
return identity.Credential{}, fmt.Errorf("oidc: no verifier is configured")
}
discovered, err := v.provider.get(ctx)
if err != nil {
return identity.Credential{}, err
}
audience := v.audience
if audience == "" {
audience = v.provider.audience
}
verifier := discovered.Verifier(&gooidc.Config{ClientID: audience})
token, err := verifier.Verify(ctx, strings.TrimSpace(rawToken))
if err != nil {
return identity.Credential{}, fmt.Errorf("oidc: verify: %w", err)
}
// Claims are read after verification and are the only source of the
// identity: an unverified token selects nothing.
var claims struct {
Subject string `json:"sub"`
ClientID string `json:"client_id"`
Scope string `json:"scope"`
Scopes []string `json:"scp"`
Email string `json:"email"`
Verified bool `json:"email_verified"`
}
_ = token.Claims(&claims)
subject, err := subjectFor(token.Issuer, claims.Subject, claims.ClientID)
if err != nil {
return identity.Credential{}, err
}
email := ""
if claims.Verified {
email = strings.TrimSpace(claims.Email)
}
return identity.Credential{
Subject: subject,
Email: email,
Scopes: scopesFor(claims.Scope, claims.Scopes),
Expires: token.Expiry,
}, nil
}
// subjectFor returns the token's subject: sub for a person, client_id for a
// machine. A token with neither is refused.
func subjectFor(issuer, subject, clientID string) (identity.Subject, error) {
switch {
case strings.TrimSpace(subject) != "":
return identity.Subject{Issuer: issuer, Subject: strings.TrimSpace(subject)}, nil
case strings.TrimSpace(clientID) != "":
return identity.Subject{Issuer: issuer, Subject: strings.TrimSpace(clientID)}, nil
default:
return identity.Subject{}, fmt.Errorf("oidc: token asserts neither sub nor client_id")
}
}
// scopesFor reads the granted scopes from either claim shape. Providers differ:
// the standard is a space-delimited scope string, and this provider also emits an
// scp array. Reading only one shape silently yields no scopes at all, which is
// worse than reading none deliberately.
func scopesFor(scope string, scopes []string) []string {
if len(scopes) > 0 {
return scopes
}
return strings.Fields(scope)
}
// NewVerifierForAudience shares discovery and signing-key caches while checking
// the browser client's audience instead of a resource-server audience.
func NewVerifierForAudience(provider *Provider, audience string) *Verifier {
return &Verifier{provider: provider, audience: audience}
}