The part of IAM that confirms a person is who they claim to be is the authentication function, executed by an identity provider (IdP) — but authentication alone proves only that someone controls a credential. The confirmation that matters is authentication evidence checked against an identity record at the moment a resource is requested. In most real deployments that means three moving parts working together: the IdP that runs the login, the credential or authenticator the user presents, and the token or assertion the resource server validates. Strip any one away and you get a login event with no trustworthy claim attached.

The Three Components That Together Produce an Identity Confirmation

People often say "IAM confirms identity" as if IAM were one system. It isn't. NIST Special Publication 800-63 defines digital identity as a bundle of distinct processes: enrollment, identity proofing, credential issuance, authentication, and federation. Only one of those processes produces the claim a resource server acts on.

IAM component What it stores or does Does it confirm "this is who they claim"?
Identity proofing and enrollment Verifies attributes (name, date of birth, address documents) before an account exists No — it confirms the identity existed at enrollment
Identity provider (IdP) Runs authentication, issues tokens and assertions Yes — it is the authority behind the claim
Authenticator Password, FIDO2 key, TOTP app, certificate No — it supplies evidence the IdP evaluates
Directory (AD, LDAP, cloud directory) Holds the account, group memberships, attributes No — it is the record, not the check
Policy engine / authorization Decides what the authenticated subject may do No — it consumes the confirmation, doesn't create it

Read that table top to bottom and the logic is plain. The IdP is the part that says "this session belongs to this account." Everything downstream, from the SaaS app to the database, trusts that statement or re-checks it against a signature. That delegation is why federation works at all — one company can confirm an identity to another without sharing a password.

NIST frames this as the distinction between the claimant (the person presenting credentials) and the verifier (the party receiving and validating the authentication information). The verifier is your IdP or your relying-party application. The confirmation lives at the verifier, not at the user's keyboard. In federated setups there are two verifiers in sequence — the IdP and the application — and that two-step chain matters later when we get to token validation.

So the precise answer: authentication, performed by a verifier using the account record in a directory. Not the password. Not the MFA prompt. Not the directory. The act of evaluating evidence and issuing a positive result is what confirms the claim derives from a record. Any IAM explanation that points at a single component misses this.

Why Identity Proofing and Authentication Answer Different Questions

A common, expensive confusion: teams think because HR verified a new hire's passport during onboarding, every subsequent Salesforce login is "verified." It isn't. Proofing and authentication answer two different questions, and only one of them is repeated on every login.

Identity proofing, per NIST 800-63A, resolves a claimed identity to a real person and validates the evidence — typically a government photo ID plus a live selfie or an in-person check. It happens once, at enrollment. The outputs are an identity assurance level (IAL) and a verified attribute record. After that moment, the proofing evidence sits in the HR system or the ID verification vendor and is rarely re-touched.

Authentication, per NIST 800-63B, happens every session. It asks whether the person presenting the credential is the same subject that was enrolled. The output is an authenticator assurance level (AAL), which is a measure of confidence in the binding between the user and the authenticator — not in the original documents.

That gap creates the classic failure case. An attacker who phishes a password and defeats SMS OTP is now authenticating as a verified employee. The proofing is intact; the authentication is compromised. Downstream systems see a valid token and treat the session as legitimate because they never see the proofing record at all. IAM's confirmation is only as good as the authenticator's strength at that login.

For privileged accounts, this matters materially. AAL3 in SP 800-63B requires hardware-based authenticators with verifier impersonation resistance — FIDO2 security keys or PIV smart cards — specifically because software OTP can be relayed by a real-time phishing proxy. If the account can wire money or reset other users' credentials, check what AAL your IdP actually enforces on it, not what AAL your vendor's datasheet claims the product supports.

Tokens, Assertions, and the Signature That Carries the Confirmation

When a user logs in, the IdP doesn't just say "OK" to the app. It emits a signed artifact — a SAML assertion, an OpenID Connect ID token, or a WS-Federation token — carrying claims: subject identifier, issuer, audience, issued-at, expiry, authentication method reference. The resource server confirms the user by validating that artifact, not by watching the user type.

Validation is a checklist. Per the OIDC Core specification, a relying party must verify the signature against the IdP's published keys (JWKS for OIDC, metadata XML for SAML), check that the issuer matches the expected IdP, verify the audience includes itself, check the expiry and not-before timestamps, and — for OIDC — verify a nonce if one was sent. Skip any step and the token is just a string. Many real breaches trace to a relying party that forgot to check audience or accepted an unsigned token because the validation library was misconfigured.

Here's a worked illustration of why expiry matters. A typical OIDC ID token from Microsoft Entra ID or Okta lives 60 minutes by default, sometimes configurable down to 5 in high-security tenants. If a token leaks and the resource server doesn't enforce expiry, an attacker has a 60-minute window instead of the intended few. Multiply across thousands of daily logins and the per-token leak rate becomes a staffing problem — not a crypto problem.

