/

CVE-2026-28790

Severity:

HIGH RISK

(7.5)

Broken Access Control in OliveTin KillAction RPC

CVE-2026-28790

Analyzed

Vulnerability type

Category:

Broken Access Control

CWE:

CWE-284, CWE-862, CWE-863

Impact:

Unauthorized Denial of Service

Severity:

HIGH RISK

(7.5)

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

OliveTin, a tool that exposes predefined shell commands via a web interface, contained a broken access control flaw in its KillAction RPC endpoint.

Even when guest authentication was required, unauthenticated users could directly invoke KillAction to terminate running actions, enabling unauthorized denial of service against legitimate command executions.

Affected context

This vulnerability appears in OliveTin deployments that:

  • Expose the OliveTin web/API interface to untrusted networks or shared environments
  • Rely on authRequireGuestsToLogin: true to prevent unauthenticated usage
  • Use long-running or critical actions that may be disrupted by premature termination

In these conditions, the KillAction RPC endpoint remains callable by unauthenticated users, even though the dashboard UI itself is correctly protected.

Exploit preconditions

  • Attack surface: Network-accessible OliveTin HTTP/RPC interface
  • Required access: Ability to reach the OliveTin instance over the network (no valid session or credentials required)
  • Trigger point: Sending a crafted KillAction RPC request targeting an existing running action
  • Why exploitation is possible: The authorization checks applied to the dashboard and general guest access are not consistently enforced on the KillAction RPC endpoint, allowing an unauthenticated caller to invoke functionality reserved for authenticated users.

Why this happens

The underlying issue is inconsistent authorization enforcement on a privileged RPC operation.

While the configuration option authRequireGuestsToLogin: true correctly restricts access to the dashboard, the KillAction endpoint does not fully honor this policy, leaving a privileged action exposed.

This maps to CWE-284: Improper Access Control, and is closely related to CWE-862: Missing Authorization and CWE-863: Incorrect Authorization, where one or more endpoints fail to verify that the caller is an authenticated and authorized user before executing sensitive operations.

Potential impact

  • Unauthenticated users may terminate legitimate long-running actions.
  • Operational workflows that depend on OliveTin-managed actions could be disrupted.
  • Repeated exploitation can result in a sustained denial of service against critical automations or maintenance tasks.
  • Loss of trust in automation outcomes if actions are unexpectedly killed mid-execution.

General mitigation guidance

Effective mitigation centers on enforcing consistent, centralized authorization for all privileged endpoints and operations.

Common patterns include:

  • Applying the same authentication and authorization checks to every RPC/API endpoint as are used for the main dashboard, especially for operations that modify or terminate actions.
  • Implementing an explicit access-control layer where each action (including KillAction) defines required roles or permissions, and verifying these before the action is executed.
  • Designing configuration flags like authRequireGuestsToLogin so they govern all relevant code paths through a single enforcement mechanism rather than per-endpoint logic.
  • Restricting network exposure of the OliveTin interface (for example, limiting it to management networks or using a reverse proxy with strong authentication in front).
  • Adopting least-privilege defaults so that unauthenticated or low-privilege users cannot invoke management or termination commands by default.

How teams detect issues like this

Detection typically involves a mix of code-level and behavior-level checks:

  • Static analysis and review: Search for handler functions or RPC endpoints that modify or terminate actions and verify that they consistently call centralized authorization routines. Flag any handler that can be triggered without an explicit authentication/authorization check.
  • Configuration-aware tests: Build automated tests that simulate unauthenticated requests to all management operations (start, stop, kill, modify) and assert that they are rejected when guest login is required.
  • Access-control policy enforcement: Use security linters or policy-as-code tools to enforce rules such as "no endpoint under /rpc may be invoked without authentication middleware."
  • Runtime monitoring: Inspect access logs for patterns of unauthenticated requests successfully invoking management or termination operations, and set alerts on such anomalies.

Sources

SourceLink
github.comgithub.com/OliveTin/OliveTin/commit/d9804182eae43cf49f735e6533ddbe1541c2b9a9
github.comgithub.com/OliveTin/OliveTin/releases/tag/3000.11.0
github.comgithub.com/OliveTin/OliveTin/security/advisories/GHSA-4fqm-6fmh-82mq

Frequently asked

questions

Yes, if the OliveTin interface is exposed over a network reachable by an attacker, they can exploit the issue remotely without authenticating, as long as they can send KillAction RPC requests.

The attacker only needs network-level access to the OliveTin service. No valid dashboard session or credentials are required when the vulnerable behavior is present.

The safest pattern is to route all RPC and web handlers through a centralized authentication and authorization layer that enforces configuration policies (such as authRequireGuestsToLogin) uniformly, and to require appropriate permissions for any action that can affect running processes.

Prevent similar flaws by designing access control as a cross-cutting concern rather than per-endpoint logic, using middleware or frameworks that apply authentication/authorization consistently, writing automated tests for unauthorized access attempts to all management operations, and including access-control checks as a standard focus area in security reviews.

Find out what's already
exploitable in your codebase.