/

CVE-2026-45632

Severity:

CRITICAL RISK

(9.9)

Broken Access Control with Remote Command Execution

CVE-2026-45632

Deferred

Vulnerability type

Category:

Broken Access Control with Remote Command Execution

CWE:

CWE-78, CWE-269, CWE-862

Impact:

Remote Code Execution via Cross-Organization Schedule Manipulation

Severity:

CRITICAL RISK

(9.9)

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

Dokploy's schedule router fails to enforce proper organization and role-based authorization, allowing any authenticated user to control schedules belonging to other organizations when they know the scheduleId/serverId.

Because certain schedule types write and execute scripts on the host or remote servers, this broken access control can be abused to achieve remote command execution (RCE) on the Dokploy host or connected target servers.

Affected context

This vulnerability affects Dokploy instances where:

  • Multiple organizations or tenants share the same Dokploy deployment.
  • Users can authenticate to the Dokploy panel but should be restricted to their own organization's resources.
  • The schedule router is used to create, update, trigger, or delete schedules, including types server and dokploy-server.

In this context, the schedule router does not reliably enforce organization or role checks, meaning that schedule operations can apply to resources outside the attacker's own organization if identifiers such as scheduleId and serverId can be guessed, discovered, or inferred.

Exploit preconditions

  • Attack surface: Dokploy HTTP/API endpoints that handle schedule creation, update, execution, and deletion.
  • Required access: Any authenticated Dokploy account (even with limited or low-privileged role) is sufficient; no direct host access is required.
  • Knowledge required: Ability to obtain or guess valid scheduleId or serverId values belonging to other organizations (e.g., through enumeration, logs, predictable IDs, or information leakage).
  • Trigger point: Invoking schedule operations (create/update/run/delete) on schedules linked to servers that execute scripts on the Dokploy host or remote servers.
  • Why exploitation is possible: The schedule router trusts the caller's requests without performing adequate organization or role-based authorization checks, exposing powerful automation hooks that can write and execute scripts.

Why this happens

The core issue is missing or incomplete authorization on sensitive schedule management endpoints.

Instead of validating that the authenticated user belongs to the organization associated with the schedule or server resource, the schedule router accepts operations based solely on the provided identifiers.

This aligns with CWE-862: Missing Authorization, where the system fails to verify permission for an already authenticated principal.

Because schedules of type server and dokploy-server ultimately write and execute scripts on hosts, the missing authorization combines with CWE-269: Improper Privilege Management and CWE-78: Improper Neutralization of Special Elements used in an OS Command.

High-privilege actions (script writes and execution on infrastructure hosts) are exposed through endpoints that do not enforce appropriate tenancy or role boundaries, allowing low-privileged users to trigger high-impact behavior.

Potential impact

  • Remote execution of arbitrary commands or scripts on the Dokploy host via manipulated schedules.
  • Remote command execution on connected servers managed by Dokploy (e.g., production application hosts).
  • Cross-organization compromise, including unauthorized deployments, task automation, or destructive operations.
  • Data exfiltration from other organizations' environments reachable from compromised hosts.
  • Service disruption or denial of service by deleting or corrupting critical schedules.
  • Lateral movement within the infrastructure, using compromised hosts to reach additional internal services.

General mitigation guidance

Effective mitigation centers on enforcing strict, explicit authorization and limiting the power of automation endpoints:

  • Introduce mandatory organization scoping on all schedule operations, ensuring that every schedule and server resource is unambiguously owned by an organization and that requests are checked against the caller's organization.
  • Apply role-based access control (RBAC) so that only specific roles (e.g., administrators or deployment operators) can create, modify, or trigger schedules that execute scripts or commands.
  • Use security checks at the controller/router layer to validate permissions for every state-changing schedule API, not just at the UI level.
  • Segregate high-privilege schedule types (such as those writing/executing scripts) behind additional policy checks or separate endpoints, and consider requiring explicit confirmation or stronger authentication for destructive or host-level tasks.
  • Limit what scripts or commands can execute by constraining interpreters, paths, and arguments, and by avoiding constructing shell commands from user-controlled input where possible.
  • Run Dokploy and any worker components under least-privilege OS accounts and containers, minimizing the damage in case a schedule is abused to run commands.
  • Improve multi-tenant isolation by design, ensuring identifiers are hard to enumerate and that tenancy boundaries are enforced at every access layer.

How teams detect issues like this

Detection focuses on both code-level issues and runtime anomalies:

  • Static analysis and code review:
  • Look for schedule-related endpoints that accept identifiers (e.g., scheduleId, serverId) and verify that they always perform organization and role checks.
  • Review controller or router logic for patterns such as "fetch by ID and operate" without verifying that the resource belongs to the calling user's organization.
  • Flag any path where sensitive operations (e.g., command execution, script writing, remote server actions) are accessible without explicit authorization checks.
  • Policy enforcement in CI/CD:
  • Use automated security checks or linting rules to require authorization decorators/middleware on all modifying routes.
  • Enforce conventions where all multi-tenant resources must include an organization context, and disallow direct lookups by global ID without scoping.
  • Runtime monitoring and logging:
  • Log all schedule operations with user identity, organization ID, target scheduleId, and serverId.
  • Alert on anomalies such as a user repeatedly targeting schedules outside their own organization, or invoking schedules for multiple organizations.
  • Monitor for unusual command execution patterns originating from Dokploy-managed schedules, including unexpected scripts or commands on hosts.

Sources

SourceLink
github.comgithub.com/Dokploy/dokploy/security/advisories/GHSA-7wmr-57mg-h5q6

Frequently asked

questions

Yes. Any user who can reach the Dokploy interface and authenticate can potentially exploit this issue if they can obtain or guess valid schedule or server identifiers. No direct network access to the underlying hosts is required.

No. The problem stems from missing authorization checks on the schedule router, so even low-privileged or non-admin users may be able to create, update, or run schedules in other organizations, leading to host-level command execution.

Apply strict authorization at every schedule-related endpoint by scoping each operation to the caller's organization and enforcing RBAC for high-impact actions. Ensure the router or controller layer uses a consistent authorization mechanism and that no schedule operation bypasses it.

Design the platform around multi-tenant isolation from the start: make organization context mandatory, use centralized authorization middleware, and treat any high-privilege automation endpoints (like those that execute scripts) as sensitive. Combine code reviews, automated authorization checks in CI, and runtime monitoring to catch missing or weak access control before deployment.

Find out what's already
exploitable in your codebase.