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

103 lines
3.7 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"
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
}
// Verifier validates tokens against the provider's published signing keys.
type Verifier struct {
verifier *gooidc.IDTokenVerifier
}
// 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) {
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")
}
provider, err := gooidc.NewProvider(ctx, issuer)
if err != nil {
return nil, fmt.Errorf("oidc: discover %q: %w", issuer, err)
}
return &Verifier{verifier: provider.Verifier(&gooidc.Config{ClientID: audience})}, nil
}
// 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 {
return identity.Credential{}, fmt.Errorf("oidc: no verifier is configured")
}
token, err := v.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"`
}
_ = token.Claims(&claims)
subject, err := subjectFor(token.Issuer, claims.Subject, claims.ClientID)
if err != nil {
return identity.Credential{}, err
}
return identity.Credential{
Subject: subject,
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)
}