---METADATA---
VENDOR: Toowiredd
PRODUCT: chatgpt-mcp-server
AFFECTED_VERSIONS: See vendor advisory for specific affected versions
---END_METADATA---

Description Summary:
A security weakness has been identified in the Toowiredd chatgpt-mcp-server, potentially allowing unauthorized access or service disruption.

Executive Summary:
A vulnerability in the Toowiredd chatgpt-mcp-server requires immediate attention as it may expose the application to unauthorized interactions or service instability.

Vulnerability Details

CVE-ID: CVE-2026-7061

Affected Software: Toowiredd chatgpt-mcp-server

Affected Versions: See vendor advisory for specific affected versions

Vulnerability: A generic security weakness exists in the server software. While technical specifics are currently limited, such vulnerabilities typically involve improper input validation or insecure handling of server-side requests.

Business Impact

The CVSS score of 7.3 indicates a high severity level. Exploitation could lead to unauthorized access to the ChatGPT-MCP integration, potentially resulting in data leakage or the manipulation of AI-driven workflows, which could disrupt business processes and compromise the integrity of automated outputs.

Remediation Plan

Immediate Action: Check the vendor’s official documentation for the latest release and apply security updates immediately.

Proactive Monitoring: Review application logs for unusual request patterns or unauthorized authentication attempts directed toward the MCP server.

Compensating Controls: Restrict network access to the server to only authorized users and services using firewall rules and VPC access controls.

Exploitation Status

Public Exploit Available: false

Analyst Notes: As of April 27, 2026, there is no public information indicating active exploitation of this vulnerability. However, due to the nature of the software, the potential for exploitation is high and should be addressed proactively.

Analyst Recommendation

Organizations utilizing the Toowiredd chatgpt-mcp-server should prioritize identifying their current version and applying the latest available security patches. Given the potential for service disruption or data exposure, maintain a high level of vigilance and monitor logs for any signs of anomalous activity.

---METADATA---
VENDOR: Docker
PRODUCT: Docker Desktop
AFFECTED_VERSIONS: See vendor advisory for specific affected versions
CONFIDENCE: high
MISSING: versions, patch
---END_METADATA---

Description Summary:
The Docker CLI --use-api-socket flag allows for the bypass of Enhanced Container Isolation (ECI) restrictions in Docker Desktop.

Executive Summary:
The Docker CLI contains a security flaw that permits the bypass of critical container isolation protections in Docker Desktop, increasing the risk of container escape.

Vulnerability Details

CVE-ID: CVE-2026-6406

Affected Software: Docker Desktop

Affected Versions: See vendor advisory for specific affected versions

Vulnerability: This vulnerability involves an improper restriction of operations when using the --use-api-socket flag within the Docker CLI. This bypasses Enhanced Container Isolation (ECI) protections, potentially allowing a user to break out of expected container security boundaries.

Business Impact

Bypassing ECI restrictions undermines the security of containerized environments, potentially allowing malicious actors to gain unauthorized access to the host system or interact with other containers. With a CVSS score of 8.8, this flaw represents a significant risk to the security posture of any organization utilizing Docker Desktop for development or testing.

Remediation Plan

Immediate Action: Update Docker Desktop to the latest version and ensure that all CLI tools are patched to incorporate the necessary security restrictions.

Proactive Monitoring: Audit container configuration files and monitor for unauthorized usage of the --use-api-socket flag in deployment scripts.

Compensating Controls: Restrict access to the Docker socket and enforce strict user permissions for individuals with access to the Docker CLI.

Exploitation Status

Public Exploit Available: false

Analyst Notes: As of May 30, 2026, there is no public information indicating active exploitation of this vulnerability. However, due to the nature of the flaw, the potential for exploitation is high.

Analyst Recommendation

Container isolation is a fundamental security control; therefore, this vulnerability must be addressed with high urgency. Organizations should audit their Docker configurations and apply the vendor-provided updates immediately to restore the integrity of their container environment.

---METADATA---
VENDOR: Gitea
PRODUCT: act_runner
AFFECTED_VERSIONS: act versions through 0.262.0
---END_METADATA---

Description Summary:
A container escape vulnerability in Gitea act_runner allows authenticated users to gain root access to the host machine by manipulating container options.

Executive Summary:
The Gitea act_runner Docker backend is vulnerable to a critical container escape flaw that permits an authenticated user to achieve root-level execution on the host system.

Vulnerability Details

CVE-ID: CVE-2026-58053

Affected Software: Gitea act_runner

Affected Versions: act versions through 0.262.0

Vulnerability: This is a container escape vulnerability where the runner fails to properly sanitize Docker container.options. An authenticated user capable of triggering a workflow can inject host-level flags, effectively bypassing security restrictions.

Business Impact

A successful exploit grants an attacker full root access to the underlying runner host, which may contain sensitive CI/CD secrets, source code, and credentials. Given the CVSS score of 9.9, this vulnerability represents a critical risk of total infrastructure compromise, potentially leading to supply chain attacks or lateral movement within the production environment.

Remediation Plan

Immediate Action: Update Gitea act_runner to the latest version immediately to ensure container configuration options are properly validated.

Proactive Monitoring: Review CI/CD pipeline logs for suspicious workflow submissions or unusual container configuration strings that attempt to utilize host namespaces.

Compensating Controls: Restrict the ability to execute workflows on Docker-backed runners to trusted users only and implement strict network segmentation for all runner hosts.

Exploitation Status

Public Exploit Available: Unknown

Analyst Notes: As of Jun 27, 2026, there is no public information indicating active exploitation of this vulnerability. However, due to the nature of the flaw allowing root-level host access, the potential for exploitation is extremely high.

Analyst Recommendation

The severity of this flaw necessitates immediate attention. Organizations utilizing Gitea act_runner must prioritize patching to prevent unauthorized host access. Failure to address this vulnerability could lead to the complete compromise of the build environment and the exposure of sensitive development assets.

---METADATA---
VENDOR: Unclecode
PRODUCT: Crawl4ai
AFFECTED_VERSIONS: < 0.9.0
CONFIDENCE: high
MISSING: none
---END_METADATA---

Description Summary:
Crawl4ai is vulnerable to command injection via the Docker API, allowing unauthenticated attackers to execute arbitrary commands on the host by injecting malicious Chromium launch arguments.

Executive Summary:
A critical command injection vulnerability in Crawl4ai allows unauthenticated remote attackers to execute arbitrary code on the host system, resulting in total system compromise.

Vulnerability Details

CVE-ID: CVE-2026-57572

Affected Software: Unclecode Crawl4ai

Affected Versions: < 0.9.0

Vulnerability: The vulnerability arises because the Docker API improperly sanitizes the browser_config.extra_args parameter. An unauthenticated attacker can inject malicious Chromium switches, including --no-zygote, to redirect process execution and run arbitrary commands as the container runtime user.

Business Impact

Given the CVSS score of 10.0, this is a critical vulnerability that allows complete, unauthenticated control over the host system. Successful exploitation could lead to full data loss, complete system compromise, and the potential for the server to be used as a pivot point into the internal network, causing catastrophic reputational and operational damage.

Remediation Plan

Immediate Action: Update Crawl4ai to version 0.9.0 or later immediately to patch the Docker API input validation.

Proactive Monitoring: Monitor for suspicious processes spawning from the Crawl4ai container and review Docker API traffic for abnormal requests containing unexpected browser configuration arguments.

Compensating Controls: Ensure the container is running with minimal privileges and use a Web Application Firewall (WAF) or network policy to restrict access to the Docker API port to authorized management hosts only.

Exploitation Status

Public Exploit Available: False

Analyst Notes: As of Jul 6, 2026, there is no public information indicating active exploitation of this vulnerability. However, due to the nature of the flaw, the potential for exploitation is high.

Analyst Recommendation

This vulnerability is of the highest severity and requires immediate attention. Because the service is unauthenticated by default and the vulnerability allows for remote command execution, any exposed Crawl4ai instances should be isolated from the internet until the patch to version 0.9.0 is successfully applied.

---METADATA---
VENDOR: Crawl4AI
PRODUCT: Crawl4AI
AFFECTED_VERSIONS: Before 0.8.7
---END_METADATA---

Description Summary:
Crawl4AI versions before 0.8.7 contain an authentication bypass vulnerability due to a hardcoded JWT signing key in the Docker API server.

Executive Summary:
A critical authentication bypass in the Crawl4AI Docker API server allows unauthenticated attackers to gain full administrative access by forging valid authentication tokens.

Vulnerability Details

CVE-ID: CVE-2026-56265

Affected Software: Crawl4AI Crawl4AI

Affected Versions: Before 0.8.7

Vulnerability: This vulnerability stems from the use of a hardcoded default JWT signing key within the Docker API server. An unauthenticated attacker can leverage this known key to forge authentication tokens, effectively bypassing all authentication controls and gaining full access to the API.

Business Impact

With a CVSS score of 9.8, this flaw is extremely critical. An attacker can gain complete control over the Crawl4AI instance, leading to unauthorized data access, potential system manipulation, and exploitation of the underlying host environment.

Remediation Plan

Immediate Action: Upgrade to Crawl4AI version 0.8.7 or later to remove the hardcoded key and enforce secure token management.

Proactive Monitoring: Monitor API access logs for anomalous authentication patterns or tokens that do not correlate with known user activity.

Compensating Controls: Ensure that the Crawl4AI Docker API is not exposed to the public internet and restrict access to the API port via network-level firewalls.

Exploitation Status

Public Exploit Available: False

Analyst Notes: As of Jun 21, 2026, there is no public information indicating active exploitation of this vulnerability. However, due to the nature of the flaw, the potential for exploitation is high.

Analyst Recommendation

The presence of a hardcoded signing key constitutes a severe security failure. Organizations must treat this as a high-priority incident and deploy the latest version of Crawl4AI immediately to remediate the authentication bypass risk.

---METADATA---
VENDOR: Kestra
PRODUCT: Kestra
AFFECTED_VERSIONS: Prior to 1.0.45 and 1.3.21
---END_METADATA---

Description Summary:
An authentication bypass vulnerability in Kestra allows unauthenticated attackers to execute arbitrary code as root by manipulating API requests.

Executive Summary:
A critical authentication bypass in Kestra allows unauthenticated attackers to achieve root-level code execution, leading to full host compromise via the Docker daemon.

Vulnerability Details

CVE-ID: CVE-2026-53576

Affected Software: Kestra Kestra

Affected Versions: Prior to 1.0.45 and 1.3.21

Vulnerability: The REST API authentication filter incorrectly processes paths ending in "/configs," allowing an unauthenticated caller to bypass Basic-Auth. This enables the caller to trigger unauthorized flows that execute tasks as root within the container, which can subsequently escape to the host via the mounted Docker socket.

Business Impact

The CVSS score of 10.0 highlights the extreme severity of this flaw. By bypassing authentication, an attacker gains full control over the orchestration platform and the underlying host server, resulting in complete loss of confidentiality, integrity, and availability of all managed infrastructure.

Remediation Plan

Immediate Action: Upgrade to Kestra version 1.0.45 or 1.3.21 immediately to fix the authentication logic flaw.

Proactive Monitoring: Audit logs for unauthorized API access attempts and monitor for unexpected execution of Shell or Process tasks within Kestra containers.

Compensating Controls: Restrict network access to the Kestra API via firewall rules and ensure the Docker socket is not exposed to the container unless strictly necessary.

Exploitation Status

Public Exploit Available: Unknown

Analyst Notes: As of Jun 26, 2026, there is no public information indicating active exploitation of this vulnerability. However, due to the nature of the flaw, the potential for exploitation is high.

Analyst Recommendation

This is a critical vulnerability that provides a direct path to host-level compromise. Organizations using Kestra must prioritize the immediate application of the security update to prevent unauthenticated attackers from gaining root access to their orchestration environment and host servers.

---METADATA---
VENDOR: containerd
PRODUCT: containerd
AFFECTED_VERSIONS: Prior to 1.7.33, 2.3.2, 2.2.5, 2.1.9, and 2.0.10
---END_METADATA---

Description Summary:
Containerd fails to validate image configuration labels, potentially allowing attackers to execute arbitrary commands on the host system.

Executive Summary:
A critical vulnerability in containerd allows malicious image labels to trigger arbitrary command execution on the host, threatening the security of the entire containerized environment.

Vulnerability Details

CVE-ID: CVE-2026-53488

Affected Software: containerd

Affected Versions: Prior to 1.7.33, 2.3.2, 2.2.5, 2.1.9, and 2.0.10

Vulnerability: The CRI plugin in containerd propagates image labels from a Dockerfile directly to the container runtime without adequate validation. If a secondary plugin or component consumes these labels to perform operations, an attacker can craft malicious labels to break out of the container boundary and execute commands on the host.

Business Impact

With a CVSS score of 9.4, this flaw poses an extreme risk to multi-tenant or shared-hosting container environments. Exploitation allows for container escape, resulting in full host compromise, cross-container data access, and the potential to disrupt all workloads running on the affected node.

Remediation Plan

Immediate Action: Update containerd to the patched versions (1.7.33, 2.3.2, 2.2.5, 2.1.9, or 2.0.10) immediately.

Proactive Monitoring: Review container image registry logs for unusual LABEL instructions and monitor host system logs for unexpected process execution originating from container runtimes.

Compensating Controls: Implement strict image signing and validation policies (e.g., Notary/Cosign) to ensure that only trusted images are deployed and to prevent the injection of malicious labels.

Exploitation Status

Public Exploit Available: No

Analyst Notes: As of Jun 30, 2026, there is no public information indicating active exploitation of this vulnerability. However, due to the nature of the flaw, the potential for exploitation is high.

Analyst Recommendation

Container escape vulnerabilities are high-value targets for attackers. It is imperative that all container hosts be updated to the specified versions to prevent host-level compromise. Organizations should also audit their container build pipelines to ensure that only authorized images are permitted for deployment.

---METADATA---
VENDOR: vm2
PRODUCT: vm2
AFFECTED_VERSIONS: vm2 prior to version 3.11.4, or versions <= 3.11.3.
---END_METADATA---

Description Summary:
A sandbox breakout vulnerability in vm2 allows unauthenticated attackers to execute arbitrary commands on the host system via promise manipulation.

Executive Summary:
A critical sandbox breakout in vm2 (versions <= 3.11.3) allows unauthenticated attackers to achieve arbitrary command execution on the host system.

Vulnerability Details

CVE-ID: CVE-2026-47208

Affected Software: vm2 (vm2)

Affected Versions: vm2 prior to version 3.11.4, or versions <= 3.11.3.

Vulnerability: This is a sandbox breakout vulnerability resulting from improper handling of the localPromise constructor. Attackers can supply a custom reject method that triggers a breakout, allowing them to escape the sandbox and execute commands with the privileges of the host process.

Business Impact

The capability to escape the sandbox and execute arbitrary commands on the host machine is a catastrophic security failure. Given the CVSS score of 10.0, this vulnerability provides a direct path for attackers to gain full control over the host system, leading to total data loss, system destruction, or deep-seated persistent access.

Remediation Plan

Immediate Action: Update the vm2 library to version 3.11.4 immediately to patch the promise handling logic.

Proactive Monitoring: Monitor host systems for unexpected shell command executions or child processes being spawned by the Node.js application process.

Compensating Controls: Use container isolation technologies (like Docker or Kubernetes security contexts) to restrict the potential damage if the sandbox is breached.

Exploitation Status

Public Exploit Available: True

Analyst Notes: As of Jun 12, 2026, public exploit code is available for this vulnerability. The combination of high impact and available exploit code makes this a top-priority remediation item.

Analyst Recommendation

The risk posed by this sandbox escape is extreme. Security teams should treat this as an urgent priority; the availability of functional exploit code necessitates immediate patching to mitigate the risk of host-level command execution.

