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.

