CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-77339

CVE-2026-77339: Unauthenticated Remote Command Execution in Process Compose via DNS Rebinding

Alon Barad
Alon Barad
Software Engineer

Sep 19, 2026·6 min read·33 visits

Executive Summary (TL;DR)

Process Compose before version 1.120.0 lacks Host header, Origin header, and authentication validation on its secondary MCP SSE listener. Remote malicious websites can leverage DNS rebinding to execute arbitrary commands locally on a developer's workstation if control tools are enabled.

CVE-2026-77339 is a critical security vulnerability in Process Compose before version 1.120.0. The Model Context Protocol (MCP) Server-Sent Events (SSE) listener transport subsystem fails to validate the HTTP Host and Origin headers, and does not enforce authentication. This omissions expose local loopback listeners to DNS rebinding attacks orchestrated by malicious remote websites visited by developers, enabling unauthorized process control and arbitrary command execution.

Vulnerability Overview

Process Compose functions as an orchestrator and scheduler for non-containerized applications and development workloads. To facilitate integration with artificial intelligence workflows and administrative tools, the application implements the Model Context Protocol (MCP). This protocol supports bidirectional message exchange using either standard input/output (stdio) or an alternative HTTP-based Server-Sent Events (SSE) transport mechanism.

Prior to version 1.120.0, enabling the MCP SSE transport launched a separate network service that listened on a designated port. This auxiliary service exposed highly critical control capabilities to connected clients. However, this endpoint was implemented outside of the main API gateway, leaving it decoupled from the core application's access control measures.

Because the auxiliary listener processed incoming requests without verifying standard browser protection headers, it presented an exposed interface to local browser contexts. When a developer visits an external untrusted website, client-side scripts running on that site can target the exposed port. By utilizing DNS rebinding techniques, malicious parties can establish an active channel directly to the loopback interface, gaining control of Process Compose operations.

Root Cause Analysis

The root cause of this vulnerability lies in the transport initialization architecture within src/mcp/server.go. When starting the MCP SSE listener, the application spawned a concurrent goroutine running a third-party library's built-in web server. This secondary server did not route through the primary Gin framework engine, effectively bypassing the X-PC-Token-Key validation middleware implemented for standard REST operations.

Furthermore, the listener accepted incoming requests implicitly without evaluating the HTTP Host header. Under normal conditions, the browser's Same-Origin Policy (SOP) blocks cross-origin reading of loopback responses. However, when an attacker configures a malicious domain to rebind to 127.0.0.1, the browser perceives the local service as part of the external origin, circumventing SOP restrictions.

The application also failed to validate the HTTP Origin header. Without explicit CORS configurations or checks to verify that the incoming Origin represents a domestic hostname, the server handled all cross-origin requests. Consequently, any web page opened by the local developer could dispatch arbitrary JSON-RPC actions directly to the local server stream.

Code-Level Analysis and Patch Review

In affected versions of Process Compose, the startSSE method in src/mcp/server.go instantiated the server using a default configuration. The library-provided server lacked built-in middleware for access control and executed without an outer HTTP wrapper:

// Vulnerable implementation in src/mcp/server.go
func (s *Server) startSSE() error {
    // ...
    sseServer := server.NewSSEServer(s.mcpServer)
    go func() {
        // Bypasses all standard token-verification layers
        if err := sseServer.Start(addr); err != nil {
            log.Error().Err(err).Msg("MCP SSE server error")
        }
    }()
    // ...
}

The security patch introduced in version 1.120.0 wraps the sseServer in a custom http.Server configured with a dedicated middleware handler called sseSecurityMiddleware. This middleware acts as a gatekeeper that validates the structural properties of each request before passing control to the underlying handler:

// Patched security middleware in src/mcp/sse_security.go
func (s *Server) sseSecurityMiddleware(next http.Handler) http.Handler {
	trusted := s.trustedHosts()
	token := config.GetApiToken()
 
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		// 1. Host validation (blocks DNS rebinding)
		if !hostAllowed(hostname(r.Host), trusted) {
			reject(w, r, http.StatusForbidden, "untrusted host")
			return
		}
 
		// 2. Origin validation (checks cross-origin requests)
		if origin := r.Header.Get("Origin"); origin != "" {
			u, err := url.Parse(origin)
			if err != nil || !hostAllowed(hostname(u.Host), trusted) {
				reject(w, r, http.StatusForbidden, "untrusted origin")
				return
			}
		}
 
		// 3. Enforce token validation if configured
		if token != "" && !tokenValid(r, token) {
			w.Header().Set("WWW-Authenticate", "Bearer")
			reject(w, r, http.StatusUnauthorized, "invalid or missing token")
			return
		}
 
		next.ServeHTTP(w, r)
	})
}

