Applications that cannot speak SAML or OpenID Connect are now the biggest gap in most MFA programmes, and closing it means putting something in front of the app that can demand a second factor on its behalf. VPN concentrators, network devices, older web apps, line-of-business systems that bind to LDAP, and appliances that only understand RADIUS all authenticate users with a password the identity provider never sees. Cyber insurers and regulators increasingly ask for MFA on all remote and privileged access, so "the app does not support it" is no longer an acceptable exception. This guide explains the four main integration patterns, how each works, where each leaves gaps, and how to roll them out safely.
It is written for identity architects, infrastructure teams and security engineers. For the vendor-neutral foundations, start with our MFA Guide; for Windows servers and Remote Desktop, see the MFA for Windows Logon and RDP Guide.
Key takeaways
- Four patterns cover most legacy apps: RADIUS proxies, LDAP proxies (LDAP shims), reverse proxies that pass identity in HTTP headers, and network-level access gateways.
- Every pattern moves the trust boundary to the proxy. If users or attackers can reach the app without going through the proxy, MFA is bypassed.
- Header-based integrations are only safe when the app accepts traffic solely from the proxy, because the app trusts whatever headers arrive.
- RADIUS and LDAP patterns usually rely on push or phone call, because the app's login screen has no field for a code. They are not phishing-resistant.
- Fail mode, timeouts and service account credentials on the proxy are security decisions, not plumbing.
- Treat each proxied app as a tracked exception on the path to modern federation, not a permanent end state.
Why legacy apps are the MFA coverage gap
Modern apps delegate sign-in to an identity provider through SAML or OIDC, so the identity provider can enforce MFA, device checks and session policy. Legacy apps hold the authentication decision themselves. They accept a username and password, then check it against Active Directory over LDAP, against a RADIUS server, or against their own user table.
That design creates three problems. The identity provider's MFA policy never applies. The password is the only thing an attacker needs, so password spraying and credential stuffing (ATT&CK T1110) work directly against the app. And the app often runs on the internal network or behind a VPN, which used to be treated as a safe zone and no longer is. Stolen valid accounts (ATT&CK T1078) are among the most common initial access routes in public incident reporting.
Before choosing a pattern, inventory how each app authenticates. Our MFA Coverage Measurement guide describes how to build that inventory and report coverage.
The four integration patterns
| Pattern | What the app sees | Typical targets |
|---|---|---|
| RADIUS proxy | A RADIUS server that returns Access-Accept only after primary and secondary authentication | VPNs, network devices, Remote Desktop Gateway, firewalls |
| LDAP proxy (LDAP shim) | An LDAP directory that answers bind requests only after secondary authentication | Apps that bind to Active Directory or OpenLDAP for login |
| Header-based reverse proxy | HTTP requests carrying identity in headers set by a trusted proxy | Older web apps that already trust a header such as a username |
| Access gateway | Traffic only from users who passed MFA at the gateway | Apps that cannot be changed at all |
RADIUS proxy
The app or appliance is configured to authenticate users against a RADIUS server. That server, or a proxy in front of it, checks the password against the directory and then requests a second factor from an MFA service. Only when both succeed does it return Access-Accept.
The constraint is the user interface. Most RADIUS clients only show a username and password field, so the second factor must be something that does not need typing, such as a push approval or phone call, or must be appended to the password. Timeouts also matter: the RADIUS client must wait long enough for the user to respond to a push.
LDAP proxy (LDAP shim)
The app is pointed at a proxy that looks like an LDAP directory. When the app sends a bind request with the user's credentials, the proxy validates them against the real directory and then triggers a second factor before returning success. The app needs no change except the LDAP server address.
Two risks need attention. LDAP binds carry passwords, so the connections between app, proxy and directory must use TLS. And the app's own service account, used for searches, is a privileged non-human identity: if it can bind without MFA, it becomes the easiest target. Our guide to finding accounts excluded from MFA and Conditional Access covers how to track these.
Header-based reverse proxy
A reverse proxy sits in front of the web app. It authenticates the user against the identity provider, including MFA, then forwards requests to the app with headers such as the username, email or groups. The app reads the headers and logs the user in.
The app trusts whatever headers arrive. If anyone can reach the app directly and set those headers, they can impersonate any user. Network restriction, so the app accepts traffic only from the proxy, is mandatory for this pattern.
Access gateway
Where the app cannot be changed at all, an access gateway or zero trust network access service can require MFA before any network connection to the app is allowed. The app still uses its own password, so this adds a gate in front rather than replacing app login. It protects against outsiders reaching the app, but not against a user or attacker already on the network segment.
Vendor approaches
The vendor sections below are listed alphabetically. Each describes that vendor's own documented approach, settings and limitations, based on its public documentation as of November 2026. Inclusion is not an endorsement.
Cisco Duo: Duo Authentication Proxy
Duo documents the Authentication Proxy as an on-premises service that receives RADIUS or LDAP authentication requests, optionally checks primary credentials against an LDAP directory or RADIUS server, then requests secondary authentication from Duo. It is configured through sections in authproxy.cfg.
- Server sections:
[radius_server_auto], which Duo recommends for most applications and which selects the user's device and factor automatically;[ldap_server_auto]for LDAP logins; and[radius_server_eap]for PEAP and EAP-GTC. Duo also documents other RADIUS modes and notes that iFrame support ended on 30 March 2024. - Primary authentication clients:
[ad_client]for an Active Directory domain controller or LDAP server,[radius_client]for another RADIUS server such as Microsoft NPS, with UDP or RadSec transport, and[duo_only_client]where the device handles primary authentication itself. - Platforms: Windows Server 2016 or later and several Linux distributions.
- Security notes: Duo discourages plain LDAP without TLS, advises restricting
authproxy.cfgto the service account on Linux, and advises against installing the proxy on a domain controller or NPS server. From version 6.8.1, RADIUS server sections drop UDP Access-Requests that contain EAP-Message but no Message-Authenticator. - Operations: stopping the service causes RADIUS, LDAP and SSO logins through it to fail until it restarts, and the proxy does not natively load balance, so Duo suggests external load balancers for scale.
Microsoft: NPS extension and Entra application proxy header-based SSO
Microsoft documents two building blocks relevant to legacy apps.
- NPS extension for Microsoft Entra multifactor authentication: a RADIUS client sends Access-Requests to a Network Policy Server; NPS verifies the username and password against Active Directory; if NPS policy conditions are met, the extension requests secondary authentication from Microsoft Entra MFA and NPS returns Access-Accept on success. In Microsoft's Remote Desktop Gateway walkthrough, supported methods are phone call and Microsoft Authenticator push, while SMS and methods that require entering a code are not supported because there is no field to enter one. Microsoft recommends raising the RADIUS client timeout to between 30 and 60 seconds.
- Header-based single sign-on with Microsoft Entra application proxy: Microsoft describes application proxy preauthenticating users with Entra ID, reading claims from the token, converting them to HTTP headers and forwarding requests through a private network connector to the backend app. Conditional Access policies, including step-up authentication, govern access, and Microsoft notes authorisation policies apply to the initial authentication request. Microsoft states the app server should accept traffic only from the connector or another permitted header-based solution, because the app trusts whatever headers arrive, and that application proxy is intended for remote access rather than general corporate access.
Security design rules for every pattern
- Close the side doors. Block direct access to the app, its LDAP or RADIUS dependencies and its management interfaces from anywhere except the proxy or gateway.
- Encrypt every hop. Use LDAPS or StartTLS for LDAP, RadSec or a protected network for RADIUS, and TLS between reverse proxy and app.
- Choose fail mode deliberately. Failing open when the MFA service is unreachable turns a network outage, or a blocked firewall rule, into an MFA bypass. Failing closed needs a tested break-glass path.
- Protect the proxy's secrets. RADIUS shared secrets, directory service account passwords and MFA integration keys live on the proxy. Store them encrypted, rotate them and restrict who can read the configuration.
- Harden the proxy host. It is now part of your authentication path and deserves the same hardening and monitoring as a domain controller.
- Log end to end. Correlate app login events, proxy events and MFA service events so you can prove a second factor was used for each session.
Push fatigue and phishing limits
Because RADIUS and LDAP patterns usually rely on push approval, they inherit push fatigue risk (ATT&CK T1556.006 covers MFA modification, and our MFA Fatigue and Bypass Guide covers the attacker techniques). Mitigations include number matching or verified push where the integration supports it, rate limits on push requests, and alerting on repeated denials.
None of these patterns are phishing-resistant in the sense used by NIST SP 800-63B-4 and CISA, because the user still types a password into an app that cannot verify it is talking to the genuine relying party. Where an app is high value, prioritise migrating it to federation with phishing-resistant authentication, or place it behind a header-based or gateway pattern where the identity provider can enforce phishing-resistant methods at the proxy.
Questions to answer before choosing a pattern
A short assessment for each app avoids choosing a pattern that later turns out not to fit. These questions are NHI Mgmt Group guidance.
- Does the vendor offer federation now? Many older products gained SAML or OIDC support in later releases. An upgrade can be cheaper than a proxy.
- Where does the login happen? A browser login suits header-based or gateway patterns; a thick client or appliance login usually points to RADIUS or LDAP.
- Can the login screen show a challenge? If there is no second field and no challenge prompt, only push or phone call methods will work.
- Who else uses the same directory binding? Changing the LDAP server address for one app may affect integrations that share the configuration.
- Can the network be restricted? If you cannot stop users reaching the app directly, the pattern cannot be enforced, and the app belongs in the exception register.
- What happens during an outage? Decide in advance whether the app should be unavailable or reachable without the second factor if the MFA service is down.
- Are there non-human users? Batch jobs, integrations and monitoring tools that log in with passwords cannot complete push MFA and need their own controls, such as dedicated credentials with restricted scope.
Rollout plan
- Inventory and classify. For each app, record how it authenticates, who uses it, whether it is internet-facing and whether it supports federation.
- Pick the pattern per app. Prefer native federation; otherwise header-based or gateway patterns for web apps, RADIUS for network devices and VPNs, LDAP proxy for directory-bound apps.
- Build the proxy tier with redundancy, since it becomes a single point of failure for every app behind it.
- Pilot with IT staff on one app per pattern. Test timeouts, fail mode and error messages.
- Close direct access before declaring the app covered.
- Expand by risk, starting with internet-facing and privileged apps.
- Track exceptions for apps that cannot yet be covered, with owners and review dates, in a register such as our MFA Exception Register Template.
Common failure patterns
- Proxy bypass: the app still accepts connections directly, so attackers skip MFA.
- Header spoofing: a header-based app is reachable from the network and trusts any request carrying the identity header.
- Fail open in production: an outage or firewall change silently disables the second factor.
- Service accounts exempt: app service accounts bind to the directory without MFA and are used by attackers.
- Short timeouts: RADIUS clients give up before users approve the push, so teams disable MFA to stop complaints.
- Unencrypted LDAP: passwords cross the network in clear text between app and proxy.
- Permanent stopgap: proxied apps are never migrated to federation.
Practitioner checklist
- Inventory every app that authenticates with LDAP, RADIUS, headers or a local user table.
- Assign an integration pattern and owner to each app.
- Restrict network access so each app is reachable only through its proxy or gateway.
- Enforce TLS on every LDAP, RADIUS and HTTP hop.
- Set fail mode deliberately and test break-glass access.
- Store proxy secrets encrypted and rotate them on a schedule.
- Set RADIUS timeouts long enough for push approvals.
- Enable number matching or verified push where supported, and alert on repeated denials.
- Track uncovered apps in an exception register with review dates.
- Plan migration of high-value apps to federation with phishing-resistant MFA.
Standards and references
- Cisco Duo: Duo Authentication Proxy reference
- Microsoft: NPS extension with Remote Desktop Gateway and Microsoft Entra MFA
- Microsoft: Header-based single sign-on with application proxy
- NIST: SP 800-63B-4 Authentication and Authenticator Management
- CISA: Implementing Phishing-Resistant MFA
- NIST: SP 800-53 Rev. 5 (IA-2 Identification and Authentication, AC-17 Remote Access)
- MITRE ATT&CK: T1078 Valid Accounts
Related NHI Mgmt Group resources: MFA Guide · Phishing-Resistant MFA Guide · MFA Fatigue and Bypass Guide · MFA Coverage Measurement