---METADATA---
VENDOR: GetArcaneApp
PRODUCT: Arcane
AFFECTED_VERSIONS: < 1.19.2
CONFIDENCE: high
MISSING: patch
---END_METADATA---

Description Summary:
Arcane, an interface for managing Docker containers, suffers from a missing authorization vulnerability that could allow unauthorized access to container management functions.

Executive Summary:
A missing authorization vulnerability in the Arcane management interface exposes container infrastructure to unauthorized administrative actions.

Vulnerability Details

CVE-ID: CVE-2026-47125

Affected Software: GetArcaneApp Arcane

Affected Versions: < 1.19.2

Vulnerability: The application is susceptible to CWE-862 (Missing Authorization), where the software performs an action without verifying if the user has the required permissions. This vulnerability allows an attacker to perform unauthorized operations within the container management environment.

Business Impact

Successful exploitation allows an unauthorized party to manipulate container images, networks, and volumes, potentially leading to full system compromise or service disruption. With a CVSS score of 8.8, this vulnerability represents a high risk to the availability and integrity of the underlying infrastructure.

Remediation Plan

Immediate Action: Upgrade to Arcane version 1.19.2 or later immediately to resolve the authorization gap.

Proactive Monitoring: Audit access logs for unusual administrative activity or unauthorized attempts to access container management endpoints.

Compensating Controls: Implement strict network access control lists (ACLs) to restrict access to the Arcane interface to authorized management IP addresses only.

Exploitation Status

Public Exploit Available: false

Analyst Notes: As of May 30, 2026, there is no public information indicating active exploitation of this vulnerability. However, due to the nature of the flaw, the potential for exploitation is high.

Analyst Recommendation

The severity of this flaw necessitates immediate attention. Administrators must prioritize updating the Arcane application to the latest version to prevent unauthorized container orchestration and potential lateral movement within the environment.

---METADATA---
VENDOR: OpenProject
PRODUCT: OpenProject
AFFECTED_VERSIONS: All versions prior to the patch
---END_METADATA---

Description Summary:
A default, insecure secret key configuration in the official OpenProject Docker image allows authenticated users to achieve remote code execution via Marshal-deserialization of cookies.

Executive Summary:
A critical security misconfiguration in the official OpenProject Docker image exposes users to remote code execution due to the use of a predictable, default Rails master key.

Vulnerability Details

CVE-ID: CVE-2026-46386

Affected Software: OpenProject

Affected Versions: All versions using the vulnerable default Docker image configuration

Vulnerability: The official Docker image ships with a default Rails secret key (SECRET_KEY_BASE=OVERWRITE_ME), which allows authenticated users to forge cookies. Because the application uses :marshal for cookie serialization, this allows an attacker to trigger arbitrary code execution during the deserialization process.

Business Impact

This vulnerability carries a CVSS score of 9.9, reflecting the extreme risk of total system compromise. By leveraging this flaw, an authenticated user can execute arbitrary code on the server hosting the OpenProject application. This grants the attacker full control over the project management environment, facilitating lateral movement, data theft, or complete system takeover.

Remediation Plan

Immediate Action: Update to the latest version of OpenProject and ensure the SECRET_KEY_BASE environment variable is changed to a strong, unique, and securely generated secret.

Proactive Monitoring: Monitor server logs for signs of anomalous process execution or unexpected system-level changes originating from the OpenProject container.

Compensating Controls: Restrict access to the OpenProject instance to trusted networks only and ensure that the application is running with the least privilege necessary within the container environment.

Exploitation Status

Public Exploit Available: No

Analyst Notes: As of Jun 26, 2026, there is no public information indicating active exploitation of this vulnerability. However, the presence of a hardcoded, publicly known default secret key makes this an attractive target for attackers, and the risk of exploitation remains critical.

Analyst Recommendation

The reliance on a default, predictable secret key in a production-ready Docker image is a significant security failure. Administrators must immediately rotate their secret keys and update their deployment configurations to ensure the environment is secured against this deserialization attack vector.

---METADATA---
VENDOR: Dokploy
PRODUCT: PaaS
AFFECTED_VERSIONS: 0.29.1 and earlier
---END_METADATA---

Description Summary:
Dokploy contains a command injection vulnerability in its Docker file upload functionality that allows authenticated users to execute arbitrary OS commands.

Executive Summary:
A critical command injection vulnerability in Dokploy allows authenticated users to execute arbitrary OS commands on the host by manipulating file upload paths.

Vulnerability Details

CVE-ID: CVE-2026-45663

Affected Software: Dokploy PaaS

Affected Versions: 0.29.1 and earlier