By ensuring that r.Host is strictly compared against trusted entities, the server rejects requests targeting attacker.com:8081 even if the underlying IP address resolves to 127.0.0.1. In addition, cryptographic token verification prevents unauthorized tools from communicating with the server.

Exploitation Methodology

To execute this attack, the victim must navigate to a malicious web page controlled by the attacker. This page serves a script that schedules background requests back to the source domain. The attacker configures a DNS nameserver with a Time-to-Live (TTL) of zero, ensuring the browser refreshes the address lookup on subsequent requests.

Upon initial resolution, the domain resolves to the attacker's web server, which supplies the payload script. During subsequent execution loops, the custom nameserver changes its response record to point directly to 127.0.0.1 on the port assigned to Process Compose (default 8081). The browser, honoring the original hostname context, allows the JavaScript payload to make cross-origin requests.

Because the vulnerable server is unauthenticated, the rebound JavaScript payload can query /sse to receive real-time streams or POST commands directly. If administrative control parameters are enabled, the payload can trigger command executions, stop local development databases, or extract environment logs containing sensitive tokens and credentials.

Security Impact Assessment

The impact of CVE-2026-77339 varies depending on the active configuration of the Process Compose environment. If control tools are disabled, the attacker is limited to auditing tasks. They can read and search execution logs, exposing configuration details, source code references, and runtime secrets that are printed to stdout or stderr streams.

When expose_control_tools is set to true, the impact escalates to active system disruption. The attacker can stop, restart, scale, or terminate any service orchestrated by Process Compose. This can result in complete workflow denial-of-service, leaving local pipelines non-functional.

If the deployment contains user-defined custom tools, the threat reaches critical levels. Because Process Compose tools run with the privileges of the executing system user, the attacker can use the exposed JSON-RPC boundary to run arbitrary shell commands. This achieves full remote code execution on the developer's workstation.

Remediation and Mitigation

The standard path to remediation is upgrading local installations of Process Compose to version 1.120.0 or later. This version introduces defensive checks that block DNS rebinding attempts. The patch is considered highly effective because it implements validation checks across Host, Origin, and token boundaries.

If upgrading immediately is not possible, security teams should configure the primary application token. Setting the PC_API_TOKEN environment variable ensures that the patched middleware rejects any request lacking an authorization header. This prevents unauthenticated command exploitation even if the Host validation check is bypassed.

Additionally, developers should avoid binding the application's network listeners to the wildcard address 0.0.0.0. Restricting binding rules strictly to local interfaces like 127.0.0.1 reduces external network discoverability. Review your configuration parameters to ensure that expose_control_tools is set to false unless specifically required.

Official Patches

F1bonacc1Fix commit implementing security validation on the MCP SSE handler

Fix Analysis (1)

Technical Appendix

CVSS Score
5.1/ 10
CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:P/VC:L/VI:L/VA:N/SC:L/SI:H/SA:N

Affected Systems

Process Compose prior to v1.120.0

Affected Versions Detail

Product
Affected Versions
Fixed Version
process-compose
F1bonacc1
< 1.120.01.120.0
AttributeDetail
CWE IDCWE-306, CWE-346
Attack VectorNetwork (Requires User Interaction & DNS Rebinding)
CVSS v4.05.1 (Medium)
EPSS ScoreNot yet assigned
ImpactInformation Disclosure, Denial of Service, Remote Code Execution
Exploit StatusPoC / Theoretical
KEV StatusNot in KEV Catalog

MITRE ATT&CK Mapping

T1190Exploit Public-Facing Application
Initial Access
CWE-306
Missing Authentication for Critical Function

The application fails to authenticate critical operations and does not validate request headers to verify appropriate cross-origin restrictions.

References & Sources

  • [1]GitHub Security Advisory GHSA-5gm3-9crp-6g3v
  • [2]Process Compose v1.120.0 Release Notes
  • [3]NVD CVE-2026-77339 Details

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•about 1 hour ago•GHSA-9J25-MM2H-2F76
9.9

CVE-2026-48750: Arbitrary File Write on Host via exec-output Symlink in Canonical LXD and Incus