SAML assertions work the same way, with two wrinkles. First, SAML 2.0 assertions are base64-encoded XML and are often signed once and embedded in a response that is signed separately — a "signed assertion inside an unsigned response" is valid, but a "signed response containing an unsigned assertion" is a known attack when the SP only validates the response. Second, SAML assertions frequently carry an audience restriction and a recipient attribute, both of which must be enforced. Check your SP configuration against your IdP's metadata; mismatched recipient URIs are one of the most common silent SAML failures.

How Federation Shifts the Locus of Confirmation

In federated login, your company's app never sees the password. It sees a token from an IdP it trusts. This is where "which part of IAM confirms" gets subtle, because the answer is "the IdP that the relying party has chosen to trust," and the relying party's trust configuration is part of the confirmation.

Take the common Microsoft 365 deployment. Entra ID is the IdP; Outlook on the web is the relying party. Outlook does not see the password. It sees a signed token from Microsoft's Entra tenant and validates issuer and signature. From Outlook's perspective, Entra is the part confirming the user. From the enterprise's perspective, the user is only confirmed because Entra's authentication succeeds — and if the enterprise federates Entra to Active Directory Federation Services (AD FS), AD FS is doing the password check. There are now three trust hops.

Each hop is a place for the chain to break. A misconfigured external tenant in Entra — say a B2B guest who should only have access to a single SharePoint site but somehow has a directory role — means the token is valid, the signature is fine, and the identity claim is wrong. Per Microsoft's public B2B documentation, guest access is scoped by access reviews and Conditional Access policy, not by default. If you haven't reviewed the guest list in the past 90 days, that's a governance gap, not an IdP bug.

Enterprise SSO abuse in 2023 and 2024 followed this pattern. Attackers register a new device, steal a session cookie, and replay it against the federation endpoint — the IdP validates the session token, the relying party validates the IdP, and nobody re-checks the device posture. Token binding, Conditional Access device compliance checks, and short session lifetimes are the mitigations. Federation moves confirmation outward; it does not eliminate the requirement.

Session Binding and the Difference Between Login and Continuous Identity

Here's the part most IAM explainers skip. A login confirms an identity at a moment in time. The session that follows carries that confirmation forward without re-checking it — which is exactly the window attackers live in. Session hijacking, session fixation, and stolen cookies all rely on the relying party trusting a session longer than the evidence warrants.

Two technical mechanisms narrow that window. Token binding (in its TLS-based form) ties a token to a client's TLS connection so a stolen token can't be replayed elsewhere. Device-bound credentials, including FIDO2 passkeys, do something similar at the authenticator level: the credential's private key never leaves the device, so a phished credential is useless without the device. The FIDO Alliance's guidance is explicit that passkeys are phishing-resistant specifically because they are origin-bound at the browser — the credential will not authenticate to a look-alike domain.

This is the difference between one-shot authentication and continuous authentication. Continuous approaches — Microsoft Entra ID Protection's risk detections, Cisco Duo's device trust signals, Google BeyondCorp-style context-aware access — re-evaluate session risk on an ongoing basis and can force re-authentication when signals change. If "confirming who a person is" is treated as an event, the confirmation goes stale the moment after login. If treated as a state that gets re-evaluated, it holds.

There's a cost tradeoff. Continuous re-evaluation requires both an IdP capable of consuming risk signals and a relying party willing to enforce step-up challenges — meaning the user sees an extra prompt mid-session. In practice, most enterprises land on a middle ground: session lifetime of 60 minutes for ordinary apps, 15 minutes for admin consoles, and step-up MFA for privileged actions. Confirm the exact session controls in your IdP before you claim to any auditor that "IAM confirms this person."

A Five-Step Validation Path for Checking What Actually Confirms Identity

If you need to determine, in your own environment, which component is genuinely confirming identity for any given system, run this check in order. It works on SaaS, on-prem AD, and hybrid.

1: Identify the relying party and its trust config. Open the application's SSO settings (SAML SP config, OIDC client registration) and list the issuer it trusts, the certificate thumbprint or JWKS URL, and the audience value. Anything outside this trusted set should fail. Anything inside it defines where the confirmation actually comes from. 2: Follow the login flow to the verifier. Trigger a login and observe the redirect chain. If it lands on your enterprise IdP tenant, that tenant's authentication is the confirmation. If it lands on a personal Microsoft or Google account page, an external IdP is being trusted — treat that as a material scope change. 3: Check which authenticator methods are enabled for the account. Query the IdP's method policy (Entra's Authentication Methods policy, Okta's Authenticator settings). Passwords-plus-SMS is not equivalent to passkeys. Note whether the account can register a new method without admin approval. 4: Verify token validation on the relying party. For OIDC, check log output for issuer/audience mismatch warnings. For SAML, check for signature-required errors. If the relying party accepts unsigned tokens or accepts tokens from any issuer, the confirmation chain is broken. 5: Test session lifetime and replay. Log in, capture the session cookie, log out in one browser, and replay the cookie in another. If access persists, session invalidation on the IdP doesn't reach the relying party — a real and common gap.

