/

CVE-2026-21881

Severity:

CRITICAL RISK

(9.1)

Authentication Bypass in Kanboard

CVE-2026-21881

Analyzed

Vulnerability type

Category:

Authentication Bypass

CWE:

CWE-287

Impact:

Full Account Takeover and Privilege Escalation

Severity:

CRITICAL RISK

(9.1)

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

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_AUTH enabled 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_AUTH and 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.

Sources

SourceLink
github.comgithub.com/kanboard/kanboard/commit/7af6143e2ad25b5c15549cca8af4341c7ac4e2fc
github.comgithub.com/kanboard/kanboard/releases/tag/v1.2.49
github.comgithub.com/kanboard/kanboard/security/advisories/GHSA-wwpf-3j4p-739w

Frequently asked

questions

Yes, if the Kanboard instance is reachable over the network and REVERSE_PROXY_AUTH is enabled without strict network or reverse-proxy controls, an attacker can send crafted HTTP requests from anywhere they can reach the service.

No. The attacker does not need existing credentials; they only need the ability to send HTTP requests with spoofed authentication headers, which Kanboard then misinterprets as a legitimate login.

The safest pattern is to ensure that authentication decisions are based on data that the application can fully trust. This often means validating tokens or credentials directly, or strictly verifying that any header-based identity information comes from a known, trusted reverse proxy and cannot be set by end users.

Adopt a design principle that treats all client-supplied headers as untrusted by default. When integrating with reverse proxy authentication, enforce clear trust boundaries: validate proxy source, strip sensitive headers at the edge, and regularly review both application and proxy configurations as part of security architecture and deployment checklists.

Find out what's already
exploitable in your codebase.