/

CVE-2026-25924

Severity:

HIGH RISK

(8.4)

Authorization Bypass in Kanboard Plugin Installation Leads

CVE-2026-25924

Analyzed

Vulnerability type

Category:

Authorization Bypass

CWE:

CWE-863

Impact:

Remote Code Execution via Unauthorized Plugin Installation

Severity:

HIGH RISK

(8.4)

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

A broken authorization check in Kanboard's plugin installation backend allows an authenticated administrator to bypass the PLUGIN_INSTALLER security control and install arbitrary plugins.

By forcing the server to download and install a malicious plugin despite the UI being disabled, an attacker can achieve full remote code execution on the Kanboard host under certain deployment conditions.

Affected context

This vulnerability appears in Kanboard deployments where:

  • The PLUGIN_INSTALLER configuration is set to false to prevent in-app plugin installation
  • At least one authenticated administrator account exists
  • Outbound network access from the Kanboard server to plugin sources (or attacker-controlled endpoints) is allowed

The risk arises because the backend plugin installation endpoint continues to accept and process installation requests even when the UI control is hidden, so security expectations based on configuration are not fully enforced.

Exploit preconditions

  • Attack surface: Kanboard HTTP(S) interface, specifically the backend endpoint responsible for plugin installation.
  • Required access: Valid authenticated administrator account on the Kanboard instance; no direct shell or database access required.
  • Trigger point: Sending a crafted HTTP request to the plugin installation endpoint while PLUGIN_INSTALLER is configured as disabled in the UI.
  • Why exploitation is possible: The application enforces the PLUGIN_INSTALLER flag only at the presentation layer (hiding the UI), but the server-side authorization logic for the underlying endpoint does not re-check this configuration, allowing direct invocation of plugin installation operations.

Why this happens

The core issue is a mismatch between front-end controls and back-end authorization, aligning with CWE-863: Incorrect Authorization.

Kanboard correctly hides the plugin installation interface when PLUGIN_INSTALLER is false, but the server-side handler responsible for installing plugins does not validate that this configuration actually allows the operation.

As a result, an authenticated administrator can directly call the endpoint and trigger plugin downloads and installations, breaking the intended policy that plugin installation should be disabled, and enabling arbitrary code execution through malicious plugin payloads.

Potential impact

  • Installation and execution of malicious plugins, leading to arbitrary code execution in the application context
  • Full compromise of the Kanboard instance, including project data, user accounts, and configuration
  • Use of the compromised Kanboard server as a pivot point for lateral movement within the hosting environment
  • Deployment of backdoors or persistence mechanisms via plugins
  • Data exfiltration or tampering affecting projects, tasks, and attachments

General mitigation guidance

Effective mitigation focuses on enforcing authorization consistently at the server side and reducing the execution power of plugins:

  • Ensure all sensitive operations (such as plugin installation) implement server-side checks for configuration flags and role-based permissions, independent of UI state.
  • Centralize authorization decisions so that configuration-driven restrictions (like disabling installers) are enforced by the same backend logic for every related endpoint.
  • Reduce the trusted surface of plugins by sandboxing plugin execution where possible and minimizing the privileges granted to plugin code.
  • Apply least-privilege principles to the Kanboard runtime (file system, OS user, network) to limit the impact of any code executed by plugins.
  • Restrict outbound network access from the Kanboard server to only required plugin sources or disable dynamic downloads entirely in high-security environments.

How teams detect issues like this

Detection typically combines code-level review with runtime monitoring:

  • Static analysis or manual review focused on identifying endpoints performing privileged actions without checking global configuration flags or consistent authorization routines.
  • Verification that all plugin-related routes and controllers invoke a centralized authorization layer that respects security settings like PLUGIN_INSTALLER.
  • Logging and alerting for plugin installation attempts, especially when the installer is configured as disabled, to spot unexpected activity.
  • Periodic integrity checks of installed plugins against an approved whitelist to detect unauthorized or unexpected additions.
  • Use of application security testing tools (SAST/DAST) to probe for endpoints that accept actions contrary to configured UI restrictions.

Sources

SourceLink
github.comgithub.com/kanboard/kanboard/commit/b9ada89b1a64034612fc4262b88c42458c0d6ee4
github.comgithub.com/kanboard/kanboard/releases/tag/v1.2.50
github.comgithub.com/kanboard/kanboard/security/advisories/GHSA-grch-p7vf-vc4f

Frequently asked

questions

Exploitability is high wherever an attacker can obtain or abuse an administrator account and the Kanboard server is allowed to download plugins from remote locations. The attack is straightforward once admin access and endpoint knowledge are available.

Yes. The vulnerability still requires authenticated administrative privileges; it does not grant access to unauthenticated users, but it undermines the expectation that disabling the installer in configuration prevents plugin installation.

Apply server-side authorization enforcement for every privileged operation, making sure configuration flags like PLUGIN_INSTALLER are checked by the backend controller or service layer, not just used to toggle UI elements.

Design authorization so that all access decisions are centralized and policy-driven; treat UI restrictions as cosmetic only and ensure every backend endpoint revalidates permissions and configuration. Regular security reviews of privileged endpoints and plugin mechanisms further reduce the risk of similar issues.

Find out what's already
exploitable in your codebase.