Summary
AdGuard Home versions prior to 0.107.73 contain an authentication bypass where HTTP/2 cleartext (h2c) upgrade requests are routed to an internal handler that lacks authentication middleware.
An unauthenticated remote attacker can send a crafted HTTP/1.1 upgrade request to h2c and gain fully authenticated access to AdGuard Home's HTTP/2 API without providing any credentials.
Affected context
The vulnerability occurs in AdGuard Home's HTTP request handling pipeline when processing HTTP/1.1 requests that request an upgrade to HTTP/2 cleartext (h2c).
Deployments are affected when:
- The AdGuard Home web interface/API is exposed over HTTP/1.1 with the ability to negotiate h2c upgrades, and
- The internal HTTP/2 mux (router) is reachable and configured without its own authentication checks.
In these conditions, the upgraded HTTP/2 connection is treated as authenticated even though no prior authentication occurred.
Exploit preconditions
- Attack surface: Network-accessible AdGuard Home HTTP endpoint that supports or accepts HTTP/1.1 requests.
- Required access: Remote network access to the AdGuard Home service (e.g., LAN, VPN, or Internet, depending on deployment).
- Trigger point: An HTTP/1.1 request that includes headers requesting an upgrade to HTTP/2 cleartext (h2c).
- Why exploitation is possible: After a successful h2c upgrade, the HTTP/2 connection is routed to an "inner" mux that has no authentication middleware attached, so all subsequent HTTP/2 streams are treated as if they originate from an already-authenticated session.
Why this happens
This issue stems from inconsistent authentication enforcement between different protocol handlers in the same service.
The primary HTTP/1.1 handler is protected by authentication middleware, but the inner HTTP/2 mux that processes upgraded h2c connections is not.
When an upgrade from HTTP/1.1 to HTTP/2 cleartext succeeds, the service incorrectly assumes the connection has already passed authentication and forwards it directly to the unauthenticated inner mux.
This maps to CWE-287: Improper Authentication, where the system fails to ensure that only properly authenticated users can access protected functionality across all protocol paths and routing layers.
Potential impact
- Remote attackers may gain full administrative access to the AdGuard Home interface without valid credentials.
- Attackers could modify DNS filtering rules, blocklists, and whitelists.
- Configuration data, logs, and potentially sensitive network metadata may be exposed.
- Attackers could disable protections, facilitating further attacks on users relying on AdGuard Home.
- In certain environments, attackers may pivot to other systems by manipulating DNS responses.
General mitigation guidance
Effective mitigation focuses on enforcing consistent authentication checks across all protocol handlers and routing paths:
- Apply authentication middleware at the earliest common entry point so that all HTTP/1.1 and HTTP/2 (including h2c upgrades) requests must pass through the same authentication layer.
- Treat protocol upgrades (such as h2c) as new, untrusted sessions that must independently satisfy authentication requirements.
- Use a single, central authorization component for all routers/muxes instead of duplicating auth logic per protocol or path.
- Restrict network exposure of the administrative interface (e.g., bind only to trusted interfaces, require VPN or reverse proxy with strong auth).
- Favor secure-by-default deployments that disable non-essential upgrade paths or advanced protocols unless necessary.
How teams detect issues like this
Detection generally involves inspection of routing logic and authentication coverage:
- Use static analysis or code review to locate multiple HTTP mux/routers and verify that each has authentication middleware consistently applied.
- Search for protocol upgrade handling (e.g., h2c, WebSocket, HTTP/2 upgrade paths) and confirm that authentication is performed after or during the upgrade, not just before.
- Review configuration and code for discrepancies between HTTP/1.1 and HTTP/2 request handling, especially where different handlers are used for each protocol.
- Apply automated tests or fuzzing that attempt to access authenticated endpoints over alternative protocols or upgrade paths without credentials.
- Monitor logs for unusual unauthenticated HTTP/1.1 upgrade requests followed by privileged HTTP/2 API calls originating from the same client.

