CVE-2026-19868 landed on CISA’s KEV catalog last week: SonicWall SonicOS SSLVPN lets anyone with valid credentials for an alternate authentication method bypass SAML and SAML-enforced MFA. You’ve configured SAML with MFA. The user authenticated with SAML + MFA. They logged in. Then they opened the SSL-VPN with a local password. The VPN let them in without SAML. Without MFA.

This isn’t a SonicWall bug. It’s a class of design flaw that shows up in every identity platform that supports multiple auth methods. I’ll call it authentication method confusion: when the existence of a secondary valid credential lets an attacker skip a stronger primary authentication flow.

How It Works

The pattern is always the same:

  1. An identity platform (SSO, VPN, admin panel, API gateway, CI/CD runner) supports multiple authentication methods.
  2. The primary method is the one configured for the organization — SAML SSO, Okta push, FIDO2 passkey, client certificate.
  3. The secondary method is a fallback — local password, API key, shared secret, RADIUS.
  4. When a user authenticates, the platform checks: does this credential exist and is it valid? It does not check: was this credential authenticated through the primary method?
  5. The secondary method grants the same access. No MFA required. No SSO redirect. No audit trail showing the primary method was used.

The attacker’s move is simple: find the secondary auth path, authenticate with whatever credentials are stored there, and walk through the front door.

Real Examples (Not Just SonicWall)

CVE-2026-19868 — SonicWall SonicOS SSLVPN

SAML + MFA configured for web portal access. SSL-VPN service configured to use SAML, but falls back to local password auth when SAML returns an error or the user selects “Password” in the auth dialog. A user who set a local password months ago — perhaps for SSH key generation or CLI access — can open the VPN tunnel without SSO or MFA.

No workaround. Patch to 7.3.4-7013 (Gen7) or 8.2.3-8015 (Gen8).

Atlassian Cloud — Jira/SAML Bypass

Atlassian platforms support SAML SSO but also accept Atlassian Account password login. If a user’s Atlassian Account has a password set (set during registration, never rotated), a phisher can harvest it and log in directly to atlassian.net without triggering SSO. MFA is enforced at the SAML level, but the direct login path may have separate MFA policies or none at all if the user never enabled Atlassian Account MFA.

GitLab — API Token Bypasses SSO

GitLab enforces SAML SSO on the web UI for groups with sso_enabled: true. But API tokens are validated server-side and don’t check SSO status. A user who set a personal access token on Day 1 — before SSO was configured, or on an account they never logged into via SAML — retains API access regardless of SSO settings. Tokens don’t expire on SSO policy changes.

GitHub — PAT Bypasses SAML SSO

Same pattern. SSO enforced on the organization web UI. Personal access tokens (classic or fine-grained) validate against the token store, not the SSO session. Tokens created before SSO was enabled continue to work. Tokens created after SSO is enabled also work — the token doesn’t carry SSO context.

Cloudflare Access enforces identity policies via a session cookie issued after SSO. But some Cloudflare Apps (e.g., Cloudflare Tunnel backends) can also authenticate via a separate cf-access-token issued to the app at registration time. If that app token hasn’t expired, it grants access regardless of SSO configuration.

Why This Is So Common

Three forces push platforms toward method confusion:

1. Fallback availability. Every identity platform needs a fallback auth path for when SSO is down, the IdP is unreachable, or the user forgot their SSO password. The natural fallback is “something else that works.”

2. Credential reuse. Users set local passwords, API keys, and shared secrets on Day 1 because they’re convenient. They rarely revisit those credentials when SSO becomes the primary method. The secondary credential sits there, valid, forgotten.

3. Stateless validation. Most platforms validate auth methods independently. The API gateway doesn’t know the user authenticated via SAML five minutes ago. The VPN doesn’t know the admin panel user has an active SSO session. Each service checks its own auth store.

How to Detect Method Confusion

1. Audit auth method inventory

For every service, list every authentication method. For each method, answer: is it primary or secondary? Is MFA enforced for this method independently of the primary?

