When Keycloak Kerberos SPNEGO SSO removes the password prompt for domain users
Workforce users on domain-joined Windows desktops who sign in to Windows once and then get asked for a password again by browser apps are the people this feature serves. Keycloak Kerberos SPNEGO SSO lets those users reach Keycloak-protected applications without a second login when the browser negotiates a Kerberos ticket. The Keycloak server administration guide documents Kerberos as an authentication mechanism, so in the normal case the desktop sign-in is the credential Keycloak accepts. The password prompt can still appear when negotiation fails or when a user signs in from a device outside the domain, so plan for those paths from the start.
Two things must be in place. The first is a Kerberos-capable directory. In most enterprises that is Active Directory, which Microsoft describes as the service that stores users and computers and replicates directory data to every domain controller in a domain. Keycloak reaches those identities through its LDAP and Active Directory user federation, and Kerberos must be configured for the realm alongside that federation so Keycloak can validate tickets issued by the domain. The second is a correctly configured browser. The browser must be permitted to negotiate Kerberos for the Keycloak hostname, usually through intranet zone or allowlist settings, and the hostname users type must match the service name the directory expects. Confirm the exact browser policies against your browser vendor documentation and your Keycloak version before rollout.
This pattern typically fits organizations that already run Active Directory, manage Windows desktops through Group Policy, and host internal web applications that users reach from the corporate network. Microsoft's comparison of Active Directory and Entra ID notes that most on-premises apps authenticate against Active Directory with LDAP, Windows-integrated authentication (NTLM and Kerberos) or header-based authentication. A team with a large internal application estate is therefore likely to find that some applications already use Windows-integrated sign-in. Organizations syncing identities to Microsoft Entra ID through Microsoft Entra Connect may still need on-premises Kerberos during a long transition, which is a question to settle with the identity team early. Teams whose users mostly work from unmanaged or mobile devices should weigh whether this feature covers enough of their sign-ins to justify the work.
The feature does not work for all clients or operating systems. Negotiation depends on the browser and the desktop operating system, so a mix of Windows, macOS and Linux machines, or non-browser clients such as command-line tools and native mobile apps, needs its own test plan before anyone assumes one setting covers everything. Microsoft's comparison also notes that Linux machines must be configured separately to authenticate against Active Directory as a Kerberos realm, so a Linux desktop population is a separate project. Ask for a written matrix of browser, operating system and application combinations in scope, and confirm which combinations were actually tested.
Before scoping, answer three questions: which applications should accept domain sign-in, which browsers and desktop builds the workforce uses, and what should happen when negotiation fails. The last question matters because a fallback to the standard Keycloak login form keeps users working during a fault, while removing that fallback turns a configuration problem into an access problem. Run a pilot group, record which accounts and machines were tested, and include service account and Kerberos key material handling in the security review. Ask any implementation partner to show written test results for each combination in scope before the rollout date is set.
Which Kerberos configuration fits your directory and login model
This table compares four ways to combine Kerberos or SPNEGO sign-in with your directory and login model, plus a constraint for FIPS 140-2 mode. Read each row by its directory requirements and its main trade-off, and confirm the exact configuration steps against the Keycloak version you plan to run. The main takeaway is that transparent desktop sign-in depends on domain-joined devices and a directory Keycloak can reach, so the fallback and brokering options matter most for unmanaged devices and external users.
| Option | When it fits | What the directory must provide | Main trade-off |
|---|---|---|---|
| Kerberos or SPNEGO with LDAP or AD federation | Windows estate where users are held in Active Directory and devices are domain-joined, so sign-in is transparent. | A reachable AD or LDAP directory, a Kerberos service principal and keytab for Keycloak, and user accounts Keycloak can federate. | Unjoined or non-Windows devices cannot sign in silently, and the Kerberos setup depends on correct DNS and time synchronization. |
| SPNEGO with form-login fallback | Mixed fleet where domain-joined desktops should sign in silently and unmanaged devices still get a password prompt. | Everything the first option needs, plus accounts that can also sign in with a password through the login form. | Two sign-in paths to test and support, and the password form becomes the weaker entry point unless it is hardened, for example with MFA. |
| Kerberos-only design | Closed environment where every user and device is domain-joined and no other sign-in path is wanted. | Complete Kerberos coverage for all users, with a directory that holds every account Keycloak needs to authenticate. | Any user or device outside the domain is locked out, and sign-in depends on the Kerberos infrastructure being healthy. |
| Brokering to an external identity provider | Organization already runs a central identity provider that handles Windows sign-in, and Keycloak should broker it to applications. | An external provider that supports OIDC, OAuth or SAML and handles the desktop sign-in itself. | Keycloak does not see the desktop sign-in, so lockout, session and logging rules depend partly on the upstream provider. |
| Any option under FIPS 140-2 mode | Regulated deployments that must run Keycloak in FIPS 140-2 mode. | Confirm in the Keycloak documentation which sign-in methods your FIPS configuration supports before design starts. | Kerberos does not work under FIPS 140-2 mode, so desktops need a different sign-in path in that environment. |
How the Kerberos sign-in flow differs from a password form
When a domain-joined user opens a Keycloak sign-in page, the browser first needs a Kerberos service ticket for the Keycloak service. The user's workstation already holds a ticket-granting ticket from logon, issued by the domain controller acting as the Key Distribution Center. The browser uses that ticket to request a service ticket for the Keycloak service principal, wraps it in a SPNEGO token, and sends it to Keycloak in an Authorization header that begins with the Negotiate scheme. Keycloak then checks the token against its own service keytab and maps the verified principal to a Keycloak user through the configured federation.
- Ticket request: The browser contacts the domain controller only when it lacks a valid service ticket for the Keycloak service principal.
- Header: The SPNEGO token travels in the Authorization header, usually on the login request that the browser makes to Keycloak.
- Validation: Keycloak uses its keytab to decrypt and verify the ticket, so the keytab must match the service principal name the browser requests.
- Identity mapping: The verified principal is matched to a user record through the Kerberos or LDAP or Active Directory federation settings.
Check the service principal name and keytab pairing first, because a mismatch there accounts for many early failures.
Browsers send Negotiate credentials only to hosts they trust for integrated authentication. If the Keycloak hostname is not on that list, the browser never sends a token, and the user sees the standard password form without any Kerberos attempt. The settings differ by browser and operating system, so confirm the exact policy names and locations against the documentation for each browser version in your fleet. Managed endpoints usually receive these settings through Group Policy or a device management tool.
- Allowlist scope: Trust is granted per host or domain, and the Keycloak hostname must match the entry exactly.
- Name consistency: Access by an IP address, a short alias or a different DNS name can fail negotiation because the requested service name no longer matches.
- Delegation is separate: Allowing a browser to negotiate does not grant credential delegation, which is a distinct setting if your design needs it.
- Coverage gaps: Browsers on unmanaged devices, or profiles created before the policy was pushed, fall back to the form.
Test each supported browser with a clean profile on a domain-joined machine and on a machine outside the domain, so you can see both the success path and the fallback.
When a request arrives without credentials, Keycloak answers with an authentication challenge that includes the Negotiate scheme. A capable browser responds by starting negotiation, and the user may see no prompt at all. When the header is present but the token is invalid, Keycloak rejects that attempt and the flow decides what happens next. In many realm configurations the Kerberos step is an alternative to the password form, so the user is shown the form. If the Kerberos step is marked as required, the login fails. Confirm which execution type your browser flow uses before you test.
- No header: Keycloak returns a 401 response with a Negotiate challenge, which prompts the browser to try negotiation.
- Invalid token: Expired tickets, a wrong service name, or a keytab mismatch cause the Kerberos authenticator to fail.
- Fallback behavior: An alternative execution lets the flow continue to the password form, while a required execution stops the login.
- Clock drift: Time differences between the client, the domain controller and Keycloak can invalidate otherwise correct tickets.
Document the expected outcome for each case in your test plan, including which screen the user should see.
A password form reports most failures on the page itself. A wrong password produces an error message, and a locked or disabled account shows its own notice. A Kerberos failure is often less visible. If negotiation fails and the flow falls back to the form, the user sees a password prompt and may assume the sign-in method is simply different. If the failure happens before the browser sends a token, the user sees the same password form and no clue about why Kerberos did not run. The cause usually appears only in server logs and login event records, so support staff need access to those sources.
- Visible on the page: Wrong credentials, disabled accounts and lockout notices.
- Silent fallback: A failed negotiation that continues to the password form, with no error shown.
- Log-only causes: Keytab mismatch, unknown service principal names, expired tickets and clock skew.
- Recorded failures: The Keycloak 26.8 upgrade notes say login failures are persisted to the database by default, which gives you a queryable record.
Confirm your event retention and log levels with your own environment before relying on them for triage.
How Keycloak Kerberos SSO combines with LDAP or Active Directory federation
Keycloak's Kerberos support and its LDAP or Active Directory user federation are two separate configurations, and most desktop SSO deployments need both. The Kerberos (SPNEGO) setting lets Keycloak validate the ticket a domain-joined browser presents, but it does not by itself give Keycloak a user store. The federation provider is what lets Keycloak read user attributes, group memberships and account status from the directory, so the ticket's identity can be mapped to a complete Keycloak user with the claims your applications expect. Plan both configurations together and test them as one flow, not as two independent checks.
Microsoft's comparison of Active Directory and Entra ID describes how most on-premises applications authenticate against Active Directory: through LDAP, through Windows-integrated authentication (NTLM and Kerberos), or through header-based methods. It also notes that Active Directory needs a federation system such as AD FS to reach SaaS applications. Keycloak sits in a similar position to AD FS in this picture when it brokers desktop sign-in for web applications. Existing Active Directory organizations often use Microsoft Entra Connect to sync identities to Microsoft Entra ID. Ask the directory team whether Entra Connect is already in place, because that affects which identities and attributes Keycloak should trust and which system is the source of truth for account changes.
Active Directory Domain Services replicates directory data to every domain controller in a domain, so Keycloak does not need to talk to a single server. In practice, the reader should confirm which domain controllers Keycloak reaches for LDAP queries, which controllers it uses for Kerberos ticket validation, and how the Kerberos keytab for the service principal is scoped to the right host names. Ask the directory team for the list of domain controllers in each site that Keycloak's network can reach, and test failover by taking one controller out of the path. Record the answers, because a misconfigured controller list is one of the more common reasons a working Kerberos login starts failing intermittently.
Keycloak Kerberos SSO setup, step by step
This sequence takes a domain-joined desktop from a password prompt to transparent sign-in in Keycloak, with a password fallback for devices outside the domain. Each step closes with a check, so problems surface before the next dependency is built. Directory administrators own the domain-side work, and the team configuring Keycloak owns the realm, proxy and testing work.
Confirm directory health and time sync
Domain administrators confirm that the domain controllers are healthy, record the Kerberos realm and the controller names, and confirm that the Keycloak host and the domain controllers keep time within the tolerance Kerberos requires. Kerberos rejects tickets when clocks drift too far apart, so this is often where sign-in breaks later. Confirm the realm and time requirements in the Keycloak server administration guide and in your Windows time service documentation. Done when the team holds a written record of the realm, the controller names and a clock comparison taken from the Keycloak host.
Create the service principal and keytab
Domain administrators create a service account and a service principal name for the HTTP service that Keycloak answers on, then export a keytab holding its keys. Agree the public host name first, because the principal must match the name browsers use. Confirm the principal format and encryption types in the Keycloak documentation, and confirm the export procedure with your directory team's Windows tooling. Restrict the keytab to the Keycloak service account on the server and record who holds a copy. Check: the Keycloak process can read the keytab, and a test authentication against it succeeds from the Keycloak host.
Configure the Kerberos and federation providers
A realm administrator enables the Kerberos authentication provider in the Keycloak admin console and points it at the keytab, realm and principal from the previous step. Kerberos identifies the user but does not supply profile attributes or groups, so the realm also needs an LDAP or Active Directory user federation provider. Confirm in the server administration guide how the Kerberos provider pairs with federation settings, including import and sync behavior. Confirm that the realm is not running in FIPS mode, because Kerberos does not work under FIPS. Check: the provider saves without errors, and a test user from the domain appears in the realm after a sync.
Set the browser and reverse proxy for negotiate
Browsers offer Kerberos sign-in only to hosts they trust, so the team adds the Keycloak host name to the intranet zone or the equivalent browser policy on managed desktops. The reverse proxy must forward the Negotiate Authorization header to Keycloak and keep TLS on all traffic. The production guidance also calls for path restrictions that keep the admin console and administration REST API off the public host name. Confirm the browser policy settings and proxy directives against the documentation for your browsers and proxy product. Check: a request from a domain-joined browser reaches Keycloak with the header present, and the proxy logs show it was forwarded.
Test sign-in from a domain-joined device
Sign in from a domain-joined desktop using a user with a current ticket and a browser configured in the previous step. The expected result is that the login form is skipped and the user reaches the target client without a password prompt. Confirm in the Keycloak logs and the domain controller's Kerberos records that the ticket was accepted and the expected principal was used. Repeat with a second browser and a user outside the federation scope to confirm that the realm limits behave as designed. Check: transparent sign-in works for the test set, and any failure produces an error your team can trace to the keytab, the clock or the browser policy.
Verify the fallback for unmanaged devices
Sign in from a device outside the domain, such as an unmanaged laptop. Negotiation fails or is skipped there, so Keycloak should show the standard login form and the user should complete sign-in with a password or another configured method. Confirm in the server administration guide how the Kerberos provider behaves when negotiation fails, and review the browser flow settings that control the fallback. Check: the standard login page loads without an error, the password sign-in completes, and a locked or disabled account is still refused through the fallback.
Security risks in Kerberos SSO and how to limit them
Kerberos SSO moves trust into a keytab, a directory service account, the browser and the network path in front of Keycloak. Each card below names one of those points, the control that limits it, and the check to run before go-live.
Keytab protection and rotation
The keytab holds the long-term secret for the HTTP service principal, so anyone who can read it can decrypt service tickets and impersonate the service. Limit read access to the account that runs Keycloak, keep the file out of images, shared drives and version control, and rotate it on a schedule agreed with the directory team. Confirm that the new key version works before the old one is removed. Verify by reading the file as another local user, which should fail, and by comparing the key version in the keytab with the directory record.
Blast radius of the service account
The HTTP service principal is normally tied to a directory account, and that account's group memberships and delegation settings decide how far an attacker can go if it is compromised. Use a dedicated account for each Keycloak environment, keep it out of privileged groups, deny interactive logon, and grant delegation only if a named downstream service requires it. Verify the account's group memberships and delegation settings with directory queries, and record who approved any delegation right.
TLS and reverse proxy path restrictions
SPNEGO negotiation travels in HTTP Authorization headers, so the path from browser to Keycloak must use TLS end to end and the reverse proxy must pass the Negotiate header through unchanged. Keycloak's production guide calls for TLS on all communication and a reverse proxy that restricts paths, so only the sign-in and required endpoints are published. Verify that management endpoints are not reachable through the public proxy, that the header reaches Keycloak intact, and that the certificate chain validates from a domain-joined desktop.
Admin console on a separate hostname
Desktop SSO runs on internal networks and is often configured on the same public hostname as the application login, which widens the target for admin functions. Keycloak's production guide recommends exposing the admin console and Administration REST API on a different hostname or context path from public frontend URLs. Keep the admin hostname reachable only from administrator networks. Verify that it does not resolve or route on the public listener, and that a request for an admin path through the public hostname is refused.
Browser trust zone configuration
Browsers send Negotiate credentials only to hosts they treat as local intranet or trusted sites, so a broad allowlist can hand Kerberos negotiation to a host outside your control. Keep the list to the Keycloak hostname or a tightly scoped domain suffix, deploy the setting through Group Policy or managed browser policy, and avoid wildcards that match external domains. Verify on a test desktop by opening a host outside the zone and confirming that the browser does not send a negotiation request to it.
Logging of failed negotiations
Failed SPNEGO attempts are the earliest signal of expired keytabs, clock drift, misconfigured SPNs or someone probing the sign-in endpoint. Keycloak 26.8 persists login failures to the database by default, and Prometheus-format metrics are exposed at /metrics on the management interface when metrics are enabled with --metrics-enabled=true. Forward server logs to your SIEM and alert on bursts of failures from one client address. Verify by triggering a deliberate failed sign-in and confirming it appears in the database, the logs and the metrics.
Why Keycloak Kerberos SSO and FIPS mode cannot run together
Kerberos and SPNEGO sign-in does not work when Keycloak runs in FIPS 140-2 mode, and the topic facts treat this as a limit that configuration cannot switch off. For a regulated buyer, that makes the choice a design input rather than a late tuning step. If your assessor expects FIPS 140-2 mode across the identity provider, transparent desktop sign-in cannot sit in that same Keycloak deployment. Decide this before you settle realm layout, federation topology, client configuration or the desktop enrollment approach, because each of those assumes Kerberos is available. Reversing the decision after the build usually means rework across clients, test plans and the evidence pack.
The practical consequence is that the Kerberos path needs its own design. There are three directions, and each changes scope. The first is a separate non-FIPS Keycloak deployment that serves domain-joined desktops with SPNEGO, while a FIPS instance handles other applications. That split adds hosts, a database, certificates, patching, monitoring and backups, and the assessor must decide whether the second instance falls inside the same boundary. The second is to keep FIPS mode everywhere and use another login method for desktops, such as password federation with OTP or passkeys, which the Keycloak administration guide documents. Users then sign in more often, so the change needs a user communication plan. The third is an accepted gap, recorded as a risk decision with a named owner and a review date.
Before you commit, confirm the current FIPS limitation list in the Keycloak documentation for the exact release you plan to run. That list is the authoritative record of what breaks, and it should be checked against the version in your design, not an older guide. Then take the list to your assessor and ask for a written position on which option they accept, whether a non-FIPS instance changes the assessment boundary, and whether Kerberos-dependent federation with LDAP or Active Directory is affected in the same way as desktop sign-in. Active Directory itself stays in place under every option. The open question is which Keycloak instance authenticates against it.
Put the decision into the written scope with any implementation partner. Ask the partner to state which option the quote assumes, what FIPS-mode testing they will run, and which Keycloak components will be inside the evidence boundary. Also ask who maintains the non-FIPS instance if you choose the split, and how its patching and access reviews will be evidenced. A scope that leaves these points open usually produces a second round of design work after the first audit question, so resolve them in writing before design starts.
Limits to confirm before you commit to Kerberos SSO
Kerberos and SPNEGO sign-in only works when the browser, the operating system, the Keycloak distribution and the directory all cooperate. Each card names one limit to confirm in your own environment and who should answer it, so the decision rests on facts about your estate rather than assumptions.
Browsers and operating systems
SPNEGO negotiation depends on the browser accepting Negotiate authentication for your Keycloak hostname and on the operating system handing over a valid Kerberos ticket. Ask your desktop engineering team to list every browser and operating system version in use, then test sign-in on each one. Confirm the Keycloak hostname is in the browser's intranet or trusted zone list, since most mismatches surface there. Record the results before you commit.
Linux and macOS client configuration
Windows domain-joined clients usually negotiate Kerberos with little extra work, but Linux and macOS clients typically need a Kerberos configuration file, a valid keytab or ticket cache, and browser settings that allow delegation to the Keycloak host. Ask your platform team which non-Windows devices must sign in transparently and whether they are enrolled in the same realm. Plan that configuration as a separate work item with its own test cases.
Keycloak version and distribution
Confirm whether you run community Keycloak or the Red Hat build of Keycloak, and which minor version is deployed or planned. Kerberos behavior, supported configuration keys and upgrade notes change between releases, and the Red Hat build follows its own support lifecycle. Ask your platform owner for the exact version and distribution, and check the Kerberos section of the release notes for that version before you design the flow.
Directory type and trust topology
Establish whether users live in Active Directory, in FreeIPA reached through a cross-forest trust, or in another Kerberos realm. Each arrangement changes which realm Keycloak must trust, how user accounts are matched, and where the service principal lives. Ask your directory team to document the realm names, the domain controllers Keycloak can reach, and whether a trust already exists. Do not assume a trust is present until the directory team confirms it.
Fallback for unmanaged devices
Transparent sign-in only works on devices that hold a valid ticket from your directory, so personal, contractor or unmanaged devices will need a different path. Decide whether those users see a password form, a passkey or an OTP prompt, and whether that fallback must meet the same authentication strength as the Kerberos path. Ask your security and service desk leads to agree the fallback policy in writing before rollout.
Operating Kerberos SSO through upgrades, high availability and monitoring
Kerberos sign-in keeps working over time only if the keytab and its service account are managed as long-lived assets. Keycloak decrypts the service ticket with a key held in a keytab for the HTTP service principal, typically named in the form HTTP/keycloak host name. When the directory account's password changes, or its keys are rotated under your domain policy, the key version changes and older keytab entries stop decrypting tickets. Before go-live, record which account owns the principal, who may reset its password, how a new keytab is generated, and where it is deployed. Ask your Active Directory team whether the account is exempt from routine password expiry and how rotation notices reach the Keycloak operators. After every rotation, test with a domain-joined browser sign-in, because a directory query alone does not prove the keytab still decrypts tickets.
Keycloak upgrades need a test pass that includes the negotiate flow, not only the admin console and form login. The project ships four minor releases a year, and since Keycloak 26.0 it has said breaking changes in a minor release will be opt-in, but your own feature list still determines what you must re-test. The current release is 26.8.1, published October 13, 2026. The Keycloak Operator documentation strongly recommends manual approval mode for operator updates, which keeps upgrade timing under your change control. Database schema migration runs automatically at startup by default, and the upgrading guide suggests manual migration for large deployments. The 26.8 upgrade notes cover SMTP StartTLS, backchannel logout token signatures, persisted login failures and the move from multi-site to stateless, none of which is Kerberos. Confirm in your environment that the SPNEGO authenticator and the Kerberos federation settings still behave as expected after each upgrade.
High availability for Kerberos SSO depends on the database as much as on the Keycloak nodes. Keycloak documents three high availability architectures: a single cluster optionally spread across availability zones, multi-cluster deployments (v2) without external Infinispan, and the deprecated multi-cluster v1 design. Both supported designs require a synchronously replicated database, so confirm that your PostgreSQL or other supported database offers synchronous replication across the zones you plan to use. Every node must hold the same keytab and must receive the Authorization header carrying the Negotiate token through the reverse proxy. Check that the proxy forwards that header unchanged and that it does not strip or rewrite it on any node. Confirm with your network and directory teams how the Kerberos service is reached from each site, including name resolution for the service host name.
Monitoring should show authentication failures before users report them. Keycloak exposes Prometheus-format metrics at /metrics on its management interface when it starts with --metrics-enabled=true, and it can add HTTP request and cache histograms as options. Keep the management interface off the public frontend, consistent with the production guidance to separate administrative and metrics paths from public URLs. Build a dashboard and alert on the authentication failure series for your version, and confirm the exact metric names in the observability guide before writing alert rules. Watch for a rise in failed negotiate attempts after a keytab rotation, a jump in users falling back to form login, and clock drift between nodes and the domain controllers, since Kerberos tickets are time sensitive. Review these signals after each upgrade and each directory change.
Questions buyers ask before hiring help with Kerberos SSO
What drives the cost of a Keycloak Kerberos SSO implementation?
Scope sets the cost, and the main drivers are the directory structure, the number of realms, the device mix, the fallback design, FIPS constraints and the test matrix. One Active Directory forest, one Keycloak realm and a uniform fleet of managed Windows desktops is a narrow job. Multiple forests, several realms, mixed domain-joined and unmanaged devices, and a fallback path for users outside the network each add design and testing work. Each item increases the number of configurations that must be built and verified. Design, build and test work is a one-time cost. Operating the service afterward, including patching Keycloak and retesting sign-in after upgrades, recurs and is either carried by your team or covered by a retainer. Ask for a quote that lists each driver as its own line, names the environments in scope and states which browsers and operating systems will be tested. The written scope is where effort is set.
How long does a Keycloak Kerberos and SPNEGO setup take?
Duration depends on scope, and no single timeline fits every environment. A proof of concept against one test domain and one realm moves faster than a production rollout across several forests, where the directory team, the desktop team and application owners must all approve changes. Time also goes to steps that are easy to underestimate: agreeing service account and keytab handling with your domain administrators, building the fallback behavior, and testing sign-in on each browser your staff use. Your schedule also depends on how quickly your teams can grant access and approve changes within change windows. DeployOpen plans most engagements as fixed-scope work, so phases, deliverables and timelines are agreed in writing before work starts. Ask for the phase plan in the quote and identify which dependencies sit with your team.
What do we need from our domain administrators for Keycloak Kerberos SSO?
Your domain administrators must create and manage the service principal and keytab, confirm the delegation and encryption settings Kerberos will use, and validate that domain controllers respond as expected. Your security team should review how SPNEGO negotiation is exposed, how the fallback login is protected, and how keytab files are stored, rotated and access-controlled. Ask who approves directory changes, who holds the keytab, and how changes are tested before they reach production. Network staff should confirm that clients can reach the domain controllers and that the Keycloak hostname resolves correctly in DNS for every browser in scope. Plan these reviews early, since approvals often set the critical path. Name each owner in the written scope so the engagement has a contact for every approval and access request.
Can our internal team set up Keycloak Kerberos SSO without outside help?
An internal team with Keycloak, Kerberos and Active Directory experience can build it, but the work spans several disciplines. It joins directory administration, Kerberos configuration, reverse proxy and TLS setup, browser policy and Keycloak realm design. Internal teams most often struggle with the test matrix and the fallback path, because a mistake there can lock users out or leave a weaker login route open. Ask whether the people who run the directory, the identity platform and the desktop fleet can commit time to the full build and to retesting after each Keycloak upgrade. If they can, they can work from a written checklist. If they cannot, a fixed-scope engagement can cover design and build while your team learns to operate the result.
Which browsers and devices must be tested for desktop SSO?
Test every browser and operating system combination your staff use on domain-joined desktops, plus the unmanaged devices that will fall back to a form login. Browsers handle SPNEGO differently, so the browser policy that allows Kerberos negotiation for the Keycloak host must be set and verified on each one. Include Windows domain-joined machines in the main sign-in path, and add Linux or macOS devices only if they are in scope and have their own configuration. Test on-network and off-network access, expired Kerberos tickets, locked accounts and users who are not in the directory. Record the full matrix in the written scope so the number of configurations is agreed before the build starts. Ask the partner to show test results for each browser and device combination before handover.
What breaks when Keycloak Kerberos sign-in falls back to a password form?
The most common problem is that the fallback login becomes the path everyone uses, so sign-in stops being transparent and the password form becomes the weakest link. Other failures include a negotiation prompt that appears when it should not, a Keycloak hostname that does not match the service principal, clock skew between clients and domain controllers, and an authentication flow that does not fall through correctly when Kerberos fails. Check each failure path with a test user in every browser. Confirm how the flow behaves for users outside the network and for users whose tickets have expired. After go-live, monitor failed logins so that a rise in fallback use is visible. Ask for the fallback design in writing, including which users reach the password form and how that form is protected.
Does Kerberos SSO in Keycloak work if our servers must run in FIPS mode?
Kerberos SPNEGO sign-in is not supported when Keycloak runs in FIPS 140-2 mode, so a regulated environment that requires FIPS mode needs a different design before the build starts. Confirm this against the Keycloak documentation for the exact version you plan to run, because support can change between releases. The FIPS topic covers the BouncyCastle FIPS libraries, strict and non-strict modes and key length limits. If FIPS mode is mandatory, the decision is between running FIPS without Kerberos and choosing a desktop sign-in method your security team has approved for that environment. Settle this during scoping, because it changes the architecture, the testing and the evidence your auditors will review. Ask the partner to state the FIPS position in the written scope.
How DeployOpen works on this
DeployOpen treats Keycloak Kerberos and SPNEGO desktop SSO as a change to how domain-joined workstations sign in across your estate. The engagement covers directory federation, Kerberos service setup, browser configuration and fallback paths, and the decision on FIPS mode is made before the build starts.
How we scope
- The written scope lists which domains, forests and desktop populations will receive transparent sign-in.
- Scoping records the Keycloak service principal, keytab ownership and the Kerberos realm that matches your Active Directory domain.
- Kerberos does not work under FIPS mode, so that choice is recorded in scope before build starts.
How we build
- Build covers the directory federation to LDAP or Active Directory, so Keycloak can resolve users and group memberships.
- Kerberos is set up as a realm federation provider, and browsers are configured to negotiate SPNEGO against Keycloak.
- Browser policy for trusted sites is rolled out through your device management, and tested on each supported desktop image.
How we hand over
- Handover includes documented Kerberos and LDAP settings, keytab rotation steps and a tested fallback login path.
- Your administrators receive test evidence from sign-in on domain-joined and unjoined machines, including failure cases.
- Operations runbooks cover keytab expiry, clock skew between desktops and domain controllers, and browser policy drift.
How we support
- Ongoing support is available as a retainer for patching Keycloak, renewing service credentials and re-testing after Windows updates.
- Each Keycloak upgrade is re-tested against the sign-in matrix before it reaches desktops.
- Scope changes, such as adding a forest or a new desktop image, are handled through a written change request.

