From c12f6b79478be3e441c76b326f27d1d5a99deb15 Mon Sep 17 00:00:00 2001 From: Sam Catlow Date: Fri, 20 Nov 2026 00:30:11 +1100 Subject: [PATCH] feat(governance): sign in to the archie binary from the Vue dashboard (#2017) The binary serves the account routes the Vue client already calls: status, setup, password and passkey sign-in, recovery, sign-out, OIDC, account passkeys, password and recovery codes, personal tokens and capabilities. The API authenticates a session cookie, a personal token or the bootstrap admin token, and unsafe requests pass cross-origin protection. The dashboard serves the Vue app at /. Copied from internal/webui/{accounts,passkeys,personal_tokens, api_capabilities,auth}.go, internal/infrastructure/oidc/{flow,oidc}.go and internal/app/archieui/account_oidc.go, which archie-ui still imports. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- api/openapi.yaml | 908 +++++++++++++++++++++- internal/app/archie/api.go | 6 +- internal/app/archie/run.go | 2 +- internal/platform/httpapi/httpapi.go | 98 ++- internal/platform/httpapi/httpapi_test.go | 77 +- modules/dashboard/dashboard.go | 6 +- modules/governance/accounts_api.go | 712 +++++++++++++++++ modules/governance/auth.go | 122 +++ modules/governance/auth_test.go | 138 ++++ modules/governance/governance.go | 3 +- modules/governance/identity.go | 6 +- modules/governance/oidc.go | 198 +++++ ui/src/lib/api.ts | 14 +- ui/vite.config.ts | 4 +- 14 files changed, 2241 insertions(+), 53 deletions(-) create mode 100644 modules/governance/accounts_api.go create mode 100644 modules/governance/auth.go create mode 100644 modules/governance/auth_test.go create mode 100644 modules/governance/oidc.go diff --git a/api/openapi.yaml b/api/openapi.yaml index f5c019d31..e7707129d 100644 --- a/api/openapi.yaml +++ b/api/openapi.yaml @@ -76,6 +76,31 @@ components: truncated: type: boolean type: object + AuthenticationInputBody: + additionalProperties: false + properties: + oidc_audience: + type: string + oidc_client_id: + type: string + oidc_issuer: + type: string + public_url: + type: string + required: + - public_url + type: object + ChangePasswordInputBody: + additionalProperties: false + properties: + current_password: + type: string + new_password: + type: string + required: + - current_password + - new_password + type: object ChatActionDone: additionalProperties: false properties: @@ -557,6 +582,17 @@ components: - name - kind type: object + CreateTokenInputBody: + additionalProperties: false + properties: + days: + format: int64 + type: integer + name: + type: string + required: + - name + type: object DeliveriesAttempt: additionalProperties: false properties: @@ -934,6 +970,43 @@ components: - workflow - enabled type: object + GovernanceAuthStatusBody: + additionalProperties: false + properties: + instance: + type: string + oidc: + type: boolean + public_url: + type: string + setup_required: + type: boolean + user: + $ref: "#/components/schemas/GovernanceIdentity" + required: + - setup_required + - user + - oidc + - public_url + - instance + type: object + GovernanceAuthenticationSettings: + additionalProperties: false + properties: + oidc_audience: + type: string + oidc_client_id: + type: string + oidc_issuer: + type: string + public_url: + type: string + required: + - public_url + - oidc_issuer + - oidc_audience + - oidc_client_id + type: object GovernanceBlackout: additionalProperties: false properties: @@ -950,6 +1023,56 @@ components: - to - reason type: object + GovernanceCapabilitiesBody: + additionalProperties: false + properties: + sections: + additionalProperties: + type: boolean + type: object + required: + - sections + type: object + GovernanceCreatedToken: + additionalProperties: false + properties: + id: + type: string + token: + type: string + required: + - id + - token + type: object + GovernanceIdentity: + additionalProperties: false + properties: + created_at: + format: date-time + type: string + display_name: + type: string + id: + type: string + kind: + type: string + lifecycle: + type: string + updated_at: + format: date-time + type: string + version: + format: int64 + type: integer + required: + - id + - kind + - display_name + - lifecycle + - version + - created_at + - updated_at + type: object GovernanceModel: additionalProperties: false properties: @@ -977,6 +1100,38 @@ components: - model - answer type: object + GovernancePasskey: + additionalProperties: false + properties: + id: + type: string + name: + type: string + required: + - id + - name + type: object + GovernancePasskeyFinishBody: + additionalProperties: false + properties: + credential: {} + name: + type: string + required: + - credential + type: object + GovernancePasskeysBody: + additionalProperties: false + properties: + passkeys: + items: + $ref: "#/components/schemas/GovernancePasskey" + type: + - array + - "null" + required: + - passkeys + type: object GovernancePersonRequest: additionalProperties: false properties: @@ -998,6 +1153,55 @@ components: - authority - identities type: object + GovernancePersonalToken: + additionalProperties: false + properties: + created_at: + format: date-time + type: string + expires_at: + format: date-time + type: + - string + - "null" + id: + type: string + last_used_at: + format: date-time + type: + - string + - "null" + name: + type: string + required: + - id + - name + - created_at + - expires_at + - last_used_at + type: object + GovernanceRegistration: + additionalProperties: false + properties: + display_name: + type: string + email: + type: string + organisation_name: + type: string + password: + type: string + public_url: + type: string + role: + type: string + workspace_name: + type: string + required: + - email + - display_name + - password + type: object GovernanceSettingsRequest: additionalProperties: false properties: @@ -1081,6 +1285,29 @@ components: - days - blackouts type: object + GovernanceTokensBody: + additionalProperties: false + properties: + available: + type: boolean + tokens: + items: + $ref: "#/components/schemas/GovernancePersonalToken" + type: + - array + - "null" + required: + - tokens + - available + type: object + GovernanceUserBody: + additionalProperties: false + properties: + user: + $ref: "#/components/schemas/GovernanceIdentity" + required: + - user + type: object JudgementAction: additionalProperties: false properties: @@ -1615,6 +1842,28 @@ components: required: - body type: object + RecoverInputBody: + additionalProperties: false + properties: + code: + type: string + email: + type: string + password: + type: string + required: + - email + - code + - password + type: object + RecoveryCodeReplyBody: + additionalProperties: false + properties: + code: + type: string + required: + - code + type: object RenameInputBody: additionalProperties: false properties: @@ -2090,6 +2339,17 @@ components: required: - text type: object + SignInInputBody: + additionalProperties: false + properties: + email: + type: string + password: + type: string + required: + - email + - password + type: object SystemAdminToken: additionalProperties: false properties: @@ -2147,15 +2407,221 @@ components: - total_tokens type: object securitySchemes: - admin: - description: The bootstrap admin token + bearer: + description: A personal API token, or the bootstrap admin token scheme: bearer type: http + session: + description: The session a browser sign-in opens + in: cookie + name: archie_session + type: apiKey info: title: Archie version: dev openapi: 3.1.0 paths: + /api/account/passkeys: + get: + operationId: list-passkeys + responses: + "200": + content: + application/json: + schema: + $ref: "#/components/schemas/GovernancePasskeysBody" + description: OK + default: + content: + application/problem+json: + schema: + $ref: "#/components/schemas/ErrorModel" + description: Error + summary: List your passkeys + tags: + - Accounts + /api/account/passkeys/begin: + post: + operationId: begin-passkey-registration + parameters: + - in: cookie + name: archie_session + schema: + type: string + responses: + "200": + content: + application/json: + schema: {} + description: OK + headers: + Cache-Control: + schema: + type: string + Set-Cookie: + schema: + type: string + default: + content: + application/problem+json: + schema: + $ref: "#/components/schemas/ErrorModel" + description: Error + summary: Start adding a passkey + tags: + - Accounts + /api/account/passkeys/finish: + post: + operationId: finish-passkey-registration + parameters: + - in: cookie + name: archie_session + schema: + type: string + - in: cookie + name: archie_passkey_registration + schema: + type: string + requestBody: + content: + application/json: + schema: + $ref: "#/components/schemas/GovernancePasskeyFinishBody" + required: true + responses: + "200": + content: + application/json: + schema: + $ref: "#/components/schemas/GovernanceUserBody" + description: OK + headers: + Cache-Control: + schema: + type: string + Set-Cookie: + schema: + type: string + default: + content: + application/problem+json: + schema: + $ref: "#/components/schemas/ErrorModel" + description: Error + summary: Finish adding a passkey + tags: + - Accounts + /api/account/passkeys/{id}: + delete: + operationId: delete-passkey + parameters: + - in: cookie + name: archie_session + schema: + type: string + - in: path + name: id + required: true + schema: + type: string + responses: + "204": + description: No Content + default: + content: + application/problem+json: + schema: + $ref: "#/components/schemas/ErrorModel" + description: Error + summary: Remove a passkey + tags: + - Accounts + /api/account/password: + post: + operationId: change-password + requestBody: + content: + application/json: + schema: + $ref: "#/components/schemas/ChangePasswordInputBody" + required: true + responses: + "204": + description: No Content + headers: + Cache-Control: + schema: + type: string + Set-Cookie: + schema: + type: string + default: + content: + application/problem+json: + schema: + $ref: "#/components/schemas/ErrorModel" + description: Error + summary: Change your password + tags: + - Accounts + /api/account/recovery: + post: + operationId: create-recovery-code + parameters: + - in: cookie + name: archie_session + schema: + type: string + responses: + "200": + content: + application/json: + schema: + $ref: "#/components/schemas/RecoveryCodeReplyBody" + description: OK + headers: + Cache-Control: + schema: + type: string + default: + content: + application/problem+json: + schema: + $ref: "#/components/schemas/ErrorModel" + description: Error + summary: Create a recovery code + tags: + - Accounts + /api/accounts: + post: + operationId: create-account + parameters: + - in: cookie + name: archie_session + schema: + type: string + requestBody: + content: + application/json: + schema: + $ref: "#/components/schemas/GovernanceRegistration" + required: true + responses: + "201": + content: + application/json: + schema: + $ref: "#/components/schemas/GovernanceUserBody" + description: Created + default: + content: + application/problem+json: + schema: + $ref: "#/components/schemas/ErrorModel" + description: Error + summary: Create an account + tags: + - Accounts /api/admin/token: post: operationId: rotate-admin-token @@ -2230,6 +2696,290 @@ paths: summary: Approve or refuse an action as the bootstrap admin tags: - Approvals + /api/auth/login: + post: + operationId: sign-in + requestBody: + content: + application/json: + schema: + $ref: "#/components/schemas/SignInInputBody" + required: true + responses: + "200": + content: + application/json: + schema: + $ref: "#/components/schemas/GovernanceUserBody" + description: OK + headers: + Cache-Control: + schema: + type: string + Set-Cookie: + schema: + type: string + default: + content: + application/problem+json: + schema: + $ref: "#/components/schemas/ErrorModel" + description: Error + security: + - {} + summary: Sign in with email and password + tags: + - Accounts + /api/auth/logout: + post: + operationId: sign-out + parameters: + - in: cookie + name: archie_session + schema: + type: string + responses: + "204": + description: No Content + headers: + Cache-Control: + schema: + type: string + Set-Cookie: + schema: + type: string + default: + content: + application/problem+json: + schema: + $ref: "#/components/schemas/ErrorModel" + description: Error + security: + - {} + summary: Sign out + tags: + - Accounts + /api/auth/passkey/begin: + post: + operationId: begin-passkey-sign-in + parameters: + - in: cookie + name: archie_session + schema: + type: string + responses: + "200": + content: + application/json: + schema: {} + description: OK + headers: + Cache-Control: + schema: + type: string + Set-Cookie: + schema: + type: string + default: + content: + application/problem+json: + schema: + $ref: "#/components/schemas/ErrorModel" + description: Error + security: + - {} + summary: Start signing in with a passkey + tags: + - Accounts + /api/auth/passkey/finish: + post: + operationId: finish-passkey-sign-in + parameters: + - in: cookie + name: archie_passkey_login + schema: + type: string + requestBody: + content: + application/json: + schema: + $ref: "#/components/schemas/GovernancePasskeyFinishBody" + required: true + responses: + "200": + content: + application/json: + schema: + $ref: "#/components/schemas/GovernanceUserBody" + description: OK + headers: + Cache-Control: + schema: + type: string + Set-Cookie: + schema: + type: string + default: + content: + application/problem+json: + schema: + $ref: "#/components/schemas/ErrorModel" + description: Error + security: + - {} + summary: Finish signing in with a passkey + tags: + - Accounts + /api/auth/recover: + post: + operationId: recover-account + requestBody: + content: + application/json: + schema: + $ref: "#/components/schemas/RecoverInputBody" + required: true + responses: + "204": + description: No Content + default: + content: + application/problem+json: + schema: + $ref: "#/components/schemas/ErrorModel" + description: Error + security: + - {} + summary: Reset a password with a recovery code + tags: + - Accounts + /api/auth/setup: + post: + operationId: set-up-account + requestBody: + content: + application/json: + schema: + $ref: "#/components/schemas/GovernanceRegistration" + required: true + responses: + "200": + content: + application/json: + schema: + $ref: "#/components/schemas/GovernanceUserBody" + description: OK + headers: + Cache-Control: + schema: + type: string + Set-Cookie: + schema: + type: string + default: + content: + application/problem+json: + schema: + $ref: "#/components/schemas/ErrorModel" + description: Error + security: + - {} + summary: Create the instance owner and sign in + tags: + - Accounts + /api/auth/status: + get: + operationId: get-auth-status + parameters: + - in: cookie + name: archie_session + schema: + type: string + responses: + "200": + content: + application/json: + schema: + $ref: "#/components/schemas/GovernanceAuthStatusBody" + description: OK + headers: + Cache-Control: + schema: + type: string + default: + content: + application/problem+json: + schema: + $ref: "#/components/schemas/ErrorModel" + description: Error + security: + - {} + summary: Report setup and who is signed in + tags: + - Accounts + /api/authentication: + get: + operationId: get-authentication + responses: + "200": + content: + application/json: + schema: + $ref: "#/components/schemas/GovernanceAuthenticationSettings" + description: OK + default: + content: + application/problem+json: + schema: + $ref: "#/components/schemas/ErrorModel" + description: Error + summary: Get the authentication settings + tags: + - Accounts + put: + operationId: put-authentication + parameters: + - in: cookie + name: archie_session + schema: + type: string + requestBody: + content: + application/json: + schema: + $ref: "#/components/schemas/AuthenticationInputBody" + required: true + responses: + "204": + description: No Content + default: + content: + application/problem+json: + schema: + $ref: "#/components/schemas/ErrorModel" + description: Error + summary: Change the authentication settings + tags: + - Accounts + /api/capabilities: + get: + operationId: get-capabilities + responses: + "200": + content: + application/json: + schema: + $ref: "#/components/schemas/GovernanceCapabilitiesBody" + description: OK + default: + content: + application/problem+json: + schema: + $ref: "#/components/schemas/ErrorModel" + description: Error + summary: Report which dashboard sections this binary serves + tags: + - Accounts /api/chat/sessions: get: operationId: list-chat-sessions @@ -3753,6 +4503,74 @@ paths: summary: Get the bootstrap values, which only the config file sets tags: - System + /api/tokens: + get: + operationId: list-personal-tokens + responses: + "200": + content: + application/json: + schema: + $ref: "#/components/schemas/GovernanceTokensBody" + description: OK + default: + content: + application/problem+json: + schema: + $ref: "#/components/schemas/ErrorModel" + description: Error + summary: List your personal API tokens + tags: + - Accounts + post: + operationId: create-personal-token + requestBody: + content: + application/json: + schema: + $ref: "#/components/schemas/CreateTokenInputBody" + required: true + responses: + "201": + content: + application/json: + schema: + $ref: "#/components/schemas/GovernanceCreatedToken" + description: Created + headers: + Cache-Control: + schema: + type: string + default: + content: + application/problem+json: + schema: + $ref: "#/components/schemas/ErrorModel" + description: Error + summary: Create a personal API token + tags: + - Accounts + /api/tokens/{id}: + delete: + operationId: revoke-personal-token + parameters: + - in: path + name: id + required: true + schema: + type: string + responses: + "204": + description: No Content + default: + content: + application/problem+json: + schema: + $ref: "#/components/schemas/ErrorModel" + description: Error + summary: Revoke a personal API token + tags: + - Accounts /api/triggers: get: operationId: list-triggers @@ -3921,5 +4739,89 @@ paths: summary: Save a workflow document as its next version tags: - Workflows + /oauth2/callback: + get: + operationId: finish-oidc-sign-in + parameters: + - explode: false + in: query + name: code + schema: + type: string + - explode: false + in: query + name: state + schema: + type: string + - explode: false + in: query + name: error + schema: + type: string + - in: cookie + name: archie_login_state + schema: + type: string + - in: cookie + name: archie_login_verifier + schema: + type: string + responses: + "303": + description: See Other + headers: + Cache-Control: + schema: + type: string + Location: + schema: + type: string + Set-Cookie: + schema: + type: string + default: + content: + application/problem+json: + schema: + $ref: "#/components/schemas/ErrorModel" + description: Error + security: + - {} + summary: Complete the identity provider's sign-in + tags: + - Accounts + /oauth2/login: + get: + operationId: begin-oidc-sign-in + parameters: + - in: cookie + name: archie_session + schema: + type: string + responses: + "303": + description: See Other + headers: + Cache-Control: + schema: + type: string + Location: + schema: + type: string + Set-Cookie: + schema: + type: string + default: + content: + application/problem+json: + schema: + $ref: "#/components/schemas/ErrorModel" + description: Error + security: + - {} + summary: Send the browser to the identity provider + tags: + - Accounts security: - - admin: [] + - session: [] + - bearer: [] diff --git a/internal/app/archie/api.go b/internal/app/archie/api.go index ad7639f6c..123eb1276 100644 --- a/internal/app/archie/api.go +++ b/internal/app/archie/api.go @@ -37,6 +37,7 @@ type apiModules struct { func (m apiModules) register(api huma.API) { m.settings.Register(api) + m.settings.RegisterAccounts(api) m.conns.Register(api) m.system.Register(api) m.tell.Register(api) @@ -54,9 +55,10 @@ func (m apiModules) register(api huma.API) { // registrations the server does, on modules with nothing behind them, so it // needs no database. func Document() ([]byte, error) { - api := httpapi.New(http.NewServeMux(), buildinfo.Version, "") + settings := &governance.Module{} + api := httpapi.New(http.NewServeMux(), buildinfo.Version, settings.Authenticator("")) apiModules{ - settings: &governance.Module{}, conns: &connectors.Module{}, system: &system.Module{}, + settings: settings, conns: &connectors.Module{}, system: &system.Module{}, tell: &deliveries.Module{}, allow: &approvals.Module{}, classes: &judgement.Classes{}, policies: &judgement.Policies{}, hear: &events.Module{}, judge: &judgement.Module{}, engine: &runs.Engine{}, chat: &chat.Module{}, drafts: &drafts.Module{}, diff --git a/internal/app/archie/run.go b/internal/app/archie/run.go index 8e1fe9d07..9c4204258 100644 --- a/internal/app/archie/run.go +++ b/internal/app/archie/run.go @@ -64,10 +64,10 @@ func Run(ctx context.Context, configPath string) error { checks.Register("database", db.PingContext) mux := http.NewServeMux() checks.Routes(mux) - api := httpapi.New(mux, buildinfo.Version, cfg.AdminTokenSHA256) runtime.RegisterBuiltinClasses() settings := governance.NewModule(db, log.With("module", "governance"), orgID) + api := httpapi.New(mux, buildinfo.Version, settings.Authenticator(cfg.AdminTokenSHA256)) //nolint:contextcheck // the middleware derives from the request's context conns, err := connectors.NewModule(db, log.With("module", "connectors"), orgID, connectors.Sealing{ Identity: cfg.AgeIdentity, Backups: cfg.AgeBackupRecipients, diff --git a/internal/platform/httpapi/httpapi.go b/internal/platform/httpapi/httpapi.go index 47c8cb376..e10f84016 100644 --- a/internal/platform/httpapi/httpapi.go +++ b/internal/platform/httpapi/httpapi.go @@ -3,6 +3,8 @@ package httpapi import ( + "context" + "errors" "net/http" "path" "reflect" @@ -11,14 +13,26 @@ import ( "github.com/danielgtaylor/huma/v2" "github.com/danielgtaylor/huma/v2/adapters/humago" - - "github.com/samcharles93/archie-core/internal/platform/httpjson" ) // DocumentPath is where the API serves its OpenAPI document, as .json and // .yaml. const DocumentPath = "/api/openapi" +// SessionCookie is the cookie a browser's sign-in sets. +const SessionCookie = "archie_session" + +// ErrUnauthenticated is what an Authenticator returns for a request whose +// credential is missing or not accepted. +var ErrUnauthenticated = errors.New("sign-in required or credentials not accepted") + +// Authenticator resolves the credential a request presents. It returns ctx +// carrying who acts, and whether that caller administers +// the instance. +type Authenticator interface { + Authenticate(ctx context.Context, r *http.Request) (acting context.Context, admin bool, err error) +} + // Reply is an operation's output whose response body is T. type Reply[T any] struct { Body T @@ -29,11 +43,50 @@ func OK[T any](v T) *Reply[T] { return &Reply[T]{Body: v} } -// New returns an API on mux whose every operation requires the bootstrap admin -// token, held only as its hash. -func New(mux *http.ServeMux, version, adminHash string) huma.API { +type access int + +const ( + accessAdmin access = iota + accessSignedIn + accessPublic +) + +const accessKey = "archie-access" + +// Public marks op as callable without a credential: signing in, for one. +func Public(op huma.Operation) huma.Operation { + op.Security = []map[string][]string{{}} + return withAccess(op, accessPublic) +} + +// SignedIn marks op as callable by any authenticated caller. Every other +// operation needs an instance administrator. +func SignedIn(op huma.Operation) huma.Operation { + return withAccess(op, accessSignedIn) +} + +func withAccess(op huma.Operation, a access) huma.Operation { + if op.Metadata == nil { + op.Metadata = map[string]any{} + } + op.Metadata[accessKey] = a + return op +} + +func accessOf(op *huma.Operation) access { + if op == nil { + return accessAdmin + } + a, _ := op.Metadata[accessKey].(access) + return a +} + +// New returns an API on mux whose operations authenticate through auth. +// Every unsafe request must also pass cross-origin protection, since a +// browser sends the session cookie with any request to this origin. +func New(mux *http.ServeMux, version string, auth Authenticator) huma.API { api := humago.New(mux, config(version)) - api.UseMiddleware(admin(api, adminHash)) + api.UseMiddleware(guard(api, auth, http.NewCrossOriginProtection())) return api } @@ -46,20 +99,39 @@ func config(version string) huma.Config { cfg.CreateHooks = nil cfg.Components.Schemas = huma.NewMapRegistry("#/components/schemas/", schemaName) cfg.Components.SecuritySchemes = map[string]*huma.SecurityScheme{ - "admin": {Type: "http", Scheme: "bearer", Description: "The bootstrap admin token"}, + "session": {Type: "apiKey", In: "cookie", Name: SessionCookie, Description: "The session a browser sign-in opens"}, + "bearer": {Type: "http", Scheme: "bearer", Description: "A personal API token, or the bootstrap admin token"}, } - cfg.Security = []map[string][]string{{"admin": {}}} + cfg.Security = []map[string][]string{{"session": {}}, {"bearer": {}}} return cfg } -func admin(api huma.API, hash string) func(huma.Context, func(huma.Context)) { +func guard(api huma.API, auth Authenticator, origins *http.CrossOriginProtection) func(huma.Context, func(huma.Context)) { return func(ctx huma.Context, next func(huma.Context)) { - token, ok := strings.CutPrefix(ctx.Header("Authorization"), "Bearer ") - if !ok || !httpjson.TokenMatches(strings.TrimSpace(token), hash) { - _ = huma.WriteErr(api, ctx, http.StatusUnauthorized, "admin token required") + r, _ := humago.Unwrap(ctx) + if err := origins.Check(r); err != nil { + _ = huma.WriteErr(api, ctx, http.StatusForbidden, "cross-origin request refused") return } - next(ctx) + need := accessOf(ctx.Operation()) + if need == accessPublic { + next(ctx) + return + } + acting, admin, err := auth.Authenticate(ctx.Context(), r) + switch { + case errors.Is(err, ErrUnauthenticated): + ctx.SetHeader("Cache-Control", "no-store") + _ = huma.WriteErr(api, ctx, http.StatusUnauthorized, ErrUnauthenticated.Error()) + return + case err != nil: + _ = huma.WriteErr(api, ctx, http.StatusServiceUnavailable, "authentication is unavailable") + return + case need == accessAdmin && !admin: + _ = huma.WriteErr(api, ctx, http.StatusForbidden, "instance administrator required") + return + } + next(huma.WithContext(ctx, acting)) } } diff --git a/internal/platform/httpapi/httpapi_test.go b/internal/platform/httpapi/httpapi_test.go index 51cf125ea..b84932cbe 100644 --- a/internal/platform/httpapi/httpapi_test.go +++ b/internal/platform/httpapi/httpapi_test.go @@ -2,48 +2,73 @@ package httpapi import ( "context" + "errors" "net/http" "net/http/httptest" "testing" "github.com/danielgtaylor/huma/v2" - - "github.com/samcharles93/archie-core/internal/platform/httpjson" ) -// TestEveryOperationRequiresTheAdminToken guards the bootstrap admin boundary: -// only a bearer token whose hash matches the configured one reaches an -// operation, and an empty configured hash locks everyone out rather than -// letting everyone in. -func TestEveryOperationRequiresTheAdminToken(t *testing.T) { - const token = "a-plainly-fake-admin-token" //nolint:gosec // test fixture, not a credential +// headerAuth admits the caller its X-Test-Caller header names. +type headerAuth struct{} + +func (headerAuth) Authenticate(ctx context.Context, r *http.Request) (context.Context, bool, error) { + switch r.Header.Get("X-Test-Caller") { + case "admin": + return ctx, true, nil + case "person": + return ctx, false, nil + case "broken": + return nil, false, errors.New("database down") + default: + return nil, false, ErrUnauthenticated + } +} + +// TestOperationAccess guards the API's authentication boundary: public +// operations need no credential, every other operation needs one, only an +// instance administrator reaches an operation not marked otherwise, and a +// cross-origin browser request cannot use the session cookie to change +// anything. +func TestOperationAccess(t *testing.T) { tests := []struct { - name string - hash string - header string - want int + name, method, path, caller, fetchSite string + want int }{ - {name: "matching token", hash: httpjson.TokenHash(token), header: "Bearer " + token, want: http.StatusOK}, - {name: "wrong token", hash: httpjson.TokenHash(token), header: "Bearer other", want: http.StatusUnauthorized}, - {name: "no token", hash: httpjson.TokenHash(token), header: "", want: http.StatusUnauthorized}, - {name: "not a bearer token", hash: httpjson.TokenHash(token), header: "Basic " + token, want: http.StatusUnauthorized}, - {name: "no configured hash locks everyone out", hash: "", header: "Bearer ", want: http.StatusUnauthorized}, + {name: "public without a credential", method: http.MethodGet, path: "/public", want: http.StatusOK}, + {name: "public sign-in from this origin", method: http.MethodPost, path: "/public", fetchSite: "same-origin", want: http.StatusOK}, + {name: "public sign-in from another origin", method: http.MethodPost, path: "/public", fetchSite: "cross-site", want: http.StatusForbidden}, + {name: "signed-in without a credential", method: http.MethodGet, path: "/signed-in", want: http.StatusUnauthorized}, + {name: "signed-in as a person", method: http.MethodGet, path: "/signed-in", caller: "person", want: http.StatusOK}, + {name: "admin without a credential", method: http.MethodGet, path: "/admin", want: http.StatusUnauthorized}, + {name: "admin as a person", method: http.MethodGet, path: "/admin", caller: "person", want: http.StatusForbidden}, + {name: "admin as the admin", method: http.MethodGet, path: "/admin", caller: "admin", want: http.StatusOK}, + {name: "mutation from this origin", method: http.MethodPost, path: "/admin", caller: "admin", fetchSite: "same-origin", want: http.StatusOK}, + {name: "mutation from another origin", method: http.MethodPost, path: "/admin", caller: "admin", fetchSite: "cross-site", want: http.StatusForbidden}, + {name: "a failed lookup is not a refusal", method: http.MethodGet, path: "/admin", caller: "broken", want: http.StatusServiceUnavailable}, + } + mux := http.NewServeMux() + api := New(mux, "test", headerAuth{}) + reached := func(context.Context, *struct{}) (*Reply[string], error) { return OK("reached"), nil } + for _, method := range []string{http.MethodGet, http.MethodPost} { + huma.Register(api, Public(huma.Operation{OperationID: "public-" + method, Method: method, Path: "/public"}), reached) + huma.Register(api, SignedIn(huma.Operation{OperationID: "signed-in-" + method, Method: method, Path: "/signed-in"}), reached) + huma.Register(api, huma.Operation{OperationID: "admin-" + method, Method: method, Path: "/admin"}, reached) } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - mux := http.NewServeMux() - api := New(mux, "test", tt.hash) - huma.Get(api, "/api/thing", func(context.Context, *struct{}) (*Reply[string], error) { - return OK("reached"), nil - }) - req := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/api/thing", nil) - if tt.header != "" { - req.Header.Set("Authorization", tt.header) + req := httptest.NewRequestWithContext(t.Context(), tt.method, tt.path, nil) + if tt.caller != "" { + req.Header.Set("X-Test-Caller", tt.caller) + } + if tt.fetchSite != "" { + req.Header.Set("Sec-Fetch-Site", tt.fetchSite) } rec := httptest.NewRecorder() mux.ServeHTTP(rec, req) if rec.Code != tt.want { - t.Fatalf("status = %d, want %d", rec.Code, tt.want) + t.Fatalf("status = %d, want %d: %s", rec.Code, tt.want, rec.Body) } }) } diff --git a/modules/dashboard/dashboard.go b/modules/dashboard/dashboard.go index 79330d8cc..6334ad8c0 100644 --- a/modules/dashboard/dashboard.go +++ b/modules/dashboard/dashboard.go @@ -1,4 +1,4 @@ -// Package dashboard serves the single binary's SPA: archie.html and its +// Package dashboard serves the single binary's SPA: index.html and its // assets from the embedded build. Every other route belongs to a module. package dashboard @@ -10,7 +10,7 @@ import ( "github.com/samcharles93/archie-core/internal/platform/httpjson" ) -const page = "archie.html" +const page = "index.html" // Routes serves the SPA from dist on mux. A path under /api/ that no module // claimed is a JSON 404, never the page. With no build embedded, the page @@ -45,7 +45,7 @@ func handler(dist fs.FS) http.Handler { return } name := strings.TrimPrefix(r.URL.Path, "/") - if name != "" && name != "index.html" && name != page { + if name != "" && name != page { if info, err := fs.Stat(dist, name); err == nil && !info.IsDir() { if strings.HasPrefix(name, "assets/") { w.Header().Set("Cache-Control", "public, max-age=31536000, immutable") diff --git a/modules/governance/accounts_api.go b/modules/governance/accounts_api.go new file mode 100644 index 000000000..7e2aeb305 --- /dev/null +++ b/modules/governance/accounts_api.go @@ -0,0 +1,712 @@ +package governance + +import ( + "context" + "crypto/rand" + "encoding/base64" + "encoding/json/jsontext" + "errors" + "fmt" + "net/http" + "strings" + "time" + "unicode/utf8" + + "github.com/danielgtaylor/huma/v2" + + "github.com/samcharles93/archie-core/internal/platform/httpapi" +) + +// Cookie names beside httpapi.SessionCookie. The sign-in flow's cookies are +// scoped to the paths that read them. +const ( + passkeyLoginCookie = "archie_passkey_login" + passkeyRegistrationCookie = "archie_passkey_registration" + loginStateCookie = "archie_login_state" + loginVerifierCookie = "archie_login_verifier" + + passkeyCookiePath = "/api/" + loginCookiePath = "/oauth2" + passkeyCookieAge = 300 + loginCookieAge = 600 + + maxTokenNameLength = 40 + // personalTokenBindTimeout is under the dashboard's own request timeout. + personalTokenBindTimeout = 10 * time.Second +) + +// client is the host a request reached, which decides whether a cookie must +// be Secure. +type client struct{ host string } + +// Resolve reads the request's host. Huma calls it for every input that +// carries a client. +func (c *client) Resolve(ctx huma.Context) []error { + c.host = ctx.Host() + return nil +} + +// cookie returns an HttpOnly, SameSite=Lax cookie, Secure unless the browser +// reached this host over loopback. A negative maxAge deletes it. +func (c *client) cookie(name, value, path string, maxAge int) http.Cookie { + return http.Cookie{ //nolint:gosec // G124: a fixed Secure would stop a browser on localhost signing in. + Name: name, Value: value, Path: path, MaxAge: maxAge, + HttpOnly: true, Secure: !loopback(c.host), SameSite: http.SameSiteLaxMode, + } +} + +func (c *client) session(s AccountSession) http.Cookie { + return c.cookie(httpapi.SessionCookie, s.Token, "/", int(time.Until(s.Expires).Seconds())) +} + +func (c *client) clear(name, path string) http.Cookie { + return c.cookie(name, "", path, -1) +} + +type sessionInput struct { + Client client + Session string `cookie:"archie_session"` +} + +type cookieReply struct { + SetCookie []http.Cookie `header:"Set-Cookie"` + CacheControl string `header:"Cache-Control"` +} + +type userBody struct { + User Identity `json:"user"` +} + +type userReply struct { + SetCookie []http.Cookie `header:"Set-Cookie"` + CacheControl string `header:"Cache-Control"` + Body userBody +} + +// RegisterAccounts adds sign-in and the signed-in person's account: password +// accounts, passkeys, recovery, OIDC, personal API tokens, the instance's +// authentication settings and what the dashboard can show. +func (m *Module) RegisterAccounts(api huma.API) { + tags := []string{"Accounts"} + public := func(id, method, path, summary string, status int) huma.Operation { + return httpapi.Public(huma.Operation{OperationID: id, Method: method, Path: path, Summary: summary, Tags: tags, DefaultStatus: status}) + } + signedIn := func(id, method, path, summary string, status int) huma.Operation { + return httpapi.SignedIn(huma.Operation{OperationID: id, Method: method, Path: path, Summary: summary, Tags: tags, DefaultStatus: status}) + } + admin := func(id, method, path, summary string, status int) huma.Operation { + return huma.Operation{OperationID: id, Method: method, Path: path, Summary: summary, Tags: tags, DefaultStatus: status} + } + huma.Register(api, public("get-auth-status", http.MethodGet, "/api/auth/status", "Report setup and who is signed in", 0), m.authStatus) + huma.Register(api, public("set-up-account", http.MethodPost, "/api/auth/setup", "Create the instance owner and sign in", 0), m.setUpAccount) + huma.Register(api, public("sign-in", http.MethodPost, "/api/auth/login", "Sign in with email and password", 0), m.signIn) + huma.Register(api, public("sign-out", http.MethodPost, "/api/auth/logout", "Sign out", http.StatusNoContent), m.signOut) + huma.Register(api, public("recover-account", http.MethodPost, "/api/auth/recover", "Reset a password with a recovery code", http.StatusNoContent), m.recoverAccount) + huma.Register(api, public("begin-passkey-sign-in", http.MethodPost, "/api/auth/passkey/begin", "Start signing in with a passkey", 0), m.beginPasskeySignIn) + huma.Register(api, public("finish-passkey-sign-in", http.MethodPost, "/api/auth/passkey/finish", "Finish signing in with a passkey", 0), m.finishPasskeySignIn) + huma.Register(api, public("begin-oidc-sign-in", http.MethodGet, "/oauth2/login", "Send the browser to the identity provider", http.StatusSeeOther), m.beginOIDC) + huma.Register(api, public("finish-oidc-sign-in", http.MethodGet, oidcCallbackPath, "Complete the identity provider's sign-in", http.StatusSeeOther), m.finishOIDC) + + huma.Register(api, signedIn("change-password", http.MethodPost, "/api/account/password", "Change your password", http.StatusNoContent), m.changePassword) + huma.Register(api, signedIn("create-recovery-code", http.MethodPost, "/api/account/recovery", "Create a recovery code", 0), m.createRecoveryCode) + huma.Register(api, signedIn("list-passkeys", http.MethodGet, "/api/account/passkeys", "List your passkeys", 0), m.listPasskeys) + huma.Register(api, signedIn("begin-passkey-registration", http.MethodPost, "/api/account/passkeys/begin", "Start adding a passkey", 0), m.beginPasskeyRegistration) + huma.Register(api, signedIn("finish-passkey-registration", http.MethodPost, "/api/account/passkeys/finish", "Finish adding a passkey", 0), m.finishPasskeyRegistration) + huma.Register(api, signedIn("delete-passkey", http.MethodDelete, "/api/account/passkeys/{id}", "Remove a passkey", http.StatusNoContent), m.deletePasskey) + huma.Register(api, signedIn("list-personal-tokens", http.MethodGet, "/api/tokens", "List your personal API tokens", 0), m.listTokens) + huma.Register(api, signedIn("create-personal-token", http.MethodPost, "/api/tokens", "Create a personal API token", http.StatusCreated), m.createToken) + huma.Register(api, signedIn("revoke-personal-token", http.MethodDelete, "/api/tokens/{id}", "Revoke a personal API token", http.StatusNoContent), m.revokeToken) + huma.Register(api, signedIn("get-capabilities", http.MethodGet, "/api/capabilities", "Report which dashboard sections this binary serves", 0), m.capabilities) + + huma.Register(api, admin("create-account", http.MethodPost, "/api/accounts", "Create an account", http.StatusCreated), m.createAccount) + huma.Register(api, admin("get-authentication", http.MethodGet, "/api/authentication", "Get the authentication settings", 0), m.getAuthentication) + huma.Register(api, admin("put-authentication", http.MethodPut, "/api/authentication", "Change the authentication settings", http.StatusNoContent), m.putAuthentication) +} + +// accountError turns an account failure into the status a person can act on. +func (m *Module) accountError(ctx context.Context, err error) error { + switch { + case refused(err): + return huma.Error401Unauthorized(httpapi.ErrUnauthenticated.Error()) + case errors.Is(err, ErrSetupComplete): + return huma.Error409Conflict(ErrSetupComplete.Error()) + case errors.Is(err, ErrIdentityConflict): + return huma.Error409Conflict("An account already uses that email.") + case errors.Is(err, ErrInvalidIdentity): + return huma.Error400BadRequest("Enter a name, valid email, organisation name for setup, and an uncommon password of at least 15 characters (at most 1024 bytes).") + case errors.Is(err, ErrProviderUnavailable): + return huma.Error503ServiceUnavailable("The sign-in provider is unavailable. Try again shortly.") + default: + m.log.ErrorContext(ctx, "account operation failed", "err", err) + return huma.Error503ServiceUnavailable("Account service unavailable.") + } +} + +// person refuses a caller that is not a signed-in person: account security +// belongs to people, not to tokens acting for the system. +func person(ctx context.Context) error { + if p, ok := PrincipalFromContext(ctx); ok && p.Kind == KindUser { + return nil + } + return huma.Error401Unauthorized("sign-in required") +} + +// requireFresh refuses an authenticator change unless the caller signed in +// within the last few minutes. +func (m *Module) requireFresh(ctx context.Context, session string) error { + if session == "" || m.RequireFreshAccountSession(ctx, session) != nil { + return huma.Error403Forbidden("Sign in again before changing account security.") + } + return nil +} + +type authStatusBody struct { + SetupRequired bool `json:"setup_required"` + User *Identity `json:"user"` + OIDC bool `json:"oidc"` + PublicURL string `json:"public_url"` + Instance string `json:"instance"` +} + +type authStatusReply struct { + CacheControl string `header:"Cache-Control"` + Body authStatusBody +} + +func (m *Module) authStatus(ctx context.Context, in *sessionInput) (*authStatusReply, error) { + required, err := m.AccountSetupRequired(ctx) + if err != nil { + return nil, m.accountError(ctx, err) + } + out := authStatusBody{SetupRequired: required, Instance: "archie"} + if in.Session != "" { + value, err := m.ResolveAccountSession(ctx, in.Session) + switch { + case err == nil && value.Kind == KindUser && value.CanAct(): + out.User = &value + case err != nil && !refused(err): + return nil, m.accountError(ctx, err) + } + } + settings, err := m.AuthenticationSettings(ctx) + if err != nil { + return nil, m.accountError(ctx, err) + } + out.PublicURL = settings.PublicURL + out.OIDC = settings.PublicURL != "" && settings.OIDCIssuer != "" + return &authStatusReply{CacheControl: "no-store", Body: out}, nil +} + +type registration struct { + PublicURL string `json:"public_url,omitempty"` + WorkspaceName string `json:"workspace_name,omitempty"` + OrganisationName string `json:"organisation_name,omitempty"` + Email string `json:"email"` + DisplayName string `json:"display_name"` + Password string `json:"password"` + Role string `json:"role,omitempty"` +} + +func (r registration) account() AccountRegistration { + return AccountRegistration(r) +} + +type setUpInput struct { + Client client + Body registration +} + +func (m *Module) setUpAccount(ctx context.Context, in *setUpInput) (*userReply, error) { + if _, err := m.RegisterAccount(ctx, in.Body.account(), true); err != nil { + return nil, m.accountError(ctx, err) + } + return m.openSession(ctx, &in.Client, in.Body.Email, in.Body.Password) +} + +type signInInput struct { + Client client + Body struct { + Email string `json:"email"` + Password string `json:"password"` + } +} + +func (m *Module) signIn(ctx context.Context, in *signInInput) (*userReply, error) { + return m.openSession(ctx, &in.Client, in.Body.Email, in.Body.Password) +} + +func (m *Module) openSession(ctx context.Context, c *client, email, password string) (*userReply, error) { + value, err := m.SignInAccount(ctx, email, password) + if err != nil { + m.log.InfoContext(ctx, "account sign-in refused") + return nil, m.accountError(ctx, err) + } + m.log.InfoContext(ctx, "account signed in", "identity", value.Identity.ID) + return &userReply{SetCookie: []http.Cookie{c.session(value)}, CacheControl: "no-store", Body: userBody{User: value.Identity}}, nil +} + +func (m *Module) signOut(ctx context.Context, in *sessionInput) (*cookieReply, error) { + if in.Session != "" { + if err := m.SignOutAccount(ctx, in.Session); err != nil { + return nil, m.accountError(ctx, err) + } + } + return &cookieReply{SetCookie: []http.Cookie{in.Client.clear(httpapi.SessionCookie, "/")}, CacheControl: "no-store"}, nil +} + +type recoverInput struct { + Body struct { + Email string `json:"email"` + Code string `json:"code"` + Password string `json:"password"` + } +} + +func (m *Module) recoverAccount(ctx context.Context, in *recoverInput) (*struct{}, error) { + if err := m.RecoverAccount(ctx, in.Body.Email, in.Body.Code, in.Body.Password); err != nil { + return nil, m.accountError(ctx, err) + } + return nil, nil +} + +type changePasswordInput struct { + Client client + Body struct { + Current string `json:"current_password"` + New string `json:"new_password"` + } +} + +// changePassword revokes every session, so the browser's cookie goes too. +func (m *Module) changePassword(ctx context.Context, in *changePasswordInput) (*cookieReply, error) { + if err := person(ctx); err != nil { + return nil, err + } + if err := m.ChangeAccountPassword(ctx, in.Body.Current, in.Body.New); err != nil { + return nil, m.accountError(ctx, err) + } + return &cookieReply{SetCookie: []http.Cookie{in.Client.clear(httpapi.SessionCookie, "/")}, CacheControl: "no-store"}, nil +} + +type recoveryCodeReply struct { + CacheControl string `header:"Cache-Control"` + Body struct { + Code string `json:"code"` + } +} + +func (m *Module) createRecoveryCode(ctx context.Context, in *sessionInput) (*recoveryCodeReply, error) { + if err := person(ctx); err != nil { + return nil, err + } + if err := m.requireFresh(ctx, in.Session); err != nil { + return nil, err + } + code, err := m.CreateAccountRecovery(ctx) + if err != nil { + return nil, m.accountError(ctx, err) + } + out := &recoveryCodeReply{CacheControl: "no-store"} + out.Body.Code = code + return out, nil +} + +type createAccountInput struct { + Session string `cookie:"archie_session"` + Body registration +} + +func (m *Module) createAccount(ctx context.Context, in *createAccountInput) (*httpapi.Reply[userBody], error) { + if err := m.requireFresh(ctx, in.Session); err != nil { + return nil, err + } + value, err := m.RegisterAccount(ctx, in.Body.account(), false) + if err != nil { + return nil, m.accountError(ctx, err) + } + return httpapi.OK(userBody{User: value}), nil +} + +func (m *Module) getAuthentication(ctx context.Context, _ *struct{}) (*httpapi.Reply[AuthenticationSettings], error) { + value, err := m.AuthenticationSettings(ctx) + if err != nil { + return nil, m.accountError(ctx, err) + } + return httpapi.OK(value), nil +} + +type authenticationInput struct { + Session string `cookie:"archie_session"` + Body struct { + PublicURL string `json:"public_url"` + OIDCIssuer string `json:"oidc_issuer,omitempty"` + OIDCAudience string `json:"oidc_audience,omitempty"` + OIDCClientID string `json:"oidc_client_id,omitempty"` + } +} + +func (m *Module) putAuthentication(ctx context.Context, in *authenticationInput) (*struct{}, error) { + if err := m.requireFresh(ctx, in.Session); err != nil { + return nil, err + } + err := m.SaveAuthenticationSettings(ctx, AuthenticationSettings(in.Body)) + if errors.Is(err, ErrInvalidIdentity) { + return nil, huma.Error400BadRequest("Use a valid instance origin and complete OIDC settings. Remove enrolled passkeys before changing the instance URL.") + } + if err != nil { + return nil, m.accountError(ctx, err) + } + return nil, nil +} + +type passkeyOptionsReply struct { + SetCookie []http.Cookie `header:"Set-Cookie"` + CacheControl string `header:"Cache-Control"` + Body jsontext.Value +} + +func (m *Module) beginPasskeySignIn(ctx context.Context, in *sessionInput) (*passkeyOptionsReply, error) { + return m.beginPasskey(ctx, &in.Client, false) +} + +func (m *Module) beginPasskeyRegistration(ctx context.Context, in *sessionInput) (*passkeyOptionsReply, error) { + if err := person(ctx); err != nil { + return nil, err + } + if err := m.requireFresh(ctx, in.Session); err != nil { + return nil, err + } + return m.beginPasskey(ctx, &in.Client, true) +} + +func passkeyCookie(registration bool) string { + if registration { + return passkeyRegistrationCookie + } + return passkeyLoginCookie +} + +func (m *Module) beginPasskey(ctx context.Context, c *client, registration bool) (*passkeyOptionsReply, error) { + value, err := m.BeginPasskey(ctx, registration) + if err != nil { + return nil, m.accountError(ctx, err) + } + return &passkeyOptionsReply{ + SetCookie: []http.Cookie{c.cookie(passkeyCookie(registration), value.Token, passkeyCookiePath, passkeyCookieAge)}, + CacheControl: "no-store", + Body: jsontext.Value(value.Options), + }, nil +} + +type passkeyFinishBody struct { + Credential jsontext.Value `json:"credential"` + Name string `json:"name,omitempty"` +} + +type passkeySignInInput struct { + Client client + Ceremony string `cookie:"archie_passkey_login"` + Body passkeyFinishBody +} + +func (m *Module) finishPasskeySignIn(ctx context.Context, in *passkeySignInInput) (*userReply, error) { + value, err := m.finishPasskey(ctx, in.Ceremony, in.Body, false) + if err != nil { + return nil, err + } + return &userReply{ + SetCookie: []http.Cookie{in.Client.clear(passkeyLoginCookie, passkeyCookiePath), in.Client.session(value)}, + CacheControl: "no-store", + Body: userBody{User: value.Identity}, + }, nil +} + +type passkeyRegistrationInput struct { + Client client + Session string `cookie:"archie_session"` + Ceremony string `cookie:"archie_passkey_registration"` + Body passkeyFinishBody +} + +func (m *Module) finishPasskeyRegistration(ctx context.Context, in *passkeyRegistrationInput) (*userReply, error) { + if err := person(ctx); err != nil { + return nil, err + } + if err := m.requireFresh(ctx, in.Session); err != nil { + return nil, err + } + value, err := m.finishPasskey(ctx, in.Ceremony, in.Body, true) + if err != nil { + return nil, err + } + return &userReply{ + SetCookie: []http.Cookie{in.Client.clear(passkeyRegistrationCookie, passkeyCookiePath)}, + CacheControl: "no-store", + Body: userBody{User: value.Identity}, + }, nil +} + +func (m *Module) finishPasskey(ctx context.Context, ceremony string, body passkeyFinishBody, registration bool) (AccountSession, error) { + if ceremony == "" { + return AccountSession{}, huma.Error401Unauthorized("passkey request expired") + } + value, err := m.FinishPasskey(ctx, ceremony, body.Credential, registration, body.Name) + if err != nil { + return AccountSession{}, m.accountError(ctx, err) + } + return value, nil +} + +type passkeysBody struct { + Passkeys []Passkey `json:"passkeys"` +} + +func (m *Module) listPasskeys(ctx context.Context, _ *struct{}) (*httpapi.Reply[passkeysBody], error) { + if err := person(ctx); err != nil { + return nil, err + } + values, err := m.ListPasskeys(ctx) + if err != nil { + return nil, m.accountError(ctx, err) + } + if values == nil { + values = []Passkey{} + } + return httpapi.OK(passkeysBody{Passkeys: values}), nil +} + +type deletePasskeyInput struct { + Session string `cookie:"archie_session"` + ID string `path:"id"` +} + +func (m *Module) deletePasskey(ctx context.Context, in *deletePasskeyInput) (*struct{}, error) { + if err := person(ctx); err != nil { + return nil, err + } + if err := m.requireFresh(ctx, in.Session); err != nil { + return nil, err + } + if err := m.DeletePasskey(ctx, in.ID); err != nil { + return nil, m.accountError(ctx, err) + } + return nil, nil +} + +// tokenOwner reports whether the caller is a person who can hold personal +// tokens; the bootstrap admin token acts as the system and cannot. +func tokenOwner(ctx context.Context) bool { + p, ok := PrincipalFromContext(ctx) + return ok && p.IdentityID != "" && p.IdentityID != SystemID +} + +type tokensBody struct { + Tokens []PersonalToken `json:"tokens"` + Available bool `json:"available"` +} + +func (m *Module) listTokens(ctx context.Context, _ *struct{}) (*httpapi.Reply[tokensBody], error) { + if !tokenOwner(ctx) { + return httpapi.OK(tokensBody{Tokens: []PersonalToken{}}), nil + } + tokens, err := m.ListPersonalTokens(ctx) + if err != nil { + return nil, m.accountError(ctx, err) + } + if tokens == nil { + tokens = []PersonalToken{} + } + return httpapi.OK(tokensBody{Tokens: tokens, Available: true}), nil +} + +type createTokenInput struct { + Body struct { + Name string `json:"name"` + Days int `json:"days,omitempty"` + } +} + +type createdToken struct { + ID string `json:"id"` + Token string `json:"token"` +} + +type createTokenReply struct { + CacheControl string `header:"Cache-Control"` + Body createdToken +} + +// createToken makes the token here and stores only its hash; the response is +// the one time the token is shown. +func (m *Module) createToken(ctx context.Context, in *createTokenInput) (*createTokenReply, error) { + if !tokenOwner(ctx) { + return nil, huma.Error403Forbidden("Personal tokens need a signed-in person.") + } + name := strings.TrimSpace(in.Body.Name) + if name == "" || utf8.RuneCountInString(name) > maxTokenNameLength { + return nil, huma.Error400BadRequest("Name a token in up to 40 characters.") + } + var expiresAt *time.Time + switch in.Body.Days { + case 0: + case 7, 30, 90: + t := time.Now().UTC().AddDate(0, 0, in.Body.Days) + expiresAt = &t + default: + return nil, huma.Error400BadRequest("Lifetime is 7, 30 or 90 days, or none.") + } + raw, subject, err := NewPersonalToken() + if err != nil { + return nil, m.accountError(ctx, err) + } + if err := m.addPersonalToken(ctx, subject, name, expiresAt); err != nil { + return nil, m.accountError(ctx, err) + } + return &createTokenReply{CacheControl: "no-store", Body: createdToken{ID: subject.Subject, Token: raw}}, nil +} + +// addPersonalToken binds the token under its own deadline. The token is +// shown only once, so a bind that fails may still have committed: revoke it, +// detached from the request that is over, rather than leave a token nobody +// holds. +func (m *Module) addPersonalToken(ctx context.Context, subject Subject, name string, expiresAt *time.Time) error { + bindCtx, cancel := context.WithTimeout(ctx, personalTokenBindTimeout) + defer cancel() + err := m.AddPersonalToken(bindCtx, subject, name, expiresAt) + if err == nil { + return nil + } + revokeCtx, revokeCancel := context.WithTimeout(context.WithoutCancel(ctx), personalTokenBindTimeout) + defer revokeCancel() + if revokeErr := m.RevokePersonalToken(revokeCtx, subject.Subject); revokeErr != nil && !errors.Is(revokeErr, ErrIdentityNotFound) { + return errors.Join(err, fmt.Errorf("revoke unconfirmed token: %w", revokeErr)) + } + return err +} + +type revokeTokenInput struct { + ID string `path:"id"` +} + +func (m *Module) revokeToken(ctx context.Context, in *revokeTokenInput) (*struct{}, error) { + if !tokenOwner(ctx) { + return nil, huma.Error403Forbidden("Personal tokens need a signed-in person.") + } + if err := m.RevokePersonalToken(ctx, in.ID); err != nil { + return nil, m.accountError(ctx, err) + } + return nil, nil +} + +type capabilitiesBody struct { + Sections map[string]bool `json:"sections"` +} + +// capabilities reports the dashboard sections this binary serves. The +// sections below have no backend here yet, so the dashboard hides them; +// settings is the instance area, which only an instance administrator +// operates. +func (m *Module) capabilities(ctx context.Context, _ *struct{}) (*httpapi.Reply[capabilitiesBody], error) { + p, _ := PrincipalFromContext(ctx) + sections := map[string]bool{"settings": p.InstanceAdmin()} + for _, name := range []string{ + "chat", "logs", "skills", "curators", "channels", "captures", "mappings", "bindings", "workflows", + "org_members", "org_agents", "org_policies", "org_denials", "org_audit", "org_usage", "org_config", + } { + sections[name] = false + } + return httpapi.OK(capabilitiesBody{Sections: sections}), nil +} + +type redirectReply struct { + Location string `header:"Location"` + SetCookie []http.Cookie `header:"Set-Cookie"` + CacheControl string `header:"Cache-Control"` +} + +// beginOIDC sends a browser to the provider, keeping the state and PKCE +// verifier the callback needs in cookies scoped to the callback path. +func (m *Module) beginOIDC(ctx context.Context, in *sessionInput) (*redirectReply, error) { + flow, err := m.oidc.flow(ctx, m) + if errors.Is(err, ErrNoCredential) { + return nil, huma.Error404NotFound("no identity provider is configured") + } + if err != nil { + return nil, m.accountError(ctx, err) + } + state, err := randomState() + if err != nil { + return nil, m.accountError(ctx, err) + } + target, verifier, err := flow.AuthCodeURL(ctx, state) + if err != nil { + return nil, m.accountError(ctx, err) + } + return &redirectReply{ + Location: target, + SetCookie: []http.Cookie{ + in.Client.cookie(loginStateCookie, state, loginCookiePath, loginCookieAge), + in.Client.cookie(loginVerifierCookie, verifier, loginCookiePath, loginCookieAge), + }, + CacheControl: "no-store", + }, nil +} + +type oidcCallbackInput struct { + Client client + Code string `query:"code"` + State string `query:"state"` + ProviderError string `query:"error"` + WantState string `cookie:"archie_login_state"` + Verifier string `cookie:"archie_login_verifier"` +} + +// finishOIDC checks the state it issued, exchanges the code with the PKCE +// verifier it issued, and opens a local session no longer than the +// provider's. +func (m *Module) finishOIDC(ctx context.Context, in *oidcCallbackInput) (*redirectReply, error) { + if in.ProviderError != "" { + return nil, m.accountError(ctx, fmt.Errorf("%w: provider returned %s", ErrCredentialRejected, in.ProviderError)) + } + if in.WantState == "" || !sameToken(in.WantState, in.State) || in.Verifier == "" { + return nil, m.accountError(ctx, fmt.Errorf("%w: sign-in state did not match", ErrCredentialRejected)) + } + flow, err := m.oidc.flow(ctx, m) + if err != nil { + return nil, m.accountError(ctx, err) + } + session, err := flow.Exchange(ctx, in.Code, in.Verifier) + if err != nil { + return nil, m.accountError(ctx, err) + } + value, err := ResolveCredential(ctx, m, session.Credential) + if err != nil { + return nil, m.accountError(ctx, err) + } + p, err := m.PrincipalFor(ctx, value.ID) + if err != nil { + return nil, m.accountError(ctx, err) + } + local, err := m.OpenAccountSession(WithPrincipal(ctx, p), session.Expires) + if err != nil { + return nil, m.accountError(ctx, err) + } + m.log.InfoContext(ctx, "account signed in through the identity provider", "identity", value.ID) + return &redirectReply{ + Location: "/", + SetCookie: []http.Cookie{ + in.Client.clear(loginStateCookie, loginCookiePath), + in.Client.clear(loginVerifierCookie, loginCookiePath), + in.Client.session(local), + }, + CacheControl: "no-store", + }, nil +} + +func randomState() (string, error) { + raw := make([]byte, 32) + if _, err := rand.Read(raw); err != nil { + return "", err + } + return base64.RawURLEncoding.EncodeToString(raw), nil +} diff --git a/modules/governance/auth.go b/modules/governance/auth.go new file mode 100644 index 000000000..3ba2484e4 --- /dev/null +++ b/modules/governance/auth.go @@ -0,0 +1,122 @@ +package governance + +import ( + "context" + "crypto/subtle" + "errors" + "net" + "net/http" + "strings" + "time" + + "github.com/samcharles93/archie-core/internal/platform/httpapi" + "github.com/samcharles93/archie-core/internal/platform/httpjson" +) + +// credentials is what authenticating a request reads. +type credentials interface { + ResolveAccountSession(context.Context, string) (Identity, error) + ResolveSubject(context.Context, Subject) (Identity, error) + PersonalTokenOf(context.Context, Subject) (PersonalToken, error) + TouchPersonalToken(context.Context, Subject, time.Time) error + PrincipalFor(context.Context, IdentityID) (Principal, error) +} + +// authenticator admits, in order, a browser session cookie, a personal API +// token, or the bootstrap admin token, which is held only as its hash. +type authenticator struct { + creds credentials + adminHash string + now func() time.Time +} + +// Authenticator returns the API's authenticator over the module's accounts +// and personal tokens, with adminHash the bootstrap admin token's hash. +func (m *Module) Authenticator(adminHash string) httpapi.Authenticator { + return authenticator{creds: m, adminHash: adminHash, now: time.Now} +} + +func (a authenticator) Authenticate(ctx context.Context, r *http.Request) (context.Context, bool, error) { + if c, err := r.Cookie(httpapi.SessionCookie); err == nil { + value, err := a.creds.ResolveAccountSession(ctx, c.Value) + return a.acting(ctx, value, err) + } + token, ok := bearer(r) + if !ok { + return nil, false, httpapi.ErrUnauthenticated + } + if subject, ok := PersonalTokenSubject(token); ok { + if err := UsePersonalToken(ctx, a.creds, subject, a.now()); err != nil { + return a.acting(ctx, Identity{}, err) + } + value, err := a.creds.ResolveSubject(ctx, subject) + return a.acting(ctx, value, err) + } + if httpjson.TokenMatches(token, a.adminHash) { + return actingAs(ctx, SharedTokenOwner()), true, nil + } + return nil, false, httpapi.ErrUnauthenticated +} + +// acting is the principal an identity resolved from a credential acts as. +func (a authenticator) acting(ctx context.Context, value Identity, err error) (context.Context, bool, error) { + if err == nil && !value.CanAct() { + err = ErrIdentityInactive + } + if err != nil { + if refused(err) { + return nil, false, httpapi.ErrUnauthenticated + } + return nil, false, err + } + p, err := a.creds.PrincipalFor(ctx, value.ID) + if err != nil { + return nil, false, err + } + p.Kind = value.Kind + return actingAs(ctx, p), p.InstanceAdmin(), nil +} + +func actingAs(ctx context.Context, p Principal) context.Context { + return WithOrg(WithPrincipal(ctx, p), p.Org) +} + +// refused reports whether err says the credential was not accepted, as +// opposed to the lookup failing. +func refused(err error) bool { + for _, target := range []error{ErrNoCredential, ErrCredentialRejected, ErrIdentityNotFound, ErrIdentityInactive, ErrSubjectUnbound} { + if errors.Is(err, target) { + return true + } + } + return false +} + +func bearer(r *http.Request) (string, bool) { + const prefix = "Bearer " + header := r.Header.Get("Authorization") + if len(header) <= len(prefix) || !strings.EqualFold(header[:len(prefix)], prefix) { + return "", false + } + token := strings.TrimSpace(header[len(prefix):]) + return token, token != "" +} + +// loopback reports whether host, as a request's Host header gives it, names +// this machine. Browsers send a Secure cookie only over HTTPS, except to +// localhost. +func loopback(host string) bool { + if name, _, err := net.SplitHostPort(host); err == nil { + host = name + } + host = strings.Trim(host, "[]") + if strings.EqualFold(host, "localhost") { + return true + } + ip := net.ParseIP(host) + return ip != nil && ip.IsLoopback() +} + +func sameToken(got, want string) bool { + return subtle.ConstantTimeCompare([]byte(got), []byte(want)) == 1 +} diff --git a/modules/governance/auth_test.go b/modules/governance/auth_test.go new file mode 100644 index 000000000..ebc65dc20 --- /dev/null +++ b/modules/governance/auth_test.go @@ -0,0 +1,138 @@ +package governance + +import ( + "context" + "errors" + "net/http" + "net/http/httptest" + "testing" + "time" + + "github.com/samcharles93/archie-core/internal/platform/httpapi" + "github.com/samcharles93/archie-core/internal/platform/httpjson" +) + +// fakeCredentials holds sessions and personal tokens by their raw value. +type fakeCredentials struct { + sessions map[string]Identity + tokens map[Subject]PersonalToken + subjects map[Subject]Identity + principals map[IdentityID]Principal +} + +func (f fakeCredentials) ResolveAccountSession(_ context.Context, token string) (Identity, error) { + if token == "broken" { + return Identity{}, errors.New("database down") + } + if v, ok := f.sessions[token]; ok { + return v, nil + } + return Identity{}, ErrIdentityNotFound +} + +func (f fakeCredentials) ResolveSubject(_ context.Context, s Subject) (Identity, error) { + if v, ok := f.subjects[s]; ok { + return v, nil + } + return Identity{}, ErrIdentityNotFound +} + +func (f fakeCredentials) PersonalTokenOf(_ context.Context, s Subject) (PersonalToken, error) { + if v, ok := f.tokens[s]; ok { + return v, nil + } + return PersonalToken{}, ErrIdentityNotFound +} + +func (fakeCredentials) TouchPersonalToken(context.Context, Subject, time.Time) error { return nil } + +func (f fakeCredentials) PrincipalFor(_ context.Context, id IdentityID) (Principal, error) { + return f.principals[id], nil +} + +// TestAuthenticateRequest guards the API's credential check: a session +// cookie or personal token acts as its own identity with that identity's +// role, the bootstrap admin token acts as the instance owner, and a +// tampered, expired or inactive credential is refused rather than acting as +// anyone. +func TestAuthenticateRequest(t *testing.T) { + const admin = "a-plainly-fake-admin-token" //nolint:gosec // test fixture, not a credential + now := time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC) + past := now.Add(-time.Hour) + owner := Identity{ID: "owner", Kind: KindUser, Lifecycle: LifecycleActive} + viewer := Identity{ID: "viewer", Kind: KindUser, Lifecycle: LifecycleActive} + suspended := Identity{ID: "suspended", Kind: KindUser, Lifecycle: LifecycleSuspended} + ownerToken, ownerSubject := personalToken(t) + viewerToken, viewerSubject := personalToken(t) + expiredToken, expiredSubject := personalToken(t) + creds := fakeCredentials{ + sessions: map[string]Identity{"owner-session": owner, "viewer-session": viewer, "suspended-session": suspended}, + tokens: map[Subject]PersonalToken{ + ownerSubject: {}, viewerSubject: {}, expiredSubject: {ExpiresAt: &past}, + }, + subjects: map[Subject]Identity{ownerSubject: owner, viewerSubject: viewer, expiredSubject: owner}, + principals: map[IdentityID]Principal{ + "owner": {IdentityID: "owner", Org: DefaultOrgID, Memberships: []Membership{{IdentityID: "owner", OrgID: DefaultOrgID, Role: RoleOwner}}}, + "viewer": {IdentityID: "viewer", Org: DefaultOrgID, Memberships: []Membership{{IdentityID: "viewer", OrgID: DefaultOrgID, Role: RoleViewer}}}, + }, + } + tests := []struct { + name, cookie, bearer, adminHash string + wantErr error + wantID IdentityID + wantRole Role + wantAdmin bool + }{ + {name: "no credential", wantErr: httpapi.ErrUnauthenticated}, + {name: "owner session", cookie: "owner-session", wantID: "owner", wantRole: RoleOwner, wantAdmin: true}, + {name: "viewer session", cookie: "viewer-session", wantID: "viewer", wantRole: RoleViewer}, + {name: "tampered session", cookie: "owner-sessiom", wantErr: httpapi.ErrUnauthenticated}, + {name: "suspended identity's session", cookie: "suspended-session", wantErr: httpapi.ErrUnauthenticated}, + {name: "a failed session lookup is not a refusal", cookie: "broken", wantErr: errors.New("any")}, + {name: "owner's personal token", bearer: ownerToken, wantID: "owner", wantRole: RoleOwner, wantAdmin: true}, + {name: "viewer's personal token keeps the viewer role", bearer: viewerToken, wantID: "viewer", wantRole: RoleViewer}, + {name: "expired personal token", bearer: expiredToken, wantErr: httpapi.ErrUnauthenticated}, + {name: "unknown personal token", bearer: "archie_pat_00", wantErr: httpapi.ErrUnauthenticated}, //nolint:gosec // G101: a token no store holds, which must be refused. + {name: "admin token", bearer: admin, adminHash: httpjson.TokenHash(admin), wantID: SystemID, wantRole: RoleOwner, wantAdmin: true}, + {name: "wrong admin token", bearer: "other", adminHash: httpjson.TokenHash(admin), wantErr: httpapi.ErrUnauthenticated}, + {name: "no admin hash locks the admin token out", bearer: admin, wantErr: httpapi.ErrUnauthenticated}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + auth := authenticator{creds: creds, adminHash: tt.adminHash, now: func() time.Time { return now }} + req := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/api/thing", nil) + if tt.cookie != "" { + req.AddCookie(&http.Cookie{Name: httpapi.SessionCookie, Value: tt.cookie}) //nolint:gosec // G124: a request cookie; attributes are the server's to set. + } + if tt.bearer != "" { + req.Header.Set("Authorization", "Bearer "+tt.bearer) + } + acting, admin, err := auth.Authenticate(req.Context(), req) + if tt.wantErr != nil { + if err == nil { + t.Fatal("authenticated, want refused") + } + if errors.Is(tt.wantErr, httpapi.ErrUnauthenticated) != errors.Is(err, httpapi.ErrUnauthenticated) { + t.Fatalf("err = %v, want %v", err, tt.wantErr) + } + return + } + if err != nil { + t.Fatalf("Authenticate: %v", err) + } + p, ok := PrincipalFromContext(acting) + if !ok || p.IdentityID != tt.wantID || p.Role("") != tt.wantRole || admin != tt.wantAdmin { + t.Fatalf("acts as %s role %q admin %v, want %s role %q admin %v", p.IdentityID, p.Role(""), admin, tt.wantID, tt.wantRole, tt.wantAdmin) + } + }) + } +} + +func personalToken(t *testing.T) (string, Subject) { + t.Helper() + raw, subject, err := NewPersonalToken() + if err != nil { + t.Fatal(err) + } + return raw, subject +} diff --git a/modules/governance/governance.go b/modules/governance/governance.go index 20d2c1a94..fc99cb6a3 100644 --- a/modules/governance/governance.go +++ b/modules/governance/governance.go @@ -255,12 +255,13 @@ type Module struct { store *store.Store log *slog.Logger credentials Credentials + oidc *oidcLogin } // NewModule returns the governance module for orgID. The ai-sdk provider // classes must already be registered. func NewModule(db *sqlx.DB, log *slog.Logger, orgID string) *Module { - return &Module{orgID: orgID, store: store.New(db), log: log} + return &Module{orgID: orgID, store: store.New(db), log: log, oidc: &oidcLogin{}} } // UseCredentials gives the module the sealed store a model's key reference diff --git a/modules/governance/identity.go b/modules/governance/identity.go index 19049c99b..df5225030 100644 --- a/modules/governance/identity.go +++ b/modules/governance/identity.go @@ -356,7 +356,11 @@ type PersonalTokenStore interface { // UsePersonalToken admits a presented token, refusing expired tokens and // recording last use at most once per minute. -func UsePersonalToken(ctx context.Context, store PersonalTokenStore, subject Subject, now time.Time) error { +func UsePersonalToken(ctx context.Context, store interface { + PersonalTokenOf(context.Context, Subject) (PersonalToken, error) + TouchPersonalToken(context.Context, Subject, time.Time) error +}, subject Subject, now time.Time, +) error { token, err := store.PersonalTokenOf(ctx, subject) if err != nil { return err diff --git a/modules/governance/oidc.go b/modules/governance/oidc.go new file mode 100644 index 000000000..674fb1218 --- /dev/null +++ b/modules/governance/oidc.go @@ -0,0 +1,198 @@ +package governance + +import ( + "context" + "fmt" + "strings" + "sync" + + gooidc "github.com/coreos/go-oidc/v3/oidc" + "golang.org/x/oauth2" +) + +// oidcCallbackPath must match the redirect URI registered at the provider: +// the provider returns the browser to the path it was given. +const oidcCallbackPath = "/oauth2/callback" + +// oidcLogin runs the browser sign-in against the provider the authentication +// settings name. It keeps the provider's discovery and signing-key cache +// until the settings change, so a change applies without a restart. +type oidcLogin struct { + mu sync.Mutex + current AuthenticationSettings + provider *oidcProvider +} + +// flow returns the authorization code flow for the saved settings, or +// ErrNoCredential when no provider is configured. +func (o *oidcLogin) flow(ctx context.Context, settings AuthenticationSettingsStore) (*oidcFlow, error) { + value, err := settings.AuthenticationSettings(ctx) + if err != nil { + return nil, err + } + if value.PublicURL == "" || value.OIDCIssuer == "" { + return nil, ErrNoCredential + } + o.mu.Lock() + defer o.mu.Unlock() + if o.provider == nil || o.current != value { + provider, err := newOIDCProvider(value.OIDCIssuer, value.OIDCAudience) + if err != nil { + return nil, err + } + o.provider, o.current = provider, value + } + return newOIDCFlow(o.provider, value.OIDCClientID, value.PublicURL+oidcCallbackPath) +} + +// oidcProvider discovers the identity provider on first use and keeps the +// result. A provider that is down does not stop the binary: discovery is +// retried on the next sign-in. +type oidcProvider struct { + issuer string + audience string + + mu sync.Mutex + discovered *gooidc.Provider +} + +func newOIDCProvider(issuer, audience string) (*oidcProvider, error) { + issuer, audience = strings.TrimSpace(issuer), strings.TrimSpace(audience) + if issuer == "" { + return nil, fmt.Errorf("oidc: issuer is required") + } + // Without an audience a token the provider minted for a different + // service would authenticate here. + if audience == "" { + return nil, fmt.Errorf("oidc: audience is required") + } + return &oidcProvider{issuer: issuer, audience: audience}, nil +} + +func (p *oidcProvider) 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", ErrProviderUnavailable, p.issuer, err) + } + p.discovered = discovered + return discovered, nil +} + +// oidcFlow runs the authorization code flow with PKCE. Discovery, the code +// exchange, PKCE and token verification are the libraries'. +type oidcFlow struct { + provider *oidcProvider + clientID string + redirectURL string +} + +func newOIDCFlow(provider *oidcProvider, clientID, redirectURL string) (*oidcFlow, error) { + if strings.TrimSpace(clientID) == "" { + return nil, fmt.Errorf("oidc: client id is required for the browser flow") + } + return &oidcFlow{provider: provider, clientID: clientID, redirectURL: redirectURL}, nil +} + +func (f *oidcFlow) 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, + Endpoint: discovered.Endpoint(), + RedirectURL: f.redirectURL, + // openid makes the provider return a subject at all; profile and + // email make a name available for 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 *oidcFlow) AuthCodeURL(ctx context.Context, state string) (string, string, error) { + config, err := f.oauth(ctx) + if err != nil { + return "", "", err + } + codeVerifier := oauth2.GenerateVerifier() + url := config.AuthCodeURL(state, + oauth2.S256ChallengeOption(codeVerifier), + oauth2.SetAuthURLParam("nonce", oauth2.S256ChallengeFromVerifier(codeVerifier)), + oauth2.SetAuthURLParam("audience", f.provider.audience), + ) + return url, codeVerifier, nil +} + +// Exchange trades the code for the provider's tokens, verifies the ID token +// against the browser client and binds its nonce to the PKCE verifier. An +// access token is not proof of a browser sign-in. +func (f *oidcFlow) Exchange(ctx context.Context, code, codeVerifier string) (ProviderSession, error) { + config, err := f.oauth(ctx) + if err != nil { + return ProviderSession{}, err + } + token, err := config.Exchange(ctx, strings.TrimSpace(code), oauth2.VerifierOption(codeVerifier)) + if err != nil { + return ProviderSession{}, fmt.Errorf("%w: exchange code: %w", ErrCredentialRejected, err) + } + rawIDToken, ok := token.Extra("id_token").(string) + if !ok || rawIDToken == "" { + return ProviderSession{}, fmt.Errorf("%w: provider returned no ID token", ErrCredentialRejected) + } + discovered, err := f.provider.get(ctx) + if err != nil { + return ProviderSession{}, err + } + verified, err := discovered.Verifier(&gooidc.Config{ClientID: f.clientID}).Verify(ctx, rawIDToken) + if err != nil { + return ProviderSession{}, fmt.Errorf("%w: verify ID token: %w", ErrCredentialRejected, err) + } + if verified.Nonce != oauth2.S256ChallengeFromVerifier(codeVerifier) { + return ProviderSession{}, fmt.Errorf("%w: ID token nonce mismatch", ErrCredentialRejected) + } + credential, err := credentialOf(verified) + if err != nil { + return ProviderSession{}, err + } + expires := token.Expiry + if credential.Expires.Before(expires) || expires.IsZero() { + expires = credential.Expires + } + return ProviderSession{Credential: credential, Token: rawIDToken, Expires: expires}, nil +} + +// credentialOf reads what a verified token proved. Claims are read only after +// verification: an unverified token selects nothing. +func credentialOf(token *gooidc.IDToken) (Credential, error) { + 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 := Subject{Issuer: token.Issuer, Subject: strings.TrimSpace(claims.Subject)} + if subject.Subject == "" { + subject.Subject = strings.TrimSpace(claims.ClientID) + } + if subject.Subject == "" { + return Credential{}, fmt.Errorf("%w: token asserts neither sub nor client_id", ErrCredentialRejected) + } + email := "" + if claims.Verified { + email = strings.TrimSpace(claims.Email) + } + scopes := claims.Scopes + if len(scopes) == 0 { + scopes = strings.Fields(claims.Scope) + } + return Credential{Subject: subject, Email: email, Scopes: scopes, Expires: token.Expiry}, nil +} diff --git a/ui/src/lib/api.ts b/ui/src/lib/api.ts index bdd79cf2c..37f0cbbba 100644 --- a/ui/src/lib/api.ts +++ b/ui/src/lib/api.ts @@ -50,7 +50,19 @@ function qs(params?: QueryParams): string { // away the only part an operator can act on. Only a text/plain body is read: // a proxy's HTML error page must not pass through as the reason. async function errorMessage(res: Response): Promise { - if ((res.headers.get("Content-Type") ?? "").includes("text/plain")) { + const type = res.headers.get("Content-Type") ?? ""; + // The single binary answers with an RFC 9457 problem whose detail is the + // reason. + if (type.includes("application/problem+json")) { + try { + const detail = ((await res.json()) as { detail?: unknown }).detail; + if (typeof detail === "string" && detail) return detail.slice(0, 200); + } catch { + // Unreadable problem; fall through to the status. + } + return `${res.status} ${res.statusText}`; + } + if (type.includes("text/plain")) { try { const body = (await res.text()).trim(); if (body) return body.split("\n")[0].slice(0, 200); diff --git a/ui/vite.config.ts b/ui/vite.config.ts index d51d76621..179e88816 100644 --- a/ui/vite.config.ts +++ b/ui/vite.config.ts @@ -15,8 +15,8 @@ export default defineConfig({ outDir: "dist", emptyOutDir: true, rollupOptions: { - // index.html is the old services' dashboard; archie.html is the single - // binary's, which calls only the new API. + // index.html is the dashboard the old services and the single binary + // both serve; the binary still serves archie.html at /archie.html. input: { main: "index.html", archie: "archie.html" }, }, },