All Classes and Interfaces

Class
Description
The answer of POST /who/me/email-addresses/confirmations.
The checks every admin endpoint makes before it looks at anything the request names, in this order: signed out is 401; a request whose permissions lack the one needed is 403; then, for a request that changes something, the caller decides: a browser session whose sign-in is no longer recent is 401 and must sign in again; a session cookie with an API key or bearer token beside it, which the session signed in and the header did not, is 403, as is any sign-in that is neither a browser session nor a bearer token or an API key.
The provider account belongs to another identity.
An identity's key as ApiKeyService.findByIdentity(UUID) lists it, with no secret in it.
Reads an API key from a request header into an ApiKeyAuthenticationToken.
Signs in requests that carry an API key header, through Spring Security's AuthenticationFilter: ApiKeyAuthenticationConverter reads the header and ApiKeyAuthenticationProvider resolves the key.
Signs in with an API key: checks the key's shape, looks it up by its hash, refuses it once expired, and resolves it to an active identity whose permissions are cut down to the key's scopes.
An unauthenticated request to sign in with an API key, holding the raw key read from the request header.
A request an API key signed in, to an API-key endpoint other than /current: a key never lists, makes, rotates or revokes keys, so a leaked key cannot make itself permanent. who answers it 403 with the code api-key-cannot-manage-keys; a browser session or a bearer token may manage keys.
Credential representing an API key, stored as a SHA-256 hash.
Repository for persisting and retrieving ApiKeyCredential records.
The shape of a who API key: a prefix, 30 random base62 characters and a 6-character base62 checksum, the shape GitHub uses for its tokens.
API-key sign-in as a StatelessLoginMethod: adds the ApiKeyAuthenticationFilter as WhoApiKeySecurity.apiKey(ApiKeyAuthenticationFilter) does, and matches the requests the key would sign in: the header is present and not blank, and the request is not already signed in.
A request named an API key that is not one of the caller's own, or asked for the key in use by a request that no API key signed in.
The caller's API keys under /who/me/api-keys: GET lists them, by name, lastUsedAt null for a key that never signed in; POST with {name, lifetime, scopes} makes one (lifetime an ISO-8601 duration) and answers 201 with the raw key; POST /{id}/rotations with {overlap} (an ISO-8601 duration) replaces one, as ApiKeyService.rotate(UUID, Duration) does, and answers 201 in the same shape; DELETE /{id} revokes one, 204; GET /current answers the key that signed this request in, in the list's shape.
Makes, lists, rotates and revokes API keys.
An API key as GET /who/me/api-keys and GET /who/me/api-keys/current show it: no secret in it.
Endpoints that a module adds to every browser chain for a signed-in person, such as changing an email address.
A signed-in request to an endpoint that needs a browser session on its own, made by something else: a bearer token or an API key, a session cookie with an API key or a bearer token beside it, or a sign-in no browser session loaded. who answers it 403 with the code browser-session-required.
The application's registrations, each one who signs in with sending the provider back to who's callback: <root>/oidc/callback/{registrationId}.
who's default WhoSignUpPolicy: refuses every sign-up, so adding a sign-in method never lets strangers create identities until the application decides it should.
An API key just made or rotated: the only answer that holds the raw key.
The answer to POST /who/invitations.
Marker interface for credential types.
A credential was added to an identity.
Thrown when the credential being enrolled is already linked to an identity.
Repository interface for managing the mapping between credential UUIDs and identity UUIDs.
The kind of a credential linked to an identity.
Deletes one credential module's credential rows.
A credential was revoked from an identity.
An email telling an address that it no longer signs in, because the identity's owner (or someone with their session) made another address theirs in its place.
Adds an email address to a signed-in identity, or makes one theirs in place of another, only once the person confirms a link or code sent to it.
A typed confirmation code counted against a request: the request and the code hash to compare the typed code with.
An email asking the person to confirm an address they asked to add to their identity, or to make their address in place of another: the link and the typed code that both confirm it.
A signed-in identity asked at POST /who/me/email-addresses to add an email address, or to make one theirs in place of another, published once per request with what became of it.
POST /who/me/email-addresses asks to add an address, or to change one (replaces), and POST /who/me/email-addresses/confirmations confirms it with the link's token or the code.
A signed-in person's request to add an email address to their identity, or to make it theirs in place of another, waiting for them to confirm the link or code sent to it.
What became of a request to add or change an email address.
Stores the requests to add or change an email address, one per identity.
Thrown when an email address is already registered.
One of the caller's email addresses, as GET /who/me/email-addresses lists it.
A counted attempt at a sign-in code: the credential it belongs to and the stored code hash to compare the submitted code against.
Hashes sign-in codes with a keyed HMAC-SHA256, bound to the credential they were issued for.
Credential representing an email address linked to an identity.
A request named an email address to replace that is not one of the caller's own.
Storage for EmailCredentials.
Registers and revokes email credentials, publishing CredentialAdded and CredentialRevoked for each change.
Authenticates an email sign-in, by the token from the link or by the address and the code typed by hand, then resolves its email credential to an active identity.
Answers POST /who/email/send with 202 at once and hands the real work to EmailLinkIssuer on another thread, so the response time does not reveal whether the address is known.
The addresses of who's email sign-in.
Does the real work behind POST /who/email/send, off the request thread: looks up the address, stores the token's hash (the upsert that is also the resend limit), and sends the link.
Email-link sign-in through Spring Security's oneTimeTokenLogin(), under who.base-path (POST /who/email/send, POST /who/email/sign-in by default), with who's hooks and no default pages.
A sign-in email to deliver: the link and the typed code that both complete the same sign-in.
What EmailLinkIssuer.issue(String, String) did with a request.
Settings for email sign-in links.
Storage for sign-in link tokens.
Emails a PasskeyAddedMessage to the identity's owner through WhoEmails.
An unauthenticated email sign-in request carrying its EmailSignInProof, as read by JsonOneTimeTokenAuthenticationConverter and authenticated by EmailLinkAuthenticationProvider.
Counts an identity's email addresses, for the last-credential rule.
What a sign-in request at POST /who/email/sign-in presents: the token from the emailed link, the address and code typed by hand, or something malformed.
An address and the code from the email, both exactly as typed.
The token from the emailed link.
A request that is neither a link token nor an address and code.
The answer of DELETE /who/me/sessions?others=true.
Records of ended or abandoned sessions were deleted.
Thrown when an enrollment is attempted for an identity that is not ACTIVE.
An immutable enrollment token that links a Credential to a pre-existing Identity.
An enrollment token was created for an identity.
Thrown when an enrollment token has passed its expiration time.
Thrown when an enrollment token cannot be found.
Thrown when an enrollment token cannot be redeemed because it is not in PENDING status (e.g. already redeemed or revoked).
Repository for persisting and retrieving EnrollmentToken instances.
An enrollment token was revoked, by request or because a newer token replaced it.
Lifecycle status of an EnrollmentToken.
An account at an identity provider or token issuer, identified by its issuer and subject: the credential both JWT sign-in and identity-provider sign-in key on.
Repository for persisting and retrieving FederatedCredential records.
Service for linking issuer/subject pairs to identities and unlinking them again.
Utility methods for computing keyed message authentication codes.
The application's human check refused a request, or could not decide it.
What became of a human check.
A request to a human-checked endpoint was checked, published once per such request with what became of it, before the endpoint runs.
What a WhoHumanCheck gets to decide on. who reads the request itself, so a check never sees, or consumes, the request body.
Utility methods for generating identifiers.
who's identity admin endpoints: GET /identities?status=&role=&email=&page=0&size=20 pages through identities, oldest first, as an IdentityPage.
Stable internal identity record.
An identity was created.
An identity was deactivated.
An identity was deleted.
The email addresses identities sign in with, as the admin endpoints read them. who's autoconfiguration supplies one, an EmailLinkIdentityEmails, when email sign-in is on; without it the endpoints show no addresses and refuse a search by address.
An identity was invited by InvitationService.invite(String, Set).
A request named an identity that does not exist, or an id that is not a UUID.
A request to change an identity that holds a permission the caller does not: deactivating or reactivating it, or assigning or removing one of its roles. who's admin endpoints change only identities whose every permission, as who resolves them whatever their status, the caller holds too; for an API key, those its scopes keep.
One page of identities, as GET /who/identities answers it.
An identity was reactivated.
Repository interface for Identity persistence.
Repository for managing the assignment of roles to identities.
Lifecycle status of an Identity.
An identity as who's admin endpoints show it.
who's record of sessions kept in memory, for tests that do not run a database.
A bearer token whose person signed in too long ago for this action: the client must have them sign in again at the identity provider and come back with a new token. who sends the RFC 9470 step-up challenge with it, in the WWW-Authenticate header given by InsufficientUserAuthenticationException.challenge().
A request to an admin endpoint that who refuses as it stands: a page or size out of range, a status who does not know, a body that is not the expected JSON, or a search by email address without email sign-in.
A request to make or rotate an API key that who refuses as it stands: a body that is not the expected JSON, a lifetime or overlap that is not an ISO-8601 duration or is out of range, a blank name, or a scope the owner does not hold.
A confirmation at POST /who/me/email-addresses/confirmations matched nothing: no request by this identity, an expired or used one, a wrong code, or a code with no attempts left.
An invitation who refuses as asked, before anything is created or with everything rolled back: the address is missing or is not an address, a role name is blank or names no role, or roles were asked for in an application without who-rbac.
A passkey registration failed verification.
A client registration who cannot sign people in with safely.
What InvitationService.invite(String, Set) did: the identity it created, which stands whatever became of the link, and what became of the sign-in link sent to it.
An email inviting a person to the application: the link and the typed code that both sign them in with the invited address, which is accepting the invitation.
Gives an invited identity its roles, for InvitationService.
POST /invitations with {"email": "...", "roles": ["..."]} invites the address through InvitationService.invite(String, Set) and answers 201 with a CreatedInvitation; roles may be left out for none.
Invites a person by email address: creates an identity for them, signs it in with that address, gives it roles, and sends it a sign-in link in an InvitationMessage.
Decodes ID tokens with Spring Security's validation plus one more check: iss must be the issuer who stores the registration's credentials under.
JDBC implementation of ApiKeyCredentialRepository backed by the who_api_key_credential table.
JDBC implementation of CredentialIdentityRepository backed by the who_credential_identity table.
JDBC implementation of EmailAddressRequestRepository on who_email_address_request.
JDBC implementation of EmailCredentialRepository on who_email_credential.
JDBC implementation of EmailLinkTokenRepository on who_email_link_token.
JDBC implementation of EnrollmentTokenRepository backed by the who_enrollment_token table.
JDBC implementation of FederatedCredentialRepository backed by the who_federated_credential table.
JDBC implementation of IdentityRepository backed by the who_identity table.
JDBC implementation of IdentityRoleRepository backed by the who_identity_role table.
JDBC implementation of RolePermissionRepository backed by the who_role_permission table.
JDBC implementation of RoleRepository backed by the who_role table.
JDBC implementation of SessionRecordRepository backed by the who_session table.
JDBC implementation of Spring Security's UserCredentialRepository on who_passkey_credential.
JDBC implementation of Spring Security's PublicKeyCredentialUserEntityRepository on who_passkey_user.
Handlers for sign-in endpoints that do not redirect: a JSON answer on success, and on failure a SignInFailedException handed to the application, which formats it.
Reads {"email": "..."} from the body of POST /who/email/send.
Reads the body of POST /who/email/sign-in: either {"token": "..."} from the emailed link, or {"email": "...", "code": "..."} typed by hand.
JWT sign-in as a StatelessLoginMethod: Spring Security's resource server, verifying with the application's JwtDecoder and signing in through WhoJwtAuthenticationConverter.
A change that would leave no active identity holding WhoAdminPermissions.IDENTITIES_MANAGE: deactivating the last one, or removing the role through which the last one holds it.
Keeps who's admin endpoints from leaving no active identity that holds WhoAdminPermissions.IDENTITIES_MANAGE.
Thrown when removing a credential would leave an identity with no way to sign in.
Keeps an identity from losing its last sign-in credential.
Remembers in the browser which way someone last signed in, so the sign-in page can mark that button "Last used" and a person who forgot does not create a second account another way.
A request to unlink named an account that is not one of the caller's own.
Lists and unlinks the caller's provider accounts: GET /who/me/accounts and DELETE /who/me/accounts/{id}.
One of the caller's linked provider accounts, as GET /who/me/accounts lists it.
Utility methods for computing message digests.
Renders who's emails from Mustache templates.
A key just made, by ApiKeyService.create(Identity, String, Duration, Set) or ApiKeyService.rotate(UUID, Duration): the only time the raw key exists outside the caller.
A request needs a signed-in caller and has none.
Sign-in with Google, GitHub or any OpenID Connect provider, mounted with Spring Security's oauth2Login().
Where a provider sign-in sends the browser: the success URL, or the failure URL with an error code added to its query.
Lets a native image keep a PendingSignUp, and Spring's OAuth2AuthorizationRequest that crosses the redirect to the provider, in a session store that serializes its attributes, such as Spring Session JDBC.
Counts an identity's linked provider accounts that a configured sign-in registration signs in, for the last-credential rule.
Turns a provider sign-in into a who session, or into a pending sign-up for an account who does not know.
Confirms a pending sign-up through the application's WhoSignUpPolicy, or links a pending account to the identity signed in.
A confirmed sign-up.
Credentials no longer linked to any identity were purged.
A rendered email, ready for a WhoEmailSender to deliver.
An email telling an identity's owner that a passkey was added to their account, so one they did not add can be noticed and removed.
Told after a passkey is registered, so the owner can notice a passkey they did not add.
A passkey, as a who credential.
The passkey module's CredentialRemover.
Passkey sign-in and registration with Spring Security's passkey filters, at who's URLs under who.base-path. who adds the filters itself (see PasskeyFilters) rather than calling Spring's webAuthn(), which fixes their URLs, and gives them who's collaborators: who's two repositories and the application's WebAuthnRelyingPartyOperations bean.
Picks the name the passkey picker shows for an identity (the user entity's name and display_name).
A request named a passkey that is not one of the caller's own: another identity's and one that does not exist are the same answer.
The answers Spring's passkey registration has no hook for.
A signed-in identity tried to add a passkey, and was refused because it signed in longer ago than the registration window allows.
Why a passkey registration was refused, reported in PasskeyRegistrationRefused.
Native-image reflection for passkeys: Spring Security WebAuthn's JSON model and webauthn4j's CBOR model.
GET /who/me/passkeys lists the caller's passkeys, oldest first; DELETE /who/me/passkeys/{credentialId} removes one.
Lists and revokes an identity's passkeys.
The relying party's settings, from who.passkey.*.
Counts an identity's passkeys, for the last-credential rule.
A passkey as shown to its owner.
One of the caller's passkeys, as GET /who/me/passkeys lists it.
Makes a browser chain safe for session sign-in, using only Spring Security's own types: Spring's SPA CSRF setup (CsrfConfigurer.spa()), 401 instead of login redirects, a logout that answers 204 and reports SignedOut, no saved requests, a no-referrer policy, and who's session-backed WhoSessionSecurityContextRepository.
A way to sign in to a browser session, contributed as a bean by a credential module (email links, passkeys, ...).
A provider account who does not know yet, waiting in the session for the person to confirm a sign-up or a link.
The pending sign-up endpoints: GET /who/oidc/pending describes it for the confirm page, POST /who/oidc/pending/sign-up confirms a sign-up (signed out), and POST /who/oidc/pending/link links it to the identity that started it, within the recent sign-in window.
There is no pending sign-up this browser may use: none, expired, or created for another identity.
Keeps the PendingSignUp in the session.
A signed-in request to an admin endpoint whose permissions lack the one it needs, such as WhoAdminPermissions.IDENTITIES_READ.
Strategy for resolving permission strings for a given Identity.
The provider account a sign-in came back with.
What who.oidc.providers.<registration-id> says about one client registration.
The InvitationRoles of who-rbac: assigns each role by name with RbacService.assignRoleByName(Identity, String).
A PermissionsResolver that resolves permissions by looking up the roles assigned to an identity and returning the union of all permissions granted to those roles.
Management service for administering roles, permissions, and identity-role assignments.
The caller signed in too long ago for this action and must sign in again.
Grants a request whose caller signed in within a window, by the factor who stamped on their token at sign-in.
Whether a caller signed in recently enough, and, when not, how to answer: the exception to throw and, for a bearer token, the step-up challenge to send.
Enforces @RequiresRecentSignIn on methods and types, right after Spring Security's @PreAuthorize checks, so a missing permission answers before a stale sign-in does.
An action needs a recent sign-in, and the caller has no sign-in time that could ever be recent: an API key, or a bearer token without an auth_time claim.
Meta-annotation that expresses a @PreAuthorize hasAuthority(...) check as a named permission string.
The caller must have signed in recently: within who.security.recent-sign-in (10 minutes by default), or within RequiresRecentSignIn.within().
The outcome of WhoService.resolveDetailed(Credential): either the resolved principal or the reason the credential did not resolve.
The credential is linked to an identity that is not active.
The credential is linked to an identity that does not exist.
The credential is not linked to any identity.
The credential resolved to an active identity.
An immutable domain record representing a named role that can be assigned to identities and granted permissions.
Thrown when a role is created with a name that is already taken.
A role was assigned to an identity.
A role was created.
A role was deleted.
A request to grant a role that carries a permission the caller does not hold itself. who's admin endpoints grant only roles within the caller's own permissions; for an API key, those its scopes keep.
Thrown when a role lookup by name finds no matching role.
A permission was granted to a role.
A permission was revoked from a role.
Repository for managing the association between roles and permission strings.
Repository for managing Role persistence.
GET /who/roles lists every role with its permissions, by name.
A role was removed from an identity.
A role as GET /who/roles shows it.
Generates secret tokens.
A request to deactivate the identity making it: an admin cannot lock themselves out.
An established session was ended by the system.
Connects SessionsController to a browser chain: ending the caller's own session through DELETE /who/me/sessions/{id} signs the browser out with that chain's logout handlers.
Why an established session was ended by the system.
A request named a session that is not one of the caller's live sessions: another identity's and one that does not exist are the same answer.
One browser sign-in, as who records it so a person can see where they are signed in and end a session from elsewhere.
Stores who's record of browser sessions.
GET /who/me/sessions lists the caller's live browser sessions; DELETE /who/me/sessions/{id} ends one; DELETE /who/me/sessions?others=true ends every one but the caller's.
One of the caller's live browser sessions, as GET /who/me/sessions lists it.
A caller signed out.
Counts one kind of sign-in credential an identity holds.
A sign-in email was requested at POST /who/email/send, published once per request by EmailLinkIssuer.issue(String, String) with what became of it.
A sign-in attempt failed.
A sign-in attempt failed: a bad, expired or used token, an unknown or invalid passkey, or an inactive identity.
Why a sign-in attempt failed.
The mechanism a caller used, or attempted to use, to sign in.
A client registration who signs people in with, and the issuer its credentials are stored under.
What kind of provider a registration signs in with.
The client registrations who signs people in with, each with the issuer its credentials are stored under.
A sign-in succeeded: an email link, an email code or a passkey, published once the session is saved.
A WhoSignUpPolicy's answer.
Create the identity.
Create nothing.
The sign-up was refused: by the application's sign-up policy, or because a who session is signed in.
Someone who proved a credential who does not know, asking to create an identity with it.
Sends who's emails over SMTP through Spring's JavaMailSender: a text-only message, or a multipart one with the HTML as an alternative to the text when the email has HTML.
Publishes who's events as Spring application events.
Endpoints that a module adds to every stateless chain for a caller signed in by a credential the request carries, such as managing the caller's API keys with a bearer token.
A way to sign in each request by a credential it carries in a header (API keys, bearer JWTs), contributed as a bean by a credential module.
A sign-in provider for tests: an OpenID Connect provider, or GitHub, on a random local port.
Cloudflare's siteverify answer about a token.
Cloudflare Turnstile as who's human check.
Decides whether Cloudflare's answer about a token passes a request.
A link named a registration who does not sign in with.
A request named a role that does not exist. who's admin endpoints assign and remove only roles the application has made.
Registers who's admin endpoints when who-admin is on the classpath, unless who.admin.enabled=false.
The permissions who's admin endpoints check. who defines them but grants them to no one: an application assigns them to its own roles, as it would any permission, for example with RbacService.addPermissionToRole(role, WhoAdminPermissions.IDENTITIES_READ).
Registers API key beans when who-apikey is on the classpath.
Adds the API key filter to a Spring Security chain.
Configurer that places the API key filter in an HttpSecurity chain.
Spring Security authentication token backed by a resolved WhoPrincipal.
who's core autoconfiguration: WhoService, the clock, the event publisher, the schema initializer, and the JDBC and RBAC beans when those modules are on the classpath.
Who signed a request in, as WhoSessionSecurityContextRepository.caller(HttpServletRequest, Authentication) tells it: by what signed the request in, never by which headers it carries.
A who sign-in that no browser session loaded and that is neither a bearer token nor an API key, such as one placed in the security context by the application or a test.
A browser session signed the request in, and the request presents no API key or bearer token beside the session cookie.
A browser session signed the request in, but the request also presents an API key or a bearer token, which was ignored because the session had already signed it in.
No who sign-in: the request is anonymous, or signed in by something that is not who's.
A bearer token or an API key signed the request in; no browser session did.
Thrown at startup when a who module is on the classpath but a setting it cannot work without is missing or unusable.
Reports a WhoConfigurationException the way Spring Boot reports its own configuration failures, so the startup output says which property is wrong and what to set.
Initializes Who module database schemas by running each module's bundled DDL script against the configured DataSource.
An email who sends, before it is rendered.
Wires who's one email seam: a WhoEmailRenderer (who-email's Mustache renderer unless the application has its own), a WhoEmailSender (who-email-smtp's unless the application has its own), and WhoEmails when both exist.
Turns email-link sign-in on when who-email-link is on the classpath; who.email-link.enabled=false turns it off.
Counts sign-in email requests as "who.sign-in.emails", tagged outcome.
A feature's bundle of default email messages, such as its subjects under who.email.<template>.subject.
Adds an application's own values to an email's template model, under the name extra: for example the recipient's display name, as {{extra.displayName}}.
Turns a WhoEmail into an OutgoingEmail: its subject, text and optional HTML.
Native-image hints for an application's email templates at the default who.email.templates location, classpath:/templates/who/email/.
Renders and sends who's emails.
Delivers a rendered email: SMTP, or a provider such as SES.
A library's email templates and subjects.
Registers enrollment beans when who-enrollment is on the classpath.
Service for managing enrollment tokens that link credentials to identities.
A failure who hands to the application, named by a stable code.
who's place in Spring MVC's exception handling; put it first among the resolvers (who's autoconfiguration does, through extendHandlerExceptionResolvers).
A security-relevant occurrence inside who, published through WhoEventPublisher.
Publishes WhoEvents to whatever listener mechanism the host application uses.
Base class for all Who framework exceptions.
Answers an exception raised outside Spring MVC (in a security filter, failure handler or entry point).
Resolves an exception the way the application resolves its controllers' exceptions.
Registers the (issuer, subject) credential's repository and service when who-federated is on the classpath, which who-jwt brings.
Decides whether a request to one of who's public, costly endpoints comes from a person rather than a script: a bot check such as Cloudflare Turnstile. who checks POST /who/email/send and POST /who/email/sign-in when the application has a bean of this type, and checks nothing without one.
Counts human checks as "who.human-checks", tagged check, action and outcome.
Converts a Spring Security Jwt (already validated by the OAuth2 resource server) into a WhoAuthenticationToken by resolving the JWT's issuer/subject pair to a WhoPrincipal.
Registers JWT beans when who-jwt is on the classpath.
Fails startup when who's controllers would not answer where who's sign-in filters, logout, public paths and error handling expect them: at WhoPaths.of(String).
who's one endpoint of its own: GET /who/me tells an app who is signed in.
The signed-in identity.
Counts who's events as Micrometer meters when the application has a MeterRegistry (for example, with Spring Boot Actuator).
A MockMvc client that behaves like a single-page app in a browser against a chain built with WhoWebSecurity.passwordless().
Loads the provider's user with Spring Security's DefaultOAuth2UserService, and for GitHub adds the primary, verified email from /user/emails, which only this step can read: it has the access token.
Runs who's own work inside a Micrometer Observation tagged with its outcome, so that a failing observation handler never changes who's answer.
Registers provider sign-in (Google, GitHub, any OpenID Connect provider) when who-oidc is on the classpath.
Spring Security OneTimeTokenService for email links.
Signs in with a passkey: verifies the assertion through the relying party, maps the verified credential to who's credential id, and resolves it to an active identity.
Registers passkey beans when who-passkey is on the classpath and the application opts in by setting who.passkey.rp-id.
Where every who endpoint lives: one root, such as /who (the default) or /auth, and each endpoint's path below it.
Resolved principal placed into the security context.
An error under who's base path, as RFC 9457 Problem Details (application/problem+json). who writes it whatever the application's own error handling does, so who's client reads one shape.
Native-image reflection for WhoProblem. who's filters and entry point write it by hand, so no controller method's signature registers it the way Spring registers a returned type.
Builds and writes WhoProblems, who's answer to every error under its base path.
Configuration properties for the Who identity framework.
Properties for the who-admin module.
Properties for the who-apikey module.
How who renders and sends its emails (who-email, who-email-smtp or an application's own sender).
Properties for the who-email-link module.
Properties for the who-enrollment module.
Properties for the who-jwt module.
Properties for method security.
Properties for sign-in with Google, GitHub or any OpenID Connect provider (who-oidc).
Settings for one client registration.
Properties for the who-passkey module.
Properties for who's security chain.
Settings for the cookie that remembers which way someone last signed in.
who's record of browser sessions, which lets a person see where they are signed in and end a session.
Properties for the who-turnstile module: Cloudflare Turnstile as the human check.
Lets a library or an application add paths a signed-out request may reach, without replacing who's WhoPublicPaths.
The paths a signed-out request may reach: Spring Boot's error page, GET /who/sign-in, every sign-in method's own endpoints, the application's who.security.public-paths and what WhoPublicPathContributor beans add. who's default security chain permits them; an application that writes its own chain can do the same with requestMatchers(whoPublicPaths.patterns()).permitAll().
who's relying party: Spring's Webauthn4JRelyingPartyOperations, configured from PasskeySettings, with three changes.
Native-image hints for who.initialize-schema.
Entry point for mounting who into a Spring Security chain the application writes itself.
Mounts every who sign-in method in the application context into one chain: when there is a PasswordlessLoginMethod bean, everything WhoWebSecurity.passwordless() does for browser sessions; every StatelessLoginMethod bean, and, when the chain has CSRF protection, an exemption for the requests that one of their credentials signs in; the BrowserEndpoints beans when there is a browser method, else the StatelessEndpoints beans; a 401 for a signed-out request and a 403 for a denied one, handed to the application's exception handling.
Core service that resolves a Credential to a WhoPrincipal.
What a browser session remembers about a signed-in identity: ids only.
Ends who's record of a session when the servlet container destroys it, by invalidation or by timeout, so the list of sessions stays current.
Native-image serialization for WhoSession.
who's record of browser sessions: one per sign-in, so a person can see where they are signed in and end a session from elsewhere, and an application can end an identity's sessions.
Keeps only a WhoSession (ids) in the HTTP session and re-resolves the principal from WhoService on every request, so a suspended identity, a removed role or a revoked credential takes effect immediately.
The Spring Security factor each way of signing in stands for, stamped with when the person signed in.
Decides whether someone who signs in with a credential who does not know may create an identity.
Wires who into Spring Security when who-spring-security is on the classpath: the session repository, GET /who/me, the exception hand-off, and method security so that @RequiresPermission is enforced (turn it off with who.method-security.enabled=false).
Mounts who's stateless sign-in methods, every StatelessLoginMethod bean (API keys, bearer JWTs), into a chain that never reads or creates a session: the security context lives in the request only, and the request's session is hidden from the whole chain, so a session cookie that another chain made signs nothing in here, and is neither given a new id nor ended.
Signed-in HTTP sessions for tests.
Cloudflare Turnstile as who's human check, on with the who-turnstile jar.
Entry points for applying who to a Spring Security chain.
who's default SecurityFilterChain, in place of Spring Boot's: every sign-in method on the classpath (WhoSecurity.all()), the public paths open to signed-out requests, CSRF for every request that brings a session, Actuator's health endpoint open as Boot's own chain leaves it, and every other request signed in.