ServiceMethodPrimary?MFA?Bypass Risk
SSL-VPNSAML SSOYesEnforcedLow
SSL-VPNLocal PasswordNoNoneHigh
Admin PanelSAML SSOYesEnforcedLow
Admin PanelPasswordNoSeparateMedium

2. Test the fallback path

Log in via SAML. Log out. Log in via the fallback method with the same user. Does it work? Is MFA enforced? Is the audit trail identical?

3. Check token lifecycles

API tokens, session cookies, service account keys — do they expire when the primary auth method changes? Do they carry the primary method’s context?

4. Look for “or” logic in auth flows

In the config or code, find where auth methods are combined with logical OR. if (saml_auth OR local_password) { grant_access } is the pattern. if (saml_auth AND local_password) { grant_access } would prevent it, but is rarely what operators want.

Design Patterns That Prevent It

Pattern 1: Primary-Only Mode

The platform has a “SSO-only” or “MFA-only” mode that rejects any non-primary auth method. SonicWall’s SSL-VPN should have a sso_enforce: true flag that makes local password auth return 401 Unauthorized regardless of whether the password is valid.

Not every platform has this. Check the docs. If the flag exists, toggle it. If it doesn’t, the fallback path is live.

Pattern 2: Cross-Method Session Binding

When a user authenticates via the primary method, the secondary method’s session is tied to that primary session. The local password session expires when the SSO session expires. When SSO is reconfigured, the local password session is invalidated.

GitLab does this partially — personal access tokens created after SSO is enabled are tied to the SSO account. But tokens created before SSO are not revalidated.

Pattern 3: Unified MFA Enforcement

MFA is enforced at the identity layer, not the application layer. The IdP (Okta, Azure AD, Keycloak) enforces MFA for all login flows, including fallback paths. The application trusts the IdP’s MFA assertion.

This works when all auth methods flow through the IdP. It breaks when the application has a local auth store that bypasses the IdP.

Pattern 4: Credential Rotation on Policy Change

When SSO is enabled or MFA is enforced, all secondary credentials expire. Users must re-authenticate via SSO to set a new local password, generate a new API token, or renew their shared secret.

This is the cleanest solution but the most disruptive. It requires a credential renewal workflow.

What to Do Right Now

  1. List every externally-facing service. VPN, admin panels, CI/CD runners, API gateways, monitoring dashboards, file shares, backup appliances.
  2. For each, identify primary and secondary auth methods. Check the config, the UI, the docs.
  3. For each secondary method, verify MFA enforcement. Is it independent of the primary? Does it have its own MFA policy?
  4. For each API token or service account, check creation date. Created before SSO/MFA was enabled? Likely unvalidated.
  5. Test the fallback path. Log in via primary. Log out. Log in via secondary. Same user, same access, no MFA? Method confusion confirmed.

The SonicWall Case Study

After the KEV addition, here’s the audit for a typical enterprise SSL-VPN:

  • Primary auth: SAML SSO + MFA (enforced on web portal)
  • Secondary auth: Local password (set during initial setup)
  • API access: Shared secret for CLI tools
  • SSH access: SSH key (authenticated via local password auth)

The local password path had no MFA enforcement because MFA was configured only for SAML. The SSH key path required the local password, which required no MFA. The shared secret had no MFA concept.

The fix: patch to enforce SSO on the SSL-VPN service. But until then, rotate the local password, revoke unused API tokens, and document which users have active fallback sessions.

Conclusion

Authentication method confusion is a design flaw, not an implementation bug. It lives in the space between “we configured SSO” and “everything else still works.” Every platform that supports multiple auth methods has it. Every platform that doesn’t have a “SSO-only” mode has it. Every API token created before SSO was enabled has it.

The fix isn’t harder to implement. It’s just less convenient. Operators choose convenience during configuration and pay for it during audits.

Check your auth inventory. Test the fallback. Rotate the stale tokens. The attacker is already doing it.

Further Reading