/

CVE-2026-44849

Severity:

HIGH RISK

(8.8)

Missing Authorization in Portainer Endpoint Security for

CVE-2026-44849

Analyzed

Vulnerability type

Category:

Missing Authorization

CWE:

CWE-862

Impact:

Privilege and Policy Bypass Leading to Unsafe Container Configurations

Severity:

HIGH RISK

(8.8)

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

Portainer Community Edition contains a missing authorization control where configured EndpointSecuritySettings are enforced for standard container creation, but some of these restrictions are not applied when users create Docker Swarm services.

In environments where non-admin users are allowed to deploy services, this discrepancy can let them bypass administrative safety controls and launch workloads with elevated or unsafe configurations.

Affected context

This issue occurs in Portainer Community Edition deployments that:

  • Allow non-admin users or teams to create or manage services in Docker Swarm environments
  • Rely on EndpointSecuritySettings to restrict container options such as privileged mode, host namespaces, and filesystem access
  • Assume that these restrictions are uniformly enforced across both container and service creation workflows

The vulnerability manifests specifically on the Docker Swarm service API path, where several EndpointSecuritySettings are not applied as expected.

Exploit preconditions

  • Attack surface: Portainer web UI and API endpoints used for Docker Swarm service creation
  • Required access: Authenticated non-admin user with permission to create or manage Docker Swarm services via Portainer
  • Trigger point: Submission of a Swarm service specification that requests configurations normally restricted by EndpointSecuritySettings (e.g., privileged mode, host PID, sensitive mounts)
  • Why exploitation is possible: The authorization and policy enforcement layer applies security restrictions to the standard container creation flow but fails to apply equivalent checks to the Swarm service API path, allowing policy-violating configurations to be accepted.

Why this happens

The core issue is inconsistent enforcement of authorization and policy checks across multiple code paths that perform logically equivalent actions.

Portainer exposes both a standard container creation workflow and a Docker Swarm service creation workflow.

While EndpointSecuritySettings are checked on the standard container creation path, equivalent checks were not fully implemented or wired into the Swarm service path.

This maps to CWE-862: Missing Authorization, where access control decisions (in this case, policy restrictions on container capabilities and host access) are omitted for a specific execution path, leading to a privilege and policy bypass for users who can reach that path.

Potential impact

  • Non-admin users may create Swarm services in privileged mode, effectively gaining broad access to the host system from within containers.
  • Attackers can configure services with host PID namespaces, improving their ability to observe or interact with host processes.
  • Bypass of restrictions on device mappings, potentially exposing sensitive host devices to containers.
  • Circumvention of limits on Linux capabilities, enabling operations that should have been disallowed for non-admin workloads.
  • Misuse of sysctls and security options (Seccomp/AppArmor) to weaken sandboxing or hardening settings.
  • Creation of services with restricted bind mounts, giving containers access to host files or directories that admins intended to protect.
  • Expansion of the attack surface within the container platform, potentially aiding lateral movement or persistence.

General mitigation guidance

Effective mitigation focuses on ensuring consistent, centralized policy enforcement and narrowing the trust boundary for user-controlled workload definitions:

  • Align access control logic so that the same EndpointSecuritySettings (or equivalent policies) are applied across all container and service creation paths, including Docker Swarm APIs.
  • Implement a single, shared policy enforcement layer that evaluates requested runtime options (privileged mode, capabilities, host namespaces, mounts, sysctls, security profiles) independently of the front-end workflow used.
  • Limit the ability of non-admin users to define or override low-level container runtime options; provide higher-level templates or curated deployment profiles instead.
  • Apply the principle of least privilege to user roles and teams, granting only the minimum necessary permissions for managing services or stacks.
  • Consider defense-in-depth controls at the orchestrator or runtime level (e.g., Docker daemon or Swarm policies, node-level hardening) so that unsafe configurations are rejected even if the management UI misconfigures them.

How teams detect issues like this

Organizations can identify and monitor for this class of issue using a mix of code-level and operational approaches:

  • During code review, verify that all endpoints or workflows capable of launching containers or services call into the same authorization and EndpointSecuritySettings enforcement mechanisms.
  • Use static analysis or policy-as-code checks to flag duplicated logic where security checks appear on one path (e.g., container creation) but not on analogous paths (e.g., service creation or stack deployment).
  • Examine audit logs from Portainer, Docker Swarm, and the container runtime for workloads created by non-admin users that exhibit restricted properties (privileged flag, host PID, sensitive binds, elevated capabilities).
  • Deploy runtime security tooling or daemon-level policies that can alert on or block creation of containers/services with disallowed configurations, independent of the management UI.
  • Periodically test the platform with security-focused functional tests: create workloads as non-admin users and confirm that configured EndpointSecuritySettings are enforced uniformly across all deployment workflows.

Sources

SourceLink
github.comgithub.com/portainer/portainer/security/advisories/GHSA-5fxq-qcf3-244w

Frequently asked

questions

It is exploitable over the network wherever Portainer is exposed, but it requires an authenticated user account with permissions to create Docker Swarm services. It does not allow an unauthenticated remote attacker to deploy workloads directly.

The attacker must be a non-admin (or limited-privilege) user who can log into Portainer and create or manage Swarm services. The vulnerability lets such a user bypass the endpoint restrictions that administrators intended to constrain those permissions.

Ensure that all code paths capable of starting containers or services defer to a single, central policy engine that enforces EndpointSecuritySettings (or equivalent constraints). This means treating the Swarm service API path as logically identical to standard container creation in terms of access control and configuration validation.

Design authorization and policy checks as reusable, mandatory components rather than per-feature logic. Any new workflow that provisions workloads should be required to pass through these shared checks. Complement this with automated tests and policy-as-code rules that validate consistent enforcement across container, service, and stack deployment flows.

Find out what's already
exploitable in your codebase.