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.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: "who.sign-ins", "who.sign-outs", "who.sessions.ended", "who.credentials.added" and "who.credentials.revoked".
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.