/

CVE-2026-34045

Severity:

HIGH RISK

(8.2)

Resource Exhaustion and Information Exposure in Podman

CVE-2026-34045

Modified

Vulnerability type

Category:

Resource Exhaustion and Information Exposure

CWE:

CWE-209, CWE-284, CWE-400, CWE-770

Impact:

Denial of Service and Information Disclosure

Severity:

HIGH RISK

(8.2)

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

An unauthenticated HTTP server in Podman Desktop prior to version 1.26.2 allows network attackers to exhaust system resources and obtain sensitive system details.

By abusing missing connection limits and timeouts, an attacker can trigger denial-of-service conditions, while verbose error messages disclose internal paths and user information that may aid further attacks.

Affected context

This vulnerability affects systems running Podman Desktop where the built-in HTTP server is reachable over a network interface.

It becomes relevant in environments where Podman Desktop is used for container or Kubernetes development and the HTTP service is exposed beyond localhost, especially on multi-user or shared networks.

The risk increases when host-level protections against resource exhaustion (such as limits on file descriptors or connection rates) are weak or absent, and when verbose error reporting is enabled in production-like setups.

Exploit preconditions

  • Attack surface: Network-accessible Podman Desktop HTTP server (no authentication required).
  • Required access: Any network-level reachability (same LAN, VPN, or routed access) to the exposed service port.
  • Trigger point: Repeated or crafted HTTP requests that maintain many open connections and elicit error responses.
  • Why exploitation is possible:
  • Absence of effective connection limits and timeouts allows unbounded consumption of file descriptors and kernel memory.
  • Detailed error responses include internal file paths and system details (such as usernames on Windows), which are returned to unauthenticated clients.

Why this happens

The core issue is a combination of unbounded resource allocation (CWE-400) and overly verbose error handling (CWE-209) in a network-exposed service that lacks sufficient access control (CWE-284).

The HTTP server accepts and maintains client connections without strict limits or aggressive timeouts, allowing attackers to hold many connections open and drive resource usage until the application or host becomes unresponsive.

In parallel, error-handling code returns rich diagnostic messages that include internal file paths and environment-specific details, leaking system information that should be confined to logs or development environments.

Together, these design choices create a service that is both fragile under hostile traffic and unnecessarily transparent about its runtime environment.

Potential impact

  • Application-level denial of service where Podman Desktop crashes or becomes unresponsive.
  • Depletion of system resources (file descriptors, kernel memory) leading to broad host instability or a full system freeze.
  • Exposure of internal filesystem paths and configuration locations.
  • Disclosure of system metadata such as OS details and usernames (particularly on Windows), which can aid privilege escalation or targeted attacks.
  • Improved reconnaissance for attackers planning further exploitation against the host or associated services.

General mitigation guidance

Mitigation generally focuses on controlling resource usage, reducing information exposure, and narrowing the attack surface:

  • Introduce conservative connection-level safeguards:
  • Limit the maximum number of concurrent connections and requests per client.
  • Configure short, reasonable timeouts for idle and incomplete connections.
  • Apply request size and rate limits to avoid resource spikes.
  • Harden error handling behavior:
  • Replace verbose error responses with generic messages that do not reveal filesystem paths, usernames, or detailed stack traces.
  • Restrict detailed diagnostics to server-side logs accessible only to trusted administrators.
  • Reduce unnecessary service exposure:
  • Bind the HTTP server to localhost by default and require explicit configuration to expose it externally.
  • Place the service behind a local proxy, firewall, or equivalent network control that restricts which hosts can reach it.
  • Apply least-privilege and isolation principles:
  • Run desktop services with non-administrative accounts and constrain available system resources where practical (e.g., ulimit, job objects).
  • Use operating system features and containerization to isolate the service and limit blast radius if it is stressed or compromised.

How teams detect issues like this

Effective detection approaches combine proactive analysis with runtime monitoring:

  • Static and configuration analysis:
  • Review HTTP server initialization code for missing connection caps, absent or overly long timeouts, and lack of backpressure mechanisms.
  • Search for error-handling paths that embed internal paths, usernames, environment variables, or stack traces in HTTP responses.
  • Use security linters or SAST tools to flag unbounded loops or allocations tied to client-controlled connections or requests.
  • Code review signals:
  • Network listeners bound to all interfaces (0.0.0.0) in developer tooling or helper services without authentication or IP restrictions.
  • Custom error middleware that serializes exceptions or system state directly to clients.
  • Logging statements duplicated in HTTP responses rather than kept server-side.
  • Runtime and operational monitoring:
  • Track file descriptor counts, memory consumption, and connection counts for the Podman Desktop process to identify abnormal growth patterns.
  • Monitor for suspicious patterns of many simultaneous or long-lived connections from single sources or untrusted networks.
  • Employ network security tools or WAF-like controls to detect and throttle abusive connection behaviors.

Sources

SourceLink
github.comgithub.com/podman-desktop/podman-desktop/security/advisories/GHSA-2q88-39rh-gxvv
access.redhat.comaccess.redhat.com/errata/RHSA-2026:13867
access.redhat.comaccess.redhat.com/security/cve/CVE-2026-34045
bugzilla.redhat.combugzilla.redhat.com/show_bug.cgi?id=2456283
security.access.redhat.comsecurity.access.redhat.com/data/csaf/v2/vex/2026/cve-2026-34045.json

Frequently asked

questions

Yes. As long as the Podman Desktop HTTP server is reachable over the network, an unauthenticated attacker can exploit it remotely without any user interaction.

The attacker only needs network access to the exposed HTTP service port; no credentials, local shell access, or prior foothold on the host are required.

The most robust fix combines strict connection and timeout management, generic error responses that avoid leaking internal details, and limiting service exposure to trusted interfaces or networks by default.

Adopt secure defaults for all auxiliary services (local HTTP servers, developer APIs), enforce resource quotas and timeouts at the application and OS levels, treat error messages as untrusted output that should reveal minimal internal state, and include checks for open management endpoints and verbose errors in regular security reviews and automated testing.

Find out what's already
exploitable in your codebase.