If steps 3–5 pass, and the token validation is correct, you have a chain where the IdP's authentication decision is enforced faithfully. If step 3 fails (bad authenticators allowed) or step 5 fails (sessions not invalidated), the IdP is confirming identity to a relying party that lets the confirmation drift.

This path is more useful than reading marketing claims about "zero trust identity" because it produces a specific answer per application: which IdP confirms, which authenticators it accepts, and whether the relying party enforces the result. Most identity incidents I've seen in post-mortems sit at step 4 or step 5 — a relying party that skipped validation or a session that never expired — not at the password field.

Authenticator Strength and Why "Confirmed" Depends on How You Logged In

Not all confirmations are equal, and IAM systems encode the difference in assurance levels. The EU's eIDAS regulation and the UK's GOV.UK One Login service both grade authentication by the strength of the authenticator: single-factor password is the weakest, TOTP app is a step up, FIDO2/passkey is currently the highest deployable option for consumer logins, and smart cards or PIV fall into the hardware-cryptographic tier.

A concrete comparison makes the difference clear.

Authenticator Phishing resistance Replay resistance Typical AAL (NIST 800-63B) Common failure mode
Password only None None — passwords leak AAL1 Credential stuffing
Password + SMS OTP Low (real-time proxy defeats) Partial AAL1 by NIST, often mislabeled AAL2 SIM swap, OTP relay
Password + TOTP app Low (real-time proxy defeats) Partial AAL2 OTP relay, shared secret theft
Push notification Medium (push fatigue, MFA bombing) Partial AAL2 User approves unintended prompt
FIDO2 security key / passkey High (origin-bound) High AAL3 with appropriate key Lost device, account recovery flow is the weak point
PIV / smart card High High AAL3 Driver and reader dependence

NIST's 800-63B places RESTRICTED and DEPRECATED authenticators in specific categories, and SMS OTP has been "RESTRICTED" for years, meaning it's allowed but not preferred — a detail many vendors quietly gloss over in AAL claims. FIDO2 keys reach AAL3 only when combined with a verifier-impersonation-resistant protocol, which FIDO2 provides by design, plus a suitable identity proofing flow for IAL2 or above.

The practical takeaway: when someone asks "does IAM confirm this person is who they claim," the honest answer is "to what assurance level, on which authenticator, enforced by which verifier policy?" A teammate logging into a low-value SaaS tool with SSO + password is confirmed to AAL1 — that is the actual confidence level. A payroll admin using a passkey and step-up authentication is confirmed to AAL3 in the same directory. The IAM system stores both; the login method determines which is operative at any moment.

Where the Chain Breaks: Three Failure Scenarios That Reveal the True Confirming Party

Failures teach the architecture better than successes. Three scenarios expose which part of IAM is really doing the confirming.

Scenario 1 — AAD/Entra token replay via stolen session. A user logs in from a compliant laptop. An infostealer on that laptop lifts the session cookie. The attacker replays it from a different network and country. The IdP validates the token, the relying party validates the IdP, and the session is accepted. What confirms identity? The IdP, but only at the original login. The 2023 breach of a Microsoft corporate email account via a replayed legacy session followed this pattern, and Microsoft's public post-incident note described the remediation as tightening session controls and legacy protocol access, not replacing the IdP.

Scenario 2 — SAML signature wrapping against a misconfigured SP. An SP validates issuer and assertion validity but not the recipient, and its XML parser is vulnerable to a wrapping attack where a valid signed assertion is moved inside a forged response. The IdP is fine. The SP accepts the forged claim as if the IdP had issued it. What confirms identity here? The IdP in theory — in practice, the SP's parser made the decision. That's why the CISA advisory on SAML parsing from 2018 still gets cited: the vulnerability was in the relying party, not the IdP.

Scenario 3 — Orphaned guest account after offboarding. An employee leaves. HR's record is updated. The IdP flags the account disabled. But a B2B guest account provisioned in another tenant, with delegated access to a shared SharePoint site, was never deprovisioned because the lifecycle didn't reach across the boundary. Six months later, the account is still valid in that other tenant, and its IdP confirms the account as legitimate — because it is. The failure is identity governance, not authentication.

