Optional technical reference. This material is for developers, integration specialists and platform administrators. For the consultant lesson, read the practical guide.
Preserved from source baseline
d4587c7c0e073e58c2d430342f65ac55dd701bf4; source/static examples retain their stated scope. They are not new runtime verification or required consultant setup steps.
External Authentication Providers Manual
Practical guide and worked examples
Separate configuration, connectivity and actual sign-in
A saved provider record is configuration, a provider test checks its supported bounded dependencies, and a successful native browser sign-in establishes a different execution boundary. Keep those outcomes separate when onboarding OIDC, SAML or directory systems. A supported provider enum or a green metadata check does not certify every authentication flow against a production IdP.
An administrator creates or updates a provider through the Authorization area or /api/admin/identity/auth-providers. Bootstrap properties seed missing records at initial setup; current provider records and mappings are then managed by their owning service. Secret settings are references resolved by the intended environment, not literal client secrets committed in JSON examples.
| Request field | Meaning | Review question |
|---|---|---|
key, type, displayName |
Stable provider coordinate and adapter kind | Does this actual adapter support the intended sign-in path? |
enabled |
Makes admitted provider configuration eligible | Have callback, trust and recovery paths been qualified before enabling? |
createUserAtLogin, updateUsersAtLogin |
JIT creation/profile/membership behavior | Which existing local accounts/groups can be affected? |
defaultGroupKeys, claimMappings |
Initial groups and incoming claim field names | Are mappings narrow and privileged groups excluded? |
settings |
Adapter-specific issuer/client/directory configuration | Are endpoints, TLS and expected audience correct for this environment? |
secretsRef |
Environment-controlled secret references | Can the runtime resolve the reference without exposing the value? |
Prepare a separate recovery administrator and test identity. Do not map a normal external claim to broad administrative authority. Check whether the normal user is allowed into the application independently of whether the IdP authenticates them.
The examples below use synthetic teaching data. They are grounded in the cited source contracts; this documentation change did not execute these operations against a running Inflow deployment. Use normal authenticated sessions and the actual returned identifiers, revisions and versions from an authorized environment.
Example ROOT-AUTH-01 — Prepare a disabled OIDC provider with referenced secrets
Scenario and inputs. Nadia has provider-administration authority and an approved test IdP/client. She wants to save reviewed OIDC configuration before making it eligible for ordinary sign-in. The issuer below is a synthetic reserved-domain example, not a reachable production identity service. Actual endpoints, client registration and secret references must be supplied by the authorized IdP owner.
Procedure. Create through the provider form or use this complete configuration request body:
POST /api/admin/identity/auth-providers
Content-Type: application/json
{"key":"people-oidc","type":"OIDC","displayName":"People Operations OIDC","enabled":false,"createUserAtLogin":false,"updateUsersAtLogin":false,"defaultGroupKeys":[],"claimMappings":{"subject":"sub","username":"preferred_username","email":"email","displayName":"name","groups":"groups"},"settings":{"issuerUri":"https://id.example.test/realms/people","clientId":"inflow-people","audience":"inflow-people"},"secretsRef":{"clientSecret":"${INFLOW_OIDC_CLIENT_SECRET}"}}
Read the saved record and inspect the safe secret-reference representation. Keep JIT and enablement off until their own mappings and normal sign-in path have been reviewed.
Expected result. The administrator has a stored provider definition using actual request fields. A saved record does not mean the issuer was contacted successfully, a browser callback was accepted or a person acquired application access. The literal ${INFLOW_OIDC_CLIENT_SECRET} is a reference, not a sample secret value.
Failure and recovery. A missing secret resolution or invalid issuer/client setup belongs to the provider owner's configuration diagnosis. Do not paste a real client secret into the document, alter trust policy or enable broad trusted-header authentication to make the test pass. Retain local recovery access while separately qualifying the real native sign-in flow.
Sources. AdminAuthProviderController.java:59, AdminAuthProviderRequest.java:1, test-auth-lab.ps1:148.
Example ROOT-AUTH-02 — Map one external group to one permitted local group
Scenario and inputs. The test provider and a local editable non-privileged Employees group exist. Nadia wants an external leave-employees claim value to map to the platform group key selected from the authorized directory. Group mapping is a security decision: a user-controlled profile field is not proof that the person belongs to an administrative group.
Procedure. Read the existing group mappings and the provider's claim configuration before editing. For the demonstrated one-entry configuration, the request shape is:
PUT /api/admin/identity/auth-providers/people-oidc/group-mappings
Content-Type: application/json
{"mappings":[{"externalGroup":"leave-employees","groupKey":"<employees-group-key>"}]}
Substitute the actual selected group key and review the full intended mapping list before saving. Then examine createUserAtLogin, updateUsersAtLogin and defaults together; a mapping change and a later login's reconciliation have related but distinct effects.
Expected result. The provider service stores explicit external-to-local mapping entries. A later admitted login uses the actual adapter's claims and current provisioning policy; it is not an arbitrary request-body membership grant. The local group still controls its separate application/workspace contributions and the resulting business eligibility.
Failure and recovery. If an intended group is protected, unavailable or outside the administrator's allowed scope, resolve that configuration rather than mapping to a broader default group. Review existing mappings before a PUT so unrelated intended mappings are not accidentally omitted. A metadata test cannot prove membership reconciliation or absence of privilege escalation; those require the actual permitted login/control cases.
Sources. AdminAuthProviderController.java:97, AdminAuthProviderGroupMappingsRequest.java:1, AuthProviderGroupMapping.java:1.
Example ROOT-AUTH-03 — Interpret a SAML metadata test without claiming browser SSO
Scenario and inputs. An authorized IdP owner has supplied an admitted SAML provider configuration and a test user. Nadia can read and test that provider. The immediate question is whether the configured metadata/trust preparation is usable; it is not yet whether a browser assertion for Mohammad has been accepted or whether he can open Leave requests.
Procedure. Use the provider's Test action or POST /api/admin/identity/auth-providers/<provider-id-or-key>/test with its existing saved settings. Inspect the returned ok and individual checks, retaining safe outcome identifiers rather than tokens/assertions. Read the SAML-specific checks in the tester and compare the metadata entity/endpoints with the IdP owner's configuration. Plan the native browser start/response, signature, audience/recipient and ordinary-user application tests as separate admitted qualification work.
Expected result. The test reports only its implemented metadata/configuration checks. A successful metadata result is useful diagnostic evidence, but it does not prove a valid browser response, session creation, JIT mappings or application authorization. The platform's native SAML path and a local Keycloak metadata exercise remain separate evidence boundaries.
Failure and recovery. On a failed metadata or certificate check, correct the configured entity/trust material through its owner and repeat only the authorized diagnostic. Never disable signature validation, replay a captured private assertion, expose authentication content or grant a user application authority to conceal a failed sign-in. Preserve the original failure and distinguish unavailable configuration from a known authentication refusal.
Sources. AdminAuthProviderController.java:87, DefaultAuthProviderTester.java:1, test-auth-lab.ps1:208.
Example ROOT-AUTH-04 — Diagnose a directory provider without conflating bind and login
Scenario and inputs. Nadia has an approved directory-test configuration whose bind identity is separately scoped by the directory owner. The selected base/search fields are synthetic examples for the owned authentication lab. A successful service bind and sample search may be necessary preparation, but they are not evidence that an end user authenticated to Inflow using LDAP credentials.
Procedure. Open the saved LDAP provider and inspect adapter-specific settings and referenced bind credential privately. Run only the admitted provider Test action, then inspect which check failed: reaching the endpoint, authenticating the bind identity or performing the intended bounded sample search. Compare those checks with DefaultAuthProviderTester and the lab script's LDAP assertion. For actual normal-user login, follow the current authenticator/browser path and its own supported evidence rather than assuming the administrative connection test creates a session.
Expected result. A green LDAP test establishes the tester's bind/search boundary against that configured system. It does not establish ordinary-user session, SSO, task access or production directory qualification. The external provider enum, disabled saved configuration and a working lab directory each answer a different question.
Failure and recovery. If the bind identity cannot read the intended search scope, ask the directory owner for the narrow correction; do not substitute a global directory administrator or print the bind password. If the desired sign-in adapter is unavailable, report that supported-path limitation explicitly. Do not turn on trusted-header impersonation or equate a lab header-JIT check with LDAP password authentication.
Sources. DefaultAuthProviderTester.java:1, test-auth-lab.ps1:235, AdminAuthProviderController.java:87.
Document status: Current provider configuration and administration reference. Verified against
origin/masteron 2026-08-14. Provider-specific production readiness still depends on real-provider certification and secure secret storage.
This manual describes the configuration shape and administration model for external authentication providers in Inflow Platform.
The platform authenticates through local password, HTTP Basic, API key, trusted header, and configured external-provider entries. External provider rows are administered in the Studio Authorization area and stored in the database. Properties remain as bootstrap seeds for first boot and local development.
Configuration Location
Bootstrap provider settings live in:
conf/custom_config.properties
Every provider uses this pattern:
identity.auth.providers.<providerKey>.<property>=<value>
providerKey is a tenant-controlled stable identifier such as corporateOidc, enterpriseSaml, ldapDirectory, or passkeys.
At runtime, providers are stored in identity_auth_providers and group mappings are stored in identity_auth_group_mappings. The first boot importer reads conf/custom_config.properties, creates any missing provider rows, and then the DB-backed registry becomes the source used by the authenticator chain. Administrators should use Studio or /api/admin/identity/auth-providers after initial bootstrap.
Common Provider Properties
enabled: Enables the provider when the matching authenticator exists.
type: Provider type. The provider model accepts BEARER_TOKEN, JWT,
OAUTH2, OIDC, SAML2, LDAP, ACTIVE_DIRECTORY, KERBEROS, WEBAUTHN,
PASSKEY, SOCIAL_LOGIN, and REMOTE_EXTENSION. Configuration acceptance is
not the same as certifying every provider against a production identity system;
use the provider test surface and deployment-specific evidence.
displayName: Administrator-facing label.
autoProvisionUsers: Legacy bootstrap property. It maps to createUserAtLogin when imported into the database.
createUserAtLogin: Allows the provider adapter to create local UserAccount records after a successful external login.
updateUsersAtLogin: Allows the provider adapter to refresh mapped profile fields and reconcile mapped group memberships on every successful external login.
defaultGroupKeys: Comma-separated platform groups assigned to newly provisioned users. super-administrators is never granted automatically.
userIdClaim: External immutable subject field to map into UserAccount.metadata.
usernameClaim: External username field.
emailClaim: External email field.
displayNameClaim: External display name field.
groupsClaim: External group field used with provider group mappings to join platform groups.
Secrets should be referenced through environment variables such as ${INFLOW_OIDC_CLIENT_SECRET} and never committed as real values.
Architecture
flowchart TD
Client["Browser or API Client"] --> Provider["External Identity Provider"]
Provider --> Authenticator["Provider Authenticator Adapter"]
Config["DB-backed provider registry"] --> Authenticator
Bootstrap["conf/custom_config.properties seeds"] --> Config
Authenticator --> AuthService["AuthenticationService"]
Authenticator --> JIT["JitProvisioningService"]
JIT --> UserRepo["UserAccountRepository"]
JIT --> Groups["GroupService"]
UserRepo --> LocalUser["Local UserAccount"]
AuthService --> Security["Spring Security Context"]
Security --> Services["Secured Platform Services"]
The external provider proves the user's identity. Inflow still keeps a local UserAccount so workflow assignment, groups, audit, preferences, and platform-specific attributes remain consistent.
Studio Administration
Open Studio, then go to Authorization and choose a provider route such as OIDC, SAML, LDAP / Active Directory, or Microsoft / Google / Okta SSO. The provider screen uses the same contract for every provider:
- Connection fields: issuer, metadata URL, LDAP URL, bind DN, and similar type-specific values.
- Secret references: environment references such as
${INFLOW_OIDC_CLIENT_SECRET}. Plaintext secrets are rejected by the API. - Attribute mapping: external claim or directory attribute names mapped to user fields.
- Provisioning:
Create user at login,Update users at login, default groups, and group mappings. - Test connection: returns structured checks and stores the latest result on the provider row.
OIDC Providers
Use OIDC for providers such as Keycloak, Auth0, Okta, Microsoft Entra ID, Google Workspace, Ping Identity, and other OpenID Connect compliant identity providers.
Minimum properties:
identity.auth.providers.corporateOidc.enabled=false
identity.auth.providers.corporateOidc.type=OIDC
identity.auth.providers.corporateOidc.issuerUri=https://login.example.com/realms/inflow
identity.auth.providers.corporateOidc.clientId=inflow-platform
identity.auth.providers.corporateOidc.clientSecret=${INFLOW_OIDC_CLIENT_SECRET}
identity.auth.providers.corporateOidc.scopes=openid,profile,email,groups
identity.auth.providers.corporateOidc.userIdClaim=sub
identity.auth.providers.corporateOidc.usernameClaim=preferred_username
identity.auth.providers.corporateOidc.emailClaim=email
identity.auth.providers.corporateOidc.displayNameClaim=name
identity.auth.providers.corporateOidc.groupsClaim=groups
Provider-specific examples for Microsoft Entra ID and Google Workspace are included in conf/custom_config.properties.
The provider Test action fetches OpenID metadata from
{issuerUri}/.well-known/openid-configuration, unless metadataUrl or
openidConfigurationUrl is configured. It then verifies JWKS reachability
using jwksUri from settings or jwks_uri from metadata, and verifies the
token endpoint using tokenEndpoint or tokenUri from settings or
token_endpoint from metadata. OIDC and OAuth 2.0 providers fail the test
when metadata, JWKS, or the token endpoint cannot be reached.
SAML Providers
Use SAML2 when the customer identity provider is enterprise SSO based on SAML metadata.
The provider Test action fetches the IdP metadata from idpMetadataUrl
or metadataUrl, parses it as SAML metadata XML, verifies that an IdP SSO
descriptor is present, and inspects the first signing certificate when one
is published. Expired or malformed signing certificates fail the test;
certificates that expire within 30 days warn. Metadata without a signing
certificate warns so administrators can still save early drafts, but the
warning remains visible in the structured test result.
Minimum properties:
identity.auth.providers.enterpriseSaml.enabled=false
identity.auth.providers.enterpriseSaml.type=SAML2
identity.auth.providers.enterpriseSaml.entityId=inflow-platform
identity.auth.providers.enterpriseSaml.assertionConsumerServiceUrl={baseUrl}/login/saml2/sso/{registrationId}
identity.auth.providers.enterpriseSaml.idpMetadataUrl=https://idp.example.com/metadata
identity.auth.providers.enterpriseSaml.nameIdFormat=urn:oasis:names:tc:SAML:1.1:nameid-format:emailAddress
identity.auth.providers.enterpriseSaml.userIdClaim=NameID
identity.auth.providers.enterpriseSaml.emailClaim=email
Certificate and private key settings should use environment variable references.
LDAP and Active Directory
Use LDAP or Active Directory when the platform must bind directly to a directory.
Minimum LDAP properties:
identity.auth.providers.ldapDirectory.enabled=false
identity.auth.providers.ldapDirectory.type=LDAP
identity.auth.providers.ldapDirectory.url=ldaps://ldap.example.com:636
identity.auth.providers.ldapDirectory.baseDn=dc=example,dc=com
identity.auth.providers.ldapDirectory.userSearchBase=ou=people
identity.auth.providers.ldapDirectory.userSearchFilter=(uid={username})
identity.auth.providers.ldapDirectory.bindDn=cn=inflow-reader,ou=service-accounts,dc=example,dc=com
identity.auth.providers.ldapDirectory.bindPassword=${INFLOW_LDAP_BIND_PASSWORD}
Minimum Active Directory properties:
identity.auth.providers.activeDirectory.enabled=false
identity.auth.providers.activeDirectory.type=ACTIVE_DIRECTORY
identity.auth.providers.activeDirectory.domain=example.com
identity.auth.providers.activeDirectory.url=ldaps://ad.example.com:636
identity.auth.providers.activeDirectory.rootDn=dc=example,dc=com
identity.auth.providers.activeDirectory.userSearchFilter=(sAMAccountName={username})
identity.auth.providers.activeDirectory.bindPassword=${INFLOW_AD_BIND_PASSWORD}
Prefer ldaps:// for directory connections.
The provider Test action performs the same two operational checks for LDAP and Active Directory:
- Service-account bind using
url,bindDn, and the resolvedbindPasswordenvironment reference. - Sample directory search using
searchBaseorbaseDnorrootDn, plussampleSearchFilterwhen supplied. If no sample filter is configured, the test uses(objectClass=*)and limits the result to one entry.
bindPassword must be stored as a secret reference such as
${INFLOW_LDAP_BIND_PASSWORD}. If the environment variable is missing in the
running API process, the Test action fails clearly before attempting the bind.
Plaintext bind passwords in provider settings are rejected.
Passkeys and WebAuthn
Use passkeys or WebAuthn for phishing-resistant authentication with platform authenticators, roaming security keys, or both.
Minimum properties:
identity.auth.providers.passkeys.enabled=false
identity.auth.providers.passkeys.type=PASSKEY
identity.auth.providers.passkeys.relyingPartyId=app.example.com
identity.auth.providers.passkeys.relyingPartyName=Inflow Platform
identity.auth.providers.passkeys.origin=https://app.example.com
identity.auth.providers.passkeys.userVerification=preferred
identity.auth.providers.passkeys.attestation=none
For hardware security keys, use WEBAUTHN and set allowedAuthenticatorAttachment=cross-platform.
MFA Enforcement
Administrators can enable MFA enforcement per platform group from Studio Authorization > MFA or through:
PUT /api/admin/identity/mfa/groups/{groupKey}
When any effective group for a user has required=true, local password and HTTP Basic authentication require a valid TOTP code after the password succeeds. API clients pass the code with:
X-MFA-TOTP: 123456
If the password is valid but the TOTP code is missing, the API returns 401 with code=MFA_REQUIRED and a WWW-Authenticate: MFA type="totp" challenge. If the TOTP code is wrong, authentication is refused.
TOTP enrollment is managed through /api/admin/identity/mfa/users/{userId}/totp/enroll and /api/admin/identity/mfa/factors/{factorId}/confirm. Enrollment returns the authenticator secret, the otpauth URI, and ten recovery codes. Recovery codes are shown once in Studio, stored only as hashes in identity_user_mfa_recovery_codes, and can be supplied in the same X-MFA-TOTP header when a user cannot access the authenticator app. Each recovery code is consumed on first successful use and cannot be reused.
Recovery codes become usable only after the TOTP factor is confirmed. Secrets are currently stored in the MFA factor secret_ref; the production credential-vault layer should replace direct secret storage before hosted production use.
Who may change MFA settings (spec 302):
- Setting a group's MFA requirement (
PUT /api/admin/identity/mfa/groups/{groupKey}) needs*and is audited asMFA_GROUP_POLICY_UPDATEDwith old and new values. - Removing a factor (
DELETE /api/admin/identity/mfa/factors/{factorId}) needsIDENTITY_MANAGE, checked before the factor is looked up, and*when the owner is an administrative person. Removing one's own factor through this route is refused (IDENTITY_SELF_CHANGE, 403). Each removal is audited asMFA_FACTOR_DISABLEDwith the owner's active factor count before and after. - Enrolling, verifying and confirming a factor are self-only; doing it for someone else answers
403 MFA_ENROLLMENT_SELF_ONLY. - Factor lists and group requirements are read with
IDENTITY_MANAGE.
Reset and welcome links require an enrolled second factor. After a person redeems a set-password link, if they have an active factor (whether or not a group MFA requirement also covers them), the answer is {"status":"mfaRequired","challengeId":"…"} with no session cookie, recorded as LOGIN_AUTH_MFA_REQUIRED (method set-password). The password is already changed and the link is spent; the person completes sign-in with POST /api/public/auth/mfa/verify and a valid code. Studio's sign-in page and custom login appearances handle this answer as they do for password sign-in. This behaviour is always on (requireMfaDuringResetIfEnrolled cannot be turned off). A person covered only by a group MFA requirement who has not enrolled a factor yet is signed in by the link, so they can enrol from their own settings (owner decision; until sign-in can ask for enrolment, such a person's reset link is not followed by a second factor). A person who is locked or deactivated, also while the link is being redeemed, is refused and their password is not changed.
User Provisioning
Provider adapters should map the external identity to a local UserAccount as follows:
- Match by configured username claim or by the supplied external username.
- Create the user only when
createUserAtLogin=trueor imported legacyautoProvisionUsers=true. - Apply
defaultGroupKeysduring first provisioning, excludingsuper-administrators. - Reconcile external group claims through
identity_auth_group_mappingswhenupdateUsersAtLogin=true. - Store provider identity metadata and external claims in
metadata. - Store tenant-selected mapped attributes in
attributesthroughsettings.attribute.<targetField>=<claimName>.
Automatic external provisioning never grants super-administrators, even if the provider default groups or external group mapping asks for it. Administrator membership must be granted by a local super administrator.
SCIM Provisioning
Inbound SCIM 2.0 provisioning lets an external identity provider push users into Inflow before those users sign in. The SCIM API is intentionally outside the normal /api authenticated surface because identity providers authenticate with a dedicated bearer token.
Supported user endpoints:
GET /scim/v2/Users
POST /scim/v2/Users
GET /scim/v2/Users/{userId}
PUT /scim/v2/Users/{userId}
PATCH /scim/v2/Users/{userId}
DELETE /scim/v2/Users/{userId}
Supported group endpoints:
GET /scim/v2/Groups
POST /scim/v2/Groups
GET /scim/v2/Groups/{groupId}
PUT /scim/v2/Groups/{groupId}
PATCH /scim/v2/Groups/{groupId}
DELETE /scim/v2/Groups/{groupId}
Each request must pass:
Authorization: Bearer <scim-token>
Content-Type: application/scim+json
Tokens are stored in identity_scim_tokens as SHA-256 hashes. A token can be disabled or given an expiry time, and inactive or expired tokens return 401.
The implemented SCIM slice supports:
- Creating or updating a local
UserAccountfromuserName,displayName,name,emails,externalId,active, andgroups. - Listing users, including simple
userName eq "..."filtering. - Reading users by local user id.
- Replacing the
activeflag through SCIM patch operations. - Deactivating users through
DELETE. - Reconciling direct platform group memberships when SCIM group values are supplied.
- Creating platform groups from SCIM
displayName,externalId, andmembers. - Listing groups, including simple
displayName eq "..."filtering. - Reading groups by local group id or key.
- Replacing a group's
displayNameor completemembersset through SCIM patch operations. - Deleting non-predefined SCIM-managed groups. Predefined platform groups remain protected by the group service.
SCIM-created users keep external metadata on the local account:
scimExternalIdscimProviderId, when the token is associated with a configured providerscimLastSyncedAt
The local UserAccount remains the source used by workflow assignment, audit, tasks, groups, and authorization. SCIM only provisions and synchronizes identity data into that local model.
SCIM tokens are managed under /api/admin/identity/scim-tokens: listing needs IDENTITY_MANAGE; issuing and revoking need *. Each issue is audited as SCIM_TOKEN_ISSUED (provider and expiry, never the token value). The token value is shown once, in the issue answer.
Provisioning boundaries (spec 302):
- Read scope.
GET /UsersandGET /Groupslist only the people and groups owned by the token's provider (people byscimProviderId, groups by provider ownership);totalResultscounts only those. Reading an id the provider does not own answers the same404as a missing id. A token without a provider sees only what it provisioned itself. - Writes to resources owned by someone else are refused with
403 SCIM_RESOURCE_OWNERSHIP. Note that this still differs from the404for a missing id. - Administrative groups are refused. SCIM cannot change the membership of a group if that group or any ancestor is predefined, holds
*or grants any administrative permission (for exampleIDENTITY_MANAGE), even when the provider owns the group:403 SCIM_PROTECTED_GROUP. Provisioning never makes anyone an administrator; super administrators manage administrative groups in Inflow. Identity providers that pushed membership of such groups must stop. - Email verification. When SCIM changes a person's email address,
emailVerifiedis reset; an unchanged address keeps its state. - Deprovisioning ends sessions. When SCIM sets
activefrom true to false (PUT or PATCH) or deletes a user, every session of the person ends at once and the MCP tokens bound to those sessions are revoked. This is audited asUSER_CREDENTIAL_CHANGED(methoddeprovision) with a system actor naming the provider. Re-activating the person restores nothing; they sign in again.
Security Notes
- Keep all provider examples disabled by default.
- Do not commit real client secrets, bind passwords, private keys, or certificates.
- Use environment variable placeholders for secrets.
- Prefer OIDC or SAML for enterprise SSO.
- Prefer passkeys/WebAuthn for high-security local account access.
- Keep local
root/rootonly for development.
Implementation Status
Current built-in authenticators:
- Local password
- HTTP Basic
- API key
- Trusted header
- Group-enforced TOTP challenge for local password and HTTP Basic authentication
- Configured external provider entries for bearer/JWT/OAuth2/OIDC/SAML2/LDAP/Active Directory/Kerberos/WebAuthn/passkeys/social/remote-extension identity flows, with shared local mapping and JIT provisioning behavior.
Documented provider configuration:
- OIDC
- SAML2
- LDAP
- Active Directory
- Passkeys
- WebAuthn security keys
The documented provider namespaces are stable bootstrap contracts. Runtime administration should use the DB-backed provider registry and Studio Authorization screens.
Canonical bootstrap defaults
The identity.auth.providers.<providerKey>.enabled entries in the canonical file are startup-captured defaults used only when seeding missing native providers. Existing native provider records remain authoritative and are managed through this administration workflow. Changing a seed or restarting does not overwrite an existing provider's enabled state. The flag API reports BOOTSTRAP_ONLY, configured/captured seed values and unknown effective provider state; its restart indication refreshes seeds only. See Feature configuration.