/

CVE-2026-32136

Severity:

CRITICAL RISK

(9.8)

Authentication Bypass in AdGuard Home

CVE-2026-32136

Analyzed

Vulnerability type

Category:

Authentication Bypass

CWE:

CWE-287

Impact:

Full Authentication Bypass and Administrative Control

Severity:

CRITICAL RISK

(9.8)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

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.

Sources

SourceLink
github.comgithub.com/AdguardTeam/AdGuardHome/security/advisories/GHSA-5fg6-wrq4-w5gh

Frequently asked

questions

Yes. Any remote party that can reach the AdGuard Home HTTP endpoint and send specially crafted HTTP/1.1 requests can potentially exploit this issue, depending on how the service is exposed on the network.

No. The core of the vulnerability is that authentication can be completely bypassed: an attacker does not need valid credentials, just the ability to establish an h2c-upgraded HTTP/2 connection.

The safest pattern is to centralize authentication at a single, mandatory entry point and ensure every protocol handler (HTTP/1.1, HTTP/2, upgrades) passes through it.

Protocol upgrades should not inherit an "authenticated" state by assumption; they must independently verify authentication before granting access to protected routes.

Design request handling so that authorization and authentication are layered above any protocol-specific routing.

During development and code review, explicitly map all paths (including upgrades and alternative transports) to the same authentication and authorization checks, and add tests that attempt to reach protected endpoints over each protocol without credentials.

Find out what's already
exploitable in your codebase.