Each case points to a different mitigating control: session binding and device trust for scenario 1, strict token validation and parser hygiene for scenario 2, access reviews and cross-tenant lifecycle management for scenario 3. None of them is "a stronger password field." If you're auditing your IAM confirmation story, test all three, not just the login screen.

How to Verify the Claim in Your Own Tenant Without Vendor Help

You can answer this question for your own environment in under an hour with tooling you already have. No vendor meeting required.

Start with the IdP admin console. In Entra ID, the sign-in logs (Audit → Sign-in logs) show the authentication method used per login and the Conditional Access policy outcome. In Okta, the System Log shows the authenticator provider and success events. Filter for the last 24 hours, sort by authentication method, and note the share of password-only logins — that number is the share of sessions confirmed at AAL1. If the share is above 20% on privileged apps, you have concrete work to do.

Next, audit app registrations and enterprise applications. Any SAML app with more than one signing certificate, or any OIDC app with a client secret older than a year, is a token-validation weak point. Check whether each app enforces "Signed SAML response required" (the checkbox lives in the SP's SAML config, not in the IdP) and whether the audience value matches the app's configured entity ID. Count the mismatches.

Finally, test session revocation. In Entra, "Revoke sessions" from the user's admin panel should invalidate refresh tokens. In Okta, "Clear user sessions" does the same. Use a test account, log in on two browsers, revoke, and see whether both end. If one persists, you've found a relying party that trusts long-lived tokens without checking the IdP's revocation list.

What you're really measuring is the gap between the IdP's authentication decision and the relying party's enforcement. IAM confirmation is only as strong as the weaker of the two. The audit path above produces the numbers — the percentage of password-only logins, the count of unvalidated SPs, the percentage of sessions surviving revocation — that turn "IAM confirms identity" into a specific, defensible claim.

FAQ

Does MFA itself confirm identity, or is it just an extra check?

MFA strengthens the authentication event but does not perform confirmation on its own — the IdP is still the party that evaluates the MFA result and issues the token. An MFA prompt that is approved on a fraudulent push notification satisfies the IdP's policy and produces a valid token. Confirmation of identity is the IdP's decision to issue the token after evaluating all evidence, including MFA.

Is a passwordless login more secure than password + MFA?

For phishing resistance, yes, if the passwordless method is FIDO2 or a passkey — those are origin-bound and cannot be relayed to a look-alike domain. Password + SMS OTP is weaker than a passkey despite feeling more complex, because SMS is classified RESTRICTED in NIST SP 800-63B and real-time phishing proxies defeat OTP reliably. The distinction matters most for accounts with admin or financial authority.

Can a relying party confirm identity without an IdP at all?

Yes, but only in the narrow sense that a standalone application running its own authentication (a legacy app with its own user table and password hashing) is both the IdP and the relying party. This used to be standard and is now generally discouraged because it multiplies credential stores, fragments account lifecycle, and typically can't meet AAL2 or AAL3 without significant custom work. Modern practice delegates authentication to a shared IdP.

How much does improper IAM confirmation cost in breach terms?

IBM's Cost of a Data Breach Report has for several years placed the global average cost of a breach at USD 4.45 million (its 2023 edition) and USD 4.88 million (2024 edition), with compromised credentials repeatedly among the top initial access vectors. Multiply the per-account cost by the number of accounts that lack phishing-resistant MFA to size your exposure; the IBM figures give you the per-breach anchor. Confirm current figures on IBM's site before citing them in a board deck.

What is the difference between authentication and authorization in this context?

Authentication is the IdP's positive result that the session belongs to a specific account; authorization is the policy engine's decision about what that account may do. A confirmed identity can still be authorized for the wrong things — that's how orphaned guest accounts become dangerous. Confirming identity does not constrain the account's permissions, so the two must be governed separately.

Does single sign-on make confirmation weaker?

SSO concentrates the confirmation in a single IdP, which is stronger than distributing it across many apps if the IdP's authenticator policy is strong. It is weaker if the one IdP accepts password-only logins for thousands of apps, because a single credential compromise then yields access everywhere. SSO amplifies whatever assurance the IdP enforces, in both directions.

Do passkeys mean the IdP is no longer the confirming party?

The IdP is still the issuer and the authority behind the token, but the cryptographic binding between user and device now lives in the authenticator, and the passkey's private key never leaves the device. Confirmation is split: the authenticator proves possession and origin; the IdP proves account enrollment and policy. Verification still happens at the relying party, as it always did.

If a session is stolen, which part of IAM failed?

The IdP authenticated correctly at the moment of login — its confirmation was true then. The relying party failed to re-evaluate session risk, or failed to bind the token to a device or network, so it treated a stale confirmation as a live one. Session controls (lifetime, binding, revocation propagation) are the part of IAM that governs how long a confirmation stays valid.