mirror of
https://github.com/hanzoai/iam.git
synced 2026-11-19 18:37:16 +00:00
An account an agent made with a wallet has no email and no phone, so a
person could sign in to it only by holding the key. PUT /v1/iam/account
refuses both fields, rightly: an address is a login identifier and a
second-factor destination, and writing one is only safe once the new
address has received a code. Nothing did that.
PUT /v1/iam/address {clientId, address, code} is that proof. The caller
is the account written (cookie or own bearer; an impersonated or
delegated one is refused; a machine is 403). The application must sign
the caller in. The code is the one POST /v1/iam/verification-codes
filed for nobody under the application's org. It adds and never
replaces (409), and an address any other account would sign in by at
that application is refused before the code is spent, in the words a
wrong code gets. Email lands verified. Audited as "address", naming the
field and the client, never the address.
A founded account works in an org of its own, so a texted code was
filed for nobody: the phone arm looked only in the application's org.
store.GetSignupByPhone is GetSignupByEmail for numbers, and the send and
resolveLoginUser fall back to it after the in-org lookup, so code
sign-in by phone finds the account the address was added to.
1227 lines
48 KiB
Go
1227 lines
48 KiB
Go
// Copyright 2026 Hanzo AI, Inc.
|
|
// SPDX-License-Identifier: MIT OR Apache-2.0
|
|
|
|
// Package store is the IAM object layer: thin, typed reads over hanzoai/orm
|
|
// against the Phase-1 entities. It replaces the v1 xorm ormer.Engine fluent
|
|
// calls with orm.TypedQuery, so handlers depend on named operations
|
|
// (GetApplicationByClientId, GetProvider, …) rather than a query builder.
|
|
//
|
|
// Every function takes a context and an orm.DB — one storage abstraction,
|
|
// backend-agnostic (sqlite / hanzoai/sql / hanzoai/datastore).
|
|
package store
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"strings"
|
|
"time"
|
|
|
|
policy "github.com/hanzoai/authz"
|
|
"github.com/hanzoai/orm"
|
|
|
|
"github.com/hanzoai/iam/internal/keyring"
|
|
"github.com/hanzoai/iam/pkg/schema"
|
|
)
|
|
|
|
// GetApplicationByClientId resolves an OAuth2/OIDC client by its clientId,
|
|
// DETERMINISTICALLY: among any rows carrying clientId it returns the platform-
|
|
// preferred one — a reserved signing owner (admin/built-in) outranks a tenant, and
|
|
// within a tier the lexically-least (owner,name) wins. clientId is globally unique
|
|
// by the applications create/update guard, so this normally has exactly one
|
|
// candidate; the ordering is defense-in-depth that makes a stray duplicate resolve
|
|
// to the PLATFORM row rather than whichever row the storage engine's heap happened
|
|
// to return first. A First() with no ORDER BY was the collidable-mint vector (safe
|
|
// on dev sqlite by rowid, UNSPECIFIED on Postgres): a tenant that registered a row
|
|
// with a mint-allow-listed clientId could have its row win resolution and
|
|
// authenticate a mint. This can no longer happen — the platform row always wins,
|
|
// and the owner-pin on the mint/capability gates denies a non-signing owner even if
|
|
// it did. Returns (nil, nil) when no application matches.
|
|
func GetApplicationByClientId(ctx context.Context, db orm.DB, clientId string) (*schema.Application, error) {
|
|
apps, err := ListApplicationsByClientId(ctx, db, clientId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return preferredApp(apps), nil
|
|
}
|
|
|
|
// ListApplicationsByClientId returns EVERY application row carrying clientId — the
|
|
// ONE place "which applications share this clientId" is answered. It backs both the
|
|
// deterministic single resolve above and the global-uniqueness guard the
|
|
// applications create/update path enforces: a JSON-document store has no per-field
|
|
// column to hang a DB UNIQUE index on, so clientId uniqueness is enforced at the
|
|
// write, exactly as the (owner,name) natural key already is. Returns nil when
|
|
// clientId is empty or unmatched.
|
|
func ListApplicationsByClientId(ctx context.Context, db orm.DB, clientId string) ([]*schema.Application, error) {
|
|
if clientId == "" {
|
|
return nil, nil
|
|
}
|
|
return orm.TypedQuery[schema.Application](db).Filter("ClientId=", clientId).GetAll(ctx)
|
|
}
|
|
|
|
// ListApplicationsByOwner returns every application row a given organization owns.
|
|
// The boot-time signing check reads it for the reserved owner: the certs those
|
|
// applications name are the ones this process must be able to sign with, so a
|
|
// mount that omits one is a partial deployment the pod must refuse rather than
|
|
// serve. Scoped by owner because a tenant's applications name a tenant's own
|
|
// certs and must never enter that decision.
|
|
func ListApplicationsByOwner(ctx context.Context, db orm.DB, owner string) ([]*schema.Application, error) {
|
|
if owner == "" {
|
|
return nil, nil
|
|
}
|
|
return orm.TypedQuery[schema.Application](db).Filter("Owner=", owner).GetAll(ctx)
|
|
}
|
|
|
|
// preferredApp deterministically selects the platform-preferred application among
|
|
// rows sharing a clientId (see morePreferredApp for the total order). Returns nil
|
|
// for an empty set, preserving GetApplicationByClientId's (nil, nil) not-found
|
|
// contract.
|
|
func preferredApp(apps []*schema.Application) *schema.Application {
|
|
var best *schema.Application
|
|
for _, a := range apps {
|
|
if a == nil {
|
|
continue
|
|
}
|
|
if best == nil || morePreferredApp(a, best) {
|
|
best = a
|
|
}
|
|
}
|
|
return best
|
|
}
|
|
|
|
// morePreferredApp reports whether a outranks b for clientId resolution: a reserved
|
|
// signing owner (admin/built-in) outranks a non-reserved one; within the same tier
|
|
// the lexically-least (owner,name) wins. The order is total and independent of
|
|
// storage/heap order, so resolution is deterministic on every backend.
|
|
func morePreferredApp(a, b *schema.Application) bool {
|
|
if sa, sb := policy.IsSigningOwner(a.Owner), policy.IsSigningOwner(b.Owner); sa != sb {
|
|
return sa
|
|
}
|
|
return a.Owner+"/"+a.Name < b.Owner+"/"+b.Name
|
|
}
|
|
|
|
// GetApplicationByName resolves an application by (owner, name).
|
|
func GetApplicationByName(_ context.Context, db orm.DB, owner, name string) (*schema.Application, error) {
|
|
app, err := orm.TypedQuery[schema.Application](db).
|
|
Filter("Owner=", owner).Filter("Name=", name).First()
|
|
if err == orm.ErrNotFound {
|
|
return nil, nil
|
|
}
|
|
return app, err
|
|
}
|
|
|
|
// GetApplicationNamed resolves an application from a NAME ALONE — for the callers
|
|
// that hold a name and no owner, which is what a User's SignupApplication is.
|
|
//
|
|
// A name is not the whole key, so those callers used to supply the owner they
|
|
// assumed: "admin". Applications are NOT all platform-owned — a tenant registers
|
|
// its own (federationOrgAllowed distinguishes the two cases, and the red-team
|
|
// suite exercises a tenant-owned app) — so that lookup missed the row entirely
|
|
// for every tenant-registered app and its caller read the miss as policy.
|
|
//
|
|
// Among rows sharing a name the platform-preferred one wins, by the SAME total
|
|
// order clientId resolution uses (morePreferredApp), so this is deterministic on
|
|
// every backend and can never resolve a tenant row ahead of a platform one.
|
|
// Returns (nil, nil) when the name is empty or unmatched.
|
|
func GetApplicationNamed(ctx context.Context, db orm.DB, name string) (*schema.Application, error) {
|
|
if name == "" {
|
|
return nil, nil
|
|
}
|
|
apps, err := orm.TypedQuery[schema.Application](db).Filter("Name=", name).GetAll(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return preferredApp(apps), nil
|
|
}
|
|
|
|
// NameHeldElsewhere reports whether an application of an owner other than owner is
|
|
// named name.
|
|
//
|
|
// A name must name one application. An account records the application that
|
|
// registered it by name alone (SignupApplication), sign-in reaches a person through
|
|
// the org that name resolves to, and GetApplicationNamed settles a shared name by
|
|
// preferring the platform's row. A second row under a name would therefore file its
|
|
// registrations under the first row's org. Every write that creates an application
|
|
// asks this first and refuses a name that is held.
|
|
func NameHeldElsewhere(ctx context.Context, db orm.DB, owner, name string) (bool, error) {
|
|
apps, err := orm.TypedQuery[schema.Application](db).Filter("Name=", name).GetAll(ctx)
|
|
if err != nil && err != orm.ErrNotFound {
|
|
return false, err
|
|
}
|
|
for _, a := range apps {
|
|
if a != nil && a.Owner != owner {
|
|
return true, nil
|
|
}
|
|
}
|
|
return false, nil
|
|
}
|
|
|
|
// An account's wallet reads live in wallet.go — HasWallet, WalletsOf, WalletRefs
|
|
// and DetachWallet together, so "what can this person sign in as" has one home.
|
|
|
|
// GetUserByName resolves a user by (owner, name) — owner is the organization.
|
|
// Returns (nil, nil) when absent.
|
|
//
|
|
// Case does not distinguish principals. New names are normalized to lowercase at
|
|
// creation (schema.Username), but rows written before that rule are stored as they
|
|
// arrived, and renaming them would move real principals — so the RESOLUTION
|
|
// tolerates case instead of the data being rewritten. Three indexed lookups,
|
|
// cheapest first: the exact name, then the lower-cased name (between them they
|
|
// answer every all-lowercase row, which is all of them going forward), then the
|
|
// NameKey (schema.Fold) for a legacy mixed-case row, which reads at most two rows
|
|
// of the org, never the org.
|
|
//
|
|
// It FAILS CLOSED when the folding is ambiguous — the same rule GetUserById
|
|
// applies to a duplicated subject. If "Alice" and "ALICE" both exist, "alice"
|
|
// names neither of them in particular, and answering with the storage engine's
|
|
// arbitrary first row would let whoever registered the second one be resolved as
|
|
// the first. An exact match always wins, so a row that is spelled the way it was
|
|
// asked for is never subject to this.
|
|
func GetUserByName(ctx context.Context, db orm.DB, owner, name string) (*schema.User, error) {
|
|
u, err := orm.TypedQuery[schema.User](db).Filter("Owner=", owner).Filter("Name=", name).First()
|
|
if err == nil {
|
|
return u, nil
|
|
}
|
|
if err != orm.ErrNotFound {
|
|
return nil, err
|
|
}
|
|
folded := strings.ToLower(strings.TrimSpace(name))
|
|
if folded == "" {
|
|
return nil, nil
|
|
}
|
|
if folded != name {
|
|
u, err := orm.TypedQuery[schema.User](db).Filter("Owner=", owner).Filter("Name=", folded).First()
|
|
if err == nil {
|
|
return u, nil
|
|
}
|
|
if err != orm.ErrNotFound {
|
|
return nil, err
|
|
}
|
|
}
|
|
// The rest of the fold is an indexed equality on NameKey (schema.Fold), not a
|
|
// read of the organization: two rows are enough to know the name is ambiguous.
|
|
us, err := orm.TypedQuery[schema.User](db).Filter("Owner=", owner).
|
|
Filter("NameKey=", schema.Fold(folded)).Limit(2).GetAll(ctx)
|
|
if err != nil && !errors.Is(err, orm.ErrNotFound) {
|
|
return nil, err
|
|
}
|
|
var match *schema.User
|
|
for _, cand := range us {
|
|
if !strings.EqualFold(cand.Name, folded) {
|
|
continue
|
|
}
|
|
if match != nil {
|
|
return nil, fmt.Errorf("store: %q and %q in organization %q both fold to %q — ambiguous username", match.Name, cand.Name, owner, folded)
|
|
}
|
|
match = cand
|
|
}
|
|
return match, nil
|
|
}
|
|
|
|
// GetUserById resolves a user by its stable opaque Id — the UUID the OIDC `sub`
|
|
// carries (schema.User.Id). Filters on the persisted "id" field, which the
|
|
// domain Id dominates over the embedded orm storage id, so the value matched is
|
|
// the UUID, never the (owner,name) key. Returns (nil, nil) when id is empty or
|
|
// unmatched (a pre-cutover user with no Id has "" here and is never matched by a
|
|
// non-empty subject).
|
|
//
|
|
// It FAILS CLOSED on multiplicity: the store has no DB UNIQUE index on Id, so if two
|
|
// rows ever shared one UUID (a broken invariant — Id is the OIDC `sub` and the authz
|
|
// principal key), returning the storage engine's arbitrary First() would let an
|
|
// attacker who planted a colliding row be resolved AS a victim. More than one match
|
|
// is therefore an error, never a silently-chosen row.
|
|
func GetUserById(ctx context.Context, db orm.DB, id string) (*schema.User, error) {
|
|
if id == "" {
|
|
return nil, nil
|
|
}
|
|
us, err := orm.TypedQuery[schema.User](db).Filter("Id=", id).GetAll(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
switch len(us) {
|
|
case 0:
|
|
return nil, nil
|
|
case 1:
|
|
return us[0], nil
|
|
default:
|
|
return nil, fmt.Errorf("store: %d users share id %q — ambiguous subject", len(us), id)
|
|
}
|
|
}
|
|
|
|
// GetUserByExternalId resolves a user by the externalId its tenant filed it
|
|
// under, CONFINED to owner — the id an operator keys a member by in its own
|
|
// directory, and the value as() accepts beside the stable subject. externalId is
|
|
// unique only within a tenant, so owner is half the question; a cross-tenant
|
|
// match cannot arise. Returns (nil, nil) when empty or unmatched, and FAILS CLOSED
|
|
// on multiplicity: two rows sharing one externalId in an org name neither in
|
|
// particular, so answering with the storage engine's arbitrary first row would let
|
|
// whoever registered the second be resolved as the first — the same refusal
|
|
// GetUserById makes for a duplicated subject.
|
|
func GetUserByExternalId(ctx context.Context, db orm.DB, owner, externalId string) (*schema.User, error) {
|
|
if owner == "" || externalId == "" {
|
|
return nil, nil
|
|
}
|
|
us, err := orm.TypedQuery[schema.User](db).Filter("Owner=", owner).Filter("ExternalId=", externalId).GetAll(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
switch len(us) {
|
|
case 0:
|
|
return nil, nil
|
|
case 1:
|
|
return us[0], nil
|
|
default:
|
|
return nil, fmt.Errorf("store: %d users in organization %q share externalId %q — ambiguous", len(us), owner, externalId)
|
|
}
|
|
}
|
|
|
|
// GetUserBySubject resolves the user a token's `sub` names — the ONE place the
|
|
// subject→user mapping lives, shared by userinfo, get-account, token exchange,
|
|
// and the authz principal, so `sub` is decoded the same way everywhere. The
|
|
// discriminator is deterministic and matches how a `sub` is MINTED (subjectOf):
|
|
// a stable opaque UUID carries no "/" and resolves by Id; an "owner/name" subject
|
|
// (a pre-cutover user with no Id, or a machine token's app identity) resolves by
|
|
// its natural key. Returns (nil, nil) when no user matches — a machine token's
|
|
// app-id subject, or a since-deleted user — the callers fail closed on nil.
|
|
func GetUserBySubject(ctx context.Context, db orm.DB, sub string) (*schema.User, error) {
|
|
if sub == "" {
|
|
return nil, nil
|
|
}
|
|
if owner, name, hasSlash := strings.Cut(sub, "/"); hasSlash {
|
|
if owner == "" || name == "" {
|
|
return nil, nil
|
|
}
|
|
return GetUserByName(ctx, db, owner, name)
|
|
}
|
|
return GetUserById(ctx, db, sub)
|
|
}
|
|
|
|
// ErrEmailAmbiguous reports that an email address identifies more than one
|
|
// account in an org, so it identifies nobody. Returned instead of a user, on
|
|
// purpose — the same refusal [GetUserByPhone] makes, for the same reason.
|
|
var ErrEmailAmbiguous = errors.New("email address matches more than one account")
|
|
|
|
// NormalizeEmail reduces an email address to the ONE form this system stores and
|
|
// compares: trimmed, and lowercase throughout.
|
|
//
|
|
// Lowercasing the LOCAL part as well as the domain is a deliberate choice, and it
|
|
// is the choice already made everywhere an address is written — signup and both
|
|
// IdP readers each lowered the whole thing before this function existed. RFC 5321
|
|
// permits a local part to be case-sensitive; no mail provider anyone signs up
|
|
// with treats it that way, and a system that stores Alice@x and alice@x as two
|
|
// accounts hands one person two identities and the other person's address to
|
|
// nobody.
|
|
//
|
|
// Applying it on WRITE and on READ is what makes one address one value. Applied
|
|
// on only one side it is a lookup that silently never matches: signup lowered on
|
|
// the way in while [GetUserByEmail] compared the raw spelling, so anyone who
|
|
// capitalized a letter of their own address created an account and was then told
|
|
// "the username or password is incorrect" for the password they had just chosen —
|
|
// forever, and with no way to tell why.
|
|
func NormalizeEmail(s string) string {
|
|
return strings.ToLower(strings.TrimSpace(s))
|
|
}
|
|
|
|
// GetUserByEmail resolves a user by (owner, email) — the email-login identifier.
|
|
//
|
|
// It FAILS CLOSED on ambiguity for the same reason [GetUserByPhone] does: the
|
|
// document store hangs no per-field UNIQUE constraint, so two rows in one org can
|
|
// carry one address, and a `.First()` would hand back an arbitrary one of them for
|
|
// the caller to authenticate somebody against. Which row that is is not even
|
|
// stable — the query carries no ORDER BY, so it is whatever the index yields. An
|
|
// address that names two accounts names none.
|
|
func GetUserByEmail(ctx context.Context, db orm.DB, owner, email string) (*schema.User, error) {
|
|
email = NormalizeEmail(email)
|
|
if email == "" {
|
|
return nil, nil
|
|
}
|
|
// Two, not one: enough to detect a collision, bounded so an address shared by
|
|
// many rows cannot pull them all into memory.
|
|
us, err := orm.TypedQuery[schema.User](db).Filter("Owner=", owner).Filter("Email=", email).Limit(2).GetAll(ctx)
|
|
if err == orm.ErrNotFound {
|
|
return nil, nil
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
switch len(us) {
|
|
case 0:
|
|
return nil, nil
|
|
case 1:
|
|
return us[0], nil
|
|
default:
|
|
return nil, ErrEmailAmbiguous
|
|
}
|
|
}
|
|
|
|
// GetSignupByEmail resolves an account registered in org, by the address it
|
|
// registered with: a row whose [schema.User.SignupApplication] names an application
|
|
// of org, carrying email.
|
|
//
|
|
// It exists because the org an account is registered in is not the tenant the
|
|
// person works in. An application that founds an org per person has its accounts
|
|
// spread across every org it founded, so scoping sign-in to the registration org
|
|
// resolves nobody; this is the scope that matches the population.
|
|
//
|
|
// The scope is the ORG, not the one application, because an org's applications
|
|
// are one front door with several entrances. hanzo.ai, the console, the CLI and
|
|
// chat are each their own client of org hanzo, and a person who registered at one
|
|
// of them is the same person at every other: keyed by the application, they could
|
|
// not sign in anywhere but where they started, and a social sign-in anywhere else
|
|
// gave them a second account and a second org. Usernames are unique per org for
|
|
// the same reason — the org is the registration namespace.
|
|
//
|
|
// It is still NARROWER than a cross-org lookup by address, which is a different
|
|
// thing and stays refused: it reads only rows some application of org registered,
|
|
// so another org's registrations — and seeded or imported rows, which carry no
|
|
// SignupApplication at all — are unreachable through it. An empty org therefore
|
|
// matches nothing rather than everything.
|
|
//
|
|
// Ambiguity FAILS CLOSED, as [GetUserByEmail] does and for the same reason: two
|
|
// rows carrying one address name nobody, and handing back an arbitrary one is how
|
|
// a person is authenticated as somebody else.
|
|
func GetSignupByEmail(ctx context.Context, db orm.DB, org, email string) (*schema.User, error) {
|
|
email = NormalizeEmail(email)
|
|
if org == "" || email == "" {
|
|
return nil, nil
|
|
}
|
|
us, err := orm.TypedQuery[schema.User](db).
|
|
Filter("Email=", email).Filter("SignupApplication!=", "").GetAll(ctx)
|
|
if err == orm.ErrNotFound {
|
|
return nil, nil
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if us, err = registeredIn(ctx, db, org, us); err != nil {
|
|
return nil, err
|
|
}
|
|
switch len(us) {
|
|
case 0:
|
|
return nil, nil
|
|
case 1:
|
|
return us[0], nil
|
|
default:
|
|
return nil, ErrEmailAmbiguous
|
|
}
|
|
}
|
|
|
|
// nameScan bounds the rows the first username read takes from every org at once.
|
|
// A name is held by at most one account per registration org, so a fuller read
|
|
// means many orgs hold it, and the lookup reads org's own applications instead.
|
|
const nameScan = 64
|
|
|
|
// SignupByName finds the account registered in org that holds a username: a row
|
|
// whose [schema.User.SignupApplication] names an application of org, compared by
|
|
// [schema.Fold], never a reserved org. held counts the matches, stopping at two, and
|
|
// the account is returned only when held is exactly one.
|
|
//
|
|
// It is [GetSignupByEmail] for the other identifier a sign-in form takes. A
|
|
// founding application moves each account it registers into an org of its own, and
|
|
// the account keeps its username there, so the registration org — the only org a
|
|
// sign-in screen can name — no longer holds that name. This is the reach that finds
|
|
// it, under the same scope.
|
|
//
|
|
// A name two accounts hold (usernames written before they were unique across a
|
|
// registration org) names nobody. That is reported as a count, not an error, so a
|
|
// sign-in refuses it exactly as it refuses a name nobody holds, and signup reads the
|
|
// same count to keep a name from being handed out twice.
|
|
func SignupByName(ctx context.Context, db orm.DB, org, name string) (user *schema.User, held int, err error) {
|
|
key := schema.Fold(strings.TrimSpace(name))
|
|
if org == "" || key == "" {
|
|
return nil, 0, nil
|
|
}
|
|
us, err := orm.TypedQuery[schema.User](db).
|
|
Filter("NameKey=", key).Filter("SignupApplication!=", "").Limit(nameScan).GetAll(ctx)
|
|
if err == orm.ErrNotFound {
|
|
return nil, 0, nil
|
|
}
|
|
if err != nil {
|
|
return nil, 0, err
|
|
}
|
|
if len(us) >= nameScan {
|
|
us, err = registeredNamed(ctx, db, org, key)
|
|
} else {
|
|
us, err = registeredIn(ctx, db, org, us)
|
|
}
|
|
if err != nil {
|
|
return nil, 0, err
|
|
}
|
|
switch len(us) {
|
|
case 0:
|
|
return nil, 0, nil
|
|
case 1:
|
|
return us[0], 1, nil
|
|
default:
|
|
return nil, 2, nil
|
|
}
|
|
}
|
|
|
|
// registeredNamed reads, application by application, the accounts org's
|
|
// applications registered under key, stopping at two: the exact answer for a name
|
|
// too many orgs hold to read in one pass, reading nothing another org registered.
|
|
func registeredNamed(ctx context.Context, db orm.DB, org, key string) ([]*schema.User, error) {
|
|
apps, err := orm.TypedQuery[schema.Application](db).Filter("Organization=", org).GetAll(ctx)
|
|
if err != nil && err != orm.ErrNotFound {
|
|
return nil, err
|
|
}
|
|
var out []*schema.User
|
|
for _, app := range apps {
|
|
us, err := orm.TypedQuery[schema.User](db).
|
|
Filter("NameKey=", key).Filter("SignupApplication=", app.Name).Limit(2).GetAll(ctx)
|
|
if err != nil && err != orm.ErrNotFound {
|
|
return nil, err
|
|
}
|
|
for _, u := range us {
|
|
if !policy.IsReservedOrg(u.Owner) {
|
|
out = append(out, u)
|
|
}
|
|
}
|
|
if len(out) >= 2 {
|
|
return out[:2], nil
|
|
}
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// RegisteredIn reports whether an application of org registered u — the reach
|
|
// [GetSignupByEmail] makes by address, asked of an account already in hand.
|
|
func RegisteredIn(ctx context.Context, db orm.DB, org string, u *schema.User) (bool, error) {
|
|
kept, err := registeredIn(ctx, db, org, []*schema.User{u})
|
|
return len(kept) == 1, err
|
|
}
|
|
|
|
// registeredIn keeps the rows an application of org registered.
|
|
//
|
|
// A reserved owner is never kept. Nothing should ever file a row of the admin org
|
|
// under an application's signup, and if something does, this must not be the
|
|
// lookup that authenticates it — the reserved orgs hold the SuperAdmin and the
|
|
// signing certs.
|
|
func registeredIn(ctx context.Context, db orm.DB, org string, us []*schema.User) ([]*schema.User, error) {
|
|
orgOf := map[string]string{}
|
|
var out []*schema.User
|
|
for _, u := range us {
|
|
if u == nil || u.SignupApplication == "" || policy.IsReservedOrg(u.Owner) {
|
|
continue
|
|
}
|
|
o, seen := orgOf[u.SignupApplication]
|
|
if !seen {
|
|
app, err := GetApplicationNamed(ctx, db, u.SignupApplication)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if app != nil {
|
|
o = app.Organization
|
|
}
|
|
orgOf[u.SignupApplication] = o
|
|
}
|
|
if o == org {
|
|
out = append(out, u)
|
|
}
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// ErrPhoneAmbiguous reports that a phone number identifies more than one account
|
|
// in an org, so it identifies nobody. Returned instead of a user, on purpose —
|
|
// see [GetUserByPhone].
|
|
var ErrPhoneAmbiguous = errors.New("phone number matches more than one account")
|
|
|
|
// LooksLikePhone reports whether an identifier is a phone NUMBER rather than an
|
|
// address or a username: at least seven digits, and nothing but digits and the
|
|
// punctuation people put in phone numbers. Seven is the shortest national subscriber
|
|
// number in general use, and requiring it keeps a short numeric username out of the
|
|
// phone arm.
|
|
//
|
|
// It is a SHAPE test, not validation — whether the number names anyone is a lookup's
|
|
// business. It lives here, beside [NormalizePhone], because the two answer one
|
|
// question together ("is this a number, and what is its canonical form") and every
|
|
// caller that normalizes has first to decide whether it should. Sign-in's identifier
|
|
// resolution and the verification code's receiver key both ask it, and a second copy
|
|
// would be a second answer.
|
|
func LooksLikePhone(s string) bool {
|
|
digits := 0
|
|
for i, r := range s {
|
|
switch {
|
|
case r >= '0' && r <= '9':
|
|
digits++
|
|
case r == '+' && i == 0, r == ' ', r == '-', r == '(', r == ')', r == '.':
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
return digits >= 7
|
|
}
|
|
|
|
// NormalizePhone reduces a phone number to the ONE form this system stores and
|
|
// compares: a leading "+" if the caller gave one, then digits, nothing else.
|
|
//
|
|
// It exists because a phone typed by a human ("(415) 555-0134", "415-555-0134",
|
|
// "+1 415 555 0134") and a phone written by SCIM are the same number in different
|
|
// clothes, and an equality lookup cannot see through clothes. Applying it on WRITE
|
|
// and on READ is what makes one number one value; applying it on only one side
|
|
// would be a lookup that silently never matches.
|
|
//
|
|
// It deliberately does NOT infer a country code. Guessing "+1" for a bare
|
|
// ten-digit string would silently claim a number in one country for a user in
|
|
// another, and this function has no idea which country anyone is in. A number
|
|
// stored without a country code matches only a number typed without one, which is
|
|
// the honest behaviour; making country codes canonical is a data decision for
|
|
// whoever collects the number, not a guess for a string function.
|
|
func NormalizePhone(s string) string {
|
|
s = strings.TrimSpace(s)
|
|
if s == "" {
|
|
return ""
|
|
}
|
|
var b strings.Builder
|
|
for i, r := range s {
|
|
switch {
|
|
case r >= '0' && r <= '9':
|
|
b.WriteRune(r)
|
|
case r == '+' && i == 0:
|
|
b.WriteRune(r)
|
|
}
|
|
}
|
|
out := b.String()
|
|
if out == "+" {
|
|
return ""
|
|
}
|
|
return out
|
|
}
|
|
|
|
// GetUserByPhone resolves a user by (owner, phone) — the SMS-login identifier.
|
|
//
|
|
// It FAILS CLOSED on ambiguity, exactly as [GetUserByEmail] does: `schema.User.
|
|
// Phone` is indexed but NOT unique, so two rows in one org can carry the same
|
|
// number; a `.First()` would then hand back an arbitrary one of them and the
|
|
// caller would authenticate a person against somebody else's account. That is the
|
|
// same defect class as the cross-org collision the login path already refuses to
|
|
// rely on. A number that names two accounts names none, so this returns
|
|
// [ErrPhoneAmbiguous] and lets the caller refuse rather than choose.
|
|
//
|
|
// One ambiguity policy for every identifier is the point. This one was argued
|
|
// here first and the address was left picking arbitrarily for a while, which is
|
|
// how a rule stated in one place drifts from the rule stated beside it.
|
|
//
|
|
// phone is normalized here so every caller compares the same way; a blank or
|
|
// punctuation-only argument returns (nil, nil) rather than matching the many rows
|
|
// that legitimately store no phone at all.
|
|
func GetUserByPhone(ctx context.Context, db orm.DB, owner, phone string) (*schema.User, error) {
|
|
phone = NormalizePhone(phone)
|
|
if phone == "" {
|
|
return nil, nil
|
|
}
|
|
// Two, not one: enough to detect a collision, and bounded so a shared number
|
|
// on many rows cannot pull them all into memory.
|
|
us, err := orm.TypedQuery[schema.User](db).Filter("Owner=", owner).Filter("Phone=", phone).Limit(2).GetAll(ctx)
|
|
if err == orm.ErrNotFound {
|
|
return nil, nil
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
switch len(us) {
|
|
case 0:
|
|
return nil, nil
|
|
case 1:
|
|
return us[0], nil
|
|
default:
|
|
return nil, ErrPhoneAmbiguous
|
|
}
|
|
}
|
|
|
|
// GetSignupByPhone is [GetSignupByEmail] for the other address a code reaches: an
|
|
// account registered in org — a row whose [schema.User.SignupApplication] names an
|
|
// application of org — carrying phone.
|
|
//
|
|
// It exists for the same reason. An account a founding application registered
|
|
// works in an org of its own, so [GetUserByPhone] scoped to the application's org
|
|
// finds nobody, and a code texted to that account's own number was filed for
|
|
// nobody and signed nobody in. The reach is the same one the address has: org's
|
|
// registrations only, reserved orgs never, seeded and imported rows (no
|
|
// SignupApplication) never.
|
|
//
|
|
// phone is normalized here, as [GetUserByPhone] normalizes it. Ambiguity FAILS
|
|
// CLOSED with [ErrPhoneAmbiguous]: two registrations carrying one number name
|
|
// nobody.
|
|
func GetSignupByPhone(ctx context.Context, db orm.DB, org, phone string) (*schema.User, error) {
|
|
phone = NormalizePhone(phone)
|
|
if org == "" || phone == "" {
|
|
return nil, nil
|
|
}
|
|
us, err := orm.TypedQuery[schema.User](db).
|
|
Filter("Phone=", phone).Filter("SignupApplication!=", "").GetAll(ctx)
|
|
if err == orm.ErrNotFound {
|
|
return nil, nil
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if us, err = registeredIn(ctx, db, org, us); err != nil {
|
|
return nil, err
|
|
}
|
|
switch len(us) {
|
|
case 0:
|
|
return nil, nil
|
|
case 1:
|
|
return us[0], nil
|
|
default:
|
|
return nil, ErrPhoneAmbiguous
|
|
}
|
|
}
|
|
|
|
// GetTokenByCode resolves a token row by its authorization code. Returns
|
|
// (nil, nil) when no row carries the code.
|
|
func GetTokenByCode(_ context.Context, db orm.DB, code string) (*schema.Token, error) {
|
|
if code == "" {
|
|
return nil, nil
|
|
}
|
|
t, err := orm.TypedQuery[schema.Token](db).Filter("Code=", code).First()
|
|
if err == orm.ErrNotFound {
|
|
return nil, nil
|
|
}
|
|
return t, err
|
|
}
|
|
|
|
// GetCert resolves a signing certificate by (owner, name), with its private key
|
|
// filled in from the keyring.
|
|
//
|
|
// The row carries the key's identity; the key itself is never a column. Filling
|
|
// it HERE is what let that change stay invisible to everything downstream: the
|
|
// signer, the verifier, the JWKS and the session-cookie key each still read
|
|
// cert.PrivateKey off the value the store handed them, and none of them had to
|
|
// learn where key material comes from.
|
|
func GetCert(_ context.Context, db orm.DB, owner, name string) (*schema.Cert, error) {
|
|
c, err := orm.TypedQuery[schema.Cert](db).Filter("Owner=", owner).Filter("Name=", name).First()
|
|
if err == orm.ErrNotFound {
|
|
return nil, nil
|
|
}
|
|
keyring.Fill(c)
|
|
return c, err
|
|
}
|
|
|
|
// GetTokenByUserCode resolves a pending device authorization by the user_code a
|
|
// human transcribes at the verification URI (RFC 8628 §3.3). Returns (nil, nil)
|
|
// when no row carries the code.
|
|
func GetTokenByUserCode(_ context.Context, db orm.DB, userCode string) (*schema.Token, error) {
|
|
if userCode == "" {
|
|
return nil, nil
|
|
}
|
|
t, err := orm.TypedQuery[schema.Token](db).Filter("UserCode=", userCode).First()
|
|
if err == orm.ErrNotFound {
|
|
return nil, nil
|
|
}
|
|
return t, err
|
|
}
|
|
|
|
// GetSigningCert resolves a TRUSTED signing certificate by name (the JWKS
|
|
// `kid`), searching only the reserved platform owners in order. A cert owned by
|
|
// any other org is never returned, so an attacker-created cert with a colliding
|
|
// name can neither sign a token iam will verify nor be published in the JWKS.
|
|
// Returns (nil, nil) when no trusted cert carries the name.
|
|
func GetSigningCert(ctx context.Context, db orm.DB, name string) (*schema.Cert, error) {
|
|
if name == "" {
|
|
return nil, nil
|
|
}
|
|
for _, owner := range policy.SigningOwners() {
|
|
c, err := GetCert(ctx, db, owner, name)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if c != nil {
|
|
return c, nil
|
|
}
|
|
}
|
|
return nil, nil
|
|
}
|
|
|
|
// PersistToken binds a domain Token onto the store and creates it. Used to
|
|
// persist an authorization code minted by oidc.MintCode. The id is (owner, name);
|
|
// callers set Name to a unique value (e.g. the code) before persisting.
|
|
func PersistToken(ctx context.Context, db orm.DB, tok *schema.Token) error {
|
|
t := orm.New[schema.Token](db)
|
|
model := t.Model
|
|
*t = *tok
|
|
t.Model = model
|
|
name := tok.Name
|
|
if name == "" {
|
|
name = tok.Code // codes are unique; use as the row name when none given
|
|
t.Name = name
|
|
}
|
|
t.SetId(tok.Owner + "/" + name)
|
|
return t.CreateCtx(ctx)
|
|
}
|
|
|
|
// SaveToken read-modify-writes an existing token row (e.g. after redemption:
|
|
// CodeIsUsed=true + AccessToken set). It looks the row up by (owner, name),
|
|
// copies the mutated fields, and updates in place.
|
|
func SaveToken(ctx context.Context, db orm.DB, tok *schema.Token) error {
|
|
existing, err := orm.Get[schema.Token](db, tok.Owner+"/"+tok.Name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
model := existing.Model
|
|
*existing = *tok
|
|
existing.Model = model
|
|
return existing.UpdateCtx(ctx)
|
|
}
|
|
|
|
// ListCerts returns every certificate ordered by name, each with its private key
|
|
// filled in from the keyring (see GetCert). The JWKS endpoint calls this and
|
|
// filters to the token-signing certs it publishes.
|
|
func ListCerts(ctx context.Context, db orm.DB) ([]*schema.Cert, error) {
|
|
certs, err := orm.TypedQuery[schema.Cert](db).Order("Name").GetAll(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, c := range certs {
|
|
keyring.Fill(c)
|
|
}
|
|
return certs, nil
|
|
}
|
|
|
|
// PlatformSigningCert returns a deterministic trusted signing cert — the
|
|
// lexically-least by (owner, name) among the reserved platform owners that both
|
|
// carries a private key AND is NAMED by a reserved-owner application. It keys
|
|
// deployment-stable secret derivations (the session-cookie MAC), so there is no
|
|
// new secret to provision; a tenant cert can never be chosen. Returns (nil, nil)
|
|
// when none is available.
|
|
//
|
|
// The choice is from the REFERENCED set, not from whatever is mounted, because
|
|
// the session-cookie MAC must be the SAME cert on every replica or a browser's
|
|
// session flaps as the load balancer moves it between them. server.RequireSigning
|
|
// requires every cert a reserved-owner application names to be mounted on any
|
|
// replica that serves, so the referenced-and-mounted set is identical on every
|
|
// booting replica and this choice is therefore identical too. An unreferenced
|
|
// cert someone happened to mount — the mounted-but-not-yet-repointed half of a
|
|
// staged rotation — is deliberately not a candidate: it would otherwise sort
|
|
// ahead of the incumbent on one replica and split the MAC across the fleet.
|
|
//
|
|
// Falls back to the plain mounted set ONLY when no reserved-owner application
|
|
// names any cert — a bare install with no sessions to flap — so a first boot
|
|
// still resolves a key.
|
|
func PlatformSigningCert(ctx context.Context, db orm.DB) (*schema.Cert, error) {
|
|
certs, err := ListCerts(ctx, db)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
apps, err := ListApplicationsByOwner(ctx, db, policy.AdminOrg)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
referenced := make(map[string]bool, len(apps))
|
|
for _, a := range apps {
|
|
if a != nil && a.Cert != "" {
|
|
referenced[a.Cert] = true
|
|
}
|
|
}
|
|
pick := func(eligible func(*schema.Cert) bool) *schema.Cert {
|
|
var best *schema.Cert
|
|
for _, c := range certs {
|
|
if c == nil || c.PrivateKey == "" || !policy.IsSigningOwner(c.Owner) || c.Delegates() || !eligible(c) {
|
|
continue
|
|
}
|
|
if best == nil || c.Owner+"/"+c.Name < best.Owner+"/"+best.Name {
|
|
best = c
|
|
}
|
|
}
|
|
return best
|
|
}
|
|
if best := pick(func(c *schema.Cert) bool { return referenced[c.Name] }); best != nil {
|
|
return best, nil
|
|
}
|
|
return pick(func(*schema.Cert) bool { return true }), nil
|
|
}
|
|
|
|
// GetTokenByAccessTokenHash resolves a live token row by the SHA-256 hash of a
|
|
// presented access token — the userinfo bearer lookup. Because the row is the
|
|
// authorization server's memory of the grant, a deleted/rotated row means the
|
|
// bearer is revoked, independent of the JWT's own expiry.
|
|
func GetTokenByAccessTokenHash(_ context.Context, db orm.DB, hash string) (*schema.Token, error) {
|
|
if hash == "" {
|
|
return nil, nil
|
|
}
|
|
t, err := orm.TypedQuery[schema.Token](db).Filter("AccessTokenHash=", hash).First()
|
|
if err == orm.ErrNotFound {
|
|
return nil, nil
|
|
}
|
|
return t, err
|
|
}
|
|
|
|
// GetTokenByRefreshHash resolves a token row by the SHA-256 hash of a presented
|
|
// refresh token — the refresh-grant lookup.
|
|
func GetTokenByRefreshHash(_ context.Context, db orm.DB, hash string) (*schema.Token, error) {
|
|
if hash == "" {
|
|
return nil, nil
|
|
}
|
|
t, err := orm.TypedQuery[schema.Token](db).Filter("RefreshTokenHash=", hash).First()
|
|
if err == orm.ErrNotFound {
|
|
return nil, nil
|
|
}
|
|
return t, err
|
|
}
|
|
|
|
// ListTokensByRefreshFamily returns every row sharing a refresh-token family —
|
|
// the rotation chain a reuse-detection event revokes as a unit.
|
|
func ListTokensByRefreshFamily(ctx context.Context, db orm.DB, family string) ([]*schema.Token, error) {
|
|
if family == "" {
|
|
return nil, nil
|
|
}
|
|
return orm.TypedQuery[schema.Token](db).Filter("RefreshFamily=", family).GetAll(ctx)
|
|
}
|
|
|
|
// ListTokensByUserApp returns every token row one user holds for one application
|
|
// — the grant an RP-initiated logout retires. User is the "owner/name" pair the
|
|
// mint stamps on the row, and BOTH filters are required: a query missing either
|
|
// would revoke across users or across applications, so an empty argument returns
|
|
// nothing rather than matching everything.
|
|
func ListTokensByUserApp(ctx context.Context, db orm.DB, user, application string) ([]*schema.Token, error) {
|
|
if user == "" || application == "" {
|
|
return nil, nil
|
|
}
|
|
return orm.TypedQuery[schema.Token](db).
|
|
Filter("User=", user).Filter("Application=", application).GetAll(ctx)
|
|
}
|
|
|
|
// ListTokensByUser returns every token row one user holds, across every
|
|
// application — what a sign-out of every application of one organization
|
|
// sorts through. An empty user returns nothing rather than matching everyone.
|
|
func ListTokensByUser(ctx context.Context, db orm.DB, user string) ([]*schema.Token, error) {
|
|
if user == "" {
|
|
return nil, nil
|
|
}
|
|
return orm.TypedQuery[schema.Token](db).Filter("User=", user).GetAll(ctx)
|
|
}
|
|
|
|
// RekeyTokens moves every token row a user holds from one identity key to
|
|
// another — the "owner/name" pair the mint stamps on the row as User. Moving a
|
|
// user between orgs re-keys their identity, and a grant still naming the old key
|
|
// resolves nobody: its refresh would answer invalid_grant to the person it was
|
|
// issued to. Both keys are required; an empty one moves nothing.
|
|
func RekeyTokens(ctx context.Context, db orm.DB, from, to string) error {
|
|
if from == "" || to == "" || from == to {
|
|
return nil
|
|
}
|
|
rows, err := orm.TypedQuery[schema.Token](db).Filter("User=", from).GetAll(ctx)
|
|
if err != nil && !errors.Is(err, orm.ErrNotFound) {
|
|
return err
|
|
}
|
|
for _, tk := range rows {
|
|
tk.User = to
|
|
if err := tk.UpdateCtx(ctx); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// DeleteToken removes a token row by (owner, name). A missing row is not an
|
|
// error — revocation is idempotent.
|
|
func DeleteToken(ctx context.Context, db orm.DB, tok *schema.Token) error {
|
|
existing, err := orm.Get[schema.Token](db, tok.Owner+"/"+tok.Name)
|
|
if err != nil {
|
|
if err == orm.ErrNotFound {
|
|
return nil
|
|
}
|
|
return err
|
|
}
|
|
return existing.DeleteCtx(ctx)
|
|
}
|
|
|
|
// GetProvider resolves a provider record by (owner, name) — e.g.
|
|
// ("admin", "provider-github"). Providers are shared org-level records the
|
|
// application's ProviderItem links to by name.
|
|
func GetProvider(_ context.Context, db orm.DB, owner, name string) (*schema.Provider, error) {
|
|
p, err := orm.TypedQuery[schema.Provider](db).
|
|
Filter("Owner=", owner).Filter("Name=", name).First()
|
|
if err == orm.ErrNotFound {
|
|
return nil, nil
|
|
}
|
|
return p, err
|
|
}
|
|
|
|
// EnrichProviders resolves each of the application's ProviderItem links to its
|
|
// shared Provider record (Category/Type/ClientId), attaching it to
|
|
// item.Provider. A link whose provider record is missing is left with a nil
|
|
// Provider (the caller treats that as unconfigured — never a dead-end button).
|
|
func EnrichProviders(ctx context.Context, db orm.DB, app *schema.Application) {
|
|
if app == nil {
|
|
return
|
|
}
|
|
for _, item := range app.Providers {
|
|
if item == nil || item.Name == "" {
|
|
continue
|
|
}
|
|
if p, err := GetProvider(ctx, db, ProviderOwner(item), item.Name); err == nil && p != nil {
|
|
item.Provider = p
|
|
}
|
|
}
|
|
}
|
|
|
|
// ProviderOwner is the organization a link's provider record is read from: the one
|
|
// the link names, or the platform's where it names none, since that is where the
|
|
// shared connectors are seeded.
|
|
//
|
|
// It is ONE function because two callers must agree: the resolution above, and the
|
|
// authorization in front of the write that stores the link. A link is a reference
|
|
// to credentials — the identity provider's client id and secret run the sign-in leg
|
|
// — so a gate that resolved the owner differently from this would authorize one
|
|
// record and use another.
|
|
func ProviderOwner(item *schema.ProviderItem) string {
|
|
if item == nil || item.Owner == "" {
|
|
return policy.AdminOrg
|
|
}
|
|
return item.Owner
|
|
}
|
|
|
|
// GetOrganizationByName resolves the organization a name refers to. Returns
|
|
// (nil, nil) when absent.
|
|
//
|
|
// Every organization row is filed under the admin owner: the NAME is the tenant
|
|
// identity and the owner half is the registry the row lives in. That is what the
|
|
// signup converge writes, what the console's list reads, and what authz states
|
|
// when it decides an organization write on its reserved-owner branch — so the
|
|
// owner is pinned here too, and a name resolves to one row rather than to
|
|
// whichever row a scan reaches first.
|
|
//
|
|
// A name is a key only WITH it. What this answer settles is which algorithm
|
|
// verifies a password, which complexity rules a new one must meet, and whether
|
|
// the organization demands a second factor — questions that take one answer.
|
|
func GetOrganizationByName(_ context.Context, db orm.DB, name string) (*schema.Organization, error) {
|
|
if name == "" {
|
|
return nil, nil
|
|
}
|
|
o, err := orm.TypedQuery[schema.Organization](db).
|
|
Filter("Owner=", policy.AdminOrg).
|
|
Filter("Name=", name).
|
|
First()
|
|
if err == orm.ErrNotFound {
|
|
return nil, nil
|
|
}
|
|
return o, err
|
|
}
|
|
|
|
// AddVerificationRecord persists a freshly minted verification code. The id is
|
|
// (owner, name); the caller sets Name to a unique value before persisting.
|
|
// Mirrors PersistToken: the orm.Model is preserved while the caller's fields are
|
|
// copied onto the fresh, db-bound entity.
|
|
func AddVerificationRecord(ctx context.Context, db orm.DB, rec *schema.VerificationRecord) error {
|
|
r := orm.New[schema.VerificationRecord](db)
|
|
model := r.Model
|
|
*r = *rec
|
|
r.Model = model
|
|
r.SetId(rec.Owner + "/" + rec.Name)
|
|
return r.CreateCtx(ctx)
|
|
}
|
|
|
|
// GetLatestVerificationRecord resolves the most recent UNUSED verification
|
|
// record sent to receiver WITHIN owner — the row the check path validates a
|
|
// submitted code against. Returns (nil, nil) when none exists.
|
|
//
|
|
// The owner filter is tenant isolation: an address is not unique across
|
|
// organizations, so unscoped this answered across every tenant at once. Every
|
|
// caller resolves the account first and therefore knows the org, so the scope costs
|
|
// nothing and closes it at the lookup rather than by a check each caller must
|
|
// remember.
|
|
func GetLatestVerificationRecord(ctx context.Context, db orm.DB, owner, receiver string) (*schema.VerificationRecord, error) {
|
|
return GetLatestVerificationRecordFor(ctx, db, owner, receiver, "")
|
|
}
|
|
|
|
// GetLatestVerificationRecordFor is GetLatestVerificationRecord for one purpose
|
|
// (schema.VerificationRecord.Purpose). The purpose is compared here rather than in
|
|
// the query, so a record written before purposes existed reads as the general one.
|
|
func GetLatestVerificationRecordFor(ctx context.Context, db orm.DB, owner, receiver, purpose string) (*schema.VerificationRecord, error) {
|
|
if owner == "" || receiver == "" {
|
|
return nil, nil
|
|
}
|
|
recs, err := orm.TypedQuery[schema.VerificationRecord](db).
|
|
Filter("Owner=", owner).Filter("Receiver=", receiver).
|
|
Filter("IsUsed=", false).Order("-Time").GetAll(ctx)
|
|
if err == orm.ErrNotFound {
|
|
return nil, nil
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, rec := range recs {
|
|
if rec.Purpose == purpose {
|
|
return rec, nil
|
|
}
|
|
}
|
|
return nil, nil
|
|
}
|
|
|
|
// PersistFederationState creates a fresh in-flight federation transaction. The
|
|
// id is (owner, name); the caller sets Name to the opaque `state` token before
|
|
// persisting. Mirrors PersistToken — the orm.Model is preserved while the
|
|
// caller's fields are copied onto the db-bound entity.
|
|
func PersistFederationState(ctx context.Context, db orm.DB, st *schema.FederationState) error {
|
|
s := orm.New[schema.FederationState](db)
|
|
model := s.Model
|
|
*s = *st
|
|
s.Model = model
|
|
s.SetId(st.Owner + "/" + st.Name)
|
|
return s.CreateCtx(ctx)
|
|
}
|
|
|
|
// GetFederationState resolves an in-flight federation transaction by its opaque
|
|
// `state` token (the row Name). The state is a 256-bit random value, so a
|
|
// name-only lookup is unambiguous. Returns (nil, nil) when no row carries it —
|
|
// the callback treats that as an invalid/expired state and fails closed.
|
|
func GetFederationState(_ context.Context, db orm.DB, state string) (*schema.FederationState, error) {
|
|
if state == "" {
|
|
return nil, nil
|
|
}
|
|
s, err := orm.TypedQuery[schema.FederationState](db).Filter("Name=", state).First()
|
|
if err == orm.ErrNotFound {
|
|
return nil, nil
|
|
}
|
|
return s, err
|
|
}
|
|
|
|
// PurgeFederationStates clears and deletes up to limit federation transactions
|
|
// that expired before cutoff, and reports how many went. Every begin and every
|
|
// form_post handoff writes a row and a burn only marks it used, so without this
|
|
// janitor the table grows without bound. limit bounds one pass's work. A row with
|
|
// no expiry (ExpireIn 0) is never one it touches.
|
|
//
|
|
// orm's Delete marks a row deleted and keeps it, so each row is first rewritten
|
|
// with nothing but its key, expiry and Used: the verifier, nonce, binding hash,
|
|
// app request and a provider's reply leave the store, and what stays is a
|
|
// tombstone. Used is set so a row left live by a failed delete completes nothing,
|
|
// and the expiry is kept so the next pass takes it again. The expiry index holds
|
|
// live rows only, so a pass reads neither tombstones nor rows still in force.
|
|
func PurgeFederationStates(ctx context.Context, db orm.DB, cutoff time.Time, limit int) (int, error) {
|
|
stale, err := orm.TypedQuery[schema.FederationState](db).
|
|
Filter("ExpireIn>", 0).
|
|
Filter("ExpireIn<", cutoff.Unix()).
|
|
Limit(limit).
|
|
GetAll(ctx)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
n := 0
|
|
for _, st := range stale {
|
|
*st = schema.FederationState{Model: st.Model, Owner: st.Owner, Name: st.Name, ExpireIn: st.ExpireIn, Used: true}
|
|
if err := st.UpdateCtx(ctx); err != nil {
|
|
return n, err
|
|
}
|
|
if err := st.DeleteCtx(ctx); err != nil {
|
|
return n, err
|
|
}
|
|
n++
|
|
}
|
|
return n, nil
|
|
}
|
|
|
|
// ErrFederationConsumed is the ONE opaque refusal for a federation state that is
|
|
// gone, already burned, expired, or that lost a concurrent burn — the single-use
|
|
// guard's "no". Callers collapse it to the same "invalid or expired" answer so a
|
|
// prober cannot tell a replay from a race from a forged state.
|
|
var ErrFederationConsumed = errors.New("federation state is invalid, used, or expired")
|
|
|
|
// BurnFederationState atomically consumes an in-flight federation transaction — the
|
|
// single-use guard for the OAuth callback. The find-and-burn runs inside a
|
|
// GetForUpdate transaction (mirroring the wallet challenge burn and TakeChallenge),
|
|
// so two concurrent callbacks on ONE state cannot both flip Used=false→true: the
|
|
// loser blocks until the winner commits, then reads it spent. It resolves the row's
|
|
// real storage key via the (owner,name) query path (Name is the opaque `state`
|
|
// token), locks by that key, refuses a used/expired row with ErrFederationConsumed
|
|
// (no write), else sets Used and returns the burned row. A store fault returns the
|
|
// raw error so the caller can distinguish it from the opaque refusal.
|
|
//
|
|
// The caller performs the browser bind-cookie (CSRF) check on a prior read BEFORE
|
|
// calling this, so a request that fails the cookie check never reaches — and never
|
|
// burns — a victim's pending state.
|
|
func BurnFederationState(ctx context.Context, db orm.DB, state string, now time.Time) (*schema.FederationState, error) {
|
|
if state == "" {
|
|
return nil, ErrFederationConsumed
|
|
}
|
|
keyed, err := GetFederationState(ctx, db, state)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if keyed == nil {
|
|
return nil, ErrFederationConsumed
|
|
}
|
|
storageID := keyed.Key().Encode()
|
|
|
|
var out *schema.FederationState
|
|
txErr := db.RunInTransaction(ctx, func(tx orm.DB) error {
|
|
fresh, err := orm.GetForUpdate[schema.FederationState](tx, storageID)
|
|
if err != nil {
|
|
if errors.Is(err, orm.ErrNotFound) {
|
|
return ErrFederationConsumed
|
|
}
|
|
return err
|
|
}
|
|
if fresh.Used || (fresh.ExpireIn != 0 && now.Unix() > fresh.ExpireIn) {
|
|
return ErrFederationConsumed
|
|
}
|
|
fresh.Used = true
|
|
if err := fresh.UpdateCtx(ctx); err != nil {
|
|
return err
|
|
}
|
|
out = fresh
|
|
return nil
|
|
})
|
|
if txErr != nil {
|
|
return nil, txErr
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// GetUserByConnector resolves the user in an organization whose federated
|
|
// connector column (field — the EXACT lowercase orm/json name, e.g. "google" or
|
|
// "github") holds subject. It is the "already linked by provider subject" lookup
|
|
// the federation broker runs first. subject must be non-empty (an empty subject
|
|
// would match every unlinked row, so it is refused). Returns (nil, nil) when no
|
|
// user is linked to that subject.
|
|
func GetUserByConnector(_ context.Context, db orm.DB, owner, field, subject string) (*schema.User, error) {
|
|
if owner == "" || field == "" || subject == "" {
|
|
return nil, nil
|
|
}
|
|
u, err := orm.TypedQuery[schema.User](db).
|
|
Filter("Owner=", owner).Filter(field+"=", subject).First()
|
|
if err == orm.ErrNotFound {
|
|
return nil, nil
|
|
}
|
|
return u, err
|
|
}
|
|
|
|
// GetSignupByConnector is [GetUserByConnector] over the accounts registered in
|
|
// org, for the same reason [GetSignupByEmail] exists: an application that founds
|
|
// an org per person has its accounts spread across the orgs it founded, so the
|
|
// registration org is not where a returning person is.
|
|
//
|
|
// The provider's subject is the authoritative match for a returning federated
|
|
// user — immune to email churn — so this is the reach that has to work, or a
|
|
// person who signed in with the same social identity yesterday, at any of org's
|
|
// applications, is treated as new and given a second account today. Two rows
|
|
// carrying one subject name nobody, so that fails closed as a duplicated user id
|
|
// does.
|
|
func GetSignupByConnector(ctx context.Context, db orm.DB, org, field, subject string) (*schema.User, error) {
|
|
if org == "" || field == "" || subject == "" {
|
|
return nil, nil
|
|
}
|
|
us, err := orm.TypedQuery[schema.User](db).
|
|
Filter(field+"=", subject).Filter("SignupApplication!=", "").GetAll(ctx)
|
|
if err == orm.ErrNotFound {
|
|
return nil, nil
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if us, err = registeredIn(ctx, db, org, us); err != nil {
|
|
return nil, err
|
|
}
|
|
switch len(us) {
|
|
case 0:
|
|
return nil, nil
|
|
case 1:
|
|
return us[0], nil
|
|
default:
|
|
return nil, fmt.Errorf("store: %d accounts registered in %q share one %s subject", len(us), org, field)
|
|
}
|
|
}
|