A vulnerability in the Linux kernel's TI ICSSG ethernet driver causes the function icssg_ndo_get_stats64() to unconditionally call emac_get_stat_by_name() with firmware PA stat names even when the PA stats block is not present. This leads to thousands of error log entries and silent corruption of network statistics counters such as rx_errors, rx_dropped, and tx_dropped. The issue arises because the error return value is widened to a large unsigned value when accumulated, distorting reported network statistics. The vulnerability has been fixed by adding a guard check to prevent calls when the PA stats block is absent.
A resource allocation issue in the Linux kernel's mtd:rawnand:pl353 driver was fixed. The vulnerability involved incorrect use of devm_ioremap() during device probe, which caused the register area not to be released upon module unload. This could lead to resource leaks. The issue has been addressed by targeting the correct device in the devm_ioremap() call.
A vulnerability in the Linux kernel's s390 architecture was fixed by adding a missing array_index_nospec() call to the memtop_get_page_count() function. The 'level' parameter is user-controlled and used to index an array, which could lead to speculative execution issues. This flaw was addressed by adding the missing speculative execution mitigation call.
A vulnerability in the Linux kernel tracing subsystem (osnoise) was resolved by ensuring synchronize_rcu() is called when unregistering, preventing premature release of tracer references. This fixes a potential race condition involving RCU readers traversing instance lists. The issue affects specific linux-hwe-edge kernel versions and has a CVSS score of 7.8, indicating a high impact on confidentiality, integrity, and availability. A patch is available to address the flaw.
A kernel bug in the Linux ext4 filesystem was fixed related to the handling of inline data when the data=journal mount option is used. The ext4_journalled_write_end() function could incorrectly call ext4_write_inline_data_end() without verifying a necessary flag, leading to a kernel BUG triggered by an out-of-bounds write attempt. This occurs if a prior conversion of inline data to an extent failed, causing inconsistent inode flags. The fix ensures the function only proceeds if the appropriate flag is set, preventing the kernel BUG.
CVE-2026-72500 is a high-severity vulnerability in the Linux kernel's RDMA bnxt_re driver. It involves improper freeing of the SRQ toggle page before firmware teardown completes, which can lead to use-after-free conditions when an NQ interrupt writes to freed memory. This flaw has been fixed by moving the free_page() call to occur only after the firmware teardown finishes.
CVE-2026-72499 is a high-severity vulnerability in the Linux kernel affecting version 6.8. It involves improper memory management in the RDMA bnxt_re driver where a toggle page is freed prematurely before firmware teardown completes. This can lead to use-after-free conditions if an NQ interrupt writes to the freed page during the bnxt_qplib_destroy_cq() process. The issue has been fixed by moving the free_page() call to occur only after firmware teardown is complete.
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.
The User Session Synchronizer plugin for WordPress is vulnerable to Authentication Bypass leading to Account Takeover in all versions up to, and including, 1.4.0. The `synchronize_session()` function, hooked on `init` and therefore executed on every request, performs no nonce, capability, or shared-secret validation against the attacker-supplied `ussync-key`, `ussync-token`, and `ussync-ref` parameters; when `ussync-key` references an unregistered slot, `get_option()` returns `false` for both the secret key and the domain list, causing the AES-256-CBC encryption key to degrade to the fully predictable `md5('')` and the referer allowlist to collapse to an empty-string match, while the AES IV is unconditionally hard-coded as `md5('another-secret')`. This makes it possible for unauthenticated attackers to supply a crafted request encrypting any known or guessable user email address in the `ussync-ref` parameter, causing the handler to call `wp_set_auth_cookie()` for the matched user and granting full authentication as that user — including administrators — with no prior knowledge of site secrets.
The bLoyal: Loyalty & Promotions by bLoyal plugin for WordPress is vulnerable to Privilege Escalation in all versions up to, and including, 3.1.611.78. This is due to the AJAX actions `save_bloyal_configuration_data` and `save_bloyal_accesskeyverification_data` being registered without any capability or nonce checks, and the `bloyal_customer_auto_login` function unconditionally trusting the `Customer.ExternalId` value returned by whichever API URL is stored in the plugin's options. This makes it possible for authenticated attackers, with Subscriber-level access and above, to overwrite the plugin's bLoyal Loyalty Engine API URL (`bloyal_custom_loyaltyengine_api_url`) and the `is_bloyal_custom_api_url` flag via the unprotected AJAX actions, then trigger the unauthenticated `/cart` REST route to cause `bloyal_customer_auto_login` to fetch customer data from an attacker-controlled endpoint and call `wp_set_auth_cookie()` with an attacker-supplied `Customer.ExternalId`, thereby authenticating as any WordPress user including the site Administrator.
---
_-= Per source details. Do not edit below this line.=-_
## Source: amazon-inspector (c6d793d1ff65b7f5a24e1aa0c176eaa5d83c7870e05cca5b64f22edb9ca7ded7)
Package published to the public npm registry under the @mexc scope without evidence of scope ownership. package.json declares a postinstall hook ("postinstall": "node postinstall.js") that runs on any installer whose resolver falls back to the public registry when resolving @mexc/shared-utils. The postinstall script collects host metadata — os.hostname(), os.userInfo().username, process.getuid(), process.cwd(), platform, node version, and multiple npm_* environment variables (npm_config_registry, npm_config_user_agent, npm_execpath, INIT_CWD) — and writes the data to os.tmpdir()/mexc-poc-execution-proof.json. The current shipped script performs local write only with no outbound network call, but the install-time code-execution primitive against any CI/build system that resolves the @mexc scope publicly is the classic dependency-confusion pattern; the author controls the code that runs and can change the payload in any future version.
The npm package @ferudionz/web_logger_js version 1.0.0 contains obfuscated malicious code that exfiltrates data to an author-controlled endpoint. The package exports a function that sends its input to a hidden URL assembled at runtime, likely targeting EVM/crypto account identifiers or keys. The obfuscation includes RC4 decoding, anti-debug wrappers, and runtime string reconstruction to conceal the network destination. This behavior is not documented and indicates intentional data theft rather than a legitimate service call.
CVE-2026-12364 is a memory-safety vulnerability in the Zephyr project affecting the user-space system-call verifier for z_log_msg_static_create(). The verifier failed to perform mandatory checks on user-supplied arguments, allowing unprivileged user-mode threads to pass arbitrary pointers and lengths to the kernel. This leads to kernel-mode denial of service via kernel faults and potential disclosure of arbitrary kernel memory through log messages. The vulnerability does not allow kernel memory corruption or out-of-bounds writes. Fixed in Zephyr versions 4.3.2 and 4.4.2.
**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.
Grav CMS before 2.0.13 contains a remote code execution vulnerability in the Flex Objects plugin settings validation that allows authenticated users to execute arbitrary code by uploading a ZIP file containing PHP code. Attackers can bypass routine name validation by using array notation instead of string notation, call the unZip routine with a malicious archive, and write PHP files to the web root for execution.
A missing await in JupyterLab's PyPIExtensionManager.install() method caused the allowlist/blocklist check to not be enforced for direct callers. This vulnerability affects only custom extensions or downstream integrations that call install() directly with untrusted input, combined with an allowlist/blocklist configured and the default PyPI Extension Manager enabled while kernels and terminals are disabled or remote. Stock JupyterLab HTTP API and Extension Manager UI are not affected. The issue is fixed in JupyterLab versions 4.6.2 and later.
GitPython versions up to 3.1.53 contain a vulnerability in the Commit.count() method where unguarded forwarding of keyword arguments to git rev-list allows an attacker to specify an --output argument. This causes git rev-list to truncate the specified file to zero bytes, resulting in arbitrary file destruction. The vulnerability is due to missing unsafe option checks in Commit.count(), unlike sibling methods that have such guards. The impact is medium severity as it allows file truncation at the process privilege level but requires control over the method call parameters.
FreePBX is an open source IP PBX. From 17.0.1 until 17.0.7, the FreePBX Music on Hold module permits dangerous command-line options for /usr/bin/mpg123 and other allowed players in validateCustomConfiguration() in Music.class.php. An authenticated administrator can use options that write files, open control channels, or create Asterisk call files because applicationUsesDisallowedPlayerOption() does not reject those arguments, resulting in arbitrary command execution as the asterisk service user. This issue is fixed in version 17.0.7.