Summary
Kanboard versions 1.2.48 and below contain an authentication bypass when reverse proxy authentication is enabled and HTTP headers are blindly trusted.
By sending spoofed authentication headers without going through a trusted reverse proxy, an attacker can impersonate any user, including administrators, and gain full control of the application.
Affected context
This vulnerability affects Kanboard deployments that enable REVERSE_PROXY_AUTH and rely on HTTP headers (such as REMOTE_USER or similar) for user identification. The issue appears when Kanboard does not verify that incoming requests actually originate from a trusted reverse proxy or gateway before honoring these headers. Environments where the application is directly exposed to users, misconfigured proxies, or permissive network paths are particularly at risk.
Exploit preconditions
- Attack surface: HTTP(S) interface of the Kanboard application.
- Required access: Ability to send HTTP requests directly to the Kanboard instance (network-level reachability).
- Configuration requirement:
REVERSE_PROXY_AUTHenabled and Kanboard relying on client-supplied headers for authentication. - Trigger point: Submission of crafted HTTP requests including spoofed authentication headers that Kanboard interprets as valid user identity.
- Why exploitation is possible: The application implicitly trusts authentication-related headers without confirming they were injected by a trusted reverse proxy or validating the source of the request.
Why this happens
The core issue maps to CWE-287: Improper Authentication. Kanboard's reverse-proxy authentication mode assumes that any incoming request with certain authentication headers has already passed through a trusted reverse proxy. Without validating the origin of those headers (for example, by checking the source IP against an allowlist or enforcing a secure integration pattern), the application treats arbitrary client-supplied headers as authoritative authentication signals.
This design breaks the authentication trust boundary: identity information intended to be controlled by infrastructure (reverse proxies) is instead controlled by end users. As a result, the application's authentication mechanism is effectively bypassed, because user identity is derived from untrusted header data rather than from credentials or validated tokens.
Potential impact
- An attacker can impersonate any regular user account.
- An attacker can impersonate administrator accounts, gaining full administrative control.
- Unauthorized access to sensitive project data, tasks, comments, attachments, and configuration.
- Creation, modification, or deletion of projects, users, and roles.
- Disruption of project workflows, task manipulation, or data tampering impacting business operations.
General mitigation guidance
Effective mitigation focuses on restoring a clear trust boundary between the reverse proxy and the application and avoiding reliance on client-controlled headers:
- Ensure that authentication or identity headers are only honored when requests are known to originate from a trusted reverse proxy or gateway (for example, by validating the source IP or interface).
- Prefer end-to-end authentication mechanisms (session-based auth, OAuth/OIDC, SSO via standard protocols) where the application validates tokens or credentials directly instead of trusting raw headers.
- Where reverse proxy authentication is required, constrain the set of accepted identity headers and strip or overwrite them at the edge so that only infrastructure components can set them.
- Apply a "deny by default" stance to header-based auth: if trust signals from the reverse proxy are absent or cannot be verified, fall back to standard login flows and reject the header-based identity.
- Use least privilege within Kanboard: restrict administrative roles and apply strong, separate accounts so that header misuse has a smaller blast radius if configuration mistakes occur.
How teams detect issues like this
Organizations can pursue a combination of configuration review, code analysis, and monitoring to detect this class of issue:
- Configuration review: Examine
REVERSE_PROXY_AUTHand related settings, confirming that Kanboard is not directly exposed and that only trusted reverse proxies can reach it. - Static analysis and code review: Look for patterns where authentication or user identity is derived directly from HTTP headers without validating request origin, reverse proxy presence, or applying strict checks. Flag any logic that trusts
REMOTE_USER-style headers or similar fields without source validation. - Security policy enforcement: Implement infrastructure policies that strip or normalize authentication-related headers at network boundaries, ensuring applications never see user-controlled identity headers.
- Runtime monitoring: Track successful logins or session creations correlated with unusual HTTP headers or from unexpected client IP ranges. Sudden admin logins from unknown locations may indicate abuse of header-based authentication.

