CPython TLS server SNI-callback reference mismanagement lets unauthenticated remote attackers trigger use-after-free causing memory corruption or service crash
The flaw is that ssl.SSLContext does not correctly maintain the underlying C structure's reference count when sni_callback is set, so after the Python object is destroyed OpenSSL still holds a function pointer to freed memory. An unauthenticated remote attacker can force the server to invoke that dangling pointer at a chosen moment via TLS 1.3 HelloRetryRequest or connection renegotiation, causing deterministic process crash, silently skipped verification, or arbitrary code constructed from concurrent request data—severely harming confidentiality, integrity, and availability.
Component
CPython is the reference interpreter for Python. Its architecture runs dynamic scripts via an efficient bytecode engine and abstracts native OS interfaces; the ssl module implements the TLS stack on OpenSSL and handles encrypted handshake, authentication, and integrity protection for network traffic so distributed applications can communicate securely.
When using SSLContext objects with an sni_callback, keep a long-lived reference for the application lifetime so the object is not collected early; on builds against older OpenSSL, explicitly disable connection renegotiation to cut off the attack path and eliminate use-after-free risk at the root.
CSSA Exclusive Early Warning
10.0 Critical
ComfyUI remote management API missing authentication enables arbitrary code execution and full system compromise
When the manager is enabled via launch flags and bound to a non-loopback address, an attacker can send unauthenticated HTTP POST requests to the exposed management API and trigger endpoints that download and install custom nodes. Auth logic depends only on a static security level rather than caller identity, and the default config does not effectively block remote installs. Attackers can plant nodes containing malicious Python, achieve arbitrary code execution with highest privileges, persist on the host, and destroy confidentiality, integrity, and availability.
Component
ComfyUI is a node-graph GUI that simplifies inference for generative AI models such as Stable Diffusion through visual workflows. A core piece is the custom-node manager that dynamically loads, installs, and updates third-party extensions; it integrates with the main service over an HTTP API and can listen on non-local interfaces for remote collaboration, making it the hub for extensibility.
Type
Missing Authentication for Critical Function (CWE-306)
Enforce strong token-based authentication on the management API and restrict sensitive operations to trusted sources. Strictly validate node provenance, forbid auto-loading of unsigned or non-allowlisted external dependencies by default, and warn clearly on non-local access so only authorized users can install or restart.
In the FireCluster Sync processing module, a missing-authentication flaw (CWE-77) allows an attacker on the cluster interconnect (for example a compromised peer or an on-path network attacker) to send crafted requests and invoke privileged firewall management actions as root. Without valid credentials the attacker can directly manipulate core firewall policy and severely threaten the cluster security boundary. All FireCluster deployments that have not fixed this authentication logic are affected. The attacker only needs to be on the interconnect path or control one cluster node; no user interaction is required for remote privilege escalation.
Component
FireCluster is software for building high-availability firewall clusters with multi-node state sync and coordination, widely used in enterprise network security.
Risks
Full system control: Attackers can run arbitrary firewall management commands as root—including changing, deleting, or bypassing rules—so the whole cluster loses protection
Privilege escalation: From ordinary network attacker to highest cluster admin (root), enabling further lateral movement to other cluster resources
No user interaction: Only specially crafted packets at the network layer are needed; exploitation is highly stealthy
In NVIDIA NeMo Agent Toolkit, critical functionality lacks required authentication (CWE-306). Attackers can exploit it remotely over the network without complex preconditions or user interaction, leading to code execution, privilege escalation, data tampering, denial of service, and information disclosure. All unpatched NeMo Agent Toolkit deployments are affected. Crafted network requests alone can trigger the flaw, fully bypass security controls, and seize illicit control of the system.
Component
NVIDIA NeMo Agent Toolkit is NVIDIA's toolkit for building and deploying AI agents, widely used in enterprise AI application development.
Risks
Privilege escalation and full control: Missing authentication lets attackers execute arbitrary code; if the service runs with high privileges they gain the highest system rights
Data integrity and confidentiality loss: Attackers can tamper with critical data or steal sensitive information, breaking business logic or leaking privacy
Service availability damage: Denial-of-service conditions can interrupt AI agent services and harm business continuity
Unauthenticated remote attack with no interaction: Exploitation needs no user interaction and can be launched directly over the network—stealthy and highly damaging