A use-after-free vulnerability in the Linux kernel Bluetooth management subsystem was fixed. The flaw involved improper cleanup of advertisement monitors during failure scenarios in the MSFT offload add path, leading to a slab-use-after-free detected by KASAN. This could cause memory corruption and potentially allow local attackers with Bluetooth management privileges to compromise system integrity. The issue affects specific Linux kernel versions and has been addressed with an official patch.
A vulnerability in the Linux kernel's ALSA usb-audio qcom driver allows unsafe memory access when disabling a stream with no active interface. The disable branch does not properly check for a negative interface index, leading to potential kernel crashes or memory corruption. This flaw can be triggered by unprivileged local userspace via AF_QIPCRTR. A patch is available to reject disable requests without a resolved interface, preventing unsafe memory dereferences.
A use-after-free vulnerability in the Linux kernel's dmaengine subsystem was fixed by reordering calls in dma_release_channel() to prevent freeing a device prematurely. This flaw could lead to memory corruption and potentially allow local attackers to compromise system integrity. Multiple specific Linux kernel versions are affected. A patch is available to address this issue.
A vulnerability in the Linux kernel's ASoC fsl_audmix driver was resolved by validating enum values before use. The issue involved improper validation of user-provided enum items in the functions fsl_audmix_put_mix_clk_src() and fsl_audmix_put_out_src(), which could lead to out-of-range values being used in operations. This flaw could allow a local attacker with limited privileges to cause high impact including confidentiality, integrity, and availability compromises. A patch is available to address this issue.
A vulnerability in the Linux kernel's BPF subsystem related to cgroup local storage cookie checks for program arrays has been resolved. The issue involves improper compatibility checks that could allow a storage-less BPF program to bridge a tail call chain improperly, potentially leading to unintended behavior. The fix tightens these checks to prevent such bridging while maintaining legitimate tail call functionality. This vulnerability affects specific Linux kernel versions used in the linux-hwe-edge product. A patch is available to address this issue.
A use-after-free vulnerability in the Linux kernel's BPF filesystem (bpffs) was fixed by restoring RCU-delayed inode freeing. The issue arose because inode cleanup was moved from free_inode() to destroy_inode(), removing the RCU delay and causing a use-after-free when concurrent unlink operations occurred. This could lead to kernel memory corruption and potentially allow local attackers to compromise system integrity. The vulnerability affects specific Linux kernel versions and has a high severity score. A patch is available to properly separate blocking cleanup and RCU-delayed freeing, preventing the use-after-free condition.
A vulnerability in the Linux kernel's RDMA/rxe component for non-SRQ Queue Pairs (QPs) allowed malicious users to modify Work Queue Element (WQE) fields during kernel processing, causing out-of-bounds reads. This issue was addressed by copying the WQE to a kernel-local buffer after validating fields, preventing unsafe user-space modifications. The vulnerability affects specific linux-azure kernel versions and has a CVSS score of 7.8, indicating a high impact on confidentiality, integrity, and availability. A patch is available to remediate this issue.
A vulnerability in the Linux kernel's KVM subsystem related to the kvm_io_bus_get_dev() function was addressed by moving locking responsibilities to the callers. The function previously returned a device matched only by address, which could lead to lifetime issues if the device type was unexpected and the lock was dropped before the caller could safely use the device. This flaw could allow local attackers to compromise system confidentiality, integrity, and availability. The issue affects specific versions of the linux-azure kernel and has been fixed in later releases.
A use-after-free vulnerability in the Linux kernel's accel/amdxdna component was fixed. The flaw occurs in the amdxdna_gem_dmabuf_mmap() function when an error path leads to a double release of a GEM object reference, causing use-after-free. This could lead to memory corruption and potentially allow local attackers to compromise system integrity. The issue affects specific linux-hwe-edge kernel versions and has been addressed by changing the error handling to avoid double freeing. A patch is available to remediate this vulnerability.
A vulnerability in the Linux kernel's mtd: rawnand subsystem was fixed by correcting a condition in the 'nand_select_target()' function to ensure the 'cs' value is within the valid range. This flaw could allow a local attacker to cause significant impact including full confidentiality, integrity, and availability compromise. Multiple specific Linux kernel versions are affected. A patch is available to address this issue.
ContextForge is an AI gateway, registry, and proxy that provides centralized discovery, guardrails, and management for MCP, A2A, and REST or gRPC APIs. Prior to 1.0.3, the /admin/gateways/test call site in mcpgateway/admin.py calls validate_gateway_test_url() in mcpgateway/common/validators.py to resolve and reject private, loopback, link-local, and cloud-metadata addresses, but ResilientHttpClient later resolves the original hostname again without binding the validated address. When MCPGATEWAY_ADMIN_API_ENABLED is enabled, an attacker with a database-backed role containing explicit gateways.read permission can use DNS rebinding to return a public address during validation and a private or metadata address during connection, bypassing ssrf_blocked_networks and ssrf_dns_fail_closed because those controls apply only to the validation-time result. The endpoint's allow_admin_bypass=False setting means a bootstrap-only virtual platform-admin identity without a database role is not sufficient. Successful exploitation can reach internal services and cloud metadata, expose cloud credentials, access internal APIs, or probe internal network ports. This issue is fixed in version 1.0.3.
---
_-= Per source details. Do not edit below this line.=-_
## Source: amazon-inspector (8da2cb00fa6d2b5a0e5f4a4bdca8ca0cfaedf7e583b0f9e9f54274bcf5c39e06)
On invocation of `agent-proxy start`, the CLI opens an outbound WebSocket to an obfuscated author-controlled endpoint (hub.client-llm.com, reconstructed at runtime via XOR+base64 with key 'gnP2p!7xQ' from a base64 blob in dist/cli.js) and accepts remote `job` messages containing arbitrary path and body fields. These are POSTed into the local proxy and forwarded to api.anthropic.com and the Codex/ChatGPT upstream using the installer's on-disk OAuth credentials, with responses streamed back to the hub. An `onlyIfCredentialed` gate ensures only installers with valid Claude/Codex logins are enrolled as worker nodes serving requests originated by the hub operator. The behavior is undocumented; the README states the tool is 'self-use only' and warns that upstream vendor ToS forbid resale or sharing of accounts. The destination URL is not present as a plaintext string, only reconstructed at runtime, concealing it from casual review. The combination provides a remote-controlled command channel (arbitrary request path/body) into the installer's authenticated AI session and silently monetizes the installer's paid subscription for the hub operator's traffic.
**CVE:** This vulnerability corresponds to [CVE-2026-72812](https://nvd.nist.gov/vuln/detail/CVE-2026-72812).
### Summary
The `/api/ref/refreshBacklink` endpoint is gated by `CheckAuth` only. Unlike its mutating siblings, it carries no `CheckAdminRole`, no `CheckReadonly`, and no inline reader-role guard so it falls through all three authorization mechanisms the codebase uses to protect write operations. A publish `RoleReader` or the anonymous account when `Publish.Auth.Enable` is `false` can invoke it, forcing the server to flush its pending write-transaction queue, scan all references globally, load and parse referencing trees from disk, and enqueue database writes. This violates the read-only invariant (it writes even in a globally read-only workspace), provides an unauthenticated resource-amplification/DoS primitive, and applies no per-object access check to the caller-supplied ID.
### Details
**Route / auth tier.** `router.go`: `Handle("POST", "/api/ref/refreshBacklink", model.CheckAuth, refreshBacklink)`, `CheckAuth` only. `CheckAuth` admits `RoleReader`; the publish proxy forwards port-6808 traffic with a Reader JWT (anonymous account when publish auth is disabled). Anonymous/reader reachable.
**Guard fall-through.** SiYuan protects write handlers with one of three mechanisms: route-level `CheckAdminRole` (AV/riff/repo/sync/setting/snippet/notebook mutations), route-level `CheckReadonly` (filetree/block/attr/tag mutations), or an inline `IsReadOnlyRoleContext` check (e.g. `updateEmbedBlock`, `updateRecentDoc*Time`). `refreshBacklink` has none of the three.
**Write path reached.** `refreshBacklink` calls `model.RefreshBacklink(id)`:
- `FlushTxQueue()` — forces the pending write-transaction queue to disk.
- `refreshRefsByDefID(defID)` → `QueryRefsByDefID(defID)` (global scan with encrypted-box fallback loop) → `filesys.LoadTrees(rootIDs)` (disk read and Lute parse of every referencing tree) → `sql.UpdateRefsTreeQueue(tree)` (enqueues DB writes) → ref-count task update.
The handler also does not consult `util.ReadOnly`, so it executes its writes even when the workspace is configured globally read-only.
**No per-object authorization.** `defID` is attacker-controlled and receives no publish-access or ownership check, so a reader can force a reference reindex of any document, including publish-forbidden/unpublished ones (cross-scope).
### Proof of Concept
Reproduced on a local instance (SiYuan running locally, publish mode enabled on port 6808, publish Basic Auth disabled), as an anonymous reader (no token):
**Target endpoint executes the full write path:**
```
POST http://127.0.0.1:6808/api/ref/refreshBacklink
{"id":"<any block id>"}
```
Returns `{"code":0,"msg":"","data":null}` HTTP 200 the handler ran to completion, flushing the transaction queue and enqueuing ref writes.
**Controls: the guarded mutating siblings correctly reject the same anonymous session:**
```
POST http://127.0.0.1:6808/api/tag/renameTag → 403 (CheckAdminRole and CheckReadonly)
POST http://127.0.0.1:6808/api/block/foldBlock → 403
POST http://127.0.0.1:6808/api/block/updateEmbedBlock → code 0 no-op (inline IsReadOnlyRoleContext blocks the write)
```
The 200-vs-403 contrast confirms `refreshBacklink` is reachable and executes where its siblings are blocked.
### Impact
An anonymous reader (publish mode with auth disabled) or any publish `RoleReader` can:
- **Bypass the read-only invariant:** trigger persistent server-side writes (transaction-queue flush and reference reindex), including in a workspace configured globally read-only.
- **Amplify resource use without authentication:** each call forces a transaction flush, a global reference scan, and disk read and parse of every referencing tree, with an attacker-controlled `id` and no rate limiting, a DoS primitive.
- **Act cross-scope:** `defID` receives no publish-access check, so a reader can force reindexing of documents outside their publish scope. This is an integrity-invariant violation and a resource-amplification vector, not data corruption or injection, the caller cannot control the content of the writes, only trigger them. Impact is integrity-low and availability-low; no confidentiality impact and no attacker-controlled data reaches storage.
### Suggested fix
Apply the same guard its mutating siblings use, add `CheckReadonly` (and `CheckAdminRole` if reference refresh is intended to be an authenticated operation) to the route, or an inline `IsReadOnlyRoleContext` check consistent with `updateEmbedBlock`. The endpoint should also honor `util.ReadOnly` and apply a publish-access check to `defID` so a reader cannot force cross-scope reindexing. More broadly, the three-way guard strategy (route middleware vs. inline check vs. none) is what allowed this handler to receive no gate at all; a structural backstop, a role-scoped route group for the mutation surface would prevent recurrence.
**CVE:** This vulnerability corresponds to [CVE-2026-72810](https://nvd.nist.gov/vuln/detail/CVE-2026-72810).
### Summary
WebSocket sessions established through the publish surface (port 6808, `RoleReader` anonymous when `Publish.Auth.Enable` is `false`) are added to the same broadcast session pool as authenticated sessions. The kernel's broadcast functions push content events transactions carrying block DOM, document save/create, move/rename to every session in the pool with no role or publish-access filtering. As a result, an anonymous reader who holds a WebSocket connection open passively receives a real-time feed of every edit made in the workspace, including edits to password-protected, publish-forbidden, and unpublished documents. Because these events are delivered over the push channel and never pass through an HTTP handler, none of the publish-access filters that gate the HTTP endpoints apply.
### Details
**Session admission.** `HandleConnect` admits the injected `RoleReader` publish token, and the session is registered via `AddPushChan` into the same `sessions` pool used for authenticated clients.
**Unfiltered broadcast.** The broadcast functions (`Broadcast`, `broadcastOthers`, `broadcastOtherAppMains`, …) write to every session in the pool with no role or publish-access check. The `isPublish` flag on a session is consulted only to send the "service closed" notice it is never used to gate content. Content events are pushed via `PushModeBroadcast → Broadcast()`, so transactions (with rendered block DOM), `savedoc`/create, and `moveDoc`/rename events reach the publish reader's socket unfiltered.
**No HTTP filter applies.** This is a push channel, the events originate from the kernel's own edit pipeline and are broadcast directly to open sockets. They never traverse an HTTP handler, so the publish-access filters that gate the HTTP content endpoints (and the incomplete/missing filters reported separately on those endpoints) are not in the path at all. The WebSocket route (`/ws`) is `CheckAuth`-only, which the publish `RoleReader` token satisfies.
### Proof of Concept
Reproduced on a local instance (SiYuan running locally, publish mode enabled on port 6808, publish Basic Auth disabled). An anonymous client (no token, no password) opens `wss://127.0.0.1:6808/ws` and holds it open while an administrator edits documents in the workspace.
The anonymous socket received, in real time and unfiltered:
- `updateAttrs` with `name=WS_LEAK_SECRET_9931` on a block whose `rootID` is a **password-protected** document.
- The secret title `WS_SECRET_DOC_7742` of a newly created document.
- The create event carrying the notebook (box) name `CritChain` and the document path.
No HTTP request was made beyond the WebSocket upgrade; the content arrived over the push channel.
### Impact
An anonymous reader (publish mode with auth disabled) or any publish `RoleReader` who merely holds a WebSocket connection open receives a live feed of every edit an administrator makes: block DOM, attributes, titles, notebook names, and document structure, including for password-protected, publish-forbidden, and unpublished documents. This defeats the publish-access and publish-password boundaries entirely for any content edited while the socket is open. The precondition is trivial: an administrator active in the workspace while the anonymous socket is connected. Confidentiality-only (passive disclosure); the channel is receive-only for the reader. Encrypted-notebook content follows the same broadcast path if edited while unlocked.
### Suggested fix
Filter broadcasts by session before writing: for any session flagged `isPublish`, apply the same publish-access/publish-ignore/publish-password checks used on the HTTP content path before pushing a content event, or exclude publish sessions from content broadcasts entirely and deliver only the events a publish viewer is authorized to see. The `isPublish` flag is already present on the session; it should gate content, not only the service-closed notice.
A Time-of-Check-Time-of-Use (TOCTOU) race condition vulnerability exists in the SoftFileLock implementation of the filelock package used by PyTorch. The flaw allows an attacker with local filesystem access and permission to create symlinks to exploit a race window between permission checking and file creation, potentially causing lock operations to fail or operate on unintended files. This can lead to silent lock acquisition failures, denial of service, and resource serialization issues. The vulnerability has been patched by adding the O_NOFOLLOW flag to prevent symlink following during lock file creation. Users should upgrade to the patched versions or apply recommended mitigations if immediate upgrade is not possible.
CVE-2026-22702 is a TOCTOU (Time-of-Check-Time-of-Use) vulnerability in virtualenv affecting all versions up to 20.36.1. It allows local attackers to exploit race conditions in directory creation to perform symlink-based attacks, potentially leading to cache poisoning, information disclosure, lock bypass, or denial of service. The issue is fixed in version 20.36.2 by using atomic directory creation calls. Users should upgrade to 20.36.2 or later or apply recommended workarounds to mitigate risk.
The OpenClaw CLI's local skill packaging script previously followed symlinks when creating .skill archives, potentially including unintended local files outside the skill directory. This vulnerability is limited to local execution by skill authors packaging skills and does not affect remote or runtime components. The issue is fixed by rejecting symlinks during packaging in version 2026.2.18.
OpenClaw CLI versions up to 2026.2.23 have a vulnerability in the safeBins allowlist policy where static default trusted directories include writable package-manager paths like /opt/homebrew/bin and /usr/local/bin. An attacker with write access to these directories can place a malicious binary with the same name as a trusted executable (e.g., jq), causing OpenClaw to execute the attacker-controlled binary. This allows command execution within the OpenClaw runtime context. The issue is fixed in version 2026.2.24 by restricting trusted directories to immutable system paths and requiring explicit opt-in for user-managed paths.