Canonical LXD and LXC Incus contain an arbitrary file write vulnerability (CWE-73 / CWE-59) in the `/1.0/instances/<name>/exec` REST API endpoint. When an instance is unpacked from an image archive, top-level symbolic links are extracted directly onto the host filesystem within the instance storage directory. If a crafted image includes a symbolic link named `exec-output` pointing to an arbitrary host path, invoking the execution endpoint with `record-output: true` causes the privileged host daemon to follow the symlink and write command output files directly to the target host directory. An authenticated attacker with permissions to import images and execute commands can exploit this flaw to write controlled content to sensitive host directories such as `/etc/cron.d`, resulting in arbitrary code execution on the host as `root`.

Alon Barad
Alon Barad
3 views•12 min read
•about 2 hours ago•GHSA-VGHH-5RFX-XHQ8
9.9

CVE-2026-48749: Arbitrary Host File Read and Write via Malicious Image Symlink in Canonical LXD and Incus

CVE-2026-48749 (tracked as GHSA-vghh-5rfx-xhq8 for LXD and GHSA-2q3f-q5pq-g8wv for Incus) is a critical container escape vulnerability in the Canonical LXD and Linux Containers Incus system container managers. By importing a specially crafted container image archive containing duplicate tar member headers, an authenticated attacker can replace the instance rootfs directory with a symbolic link pointing to the underlying host root filesystem. When performing file operations on a stopped container, the privileged forkfile helper binary resolves the symbolic link without confinement and chroots directly into the host filesystem, granting arbitrary root-level file read and write access.

Amit Schendel
Amit Schendel
3 views•9 min read
•about 3 hours ago•GHSA-FMC8-P6Q7-75CC
9.9

GHSA-fmc8-p6q7-75cc: Argument Injection in Canonical LXD Backup Compression Leads to Host Root Code Execution

GHSA-fmc8-p6q7-75cc (associated with CVE-2026-48755) is a critical argument injection vulnerability in Canonical LXD (github.com/canonical/lxd). The vulnerability occurs during instance and storage volume backup operations when processing the user-supplied compression_algorithm configuration parameter. While LXD validates the primary executable token against an allowlist of supported compression binaries, it fails to sanitize or restrict subsequent tokens parsed via shellquote.Split. These additional arguments are passed directly to exec.Command. An authenticated attacker with privileges to trigger backups can inject command-line flags for utilities like zstd to read staged files from a container filesystem and write them to arbitrary paths on the underlying host filesystem, such as /etc/cron.d/, achieving root-level arbitrary code execution on the host.

Amit Schendel
Amit Schendel
6 views•10 min read
•about 4 hours ago•GHSA-PJFF-C2WC-F6JM
9.9

CVE-2026-48769: Arbitrary File Write and Remote Code Execution via Trusted Image Hash in Canonical LXD and Linux Containers Incus

A critical path traversal vulnerability caused by improper input validation (CWE-20) exists in the direct image download handler of Canonical LXD and Linux Containers Incus. When an authenticated user requests an image import using the URL source type, the daemon reads the image fingerprint from an untrusted HTTP response header (`Incus-Image-Hash` or `LXD-Image-Hash`) without validating that it conforms to a SHA-256 format. This unvalidated string is concatenated directly into a filesystem path via `filepath.Join` prior to file creation and cryptographic verification, allowing directory traversal sequences to write arbitrary files on the host filesystem as root.

Alon Barad
Alon Barad
7 views•10 min read
•about 8 hours ago•CVE-2026-9639
6.5

CVE-2026-9639: Authenticated Denial of Service via Nil-Pointer Dereference in Canonical LXD Custom Volume Backup Import

CVE-2026-9639 (GHSA-j93m-3j9p-m5m8) is a null pointer dereference vulnerability in Canonical LXD affecting versions 5.0.0 through 5.21.4 and 6.0 through 6.8. The flaw resides in the (*lxdBackend).CreateCustomVolumeFromBackup method within lxd/storage/backend_lxd.go. An authenticated attacker with the can_create_storage_volumes permission can upload a crafted custom volume backup tarball that omits the expires_at field on a snapshot entry, triggering an unhandled SIGSEGV panic and terminating the LXD daemon.

Amit Schendel
Amit Schendel
7 views•9 min read
•about 9 hours ago•CVE-2026-33050
8.8

CVE-2026-33050: OS Command Injection in GeoNode Vector Upload Handler

An operating system command injection vulnerability (CWE-78) exists in GeoNode versions prior to 5.1.0. The vulnerability occurs in the vector upload processing pipeline when handling user-supplied geospatial files. By supplying a crafted layer name containing shell metacharacters, an authenticated attacker with basic data upload privileges can execute arbitrary commands on the underlying server or container hosting the GeoNode application and Celery worker processes.

Alon Barad
Alon Barad
6 views•9 min read