Vulnerability: The application fails to sanitize the destinationPath parameter during Docker file uploads, instead interpolating it directly into a shell command. An authenticated attacker can inject shell metacharacters (e.g., ;, ") to break out of the intended docker cp command and execute arbitrary commands on the host operating system.

Business Impact

With a CVSS score of 9.9, this vulnerability allows for total host compromise. An authenticated attacker can gain full control over the server hosting the Dokploy PaaS, potentially leading to unauthorized data access, service disruption, or further exploitation of the internal infrastructure.

Remediation Plan

Immediate Action: Upgrade Dokploy to the latest version immediately to resolve the improper parameter sanitization.

Proactive Monitoring: Monitor system logs for unexpected shell execution patterns or unauthorized changes to system files originating from the Dokploy service user.

Compensating Controls: Implement strict file path validation and limit the permissions of the user account running the Dokploy service to the minimum necessary to perform its functions.

Exploitation Status

Public Exploit Available: No data available.

Analyst Notes: As of May 29, 2026, there is no public information indicating active exploitation of this vulnerability. However, due to the nature of the flaw, the potential for exploitation is high.

Analyst Recommendation

This vulnerability represents a significant breach of isolation between the user and the host system. All organizations using Dokploy must patch immediately and audit their environments for any signs of unauthorized access or malicious command execution.

---METADATA---
VENDOR: Dokploy
PRODUCT: Dokploy (PaaS)
AFFECTED_VERSIONS: See vendor advisory for specific affected versions
CONFIDENCE: low
MISSING: versions, patch, technical_details
---END_METADATA---

Description Summary:
Dokploy, a self-hostable Platform as a Service (PaaS), is affected by a critical vulnerability that may allow unauthorized access or administrative control.

Executive Summary:
A critical security vulnerability in the Dokploy PaaS platform poses a significant risk of unauthorized system access and potential compromise.

Vulnerability Details

CVE-ID: CVE-2026-45662

Affected Software: Dokploy PaaS

Affected Versions: See vendor advisory for specific affected versions

Vulnerability: The specific nature of this vulnerability is currently under-disclosed, but the high CVSS score suggests a flaw in authentication or authorization mechanisms within the PaaS environment.

Business Impact

As a Platform as a Service, a compromise of Dokploy could grant an attacker control over all hosted applications and their associated data. The 8.8 CVSS score reflects the high potential for total system takeover and the resulting catastrophic business impact.

Remediation Plan

Immediate Action: Review the official Dokploy security advisories and apply the latest available patches or version upgrades.

Proactive Monitoring: Monitor platform logs for unauthorized administrative logins and verify the integrity of deployed container configurations.

Compensating Controls: Utilize a Web Application Firewall (WAF) to filter malicious traffic and restrict exposure of the Dokploy dashboard to the public internet.

Exploitation Status

Public Exploit Available: false

Analyst Notes: As of May 30, 2026, there is no public information indicating active exploitation of this vulnerability. However, due to the nature of the flaw, the potential for exploitation is high.

Analyst Recommendation

Given the lack of granular technical detail, administrators should treat this vulnerability with high urgency. Immediately audit the Dokploy installation and apply any vendor-provided security updates to mitigate the risk of unauthorized platform access.

---METADATA---
VENDOR: Dokploy
PRODUCT: PaaS
AFFECTED_VERSIONS: 0.26.6 and earlier
---END_METADATA---

Description Summary:
Dokploy contains a command injection vulnerability in the /docker-container-logs WebSocket endpoint that allows authenticated users to execute arbitrary commands with root privileges.

Executive Summary:
A command injection vulnerability in Dokploy allows authenticated users to achieve root-level remote code execution.

Vulnerability Details

CVE-ID: CVE-2026-45633

Affected Software: Dokploy PaaS

Affected Versions: 0.26.6 and earlier

Vulnerability: The vulnerability exists in the /docker-container-logs WebSocket endpoint where the 'tail' and 'since' parameters are improperly validated before being concatenated into shell commands. This allows an authenticated user to escape the intended functionality and execute arbitrary commands with root privileges on the host system.

Business Impact

The exploitation of this vulnerability carries a CVSS score of 9.9, indicating a critical risk to the confidentiality, integrity, and availability of the hosting environment. Successful exploitation grants an attacker full root-level control over the server, facilitating complete system compromise, data theft, or the deployment of persistent backdoors.

Remediation Plan

Immediate Action: Upgrade Dokploy to version 0.26.7 or later immediately.

Proactive Monitoring: Audit WebSocket traffic logs for unusual 'tail' or 'since' parameter values and monitor system logs for unexpected shell process spawning.

Compensating Controls: Implement strict network access controls to limit access to the Dokploy management interface to trusted administrative IP addresses.

Exploitation Status

Public Exploit Available: None

Analyst Notes: As of May 29, 2026, there is no public information indicating active exploitation of this vulnerability. However, due to the nature of the flaw, the potential for exploitation is high.

Analyst Recommendation

Given the critical severity of this vulnerability, immediate patching is required to prevent unauthorized root-level access. Organizations utilizing Dokploy must prioritize upgrading to version 0.26.7 to eliminate the command injection vector.

---METADATA---
VENDOR: Dozzle
PRODUCT: Dozzle
AFFECTED_VERSIONS: See vendor advisory for specific affected versions
CONFIDENCE: low
MISSING: versions, patch, technical_details
---END_METADATA---

Description Summary:
Dozzle, a realtime log viewer for Docker containers, contains a security vulnerability requiring immediate attention.

Executive Summary:
A high-severity vulnerability in the Dozzle log viewer for Docker containers poses a significant risk to containerized infrastructure security.

Vulnerability Details

CVE-ID: CVE-2026-45298

Affected Software: Dozzle

Affected Versions: See vendor advisory for specific affected versions

Vulnerability: The specific technical nature of this vulnerability is currently underspecified in available documentation. Further analysis is required to determine the authentication requirements and the specific attack vector targeting the log viewing functionality.

Business Impact

With a CVSS score of 8.6, this vulnerability is categorized as High severity. Exploitation could potentially allow unauthorized access to sensitive application logs, leading to the exposure of credentials, environment variables, or other proprietary data stored within container streams, resulting in severe reputational and operational damage.

Remediation Plan

Immediate Action: Consult the official Dozzle project repository or vendor security advisories to identify and apply the latest security patches.

Proactive Monitoring: Review container access logs for anomalous request patterns or unauthorized attempts to access the log viewer interface.

Compensating Controls: Implement network-level restrictions or authentication proxies to limit access to the Dozzle interface to trusted internal networks only.

Exploitation Status

Public Exploit Available: false

Analyst Notes: As of May 29, 2026, there is no public information indicating active exploitation of this vulnerability. However, due to the nature of the flaw, the potential for exploitation is high.

Analyst Recommendation

Given the High severity score, organizations utilizing Dozzle should treat this as a priority update. Administrators must verify their current deployment version against the vendor’s security advisory and apply the necessary patches as soon as they become available to mitigate the risk of unauthorized log exposure.

---METADATA---
VENDOR: Portainer
PRODUCT: Portainer Community Edition
AFFECTED_VERSIONS: See vendor advisory for specific affected versions
CONFIDENCE: low
MISSING: versions, patch, exploit_status, technical_details
---END_METADATA---

Description Summary:
A security vulnerability exists in Portainer Community Edition, a management platform for containerized environments including Docker, Swarm, and Kubernetes.

Executive Summary:
Portainer Community Edition is affected by a critical security vulnerability that could allow unauthorized management of containerized infrastructure.

Vulnerability Details

CVE-ID: CVE-2026-44850

Affected Software: Portainer Portainer Community Edition

Affected Versions: See vendor advisory for specific affected versions

Vulnerability: The specific vulnerability type is not detailed in the source, but the product manages highly privileged container environments. Any flaw in this interface could potentially lead to unauthorized access or control over the underlying host or orchestration layer.

Business Impact

Exploitation of this vulnerability could grant an attacker full control over containerized applications and the host infrastructure, leading to data exfiltration or total system compromise. The CVSS score of 8.5 underscores the critical nature of this risk to business operations and cloud-native security.

Remediation Plan

Immediate Action: Update Portainer Community Edition to the latest stable release provided by the vendor to address the security flaw.

Proactive Monitoring: Analyze Portainer access logs for suspicious administrative activity or attempts to access containers without proper authorization.

Compensating Controls: Restrict network access to the Portainer management interface using a VPN or firewall rules, ensuring it is not reachable from the public internet.

Exploitation Status

Public Exploit Available: false

Analyst Notes: As of May 29, 2026, there is no public information indicating active exploitation of this vulnerability. Given the high level of access provided by the platform, the risk of exploitation is severe.

Analyst Recommendation

Due to the critical nature of the management interface, administrators should treat this vulnerability with extreme urgency. Apply the necessary patches immediately and review the security configuration of all managed Docker, Swarm, and Kubernetes environments to ensure least-privilege access is enforced.

---METADATA---
VENDOR: Docker
PRODUCT: Portainer Community Edition / Swarm
AFFECTED_VERSIONS: Portainer Community Edition from 2.33.0 to before 2.33.8, 2.39.0 to before 2.39.2, and 2.40.0 to before 2.41.0
---END_METADATA---

Description Summary:
A security bypass in Portainer allows non-admin users with access to a Docker Swarm endpoint to create or update services with elevated privileges.

Executive Summary:
A critical vulnerability in Portainer Community Edition allows non-admin users to bypass security settings, potentially gaining root-level control over the host system via Docker Swarm.

Vulnerability Details

CVE-ID: CVE-2026-44849

Affected Software: Docker / Portainer Community Edition (Swarm service)

Affected Versions: Portainer Community Edition from 2.33.0 to before 2.33.8, 2.39.0 to before 2.39.2, and 2.40.0 to before 2.41.0

Vulnerability: This vulnerability allows a non-admin user with access to a Docker Swarm endpoint to bypass security controls. By manipulating the creation or update process of Swarm services, an attacker can gain elevated privileges and potentially control the host system.

Business Impact

With a CVSS score of 8.8, this flaw presents a high risk of host-level compromise. An attacker could leverage this to gain root access to the host, leading to full system takeover, data theft, and the disruption of containerized applications, causing significant reputational and operational damage.

Remediation Plan

Immediate Action: Update Portainer Community Edition to versions 2.33.8, 2.39.2, or 2.41.0 immediately.

Proactive Monitoring: Monitor Swarm service creation/update logs for anomalous activity originating from non-admin accounts.

Compensating Controls: Restrict access to the Portainer interface and Docker Swarm endpoints to verified administrative users only.

Exploitation Status

Public Exploit Available: true

Analyst Notes: As of June 2, 2026, public Proof-of-Concept (PoC) exploits are available for this vulnerability, significantly increasing the risk of active exploitation.

Analyst Recommendation

This vulnerability, combined with public exploit availability, necessitates an immediate response. Organizations should prioritize patching their Portainer installations to prevent attackers from escalating privileges and gaining control over their containerized environments and underlying infrastructure.

---METADATA---
VENDOR: Docker
PRODUCT: Portainer Community Edition
AFFECTED_VERSIONS: Portainer Community Edition from 2.33.0 to before 2.33.8, 2.39.0 to before 2.39.2, and 2.40.0 to before 2.41.0
---END_METADATA---

Description Summary:
A critical flaw in Portainer's RBAC layer allows non-admin users with Docker endpoint access to execute privileged operations directly against the Docker daemon.

Executive Summary:
A critical vulnerability in Portainer Community Edition permits non-admin users to escalate privileges to host root code execution via direct interaction with the Docker daemon.

Vulnerability Details

CVE-ID: CVE-2026-44848

Affected Software: Docker / Portainer Community Edition

Affected Versions: Portainer Community Edition from 2.33.0 to before 2.33.8, 2.39.0 to before 2.39.2, and 2.40.0 to before 2.41.0

Vulnerability: This vulnerability resides in the Role-Based Access Control (RBAC) layer. It allows a non-admin user who has access to a Docker endpoint to bypass security checks and call privileged plugin operations directly against the underlying Docker daemon.

Business Impact

Assigned a CVSS score of 8.8, this vulnerability is extremely dangerous as it enables host-level root code execution. A successful exploit could lead to complete system compromise, unauthorized access to all containerized data, and lateral movement within the environment, resulting in catastrophic business impact.

Remediation Plan

Immediate Action: Update Portainer Community Edition to versions 2.33.8, 2.39.2, or 2.41.0 immediately.

Proactive Monitoring: Monitor Docker daemon logs and Portainer audit logs for suspicious API calls or unauthorized plugin management activities.

Compensating Controls: Implement the principle of least privilege by restricting user access to Docker endpoints and utilizing host-based intrusion detection systems.

Exploitation Status

Public Exploit Available: true

Analyst Notes: As of June 2, 2026, public Proof-of-Concept (PoC) exploits are available for this vulnerability, significantly increasing the risk of active exploitation.

Analyst Recommendation

Given the availability of public exploits and the severity of root-level code execution, this patch should be treated as an emergency. Administrators must apply the recommended updates immediately to prevent attackers from gaining full control over the container infrastructure and the underlying host.

---METADATA---
VENDOR: BentoML
PRODUCT: BentoML
AFFECTED_VERSIONS: See vendor advisory for specific affected versions
CONFIDENCE: low
MISSING: versions, patch, technical_details
---END_METADATA---

Description Summary:
A security vulnerability impacts the BentoML Python library, which is used for building online serving systems for AI applications and model inference.

Executive Summary:
The BentoML framework for AI model serving is affected by a vulnerability that could potentially expose systems hosting sensitive machine learning inference models.

Vulnerability Details

CVE-ID: CVE-2026-44346

Affected Software: BentoML

Affected Versions: See vendor advisory for specific affected versions

Vulnerability: The vulnerability resides within the BentoML library, a toolset designed for model serving and AI inference. The specific technical details regarding the vulnerable component or authentication requirements are currently unconfirmed.

Business Impact

Exploitation of AI infrastructure can lead to model theft, data poisoning, or unauthorized execution of code within the inference environment. A CVSS score of 8.8 indicates a high-impact scenario, potentially compromising the integrity of AI-driven business processes and the underlying infrastructure.

Remediation Plan

Immediate Action: Identify all services utilizing BentoML and ensure they are updated to the most recent version available from the maintainer.

Proactive Monitoring: Monitor inference endpoints for unusual latency, unexpected request patterns, or unauthorized API calls that deviate from standard model usage.

Compensating Controls: Implement strict network segmentation for AI serving clusters and deploy WAF rules to validate input data being sent to inference models.

Exploitation Status

Public Exploit Available: false

Analyst Notes: As of May 28, 2026, there is no public information indicating active exploitation of this vulnerability. However, due to the nature of the flaw, the potential for exploitation is high.

Analyst Recommendation

As AI components increasingly become critical parts of the enterprise stack, their security is paramount. Organizations using BentoML should proactively track vendor security advisories and apply patches as soon as they are made available to protect their model serving environments from potential compromise.

---METADATA---
VENDOR: BentoML
PRODUCT: BentoML
AFFECTED_VERSIONS: See vendor advisory for specific affected versions
CONFIDENCE: low
MISSING: versions, patch, exploit_status, technical_details
---END_METADATA---

Description Summary:
A vulnerability exists within the BentoML Python library, which is used for building AI model inference and online serving systems.

Executive Summary:
The BentoML library is affected by a high-severity vulnerability that may compromise the security of AI serving infrastructure.

Vulnerability Details

CVE-ID: CVE-2026-44345

Affected Software: BentoML BentoML

Affected Versions: See vendor advisory for specific affected versions

Vulnerability: The provided data lacks specific technical details regarding the nature of the vulnerability, such as the attack vector or authentication requirements. Users should treat the library as potentially insecure until further vendor documentation is reviewed.

Business Impact

Given the CVSS score of 8.8, this vulnerability poses a significant risk to organizations deploying AI models. Successful exploitation could lead to unauthorized access to sensitive model inference data, potential manipulation of AI outputs, or compromise of the underlying serving infrastructure.

Remediation Plan

Immediate Action: Monitor the official BentoML security advisory page for the release of a patched version and apply updates immediately upon availability.

Proactive Monitoring: Review system and access logs for unusual patterns originating from the AI serving environment.

Compensating Controls: Implement strict network segmentation around AI inference servers and utilize a Web Application Firewall (WAF) to inspect traffic for anomalous requests.

Exploitation Status

Public Exploit Available: false

Analyst Notes: As of May 28, 2026, there is no public information indicating active exploitation of this vulnerability. However, due to the high CVSS score, the potential for exploitation is considered significant.

Analyst Recommendation

Organizations utilizing BentoML in production environments should prioritize this alert. Until specific patch details are provided by the vendor, ensure that all AI serving systems are isolated and monitored for unauthorized access.

---METADATA---
VENDOR: SOCFortress
PRODUCT: CoPilot
AFFECTED_VERSIONS: Prior to 0.1.57
---END_METADATA---

Description Summary:
SOCFortress CoPilot uses a hardcoded JWT signing secret, allowing unauthenticated attackers to forge administrative tokens.

Executive Summary:
An unauthenticated attacker can gain full control of the SOCFortress CoPilot platform by forging administrative JWT tokens using a publicly known hardcoded secret.

Vulnerability Details

CVE-ID: CVE-2026-42869

Affected Software: SOCFortress CoPilot

Affected Versions: Prior to 0.1.57

Vulnerability: This is a hardcoded secret vulnerability found in backend/app/auth/utils.py. The use of a predictable JWT signing secret allows attackers to craft their own tokens with administrative privileges, bypassing all authentication mechanisms.

Business Impact

This vulnerability allows for complete, unauthorized control over the application and every security tool it manages. With a 10.0 CVSS score, this is a critical failure that enables total system takeover and potential lateral movement within the security infrastructure.

Remediation Plan

Immediate Action: Upgrade to CoPilot version 0.1.57 or later and rotate all existing JWT secrets immediately.

Proactive Monitoring: Monitor for authentication logs showing logins from unrecognized administrative accounts or tokens with suspicious claims.

Compensating Controls: If immediate patching is not possible, ensure the instance is not exposed to the internet and restrict access to authorized network segments.

Exploitation Status

Public Exploit Available: false

Analyst Notes: As of May 11, 2026, there is no public information indicating active exploitation of this vulnerability. However, due to the nature of the flaw, the potential for exploitation is high.

Analyst Recommendation

This vulnerability represents the highest level of risk. Administrators must update to the latest version immediately and perform a mandatory rotation of all authentication secrets to ensure the integrity of the platform.

---METADATA---
VENDOR: Gotenberg
PRODUCT: Gotenberg
AFFECTED_VERSIONS: Prior to 8.31.0
---END_METADATA---

Description Summary:
A bypass of Gotenberg's URL deny-list allows an unauthenticated attacker to force the server to make outbound requests to internal-only targets.

Executive Summary:
A critical SSRF vulnerability in Gotenberg allows unauthenticated attackers to bypass security boundaries and access internal network services.

Vulnerability Details

CVE-ID: CVE-2026-42596

Affected Software: Gotenberg

Affected Versions: Prior to 8.31.0

Vulnerability: The application utilizes a case-sensitive regex-based filter for URL validation that can be bypassed using IPv6-mapped IPv4 addresses, allowing access to internal loopback or private network services.

Business Impact

This Server-Side Request Forgery (SSRF) vulnerability allows an attacker to probe internal networks, potentially accessing sensitive services or metadata endpoints that are otherwise unreachable from the internet. With a CVSS score of 9.4, this poses a high risk of lateral movement and information disclosure.

Remediation Plan

Immediate Action: Upgrade the Gotenberg Docker image to version 8.31.0 or higher to implement robust URL validation.

Proactive Monitoring: Monitor for outbound requests from the Gotenberg service to internal IP ranges or sensitive internal infrastructure.

Compensating Controls: Restrict the service's network access using strict egress firewall rules to ensure it can only reach necessary external endpoints.

Exploitation Status

Public Exploit Available: No

Analyst Notes: As of May 14, 2026, there is no public information indicating active exploitation of this vulnerability. However, due to the nature of the flaw, the potential for exploitation is high.

Analyst Recommendation

This vulnerability enables attackers to bypass network security perimeters. Updating the software to a patched version is essential to maintaining the integrity of internal network segmentation.

---METADATA---
VENDOR: Gotenberg
PRODUCT: Gotenberg
AFFECTED_VERSIONS: Prior to 8.31.0
---END_METADATA---

Description Summary:
A command injection vulnerability in the Gotenberg PDF API allows unauthenticated remote attackers to execute OS commands via malicious JSON metadata.

Executive Summary:
A critical command injection vulnerability in Gotenberg allows an unauthenticated attacker to execute arbitrary OS commands through a single HTTP request.

Vulnerability Details

CVE-ID: CVE-2026-42589

Affected Software: Gotenberg (Docker-powered API)

Affected Versions: Prior to 8.31.0

Vulnerability: The application insecurely passes JSON metadata keys to ExifTool, allowing an attacker to inject newline characters and arbitrary flags, such as -if for Perl expression evaluation.

Business Impact

Successful exploitation results in full unauthenticated remote code execution, granting the attacker control over the container and potentially the underlying host. With a CVSS score of 9.8, this flaw represents an immediate and extreme threat to any production environment running this service.

Remediation Plan

Immediate Action: Upgrade the Gotenberg Docker image to version 8.31.0 or higher immediately.

Proactive Monitoring: Inspect web server logs for HTTP requests containing unexpected characters in JSON keys or suspicious command-line flag patterns.

Compensating Controls: Deploy a WAF with rules configured to block malicious input containing newline characters or suspicious command flags intended for ExifTool.

Exploitation Status

Public Exploit Available: No

Analyst Notes: As of May 14, 2026, there is no public information indicating active exploitation of this vulnerability. However, due to the nature of the flaw, the potential for exploitation is high.

Analyst Recommendation

The ease of exploitation and high severity of this command injection vulnerability require immediate remediation. Organizations should update their Docker deployments immediately to prevent unauthenticated access and potential system takeover.

---METADATA---
VENDOR: Termix
PRODUCT: Termix
AFFECTED_VERSIONS: Prior to 2.1.0
---END_METADATA---

Description Summary:
Termix is vulnerable to OS command injection in its Docker management endpoints, leading to remote code execution.

Executive Summary:
An authenticated remote code execution vulnerability in Termix allows attackers to execute arbitrary OS commands on remote managed servers.

Vulnerability Details

CVE-ID: CVE-2026-42454

Affected Software: Termix

Affected Versions: Prior to 2.1.0

Vulnerability: The application fails to sanitize containerId parameters and WebSocket messages before passing them to shell commands, allowing an authenticated attacker to inject malicious commands.

Business Impact

With a CVSS score of 9.9, this vulnerability grants an authenticated attacker the ability to achieve full remote code execution on all managed servers. This is a catastrophic risk that could lead to widespread system compromise across the entire infrastructure.

Remediation Plan

Immediate Action: Update Termix to version 2.1.0 or later immediately.

Proactive Monitoring: Monitor managed servers for unauthorized shell processes or unusual command execution patterns originating from Termix.

Compensating Controls: Implement strict command allow-lists and sanitize all inputs before they reach the shell execution layer in the Termix backend.

Exploitation Status

Public Exploit Available: No

Analyst Notes: As of May 8, 2026, there is no public information indicating active exploitation of this vulnerability. However, due to the nature of the flaw, the potential for exploitation is high.

Analyst Recommendation

This is an extremely critical vulnerability that requires immediate remediation. Administrators should ensure that all instances of Termix are patched to prevent the risk of remote server compromise.

---METADATA---
VENDOR: OpenC3
PRODUCT: COSMOS
AFFECTED_VERSIONS: Prior to 7.0.0-rc3
---END_METADATA---

Description Summary:
A vulnerability in the OpenC3 COSMOS Script Runner widget allows authenticated users to bypass permissions and perform administrative actions on Redis and other services.

Executive Summary:
A critical authorization bypass in OpenC3 COSMOS allows users to execute administrative actions, including accessing secrets and modifying system configurations.

Vulnerability Details

CVE-ID: CVE-2026-42088

Affected Software: OpenC3 COSMOS

Affected Versions: Prior to 7.0.0-rc3

Vulnerability: The Script Runner widget allows for the execution of Python and Ruby scripts. Because containers share a network, an attacker with script execution permissions can bypass API checks to interact directly with internal services like Redis, potentially reading secrets, changing configurations, or modifying data in the buckets service.

Business Impact

With a CVSS score of 9.6, this vulnerability poses a severe threat to system integrity. An attacker can gain administrative-level control over the COSMOS platform, leading to the unauthorized disclosure of sensitive information and the potential for persistent backdoors within the system configuration.

Remediation Plan

Immediate Action: Upgrade OpenC3 COSMOS to version 7.0.0-rc3 or later to enforce proper permissions checking.

Proactive Monitoring: Review script execution logs and monitor for unauthorized network connections to internal services like Redis from the script runner container.

Compensating Controls: Implement network segmentation between Docker containers to prevent unauthorized inter-container communication, ensuring that only necessary services can communicate with the database.

Exploitation Status

Public Exploit Available: No

Analyst Notes: As of May 4, 2026, there is no public information indicating active exploitation of this vulnerability. However, due to the nature of the flaw, the potential for exploitation is high.

Analyst Recommendation

The ability to bypass administrative controls via the script runner is a critical security failure. Organizations must prioritize the patch and consider implementing stricter network isolation between microservices to prevent similar lateral movement and privilege escalation attacks.

---METADATA---
VENDOR: PraisonAI
PRODUCT: PraisonAI
AFFECTED_VERSIONS: 4.5.139 and below
---END_METADATA---

Description Summary:
PraisonAI GitHub Actions workflows are vulnerable to credential leakage via the ArtiPACKED attack, allowing unauthorized access to repository secrets and supply chain compromise.

Executive Summary:
A critical credential leakage vulnerability in PraisonAI GitHub Actions allows attackers to steal tokens and execute a full supply chain compromise.

Vulnerability Details

CVE-ID: CVE-2026-40313

Affected Software: PraisonAI

Affected Versions: 4.5.139 and below

Vulnerability: The vulnerability stems from improper configuration of the actions/checkout step, where persist-credentials is not set to false, causing sensitive authentication tokens to be written to .git/config and subsequently leaked through build artifacts.

Business Impact

The exposure of GITHUB_TOKEN and other secrets allows an attacker to perform unauthorized repository actions, including code injection, poisoning of software releases, and theft of sensitive intellectual property. Given the 9.1 CVSS score, this represents a major risk to the integrity of the software supply chain and downstream users.

Remediation Plan

Immediate Action: Update PraisonAI to version 4.5.140 and ensure all GitHub Actions workflows set persist-credentials: false in actions/checkout steps.

Proactive Monitoring: Audit existing repository secrets and rotate all tokens that were potentially exposed within artifacts generated by affected workflow versions.

Compensating Controls: Implement strict artifact access controls and scan build outputs for leaked credentials using automated secret scanning tools.

Exploitation Status

Public Exploit Available: Unknown

Analyst Notes: As of Apr 14, 2026, there is no public information indicating active exploitation of this vulnerability. However, due to the nature of the flaw, the potential for exploitation is high.

Analyst Recommendation

Organizations using PraisonAI must treat this as a high-priority supply chain security incident. Updating the software is mandatory, but security teams must also assume that any credentials used in previous CI/CD runs are compromised and initiate a full rotation of those secrets.

---METADATA---
VENDOR: Gotenberg
PRODUCT: Gotenberg
AFFECTED_VERSIONS: 8.30.1 and earlier
---END_METADATA---

Description Summary:
Gotenberg contains a command injection vulnerability where unsanitized metadata values allow attackers to manipulate ExifTool arguments, leading to arbitrary file system operations.

Executive Summary:
An unauthenticated command injection vulnerability in Gotenberg allows attackers to overwrite or move arbitrary files within the container environment.

Vulnerability Details

CVE-ID: CVE-2026-40281

Affected Software: Gotenberg

Affected Versions: 8.30.1 and earlier

Vulnerability: The application fails to sanitize newline characters in metadata values, allowing an unauthenticated attacker to inject ExifTool flags. This permits the manipulation of files, including the creation of symlinks or overwriting system files.

Business Impact

This flaw grants an attacker significant control over the container file system, which may lead to privilege escalation or the destruction of critical application data. Given the 10.0 CVSS score, the potential for total loss of container integrity and subsequent lateral movement is extreme.

Remediation Plan

Immediate Action: Upgrade to the latest version of Gotenberg to ensure proper metadata sanitization.

Proactive Monitoring: Review application logs for evidence of unusual metadata input or unexpected file system operations within the container.

Compensating Controls: Run the container with a read-only root file system and strictly limit the privileges of the user running the service to minimize the impact of file-system manipulation.

Exploitation Status

Public Exploit Available: false

Analyst Notes: As of May 6, 2026, there is no public information indicating active exploitation of this vulnerability. However, due to the nature of the flaw, the potential for exploitation is high.

Analyst Recommendation

This vulnerability is critical due to its potential for full container compromise. Organizations utilizing Gotenberg should apply the vendor-supplied patches immediately to prevent unauthorized file system modifications.

---METADATA---
VENDOR: Sonicverse
PRODUCT: Sonicverse Radio Audio Streaming Stack
AFFECTED_VERSIONS: Installations created via install.sh
CONFIDENCE: high
MISSING: patch
---END_METADATA---

Description Summary:
A Server-Side Request Forgery (SSRF) vulnerability in the Sonicverse Radio dashboard allows authenticated operators to perform arbitrary HTTP requests to internal or external systems.

Executive Summary:
An SSRF vulnerability in the Sonicverse Radio streaming dashboard enables authenticated attackers to perform unauthorized requests against internal and external infrastructure.

Vulnerability Details

CVE-ID: CVE-2026-40089

Affected Software: Sonicverse Radio Audio Streaming Stack

Affected Versions: Installations created via the provided install.sh script.

Vulnerability: The dashboard API client lacks sufficient validation when processing user-controlled URLs, leading to a Server-Side Request Forgery (SSRF) vulnerability. An authenticated operator can abuse this flaw to force the backend to make arbitrary HTTP requests to internal network resources or external systems.

Business Impact

SSRF vulnerabilities are frequently used to bypass network perimeters, scan internal infrastructure, or interact with cloud metadata services. With a CVSS score of 9.9, the potential for lateral movement and unauthorized access to sensitive internal services is extreme, posing a significant risk to the integrity and confidentiality of the host network.

Remediation Plan

Immediate Action: Apply the fix provided in commit cb1ddbacafcb441549fe87d3eeabdb6a085325e4 or update to the latest available version provided by the project maintainers.

Proactive Monitoring: Review application logs for anomalous API requests and monitor network traffic for unexpected internal scans originating from the streaming stack dashboard.

Compensating Controls: Utilize a Web Application Firewall (WAF) to filter and block suspicious URL parameters or requests directed at internal IP ranges from the dashboard application.

Exploitation Status

Public Exploit Available: No

Analyst Notes: As of Apr 9, 2026, there is no public information indicating active exploitation of this vulnerability. However, due to the nature of the flaw, the potential for exploitation is high.

Analyst Recommendation

Given the exceptionally high CVSS score, this vulnerability should be treated as a priority. Administrators must immediately apply the code-level fix and restrict access to the dashboard to trusted users only to mitigate the risk of internal network reconnaissance and exploitation.

---METADATA---
VENDOR: Kestra
PRODUCT: Kestra
AFFECTED_VERSIONS: Prior to version 1.3.7
---END_METADATA---

Description Summary:
A SQL Injection vulnerability in Kestra's flow search endpoint allows authenticated users to execute arbitrary OS commands on the host via PostgreSQL's COPY TO PROGRAM functionality.

Executive Summary:
Kestra orchestration platforms are vulnerable to a critical SQL injection that enables authenticated attackers to execute arbitrary operating system commands on the host server.

Vulnerability Details

CVE-ID: CVE-2026-34612

Affected Software: Kestra Kestra

Affected Versions: Prior to version 1.3.7

Vulnerability: The GET /api/v1/main/flows/search endpoint is susceptible to SQL injection. An authenticated attacker can use a crafted link to trigger a payload executed by the underlying PostgreSQL database to run arbitrary shell commands.

Business Impact

Successful exploitation results in Remote Code Execution (RCE) on the host system, leading to full server compromise and data exfiltration. With a CVSS score of 9.9, this vulnerability presents a near-maximum risk to any organization running the default docker-compose deployment of Kestra.

Remediation Plan

Immediate Action: Update the Kestra platform to version 1.3.7 or later to patch the vulnerable API endpoint and sanitize SQL inputs.

Proactive Monitoring: Audit database logs for unusual COPY ... TO PROGRAM statements and review application logs for suspicious activity on the /flows/search endpoint.

Compensating Controls: Implement a Web Application Firewall (WAF) with strict SQL injection protection rules to filter malicious parameters in API requests.

Exploitation Status

Public Exploit Available: false

Analyst Notes: As of Apr 3, 2026, there is no public information indicating active exploitation of this vulnerability. The requirement for authentication slightly mitigates the risk, but the ease of triggering RCE via a simple link remains a critical threat.

Analyst Recommendation

Remote Code Execution via SQL injection is a highly critical threat vector. Organizations must prioritize the update to Kestra version 1.3.7 immediately to secure their orchestration workflows and the underlying host infrastructure.

---METADATA---
VENDOR: Home Assistant
PRODUCT: Home Assistant (Supervisor)
AFFECTED_VERSIONS: < 2026.03.02
---END_METADATA---

Description Summary:
Home Assistant Supervisor fails to restrict access to internal Docker endpoints when using host network mode on Linux, exposing unauthenticated management interfaces to the local network.

Executive Summary:
Home Assistant installations on Linux are vulnerable to unauthenticated access to internal management endpoints, potentially allowing local network attackers to compromise the home automation system.

Vulnerability Details

CVE-ID: CVE-2026-34205

Affected Software: Home Assistant Home Assistant Supervisor

Affected Versions: Versions prior to 2026.03.02

Vulnerability: On Linux, Home Assistant apps configured with "host network mode" fail to isolate unauthenticated endpoints bound to the internal Docker bridge. This allows any device on the same local network to access these administrative interfaces without any authentication.

Business Impact

Unauthorized access to Home Assistant can lead to the control of physical smart home devices, access to private camera feeds, and the theft of sensitive configuration data. The CVSS score of 9.6 reflects the high risk of unauthenticated access and the potential for complete system takeover by an attacker on the local network.

Remediation Plan

Immediate Action: Update Home Assistant Supervisor to version 2026.03.02 or later immediately.

Proactive Monitoring: Inspect local network traffic for unauthorized connections to Home Assistant's internal management ports (typically 8123 or other Docker-assigned ports).

Compensating Controls: Implement network segmentation (VLANs) to isolate the Home Assistant server from untrusted local devices until the update is applied.

Exploitation Status

Public Exploit Available: false

Analyst Notes: As of Mar 27, 2026, there is no public information indicating active exploitation. This vulnerability is particularly relevant for users who run Home Assistant on generic Linux distributions rather than the dedicated Home Assistant OS.

Analyst Recommendation

The update to Supervisor 2026.03.02 is critical for maintaining the privacy and security of the Home Assistant environment. Users should prioritize this update and review their network configuration to ensure that management interfaces are not exposed to untrusted segments of their local network.

---METADATA---
VENDOR: Coollabsio
PRODUCT: Coolify
AFFECTED_VERSIONS: < 4.0.0-beta.469
CONFIDENCE: high
MISSING: none
---END_METADATA---

Description Summary:
Coolify contains an authenticated remote command injection vulnerability in application deployment handling, allowing remote code execution and sensitive data exfiltration.

Executive Summary:
An authenticated remote code execution vulnerability in Coolify allows attackers with application write permissions to compromise host environments and exfiltrate sensitive configuration data.

Vulnerability Details

CVE-ID: CVE-2026-34038

Affected Software: Coollabsio Coolify

Affected Versions: < 4.0.0-beta.469

Vulnerability: This is an OS command injection vulnerability triggered via application deployment fields like dockerfile_location and deployment commands. An attacker must possess authenticated application write permissions to exploit the flaw.

Business Impact

The vulnerability carries a CVSS score of 9.9, reflecting its ability to grant full system control to an attacker. Successful exploitation allows for the exfiltration of environment variables, which often contain database credentials, API keys, and other sensitive infrastructure secrets, leading to a complete compromise of the hosted application stack.

Remediation Plan

Immediate Action: Upgrade Coolify to version 4.0.0-beta.469 or later immediately to patch the command injection vulnerability.

Proactive Monitoring: Review deployment logs and audit application configuration changes for suspicious entries within the dockerfile_location or deployment command fields.

Compensating Controls: Implement strict Role-Based Access Control (RBAC) to limit the number of users with application write permissions until the patch is applied.

Exploitation Status

Public Exploit Available: True

Analyst Notes: As of Jul 6, 2026, a public proof-of-concept exploit is available. Given the availability of exploit code, the risk of active exploitation is significant.

Analyst Recommendation

The presence of a public exploit combined with the high CVSS score makes this a critical priority. Administrators must prioritize updating to version 4.0.0-beta.469 to prevent potential full-system compromise and data theft.

---METADATA---
VENDOR: Docker
PRODUCT: BuildKit
AFFECTED_VERSIONS: See vendor advisory for affected versions
---END_METADATA---

Description Summary:
Docker BuildKit contains a vulnerability that could affect the efficiency and repeatability of build artifacts, potentially leading to unauthorized access or build-time exploits.

Executive Summary:
A high-severity vulnerability in Docker BuildKit could allow attackers to compromise the container build process, potentially leading to the injection of malicious code or unauthorized data access.

Vulnerability Details

CVE-ID: CVE-2026-33747

Affected Software: Docker BuildKit

Affected Versions: See vendor advisory for affected versions

Vulnerability: BuildKit is a critical component for converting source code into build artifacts. The vulnerability likely involves improper handling of build instructions or environment isolation, which could allow an attacker with control over the build configuration to execute unauthorized actions or access sensitive information from the host or other build stages.

Business Impact

With a CVSS score of 8.4, this vulnerability represents a High-severity risk to the software supply chain. Successful exploitation could result in "poisoned" container images being deployed into production, leading to widespread compromise. Additionally, it could allow for the theft of build secrets, such as API keys or credentials, stored within the build environment.

Remediation Plan

Immediate Action: Update Docker and BuildKit to the latest versions immediately to incorporate the necessary security fixes for the build engine.

Proactive Monitoring: Audit build logs for unusual activity, such as unexpected network connections during the build phase or modifications to sensitive system files within the build container.

Compensating Controls: Implement build-time security scanning and use "rootless" mode for Docker builds to limit the potential impact of a build-stage escape or compromise.

Exploitation Status

Public Exploit Available: false

Analyst Notes: As of March 27, 2026, there is no public information indicating active exploitation. However, supply chain vulnerabilities are increasingly targeted by sophisticated actors, making this a high-priority concern for DevOps teams.

Analyst Recommendation

Securing the build pipeline is essential for modern software development. Organizations should treat this BuildKit update as a critical priority to ensure that container images remain untainted and that the build environment remains isolated from potential attackers.

---METADATA---
VENDOR: Open Notebook
PRODUCT: Open Notebook
AFFECTED_VERSIONS: v1.8.3
---END_METADATA---

Description Summary:
A Server-Side Template Injection (SSTI) vulnerability in Open Notebook v1.8.3 allows authenticated users to execute arbitrary Python code and OS commands within the Docker container.

Executive Summary:
A critical Server-Side Template Injection vulnerability in Open Notebook allows attackers to achieve arbitrary code execution within the container environment.

Vulnerability Details

CVE-ID: CVE-2026-33587

Affected Software: Open Notebook

Affected Versions: v1.8.3

Vulnerability: The application fails to sanitize user-provided input during transformations, resulting in SSTI. An authenticated user can leverage this flaw to execute arbitrary Python code, leading to full OS command execution on the host Docker container.

Business Impact

The ability to execute arbitrary commands at the container level poses a severe risk to data confidentiality, integrity, and availability. With a CVSS score of 10.0, this vulnerability represents the highest level of risk, potentially allowing an attacker to pivot into the internal network, steal sensitive data, or compromise the integrity of the application environment.

Remediation Plan

Immediate Action: Update Open Notebook to the latest available version provided by the vendor to remediate the input sanitization flaw.

Proactive Monitoring: Review application logs for suspicious transformation requests and monitor for anomalous process spawning within the container.

Compensating Controls: Implement strict network segmentation for the Docker container and utilize security tools to restrict execution permissions for the application user.

Exploitation Status

Public Exploit Available: Unknown

Analyst Notes: As of May 7, 2026, there is no public information indicating active exploitation of this vulnerability. However, due to the nature of the flaw, the potential for exploitation is high.

Analyst Recommendation

Given the critical CVSS 10.0 severity, this vulnerability must be treated as a top priority. Organizations using Open Notebook v1.8.3 should apply the necessary patches immediately to prevent unauthorized code execution and mitigate the risk of a full container compromise.

---METADATA---
VENDOR: OpenClaw
PRODUCT: OpenClaw
AFFECTED_VERSIONS: Before 2026.2.24
---END_METADATA---

Description Summary:
OpenClaw versions before 2026.2.24 contain a sandbox network isolation bypass vulnerability allowing trusted operators to access other container networks.

Executive Summary:
OpenClaw is vulnerable to a critical network isolation bypass that allows authenticated operators to violate container boundaries and access restricted services.

Vulnerability Details

CVE-ID: CVE-2026-32038

Affected Software: OpenClaw

Affected Versions: Before 2026.2.24

Vulnerability: This flaw allows a trusted operator to join another container's network namespace by manipulating the docker.network parameter. By using container:<id> values, an attacker can bypass network hardening controls and reach services that should be isolated within other container namespaces.

Business Impact

While this exploit requires "trusted operator" (authenticated) status, it represents a significant breakdown of the security model in containerized environments. An insider threat or a compromised operator account could use this to pivot across the infrastructure, accessing sensitive services or data in supposedly isolated containers. The CVSS score of 9.8 reflects the high potential for lateral movement.

Remediation Plan

Immediate Action: Update OpenClaw to version 2026.2.24 or later to enforce proper network namespace isolation and prevent the bypass.

Proactive Monitoring: Audit container configuration changes and monitor for unusual inter-container network traffic that deviates from established security policies.

Compensating Controls: Implement strict IAM policies to limit who can modify container network parameters and use network-level micro-segmentation to provide defense-in-depth.

Exploitation Status

Public Exploit Available: No

Analyst Notes: As of Mar 19, 2026, there is no public information indicating active exploitation. This vulnerability is particularly relevant for multi-tenant environments where network isolation is a primary security requirement.

Analyst Recommendation

Container escape and isolation bypasses are high-impact events. Even though authentication is required, the potential for lateral movement within a cloud or data center environment is severe. Apply the 2026.2.24 update immediately to maintain the integrity of your container security boundaries.

---METADATA---
VENDOR: ImageMagick Studio LLC
PRODUCT: ImageMagick
AFFECTED_VERSIONS: See vendor advisory for specific affected versions
---END_METADATA---

Description Summary:
ImageMagick is susceptible to a vulnerability during image manipulation that could allow for unauthorized code execution or system instability when processing crafted files.

Executive Summary:
A high-severity vulnerability in ImageMagick poses a significant risk of remote exploitation through the processing of maliciously crafted image files by unauthenticated attackers.

Vulnerability Details

CVE-ID: CVE-2026-30929

Affected Software: ImageMagick Studio LLC ImageMagick

Affected Versions: See vendor advisory for specific affected versions

Vulnerability: The vulnerability involves improper handling of image data during editing and manipulation processes. An unauthenticated attacker could provide a specially crafted image file that triggers a memory corruption or logic flaw within the software.

Business Impact

Exploitation could lead to arbitrary code execution on the server or workstation processing the image, or a denial-of-service (DoS) condition that halts automated workflows. Given the CVSS score of 7.7, this is a High-severity issue, particularly for web applications that automatically process user-uploaded content, potentially leading to full server takeover.

Remediation Plan

Immediate Action: Update ImageMagick to the latest stable version provided by the vendor or the relevant Linux distribution maintainer.

Proactive Monitoring: Monitor application logs for crashes in image processing modules and inspect incoming file uploads for unusual header signatures.

Compensating Controls: Deploy a Web Application Firewall (WAF) to inspect uploaded files and utilize sandboxing (e.g., Bubblewrap or Docker) to isolate the ImageMagick process from the rest of the system.

Exploitation Status

Public Exploit Available: false

Analyst Notes: As of March 10, 2026, there is no public information indicating active exploitation of this vulnerability. ImageMagick vulnerabilities are frequently targeted by researchers and attackers due to the software's widespread use in automated web backends.

Analyst Recommendation

The severity of this vulnerability necessitates immediate patching, especially for any system that processes untrusted image content. Security teams should verify that all instances of ImageMagick, including those bundled within other software stacks, are updated to the latest secure version to prevent remote code execution.

---METADATA---
VENDOR: Kaniko Project
PRODUCT: Kaniko
AFFECTED_VERSIONS: See vendor advisory for affected versions
---END_METADATA---

Description Summary:
A high-severity vulnerability in Kaniko, a container image builder, could allow attackers to compromise build environments within Kubernetes clusters.

Executive Summary:
Kaniko is affected by a high-severity vulnerability that could allow for the compromise of container build processes, potentially leading to supply chain attacks.

Vulnerability Details

CVE-ID: CVE-2026-28406

Affected Software: Kaniko

Affected Versions: See vendor advisory for affected versions

Vulnerability: Kaniko, which builds container images from Dockerfiles inside Kubernetes clusters, contains a flaw with a CVSS score of 8.2. This suggests a vulnerability that could allow an attacker to escape the build container or inject malicious code into resulting images.

Business Impact

A vulnerability in a build tool like Kaniko presents a significant supply chain risk. Attackers could potentially modify container images during the build process, leading to the deployment of backdoored software across the entire enterprise infrastructure. The high CVSS score justifies urgent attention to prevent unauthorized access to the cluster environment.

Remediation Plan

Immediate Action: Update Kaniko to the latest version as specified in the project's security advisory and rebuild any images created during the potential window of vulnerability.

Proactive Monitoring: Audit Kubernetes audit logs for unusual pod behavior associated with Kaniko build jobs and monitor container registries for unauthorized image modifications.

Compensating Controls: Implement strict Pod Security Policies or Admission Controllers to limit the privileges of Kaniko build pods, following the principle of least privilege.

Exploitation Status

Public Exploit Available: false

Analyst Notes: As of February 28, 2026, there is no public information indicating active exploitation of this vulnerability. However, build tools are high-value targets for sophisticated attackers looking to compromise the software supply chain.

Analyst Recommendation

The security of the container build pipeline is paramount. Organizations using Kaniko within their CI/CD pipelines must apply vendor-provided security updates immediately to ensure the integrity of their container images and the safety of their Kubernetes clusters.

---METADATA---
VENDOR: Docker
PRODUCT: Docker Model Runner (DMR)
AFFECTED_VERSIONS: See vendor advisory for specific affected versions
---END_METADATA---

Description Summary:
Docker Model Runner (DMR), used for managing AI models, contains a high-severity vulnerability that could lead to unauthorized access or model manipulation.

Executive Summary:
A security vulnerability in Docker Model Runner (DMR) poses a high risk to AI deployment environments, potentially allowing for the unauthorized execution of commands or manipulation of AI models.

Vulnerability Details

CVE-ID: CVE-2026-28400

Affected Software: Docker Docker Model Runner (DMR)

Affected Versions: See vendor advisory for specific affected versions

Vulnerability: The vulnerability exists within the Docker Model Runner (DMR) software. With a CVSS score of 7.5, the flaw likely involves improper isolation or inadequate access controls within the model deployment pipeline, potentially allowing an attacker to interact with the containerized environment in an unauthorized manner.

Business Impact

Exploitation of this vulnerability could lead to the compromise of proprietary AI models, unauthorized data access within the Docker environment, or the use of infrastructure for malicious computing. The CVSS score of 7.5 indicates a high severity, particularly for organizations integrating AI into their core production workflows.

Remediation Plan

Immediate Action: Apply the latest security updates for Docker Model Runner immediately to ensure all components are patched against this flaw.

Proactive Monitoring: Audit container logs and network traffic for unusual activity originating from or directed toward DMR-managed instances.

Compensating Controls: Implement strict network segmentation for AI model deployment environments and use container security scanning tools to detect anomalous configurations.

Exploitation Status

Public Exploit Available: false

Analyst Notes: As of March 1, 2026, there is no public information indicating active exploitation of this vulnerability. However, the critical role of AI infrastructure makes it a significant point of failure if left unpatched.

Analyst Recommendation

Organizations utilizing Docker Model Runner for AI deployments should prioritize this update. Immediate remediation is necessary to maintain the integrity of AI models and the security of the underlying Docker infrastructure.

---METADATA---
VENDOR: bleon-ethical
PRODUCT: api-gateway-deploy
AFFECTED_VERSIONS: Version 1.0.0
---END_METADATA---

Description Summary:
A critical attack chain involving OS command injection and privilege escalation in api-gateway-deploy allows for root-level execution and container escape.

Executive Summary:
Attackers can exploit command injection flaws in the api-gateway-deploy container to gain root privileges and potentially escape to the host infrastructure.

Vulnerability Details

CVE-ID: CVE-2026-27208

Affected Software: bleon-ethical api-gateway-deploy

Affected Versions: Version 1.0.0

Vulnerability: The vulnerability stems from insecure input handling in entrypoint.sh and the use of the root user within the Dockerfile. An attacker can use OS command injection to execute arbitrary code, which, combined with the default root configuration, facilitates a container escape.

Business Impact

This vulnerability poses a severe threat to infrastructure integrity, as a successful container escape can lead to unauthorized access to the underlying host and adjacent network resources. With a CVSS score of 9.2, the risk of significant infrastructure modification and data theft is critical.

Remediation Plan

Immediate Action: Upgrade to version 1.0.1, which implements strict input sanitization and enforces a non-root "appuser" for container execution.

Proactive Monitoring: Monitor container logs for suspicious shell commands and audit host systems for unauthorized processes originating from the container runtime.

Compensating Controls: Utilize runtime security tools (e.g., Falco or AppArmor) to restrict container capabilities and prevent unauthorized system calls or file access.

Exploitation Status

Public Exploit Available: No

Analyst Notes: As of February 24, 2026, no active exploitation has been reported. However, the combination of command injection and root execution makes this a highly attractive target for attackers seeking to compromise cloud environments.

Analyst Recommendation

The transition from root to a non-privileged user is a fundamental security best practice that was missing in the initial release. Organizations must update to version 1.0.1 immediately to mitigate the risk of host-level compromise and ensure secure deployment of their API gateways.

---METADATA---
VENDOR: OpenClaw
PRODUCT: tool sandbox
AFFECTED_VERSIONS: Prior to version 2026.2.15
---END_METADATA---

Description Summary:
OpenClaw's Docker tool sandbox is vulnerable to configuration injection, allowing dangerous Docker options that can lead to container escape and host data access.

Executive Summary:
A critical configuration injection vulnerability in OpenClaw's Docker sandbox enables attackers to escape container environments and access sensitive host system data.

Vulnerability Details

CVE-ID: CVE-2026-27002

Affected Software: Docker tool sandbox (OpenClaw)

Affected Versions: Prior to version 2026.2.15

Vulnerability: This issue involves the injection of dangerous Docker configuration options (such as bind mounts and host networking) into the sandbox environment. This allows an attacker to bypass container isolation, potentially achieving a full container escape or gaining unauthorized access to the host file system.

Business Impact

An exploit could lead to the total compromise of the host server supporting the AI assistant. Attackers could steal sensitive host data, escalate privileges, or move laterally within the network. The CVSS score of 9.8 underscores the critical risk to infrastructure integrity and data confidentiality.

Remediation Plan

Immediate Action: Update OpenClaw to version 2026.2.15 or later, which implements runtime enforcement and validation of Docker arguments.

Proactive Monitoring: Audit Docker logs for unauthorized container creations with network=host or unconfined profiles and monitor host file systems for unauthorized access.

Compensating Controls: As a workaround, ensure that sandbox configurations do not use system directory bind mounts, keep networking set to none or bridge, and enforce strict seccomp/AppArmor profiles.

Exploitation Status

Public Exploit Available: No

Analyst Notes: As of Feb 20, 2026, there is no public information indicating active exploitation. The vendor has proactively released a patch and detailed workarounds to mitigate the risk.

Analyst Recommendation

Organizations using OpenClaw must prioritize the update to version 2026.2.15. In environments where immediate updates are not possible, the provided configuration workarounds should be applied manually to prevent the use of dangerous Docker options that facilitate container escapes.

---METADATA---
VENDOR: Crawl4AI
PRODUCT: Docker API deployment
AFFECTED_VERSIONS: Versions prior to 0.8.0
---END_METADATA---

Description Summary:
Crawl4AI versions prior to 0.8.0 allow unauthenticated remote code execution via the /crawl endpoint by exploiting the hooks parameter to import arbitrary Python modules.

Executive Summary:
An unauthenticated remote code execution vulnerability in Crawl4AI's Docker API allows attackers to achieve full server compromise, including data exfiltration and lateral movement.

Vulnerability Details

CVE-ID: CVE-2026-26216

Affected Software: Crawl4AI

Affected Versions: Versions prior to 0.8.0

Vulnerability: The /crawl endpoint accepts a hooks parameter containing Python code executed via exec(). Because the __import__ builtin was not restricted, unauthenticated attackers can import arbitrary modules and execute system commands on the host.

Business Impact

This vulnerability carries a CVSS score of 10, the highest possible severity. Successful exploitation allows for complete system takeover, sensitive data theft, and the ability for attackers to pivot into internal networks, resulting in catastrophic operational and financial damage.

Remediation Plan

Immediate Action: Update the Crawl4AI Docker API deployment to version 0.8.0 or later immediately to remove the vulnerable code execution path.

Proactive Monitoring: Review API logs for requests to the /crawl endpoint that include suspicious Python code or attempts to use the hooks parameter.

Compensating Controls: Place the Docker API behind a Web Application Firewall (WAF) with rules designed to block Python-style injection and restrict API access to authenticated users only.

Exploitation Status

Public Exploit Available: false

Analyst Notes: As of Feb 12, 2026, there is no public information indicating active exploitation. However, the technical nature of the flaw makes it trivial to exploit once the endpoint is identified.

Analyst Recommendation

A CVSS 10.0 vulnerability requires immediate, out-of-band patching. Organizations must ensure that no Crawl4AI instances are exposed to the public internet without authentication and that all instances are updated to version 0.8.0 or higher.

---METADATA---
VENDOR: SandboxJS
PRODUCT: SandboxJS
AFFECTED_VERSIONS: Prior to 0.8.29
---END_METADATA---

Description Summary:
SandboxJS is vulnerable to a sandbox escape via unwrapped function return values. Attackers can access the host's Function constructor to execute arbitrary code outside the restricted environment.

Executive Summary:
A critical sandbox escape vulnerability in SandboxJS allows unauthenticated attackers to bypass security restrictions and execute arbitrary code on the host system.

Vulnerability Details

CVE-ID: CVE-2026-25520

Affected Software: SandboxJS

Affected Versions: Prior to 0.8.29

Vulnerability: The library fails to wrap function return values, allowing an unauthenticated attacker to use Object.values or Object.entries to retrieve the host's Function constructor. By leveraging Array.prototype.at, the attacker can invoke this constructor to escape the sandbox.

Business Impact

This vulnerability completely negates the security benefits of the sandbox, leading to host-level arbitrary code execution (ACE). With a CVSS score of 10.0, the impact is catastrophic, potentially resulting in full system takeover, data exfiltration, and lateral movement within the infrastructure.

Remediation Plan

Immediate Action: Update SandboxJS to version 0.8.29 or higher to ensure all return values are properly wrapped and constructors are protected.

Proactive Monitoring: Monitor application logs for unusual patterns of prototype access or attempts to access the Function constructor from within sandboxed scripts.

Compensating Controls: Restrict the capabilities of the process running the sandbox using OS-level isolation (e.g., Docker containers or seccomp profiles) to limit the impact of a successful escape.

Exploitation Status

Public Exploit Available: No

Analyst Notes: As of Feb 6, 2026, there is no public information indicating active exploitation of this vulnerability. However, the technical details provided in the disclosure make the development of a functional exploit trivial.

Analyst Recommendation

Given the CVSS 10.0 rating, this is a maximum-severity issue. Organizations must update to version 0.8.29 immediately to restore the integrity of their sandboxing environment and prevent unauthorized host code execution.

Executive Summary:
A critical vulnerability has been identified in the SandboxJS library, a tool designed to safely execute untrusted JavaScript code. This flaw allows an attacker to bypass the library's security restrictions and execute arbitrary code on the underlying server. Successful exploitation could lead to a complete system compromise, resulting in data theft, service disruption, or further network intrusion.

Vulnerability Details

CVE-ID: CVE-2026-25142

Affected Software: SandboxJS library

Affected Versions: Versions prior to 0.8.27

Vulnerability: The SandboxJS library fails to properly restrict access to the __lookupGetter__ JavaScript object method. An attacker can craft malicious JavaScript code that leverages this method to access and modify object prototypes. By manipulating the prototype chain, the attacker can gain access to powerful, unrestricted functions outside of the sandbox environment, such as the Function constructor, ultimately leading to a sandbox escape and remote code execution (RCE) on the host system.

Business Impact

This vulnerability is rated as critical severity with a CVSS score of 10. A successful exploit would grant an attacker the ability to execute commands on the server with the same privileges as the application running the SandboxJS library. This could lead to a complete loss of confidentiality, integrity, and availability of the affected system and its data. Potential consequences include theft of sensitive data, deployment of ransomware, manipulation of application data, or using the compromised server as a pivot point to attack other systems within the organization's network.

Remediation Plan

Immediate Action: All systems utilizing the SandboxJS library must be immediately updated to version 0.8.27 or later, which contains the fix for this vulnerability. After patching, review application and system logs for any signs of exploitation that may have occurred prior to the update.

Proactive Monitoring: Implement enhanced monitoring on affected systems. Security teams should look for suspicious patterns in logs, such as unexpected process creation by the application, unusual network connections, or logs of user-submitted JavaScript containing strings like __lookupGetter__, prototype, or constructor.

Compensating Controls: If immediate patching is not feasible, consider implementing the following compensating controls:

• Run the application utilizing SandboxJS within a heavily restricted, isolated environment (e.g., a minimal Docker container with no unnecessary privileges or network access).
• Implement a Web Application Firewall (WAF) with rules designed to detect and block malicious JavaScript patterns attempting to exploit this vulnerability.
• Enhance input validation to sanitize or reject any user-supplied code before it is passed to the SandboxJS library.

Exploitation Status

Public Exploit Available: false

Analyst Notes: As of February 2, 2026, there are no known public exploits targeting this vulnerability. However, given the critical CVSS score of 10 and the public disclosure of the vulnerability's technical details, it is highly probable that proof-of-concept exploits will be developed and released by security researchers or malicious actors in the near future.

Analyst Recommendation

Due to the critical severity (CVSS 10) of this vulnerability and the high risk of complete system compromise, immediate remediation is strongly recommended. Organizations must prioritize applying the update to version 0.8.27 or later across all affected applications without delay. Although this CVE is not currently on the CISA KEV list, its characteristics make it a prime candidate for widespread exploitation, and it should be treated with the highest urgency.

Executive Summary:
A critical command injection vulnerability has been identified in the Dokploy PaaS, affecting versions prior to 0.26.6. This flaw allows an authenticated attacker to execute arbitrary commands on the underlying server, potentially leading to a complete system compromise, data theft, and service disruption. Due to the high severity (CVSS 9.9), immediate patching is required to prevent a full takeover of the host environment.

Vulnerability Details

CVE-ID: CVE-2026-24841

Affected Software: Dokploy is a Multiple Products

Affected Versions: All versions prior to 0.26.6

Vulnerability: The vulnerability is a command injection flaw within the /docker-container-terminal WebSocket endpoint. The endpoint accepts containerId and activeWay parameters which are insecurely passed to a shell command on the host server without proper sanitization or validation. An authenticated attacker can manipulate these parameters to inject and execute arbitrary shell commands with the privileges of the Dokploy service, leading to remote code execution (RCE) on the host.

Business Impact

This vulnerability is rated as critical severity with a CVSS score of 9.9. Successful exploitation would result in a complete compromise of the server hosting Dokploy, granting the attacker full control. The potential business impact includes theft or modification of sensitive data, deployment of ransomware, complete disruption of all applications managed by Dokploy, and the ability for an attacker to use the compromised server as a pivot point to attack other systems within the internal network. This represents a total loss of confidentiality, integrity, and availability for the affected system and its hosted services.

Remediation Plan

Immediate Action: Immediately upgrade all Dokploy instances to version 0.26.6 or later, which contains the fix for this vulnerability. After patching, review system and application logs for any signs of compromise or suspicious activity preceding the update.

Proactive Monitoring:

• Monitor WebSocket connection logs for unusual or malformed requests to the /docker-container-terminal endpoint.
• Implement host-based monitoring to detect anomalous process execution, especially unexpected shell commands spawned by the Dokploy user/service.
• Analyze outbound network traffic from the Dokploy server for connections to unknown or malicious destinations.
• Review Dokploy access logs for unauthorized or suspicious authentication events.

Compensating Controls: If patching cannot be performed immediately, implement the following controls:

• Restrict network access to the Dokploy management interface and API endpoints to trusted IP addresses using a firewall.
• Deploy a Web Application Firewall (WAF) with rules specifically designed to inspect and block malicious WebSocket payloads targeting command injection.
• Enforce the principle of least privilege for all user accounts with access to Dokploy, and ensure multi-factor authentication is enabled.

Exploitation Status

Public Exploit Available: true

Analyst Notes: As of Jan 28, 2026, there are no widespread reports of active exploitation in the wild. However, command injection vulnerabilities of this nature are trivial to exploit once discovered. It is highly probable that functional proof-of-concept (PoC) exploit code will become publicly available shortly, significantly increasing the risk. The only mitigating factor is the requirement for the attacker to be authenticated.

Analyst Recommendation

Given the critical CVSS score of 9.9 and the risk of complete system compromise, it is imperative that organizations treat this vulnerability with the highest priority. The provided remediation to upgrade to version 0.26.6 or later should be applied immediately across all affected systems. Although this vulnerability is not currently listed on the CISA KEV list, its severity makes it a prime candidate for future inclusion. Do not delay patching.

Executive Summary:
A high-severity vulnerability has been discovered in multiple Docker products, specifically related to the Runtipi homeserver orchestrator. Successful exploitation could allow an attacker to escape container environments, gain elevated privileges on the host server, and execute arbitrary code. This could lead to a complete system compromise, resulting in data theft, service disruption, and unauthorized access to the underlying infrastructure.

Vulnerability Details

CVE-ID: CVE-2026-24129

Affected Software: Docker Multiple Products

Affected Versions: See vendor advisory for specific affected versions

Vulnerability: This vulnerability exists within the Runtipi orchestration layer that interacts with the Docker engine. A flaw in how Runtipi processes and manages container configurations can be exploited by a malicious actor, potentially with low-level access to a container or by tricking an administrator into deploying a specially crafted service. By exploiting this flaw, an attacker can break out of the intended container isolation, gaining root-level access to the host operating system, thereby compromising all other services and data on that server.

Business Impact

This vulnerability is rated as High severity with a CVSS score of 8. Exploitation could lead to a complete compromise of the server hosting the Docker environment. The potential business impact includes the theft of sensitive corporate or customer data, deployment of ransomware, disruption of critical business applications, and the use of the compromised system as a launchpad for further attacks within the corporate network. The reputational damage and financial costs associated with a breach of this nature are significant.

Remediation Plan

Immediate Action: Apply the security updates provided by the vendor across all affected systems immediately. After patching, review system and container access logs for any anomalous activity or indicators of compromise that may have occurred prior to the update.

Proactive Monitoring: Security teams should actively monitor for unusual process execution originating from the Docker daemon or containers, unexpected network connections to or from the host server, and unauthorized modifications to container configurations. Scrutinize Docker API logs for suspicious commands or unauthorized access attempts.

Compensating Controls: If immediate patching is not feasible, organizations should implement compensating controls. These include applying stricter security profiles (e.g., AppArmor, SELinux) to limit container capabilities, enforcing the principle of least privilege for users managing the Docker environment, and using network segmentation to isolate vulnerable hosts from critical network segments.

Exploitation Status

Public Exploit Available: false

Analyst Notes: As of January 23, 2026, there are no known public exploits or active exploitation campaigns targeting this vulnerability. However, given the high-severity rating and the widespread deployment of Docker, it is highly probable that threat actors will develop exploits in the near future.

Analyst Recommendation

Given the high severity of this vulnerability, immediate action is required. Organizations must prioritize the deployment of vendor-supplied patches to all affected systems. Although this CVE is not currently listed on the CISA KEV list, its potential for complete system compromise warrants treating it with the highest urgency. If patching is delayed, the compensating controls listed above should be implemented as a temporary mitigation measure while a patching schedule is finalized.

---METADATA---
VENDOR: Node.js (vm2)
PRODUCT: vm2
AFFECTED_VERSIONS: Prior to 3.11.0
---END_METADATA---

Description Summary:
A sandbox breakout vulnerability in the Node.js vm2 library allows attackers to escape the sandbox and execute arbitrary commands on the host system.

Executive Summary:
A critical sandbox breakout vulnerability in vm2 allows attackers to escape the virtual environment and achieve arbitrary command execution on the host.

Vulnerability Details

CVE-ID: CVE-2026-24118

Affected Software: vm2 (Node.js)

Affected Versions: Prior to 3.11.0

Vulnerability: The vulnerability allows an attacker to break out of the vm2 sandbox environment. By crafting specific code, an attacker can bypass security restrictions and execute arbitrary commands directly on the host system running the Node.js application.

Business Impact

With a CVSS score of 9.8, this flaw represents a complete failure of the isolation mechanism. If a Node.js application uses vm2 to process untrusted input, an attacker can gain full access to the underlying server, potentially compromising all data and services hosted on that machine.

Remediation Plan

Immediate Action: Update the vm2 dependency to version 3.11.0 or later immediately.

Proactive Monitoring: Review application logs for unusual child process creation or unauthorized file system access originating from the Node.js application.

Compensating Controls: Run the Node.js application within a containerized environment (e.g., Docker) with restricted capabilities and no root privileges to limit the impact of a potential breakout.

Exploitation Status

Public Exploit Available: No

Analyst Notes: As of May 4, 2026, there is no public information indicating active exploitation of this vulnerability. However, due to the nature of the flaw, the potential for exploitation is high.

Analyst Recommendation

The vm2 library is inherently difficult to secure, and this breakout vulnerability highlights the risks of relying on it for sandboxing untrusted code. Organizations must update to the latest version and consider adopting stronger isolation methods, such as hardware-based virtualization or separate, hardened processes.

Executive Summary:
A high-severity vulnerability has been discovered in Tugtainer, a self-hosted application used for automating Docker container updates. This flaw could allow a remote, unauthenticated attacker to execute arbitrary code on the server hosting the application, potentially leading to a complete compromise of the container environment. Successful exploitation could result in significant data breaches, service disruption, and unauthorized access to the underlying infrastructure.

Vulnerability Details

CVE-ID: CVE-2026-23846

Affected Software: Docker Multiple Products (via the Tugtainer application)

Affected Versions: See vendor advisory for specific affected versions

Vulnerability: The vulnerability exists within the API of the Tugtainer application. A lack of proper input sanitization in a specific API endpoint allows an unauthenticated remote attacker to craft a malicious request that results in arbitrary command injection. An attacker can exploit this by sending a specially crafted HTTP request to the vulnerable endpoint, which the application then executes with the privileges of the Tugtainer service account, leading to remote code execution (RCE) on the host system.

Business Impact

This vulnerability is rated as High severity with a CVSS score of 8.1. A successful exploit would grant an attacker full control over the Tugtainer instance and, by extension, the Docker host it manages. This could lead to severe consequences, including the theft or destruction of sensitive data within containers, deployment of malicious containers (e.g., for cryptomining), disruption of critical business applications, and using the compromised host as a pivot point to attack other systems on the internal network. The potential business impact includes significant operational downtime, financial loss, reputational damage, and regulatory penalties related to a data breach.

Remediation Plan

Immediate Action: Apply the security updates provided by the vendor immediately to all affected Tugtainer instances. After patching, review system and application access logs for any signs of compromise or unusual activity preceding the update.

Proactive Monitoring:

• Monitor web server access logs for the Tugtainer application for unusual or malformed API requests, particularly from unknown IP addresses.
• Audit Docker daemon logs for unexpected container start, stop, or modification events that do not correlate with legitimate administrative actions.
• Monitor for suspicious outbound network connections originating from the Tugtainer host or its containers.
• Look for unexpected processes being spawned by the Tugtainer service user on the host operating system.

Compensating Controls: If immediate patching is not feasible, implement the following controls:

• Restrict network access to the Tugtainer web interface and API to a limited set of trusted IP addresses using a firewall.
• Place the application behind a Web Application Firewall (WAF) with rules designed to detect and block command injection attempts.
• Ensure the Tugtainer service runs with the lowest possible privileges to limit the impact of a potential compromise.

Exploitation Status

Public Exploit Available: false

Analyst Notes: As of January 20, 2026, there are no known public exploits or active exploitation campaigns targeting this vulnerability. However, due to the high severity score and the potential for remote code execution, it is highly probable that threat actors will develop exploits in the near future.

Analyst Recommendation

Given the high CVSS score of 8.1 and the critical nature of the systems managed by Tugtainer, this vulnerability poses a significant risk to the organization. We strongly recommend prioritizing the immediate deployment of vendor-supplied patches to all affected systems. Although this CVE is not currently listed on the CISA KEV catalog, its high impact makes it a prime candidate for future inclusion and exploitation. Organizations should assume it will be targeted and act decisively to mitigate the risk.

---METADATA---
VENDOR: Arcane
PRODUCT: Docker Management
AFFECTED_VERSIONS: Prior to 1.13.0
CONFIDENCE: high
MISSING: none
---END_METADATA---

Description Summary:
Arcane Docker management software prior to 1.13.0 contains a command injection vulnerability in the updater service, allowing authenticated users to execute arbitrary shell commands.

Executive Summary:
An authenticated command injection vulnerability in Arcane prior to 1.13.0 allows malicious users to execute arbitrary commands during the container update process.

Vulnerability Details

CVE-ID: CVE-2026-23520

Affected Software: Arcane Docker Management

Affected Versions: Prior to 1.13.0

Vulnerability: The updater service improperly validates lifecycle labels (com.getarcaneapp.arcane.lifecycle.pre-update and post-update), which are passed directly to /bin/sh. An authenticated user can create a project with a malicious label, which is then executed with higher privileges when an administrator triggers an update.

Business Impact

The CVSS score of 9.0 highlights the severe risk of privilege escalation and remote code execution. Successful exploitation allows an attacker to break out of the container context or influence the host environment, potentially leading to full system compromise.

Remediation Plan

Immediate Action: Upgrade Arcane to version 1.13.0 or later immediately to resolve the command injection flaw.

Proactive Monitoring: Audit existing project configurations for unauthorized lifecycle labels and review logs for unexpected shell process spawning.

Compensating Controls: Implement strict Role-Based Access Control (RBAC) to limit which users can create projects and restrict API access to trusted segments.

Exploitation Status

Public Exploit Available: None

Analyst Notes: As of Jan 15, 2026, there is no public information indicating active exploitation of this vulnerability. However, due to the nature of the flaw, the potential for exploitation is high.

Analyst Recommendation

The ability for a standard user to trigger arbitrary command execution makes this a high-priority update. Administrators must ensure all instances of Arcane are updated to 1.13.0 to eliminate the injection vector and secure the administrative update process.

Executive Summary:
A critical sandbox escape vulnerability has been identified in vm2, a widely used Node.js library. This flaw allows an attacker to bypass security restrictions and execute arbitrary code on the underlying server, potentially leading to a full system compromise. Organizations using applications that rely on vulnerable versions of vm2 are at high risk of data theft, service disruption, and further network intrusion.

Vulnerability Details

CVE-ID: CVE-2026-22709

Affected Software: Unknown Multiple Products (due to the vulnerability existing in the third-party library vm2)

Affected Versions: Products using vm2 versions prior to 3.10.2 are affected.

Vulnerability: The vulnerability is a sandbox escape within the vm2 Node.js library. The library fails to properly sanitize promise callbacks returned by async functions. While the sandbox correctly handles promises created within its own context (localPromise), it does not apply the same security controls to native promises (globalPromise) that are returned by asynchronous functions. An attacker can craft malicious code within the sandbox that uses an async function to return a native promise. The callback function attached to this promise (via .then() or .catch()) will then execute outside the sandbox's security context, granting the attacker arbitrary code execution on the host machine.

Business Impact

This vulnerability is rated as critical severity with a CVSS score of 9.8. Successful exploitation allows an attacker to completely bypass the intended security isolation of the sandbox environment. This could lead to a full compromise of the application server, enabling the attacker to steal sensitive data, install malware or ransomware, disrupt critical services, or use the compromised system as a pivot point to attack other resources on the internal network. The potential for complete system takeover poses a direct and severe risk to business operations, data confidentiality, and system integrity.

Remediation Plan

Immediate Action: Identify all applications and systems utilizing the vm2 Node.js library and update it to the patched version 3.10.2 or later. After patching, monitor affected systems for any signs of post-exploitation activity and review historical access and application logs for indicators of compromise.

Proactive Monitoring: Implement enhanced monitoring on servers running applications with the vm2 library. Look for anomalous behavior from the Node.js process, such as unexpected child processes (e.g., /bin/sh, powershell.exe), outbound network connections to unfamiliar IP addresses, or modifications to sensitive system files. Application-level logging should be reviewed for suspicious inputs that may be attempting to trigger the exploit.

Compensating Controls: If immediate patching is not feasible, apply compensating controls to reduce risk. Run the application in a minimal, hardened container (e.g., Docker) with restricted user permissions and no unnecessary tools. Implement strict network egress filtering to block potential command-and-control (C2) communications. A Web Application Firewall (WAF) may also be configured to block patterns associated with known exploit attempts.

Exploitation Status

Public Exploit Available: False

Analyst Notes: As of the publication date, Jan 26, 2026, there are no public reports of active, widespread exploitation of this vulnerability. However, sandbox escape vulnerabilities in popular libraries are highly sought after by threat actors. It is highly probable that proof-of-concept (PoC) exploits will be developed and made public, significantly increasing the risk of exploitation.

Analyst Recommendation

Immediate and decisive action is required to mitigate this critical vulnerability. All development and security teams must prioritize the identification of any product using the vm2 library and immediately update it to a patched version (3.10.2 or newer). Although this vulnerability is not yet on the CISA KEV list, its critical CVSS score of 9.8 signifies the highest level of risk. Due to the potential for complete system compromise, remediation of this flaw should be treated as an emergency security priority.

---METADATA---
VENDOR: Gitea
PRODUCT: Gitea Open Source Git Server
AFFECTED_VERSIONS: Up to and including 1.26.2
---END_METADATA---

Description Summary:
A default configuration error in Gitea Docker images allows unauthenticated attackers to spoof user identities via reverse-proxy authentication headers.

Executive Summary:
A critical authentication bypass vulnerability in Gitea's default Docker configuration allows remote attackers to impersonate any user, leading to total unauthorized access to the repository server.

Vulnerability Details

CVE-ID: CVE-2026-20896

Affected Software: Gitea Gitea Open Source Git Server

Affected Versions: Up to and including 1.26.2

Vulnerability: The application incorrectly defaults to trusting all reverse-proxy headers (REVERSE_PROXY_TRUSTED_PROXIES=*), which permits an unauthenticated attacker to inject headers like X-WEBAUTH-USER to masquerade as any authenticated user.

Business Impact

The ability to impersonate any user, including administrative accounts, grants an attacker full control over the Git infrastructure. This poses a significant risk of intellectual property theft, unauthorized code injection into production pipelines, and total system compromise. With a CVSS score of 9.8, this is an extremely high-risk vulnerability that could lead to catastrophic business disruption.

Remediation Plan

Immediate Action: Update Gitea to the latest version and explicitly configure the REVERSE_PROXY_TRUSTED_PROXIES setting to only include authorized IP addresses of known proxies.

Proactive Monitoring: Audit access logs for suspicious authentication patterns or inconsistencies in user identity headers.

Compensating Controls: If an immediate update is not feasible, restrict network access to the Gitea instance to trusted internal networks only via firewall rules.

Exploitation Status

Public Exploit Available: No

Analyst Notes: As of Jul 3, 2026, there is no public information indicating active exploitation of this vulnerability. However, due to the nature of the flaw, the potential for exploitation is high.

Analyst Recommendation

This vulnerability represents a fundamental failure in identity verification. Organizations hosting Gitea must treat this as a top-priority remediation, ensuring both the software update is applied and the configuration is hardened to restrict trusted proxy sources.

Executive Summary:
A critical sandbox escape vulnerability has been identified in multiple products from the vendor 'Using'. This flaw allows an attacker to bypass security restrictions within the application's Python execution environment, enabling them to run arbitrary code on the underlying server, which could lead to a complete system compromise, data theft, or further network intrusion.

Vulnerability Details

CVE-ID: CVE-2026-0863

Affected Software: Using Multiple Products

Affected Versions: See vendor advisory for specific affected versions

Vulnerability: The vulnerability exists within the n8n python-task-executor, which is designed to run user-supplied Python code in a restricted sandbox environment. An attacker can craft a malicious Python script that leverages a combination of specific string formatting techniques and exception handling. This specially crafted input exploits a flaw in the sandbox's validation logic, allowing the code to break out of the intended restrictions and execute arbitrary commands with the permissions of the application service on the host operating system.

Business Impact

This vulnerability is rated as High severity with a CVSS score of 8.5. Successful exploitation results in remote code execution (RCE) on the server hosting the affected application. This could allow an attacker to steal sensitive data processed by the application, install ransomware or other malware, modify or delete critical system files, and use the compromised server as a pivot point to attack other systems within the corporate network. The potential consequences include significant data breaches, operational downtime, financial loss, and reputational damage.

Remediation Plan

Immediate Action: Organizations must apply the security updates provided by the vendor across all affected products immediately. The vendor's patch directly addresses the sandbox escape flaw, preventing the execution of unauthorized code. After patching, review application and system logs for any signs of compromise that may have occurred prior to the update.

Proactive Monitoring: Security teams should actively monitor for signs of exploitation. This includes reviewing application logs for unusually complex or obfuscated Python code submissions, monitoring for unexpected processes spawned by the application service (e.g., shells, network utilities like curl or wget), and scrutinizing network traffic for anomalous outbound connections from the application server.

Compensating Controls: If immediate patching is not feasible, the following controls can help reduce risk:

• Restrict network access to the application interface, allowing connections only from trusted IP addresses.
• Run the application in a hardened, isolated environment (e.g., a minimal Docker container with strict egress filtering) to limit the impact of a potential compromise.
• Implement a Web Application Firewall (WAF) with custom rules to detect and block code patterns associated with sandbox escape techniques.

Exploitation Status

Public Exploit Available: false

Analyst Notes: As of January 19, 2026, there are no known public exploits or active exploitation campaigns targeting this vulnerability. However, given the high severity and the direct path to remote code execution, it is highly likely that threat actors will develop a functional exploit in the near future.

Analyst Recommendation
This is a high-severity vulnerability that exposes the organization to the risk of a full system compromise. The primary and most effective mitigation is to apply the vendor-provided security patches immediately. Although CVE-2026-0863 is not currently on the CISA Known Exploited Vulnerabilities (KEV) catalog, its critical impact necessitates an urgent response. Organizations must prioritize patching this vulnerability to prevent potential exploitation and protect critical systems and data.

Executive Summary:
A critical server-side request forgery (SSRF) vulnerability has been identified in LibreChat, a popular open-source AI chat platform. This flaw allows an authenticated user to force the application's server to make unauthorized requests to internal network services, potentially leading to sensitive data exposure and further network compromise. Due to the high severity and the vulnerability's presence in the default configuration, immediate remediation is strongly advised.

Vulnerability Details

CVE-ID: CVE-2025-69222

Affected Software: LibreChat is a ChatGPT clone with additional Multiple Products

Affected Versions: Versions prior to 0.8.1-rc2

Vulnerability: The vulnerability is a Server-Side Request Forgery (SSRF) within the "Actions" feature of LibreChat. This feature allows users to configure agents that can interact with external services through OpenAPI specifications. The default configuration lacks restrictions on which URLs or IP addresses these actions can target. An attacker with the ability to configure an agent can create a malicious action pointing to an internal, non-public service (e.g., http://127.0.0.1/api or an internal corporate server). When this action is triggered, the LibreChat server will execute the request, effectively bypassing firewall rules and allowing the attacker to interact with, scan, and potentially exfiltrate data from sensitive internal systems like the RAG API.

Business Impact

This vulnerability is rated as critical severity with a CVSS score of 9.1, posing a significant risk to the organization. Successful exploitation could lead to unauthorized access to internal network resources, theft of confidential data from internal databases and APIs, and comprehensive reconnaissance of the internal network architecture. An attacker could leverage this access to pivot to other systems, potentially leading to a more widespread network compromise, loss of intellectual property, and reputational damage.

Remediation Plan

Immediate Action: Immediately upgrade all instances of LibreChat to the fixed version (0.8.1-rc2) or the latest available version as recommended by the vendor. After patching, review server access logs and application logs for any signs of exploitation, such as unexpected requests originating from the LibreChat server to internal IP addresses.

Proactive Monitoring: Monitor all outbound network traffic from the LibreChat server. Specifically, look for and alert on any HTTP/S requests destined for internal or loopback IP address ranges (e.g., 127.0.0.1, 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16). Regularly audit agent configurations within LibreChat for any actions that point to suspicious or internal endpoints.

Compensating Controls: If immediate patching is not feasible, implement the following controls:

• Apply strict network egress filtering rules on the host firewall of the LibreChat server to block all outbound connections to internal network segments.
• If possible within the application's configuration, disable the "Actions" feature for all non-administrative or untrusted users.
• Place the LibreChat instance behind a Web Application Firewall (WAF) with rules designed to detect and block common SSRF attack patterns.

Exploitation Status

Public Exploit Available: false

Analyst Notes: As of Jan 7, 2026, there is no known public proof-of-concept exploit or active exploitation in the wild for this vulnerability. However, SSRF is a well-understood vulnerability class, and the flaw exists in the default configuration, making it a high-value target for threat actors. Organizations should assume that an exploit could be developed and weaponized quickly.

Analyst Recommendation

Given the critical CVSS score of 9.1 and the potential for direct access to internal network resources, this vulnerability requires immediate attention. We strongly recommend that all affected LibreChat instances be patched to version 0.8.1-rc2 or newer without delay. Although this CVE is not currently listed on the CISA KEV list, its severity and the ease of exploitation in a default setup make it a critical risk that should be prioritized for remediation.

Executive Summary:
A critical vulnerability exists in the cpp-httplib library, a component used in multiple software products, which allows an attacker to spoof their network address and other connection details. By sending a specially crafted request, an attacker can bypass IP-based security controls, poison logs with false information, and potentially gain unauthorized access to systems. This flaw presents the highest possible risk and requires immediate attention.

Vulnerability Details

CVE-ID: CVE-2025-66570

Affected Software: Unknown Multiple Products

Affected Versions: All versions of the cpp-httplib library prior to 0.27.0.

Vulnerability:
The vulnerability, known as header shadowing, stems from how the cpp-httplib library processes incoming HTTP headers. An attacker can inject headers with reserved names such as REMOTE_ADDR, REMOTE_PORT, LOCAL_ADDR, and LOCAL_PORT into a request. The library's read_headers() function parses and stores these malicious headers first. Subsequently, the server's process_request function appends the legitimate connection metadata using the same header names but fails to remove or overwrite the attacker-supplied duplicates. When downstream application code calls the Request::get_header_value function to retrieve connection information, the function returns the first value it finds, which is the spoofed value provided by the attacker. This allows an attacker to control server-visible metadata, leading to IP spoofing, which can be leveraged to bypass IP-based authorization controls, obscure the true source of an attack in logs, and interfere with other security mechanisms that rely on accurate client connection data.

Business Impact

This vulnerability is rated critical with a CVSS score of 10, indicating the highest possible risk of exploitation with severe potential consequences. A successful exploit could directly impact business operations by enabling attackers to bypass critical security controls designed to protect sensitive data and internal systems. The primary business risks include unauthorized access to confidential information, data breaches, and compromise of internal infrastructure by an attacker masquerading as a trusted internal user. Furthermore, the log poisoning aspect significantly hinders incident response and forensic investigations, making it difficult to identify the true source of an attack and assess the extent of a compromise. A public breach resulting from this vulnerability could lead to significant financial loss, regulatory fines, and severe reputational damage.

Remediation Plan

Immediate Action:
Organizations must conduct a thorough software inventory to identify all applications and systems that utilize the vulnerable cpp-httplib library. Once identified, update the affected products or underlying library to a patched version incorporating cpp-httplib 0.27.0 or later. After patching, monitor application and network logs for any signs of post-remediation exploitation attempts.

Proactive Monitoring:
Implement monitoring and alerting for incoming HTTP requests that contain headers such as REMOTE_ADDR, REMOTE_PORT, LOCAL_ADDR, or LOCAL_PORT, as these are not standard client-sent headers and are strong indicators of an exploit attempt. Security teams should correlate application-level logs with network firewall and proxy logs to detect discrepancies between the source IP address logged by the application and the actual source IP of the network connection.

Compensating Controls:
If immediate patching is not feasible, implement the following compensating controls:

• Deploy a Web Application Firewall (WAF) or reverse proxy rule to inspect all incoming traffic and strip the malicious headers (REMOTE_ADDR, etc.) before the request reaches the vulnerable application.
• Enforce stricter network segmentation to limit the impact of a potential authorization bypass, preventing an attacker from moving laterally within the network.
• If possible, modify application logic to use a more reliable method of determining the client's IP address that does not rely on the vulnerable get_header_value function for these specific keys.

Exploitation Status

Public Exploit Available: false

Analyst Notes:
As of December 5, 2025, there is no known public proof-of-concept exploit code or evidence of this vulnerability being actively exploited in the wild. However, given the critical severity (CVSS 10) and the relatively straightforward nature of the attack, it is highly probable that threat actors will develop and deploy exploits rapidly.

Analyst Recommendation

This vulnerability represents a critical and immediate threat to the organization. The primary recommendation is to urgently identify all assets using the vulnerable cpp-httplib library and apply the vendor-supplied patches or updates without delay. While this CVE is not currently listed on the CISA Known Exploited Vulnerabilities (KEV) catalog, its critical severity and potential for widespread impact make it a prime candidate for future inclusion. If patching cannot be performed immediately, the compensating controls outlined above, particularly the use of a WAF to strip malicious headers, must be implemented as a critical temporary mitigation to protect against potential exploitation.

Executive Summary:
A critical remote code execution vulnerability exists in the Coolify management tool. An attacker can gain complete control of the server running Coolify by tricking a user into deploying an application from a malicious code repository. Successful exploitation allows the attacker to execute commands as the root user, leading to a full system compromise.

Vulnerability Details

CVE-ID: CVE-2025-64419

Affected Software: Coolify is an Multiple Products

Affected Versions: All versions prior to 4.0.0-beta.445

Vulnerability: The vulnerability is a command injection flaw due to improper sanitization of input from docker-compose.yaml files. When a user configures Coolify to build an application from a Git repository using the "docker compose" build pack, Coolify parses the docker-compose.yaml file and uses parameters from it to construct system commands. An attacker can craft a malicious docker-compose.yaml file with specially designed parameters that break out of the intended command and inject arbitrary new commands, which are then executed on the Coolify host with root privileges.

Business Impact

This vulnerability is rated as critical severity with a CVSS score of 9.6, posing a severe risk to the organization. A successful exploit grants an attacker full administrative (root) access to the server hosting Coolify. This can lead to the theft or destruction of all data on the server, including application source code, databases, and sensitive credentials. Furthermore, the compromised server can be used as a pivot point to launch further attacks against the internal network, disrupt critical services managed by Coolify, or be used in botnets for malicious activities.

Remediation Plan

Immediate Action: Immediately upgrade all instances of Coolify to version 4.0.0-beta.445 or a later version, which contains the fix for this vulnerability. After patching, carefully review system and application access logs for any signs of compromise, such as unusual commands being executed or deployments from untrusted repositories.

Proactive Monitoring: Implement enhanced logging and monitoring on the Coolify host. Specifically, monitor for suspicious child processes spawned by the Coolify service, unexpected outbound network connections, and review Coolify's own deployment logs for any applications created from unfamiliar or suspicious source code repositories.

Compensating Controls: If immediate patching is not feasible, implement strict access controls to limit which users can deploy new applications. Enforce a policy that only allows deployments from vetted, internal code repositories. Additionally, consider running the Coolify instance behind a firewall with strict egress filtering rules to block potential command-and-control (C2) communication from a compromised host.

Exploitation Status

Public Exploit Available: false

Analyst Notes: As of Jan 5, 2026, there are no known public proof-of-concept exploits or active exploitation campaigns targeting this vulnerability. The vulnerability is not currently listed on the CISA Known Exploited Vulnerabilities (KEV) catalog. However, due to the simplicity of the attack vector and the high impact, it is likely to be targeted by threat actors in the near future.

Analyst Recommendation

Given the critical severity (CVSS 9.6) and the potential for complete system compromise, we strongly recommend that organizations prioritize patching this vulnerability immediately. All instances of Coolify should be upgraded to version 4.0.0-beta.445 or newer without delay. Due to the high risk of root-level remote code execution, this vulnerability should be treated as an imminent threat, even in the absence of current public exploits or its inclusion in the CISA KEV catalog.

Executive Summary:
A critical Server-Side Template Injection (SSTI) vulnerability has been identified in the mailcow: dockerized email suite. This flaw allows a remote attacker to execute arbitrary code on the server by injecting malicious content into a notification template, potentially leading to a complete system compromise, data theft, and disruption of email services.

Vulnerability Details

CVE-ID: CVE-2025-53909

Affected Software: mailcow: dockerized

Affected Versions: All versions prior to 2025-07

Vulnerability: The vulnerability is a Server-Side Template Injection (SSTI) within the notification template system of mailcow: dockerized. An attacker with privileges to modify these templates can inject template syntax that is improperly sanitized and executed directly on the server. By crafting a malicious payload, an attacker can escape the template sandbox and execute arbitrary commands with the permissions of the web application, leading to Remote Code Execution (RCE).

Business Impact

This vulnerability is rated as critical severity with a CVSS score of 9.1. Successful exploitation would grant an attacker full control over the mail server, posing a severe risk to the organization. Potential consequences include the theft of sensitive communications and credentials, loss of data integrity as the attacker could modify or delete emails, and loss of availability of the email service. The compromised server could also be used as a pivot point to attack other internal network resources or be leveraged for malicious activities such as phishing campaigns, further damaging the organization's reputation.

Remediation Plan

Immediate Action: Immediately update all instances of mailcow: dockerized to version 2025-07 or a later version, which contains the patch for this vulnerability. After patching, it is crucial to review system and application logs for any signs of compromise that may have occurred prior to the update.

Proactive Monitoring: Security teams should actively monitor application logs for suspicious input in fields related to notification templates, specifically looking for common template syntax such as {{...}}, {%...%}, or ${...}. Monitor for unexpected processes being spawned by the mailcow web server and any unusual outbound network connections from the mailcow containers, as these could indicate a successful compromise.

Compensating Controls: If immediate patching is not feasible, implement the following controls to mitigate risk:

• Restrict administrative access to the mailcow UI to a limited set of trusted IP addresses.
• Utilize a Web Application Firewall (WAF) with rules designed to detect and block SSTI attack patterns.
• If the custom notification feature is not in use, disable it to remove the attack vector.

Exploitation Status

Public Exploit Available: false

Analyst Notes: As of Jul 17, 2025, there are no known public proof-of-concept exploits or reports of this vulnerability being actively exploited in the wild. However, SSTI vulnerabilities are well-understood, and it is highly likely that a reliable exploit will be developed and published by security researchers or malicious actors in the near future due to the critical severity.

Analyst Recommendation

Given the critical CVSS score of 9.1 and the high potential for full system compromise, this vulnerability requires immediate attention. Although not currently listed on the CISA KEV catalog, its severity warrants treating it as an urgent threat. We strongly recommend that organizations prioritize the deployment of the security update for all affected mailcow: dockerized instances without delay. If patching is not immediately possible, the compensating controls outlined above should be implemented as a temporary measure to reduce the attack surface.

Executive Summary:
A critical remote code execution vulnerability exists in the Keras machine learning framework. An attacker can exploit this flaw by tricking a user or an automated system into loading a maliciously crafted model file, which could result in a complete compromise of the host system. Due to the high severity (CVSS 9.8), immediate patching is necessary to prevent potential data breaches, service disruption, and further network intrusion.

Vulnerability Details

CVE-ID: CVE-2025-49655

Affected Software: Keras Framework

Affected Versions: 3.11.0 up to (but not including) 3.11.3

Vulnerability:
This vulnerability is an insecure deserialization of untrusted data. The Keras framework fails to properly sanitize user-supplied data when loading a .keras model file that utilizes the PyTorch backend. An attacker can craft a malicious model file containing a serialized PyTorch module (TorchModule) with an embedded payload. When a vulnerable version of Keras attempts to deserialize and load this model, the payload is executed with the permissions of the application, leading to remote code execution (RCE) on the target system.

Business Impact

This vulnerability is rated as critical severity with a CVSS score of 9.8. Successful exploitation allows an unauthenticated attacker to execute arbitrary code on the server where the Keras model is being loaded. The business impact includes the potential for complete system compromise, leading to sensitive data exfiltration, deployment of ransomware, or the use of the compromised system as a pivot point for further attacks within the network. Any application or service that loads Keras models from potentially untrusted sources is at immediate risk of a full security breach.

Remediation Plan

Immediate Action:
Update the affected Keras framework to the latest secure version (3.11.3 or later) as recommended by the vendor. After patching, monitor systems for any signs of post-exploitation activity, such as unusual processes or network connections, and review historical access logs for evidence of malicious file uploads.

Proactive Monitoring:

• Monitor application logs for errors or warnings related to model deserialization.
• Scrutinize system logs for suspicious child processes being spawned by the Python application responsible for loading Keras models (e.g., sh, bash, curl, powershell).
• Monitor outbound network traffic from application servers for connections to unusual IP addresses or domains, which could indicate a C2 channel.

Compensating Controls:
If immediate patching is not feasible, implement the following controls to mitigate risk:

• Input Sanitization: Only allow model files to be loaded from trusted and verified internal sources. Do not process Keras models uploaded by external or unauthenticated users.
• Sandboxing: Run the model-loading process within a heavily restricted, containerized environment (e.g., Docker) with no network access and minimal file system permissions.
• Code Signing: Implement a process to cryptographically sign all legitimate models and verify the signature before loading them.

Exploitation Status

Public Exploit Available: false

Analyst Notes:
As of October 17, 2025, there is no known publicly available exploit code, and the vulnerability is not reported to be under active exploitation. However, deserialization vulnerabilities are well-understood, and proof-of-concept exploits can be developed with relative ease. Organizations should assume that attackers will develop and deploy exploits for this vulnerability shortly.

Analyst Recommendation
Given the critical CVSS score of 9.8 and the risk of remote code execution, this vulnerability poses a severe threat to the organization. We recommend that all systems running affected versions of the Keras framework be patched immediately. While this CVE is not currently listed on the CISA KEV list, its critical nature demands that it be treated with the highest priority. If patching cannot be performed immediately, the compensating controls outlined above, particularly sandboxing and restricting model sources, must be implemented without delay.

Executive Summary:
A critical remote command injection vulnerability has been identified in Shiguangwu sgwbox products. This flaw allows a remote, unauthenticated attacker to execute arbitrary commands on an affected device by sending a specially crafted request, potentially leading to a full system compromise, data theft, or further network intrusion.

Vulnerability Details

CVE-ID: CVE-2025-14707

Affected Software: A security flaw has been discovered in Shiguangwu sgwbox Multiple Products

Affected Versions: Shiguangwu sgwbox N3 version 2.0.25 is confirmed to be affected. Other products and versions may also be vulnerable. See vendor advisory for specific affected versions.

Vulnerability: The vulnerability is a command injection flaw within the DOCKER Feature component. Specifically, an unknown function in the /usr/sbin/http_eshell_server binary fails to properly sanitize user-supplied input to the params argument. A remote, unauthenticated attacker can craft a malicious request containing arbitrary OS commands within this argument. When the server processes this request, the injected commands are executed on the underlying operating system with the privileges of the server process, leading to a full system compromise.

Business Impact

This vulnerability is rated as critical severity with a CVSS score of 9.8, indicating a high risk to the organization. Successful exploitation could lead to a complete compromise of the affected sgwbox device, allowing an attacker to steal sensitive data, disrupt critical services, or install malicious software. The compromised device could then be used as a foothold to launch further attacks against the internal network, significantly expanding the scope of the breach and potentially leading to substantial financial and reputational damage.

Remediation Plan

Immediate Action: The primary recommendation is to update affected Shiguangwu sgwbox products to the latest version that addresses this vulnerability. If a patch is available, apply it immediately. Following any update, continue to monitor for exploitation attempts and review access logs for signs of compromise.

Proactive Monitoring: Actively monitor logs associated with the /usr/sbin/http_eshell_server process for any unusual or malformed requests, specifically focusing on the contents of the params argument for shell metacharacters (e.g., |, &, ;, $). Implement network traffic analysis to detect anomalous outbound connections from affected devices. Monitor for unexpected shell processes (e.g., sh, bash, wget, curl) being spawned by the server process.

Compensating Controls: If patching cannot be performed immediately, or if a patch is not available due to the vendor's lack of response, implement the following controls:

• Restrict network access to the device's management interface to a minimal set of trusted IP addresses using a firewall or Access Control Lists (ACLs).
• If possible, disable the DOCKER Feature or the http_eshell_server service if it is not essential for business operations.
• Place the device behind a Web Application Firewall (WAF) with rules specifically designed to detect and block command injection attempts.

Exploitation Status

Public Exploit Available: true

Analyst Notes: As of December 15, 2025, a proof-of-concept exploit for this vulnerability has been publicly released. The availability of this exploit code significantly increases the likelihood of widespread, automated attacks. The vendor's unresponsiveness further elevates the risk, as a timely patch is not guaranteed.

Analyst Recommendation

Due to the critical severity (CVSS 9.8), remote exploitability, and the public availability of an exploit, immediate action is required. We strongly recommend that all affected Shiguangwu sgwbox devices be patched or have compensating controls applied immediately. Given the lack of vendor response, organizations should prioritize isolating these devices from the internet and prepare for the possibility that a patch will not be forthcoming. Although this vulnerability is not currently listed on the CISA KEV catalog, its characteristics make it a prime candidate for future inclusion, and it should be treated with the highest priority.

Executive Summary:
A high-severity vulnerability has been identified in the Fluent Bit component used by "The Multiple Products." The flaw allows an attacker who can control Docker container names to cause a buffer overflow, which could crash the logging service or, in a worst-case scenario, allow the attacker to execute arbitrary code and take control of the affected system. This presents a significant risk of service disruption and potential system compromise.

Vulnerability Details

CVE-ID: CVE-2025-12970

Affected Software: The Multiple Products

Affected Versions: See vendor advisory for specific affected versions

Vulnerability: The vulnerability is a stack-based buffer overflow within the extract_name function of the Fluent Bit in_docker input plugin. This function is responsible for processing Docker container names for logging purposes. It copies the container name into a fixed-size buffer on the stack without first verifying that the name's length does not exceed the buffer's capacity. An attacker with privileges to create or rename Docker containers on a monitored host can exploit this by creating a container with an exceptionally long name, causing the buffer to overflow. This can lead to a denial of service by crashing the Fluent Bit process or, if the oversized name is specially crafted, could overwrite critical control data on the stack, enabling arbitrary code execution with the permissions of the Fluent Bit service.

Business Impact

This is a high-severity vulnerability with a CVSS score of 8.8, posing a significant risk to the organization. Successful exploitation could lead to two primary outcomes. First, a denial-of-service attack would disrupt critical log collection and monitoring capabilities, potentially blinding security teams to other ongoing attacks and impacting compliance requirements. Second, and more severe, successful remote code execution would grant an attacker a foothold on the underlying infrastructure, potentially leading to data theft, lateral movement across the network, deployment of ransomware, or a complete compromise of the host system.

Remediation Plan

Immediate Action: Apply vendor security updates immediately. The vendor has released patches to address this vulnerability, and they should be deployed on all affected systems as a top priority. In the interim, monitor for any signs of exploitation attempts and review Docker and system access logs for unusual activity.

Proactive Monitoring: Security teams should monitor for Fluent Bit service crashes or unexpected restarts, which could indicate exploitation attempts. Review Docker daemon logs for the creation of containers with unusually long or malformed names. Monitor network traffic for any anomalous outbound connections from hosts running Fluent Bit, as this could signal a successful compromise.

Compensating Controls: If immediate patching is not feasible, implement compensating controls to reduce the risk. Strictly limit user and service permissions to create or rename Docker containers on monitored hosts. If possible, use policy enforcement tools like container admission controllers to enforce a maximum length and character set for all container names, preventing the exploit condition from being triggered.

Exploitation Status

Public Exploit Available: false

Analyst Notes: As of November 24, 2025, there are no known public exploits or active exploitation campaigns targeting this vulnerability. However, stack-based buffer overflows are a well-understood vulnerability class, and it is highly probable that a functional proof-of-concept exploit will be developed by security researchers. Organizations must assume that this vulnerability is exploitable and act accordingly.

Analyst Recommendation

Given the high severity (CVSS 8.8) and the potential for remote code execution, this vulnerability requires immediate attention. It is strongly recommended that organizations identify all affected instances of "The Multiple Products" and prioritize the immediate application of the vendor-supplied security patches. Although this vulnerability is not currently on the CISA Known Exploited Vulnerabilities (KEV) catalog, its severity and the potential for severe impact make proactive remediation essential to defend against future exploitation.

---METADATA---
VENDOR: NetBox
PRODUCT: netbox-docker
AFFECTED_VERSIONS: Versions before 2.5.0
---END_METADATA---

Description Summary:
NetBox-docker versions before 2.5.0 contain a superuser account with default credentials and a static API token, potentially allowing unauthorized administrative access.

Executive Summary:
The use of default administrative credentials and a static API token in netbox-docker poses a critical risk of unauthorized access and data exposure.

Vulnerability Details

CVE-ID: CVE-2023-27573

Affected Software: NetBox netbox-docker

Affected Versions: Versions before 2.5.0

Vulnerability: This issue stems from the inclusion of a default superuser account (admin/admin) and a hard-coded SUPERUSER_API_TOKEN. While intended for development, many production deployments failed to change these values, leaving them vulnerable to unauthenticated attackers who can access the instance over the network.

Business Impact

A successful exploit allows an attacker to gain full control over the NetBox instance, which typically contains sensitive network infrastructure data, IP addresses, and device configurations. The CVSS score of 9.0 reflects the high potential for data exfiltration and the compromise of critical network documentation, which could facilitate further attacks on the organization.

Remediation Plan

Immediate Action: Update netbox-docker to version 2.5.0 or later and ensure that all default passwords and API tokens are changed to unique, complex values.

Proactive Monitoring: Review NetBox access logs and API usage records for any activity associated with the default "admin" account or the known static token.

Compensating Controls: Implement network segmentation to ensure the NetBox instance is only accessible from trusted management networks and not the public internet.

Exploitation Status

Public Exploit Available: No

Analyst Notes: As of Mar 11, 2026, there is no public information indicating active exploitation. This is a late-disclosure vulnerability; organizations should verify that historical deployments of netbox-docker were properly secured and that default values were rotated.

Analyst Recommendation

The reliance on default credentials in a production environment is a critical security failure. Administrators must immediately verify their NetBox configurations, rotate all secrets, and update to the latest version. Given the sensitivity of the data stored in NetBox, this remediation should be completed within the current maintenance cycle to prevent unauthorized infrastructure mapping.