package oidc import ( "context" "fmt" "strings" gooidc "github.com/coreos/go-oidc/v3/oidc" "golang.org/x/oauth2" "github.com/samcharles93/archie-core/internal/domain/identity" ) // Flow runs the authorization code flow with PKCE, so a person signs in at the // provider and the dashboard learns who they are without archie ever seeing a // 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 } // 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") } 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, }, nil } // AuthCodeURL returns the provider URL to send a browser to, and the PKCE // verifier the callback must present with the code. // // The audience is requested HERE, at the authorization endpoint, and not only at // the token endpoint: a provider that returns the audience empty otherwise mints // a token this dashboard must refuse, and the refusal looks like a signing fault // rather than a missing request parameter. The verifier is generated by the // library, not by archie. func (f *Flow) AuthCodeURL(state string) (string, string) { codeVerifier := oauth2.GenerateVerifier() url := f.oauth.AuthCodeURL(state, oauth2.S256ChallengeOption(codeVerifier), oauth2.SetAuthURLParam("audience", f.audience), ) return url, codeVerifier } // Exchange completes the flow: it trades the code for the provider's tokens and // verifies the access token through the same Verifier a presented token goes // 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)) if err != nil { return identity.ProviderSession{}, fmt.Errorf("oidc: exchange code: %w", err) } credential, err := f.verifier.Verify(ctx, token.AccessToken) if err != nil { return identity.ProviderSession{}, err } expires := token.Expiry if credential.Expires.Before(expires) || expires.IsZero() { expires = credential.Expires } return identity.ProviderSession{Credential: credential, Token: token.AccessToken, Expires: expires}, nil }