Because the IdP establishes who authenticated, but the app still decides how the session behaves after login. Local controls determine token persistence, reauthentication, logout effects, and whether the app accepts stale credentials. Without those rules, federation solves entry but leaves session governance incomplete.
What federation actually solves, and what it does not
Federated login answers the front door question: which identity provider vouched for the user, and what assurance level came with that assertion. It does not by itself define what happens after the app issues its own session. The application still has to decide how long that session lives, when it must be rechecked, and what happens if the upstream assertion is no longer trustworthy.
That boundary matters because authentication and session management are different controls. OpenID Connect shows the split clearly: the IdP authenticates the user and the app consumes that result, but the app still owns local session behavior, including cookie handling, token storage, and step-up timing. For the federation layer, see OpenID Connect Core 1.0.
Local session controls also decide whether the app treats the login as a one-time event or as a continuing authorization relationship. That includes reauthentication after inactivity, logout propagation, refresh token use, and whether the app will accept an old session after password reset, account disablement, or IdP policy change. Without those controls, federation authenticates entry but leaves the session state unmanaged.
Why local session policy still matters after SSO
The practical reason is that the app owns its own trust boundary. If the app keeps a session cookie or bearer token alive for too long, then an attacker who steals it can continue operating even if the IdP later revokes the account. If the app never revalidates session state, it can keep trusting a now-stale login decision that no longer matches current user status or risk posture.
Local controls also shape user experience in ways security teams usually have to tune deliberately. A short session timeout may reduce replay risk but increase friction. A persistent session may help productivity but raise exposure on shared devices, unmanaged endpoints, or long-lived browser sessions. The right balance depends on data sensitivity, device trust, and whether the app can reliably detect stale or high-risk sessions.
Federation therefore reduces password handling and centralizes authentication, but it does not remove the app’s responsibility for session governance. That is why mature programs treat federated sign-in, token lifetime, local cookie policy, and logout behavior as separate design decisions rather than a single “SSO enabled” checkbox. Identity and session guidance such as Identity Provider and SSO Security Guide and Workforce Identity Security Guide both reinforce that distinction.
What breaks when the app trusts federation too much
The most common failure mode is overreliance on the upstream login event. An app may accept a valid SSO assertion and then let the resulting session drift for hours or days without checking whether the account was disabled, the device became untrusted, or the original token was replayed elsewhere. That creates a gap between identity proofing at login and session trust during use.
Another failure mode is weak token handling. If refresh tokens, session cookies, or downstream access tokens are stored too long or accepted too broadly, a compromised browser profile or intercepted token can survive the original login event. This is why stolen-token incidents are so damaging, even in federated environments: the IdP may have authenticated the user correctly, but the app still accepted a reusable session artifact. The pattern is visible in the Salesloft OAuth token breach and the Klue OAuth Supply Chain Breach.
Reauthentication rules are the other weak spot. If the app never asks for step-up authentication before sensitive actions, a hijacked but still-valid session can be used for privilege-sensitive transactions, account changes, or data export. That is why session policy has to be tied to risk, not just login success.
Standards & Framework Alignment
This section maps relevant standards and security frameworks to the operational risks and controls described in this guidance.
NIST SP 800-53 Rev 5 and OWASP ASVS set the governance and control requirements practitioners need to meet.
| Framework | Control / Reference | Relevance |
|---|---|---|
| NIST SP 800-53 Rev 5 | IA-2 — Identification and Authentication (Organizational Users) | Federated login still depends on authenticated user identity at session start. |
| IA-5 — Authenticator Management | Session persistence and token handling depend on lifecycle rules for authenticators and tokens. | |
| AC-12 — Session Termination | Local logout and idle timeout are the core session controls this question asks about. | |
| Recommendation — Require authenticated user sessions before granting application access. Set rotation, revocation, and expiry rules for session-bearing credentials. Enforce session termination on logout and after inactivity. | ||
| OWASP ASVS | V7 — Session Management | This question is fundamentally about how applications govern sessions after authentication. |
| V10 — OAuth and OIDC | Federated login commonly uses OIDC, which separates authentication from local session handling. | |
| Recommendation — Verify session creation, persistence, timeout, and invalidation behavior. Validate the OIDC flow and map it to app-local session controls. | ||
Practitioner Guidance
What to verify: Check whether the app has its own session TTL, idle timeout, logout invalidation, and token refresh rules, and confirm those rules are independent of IdP authentication. If the answer is “the SSO provider handles it,” the implementation is usually incomplete.
Decision rule: If a session can still reach sensitive functions after the user is disabled, the password is changed, or the IdP session ends, treat local session control as a priority control gap. If the app cannot invalidate or shorten sessions reliably, reduce token lifetime and require step-up for high-impact actions.
What good looks like: The app should bound session lifetime, recheck trust at meaningful intervals, and end local access when the underlying identity state changes. Federation should establish the user, while the application should continually govern the session.
Practitioner takeaway: Federation authenticates the entry point; local session control protects the working session, and both are required if you want login assurance to persist beyond the first redirect.