A critical vulnerability exists in the human resources component of Roskus Prospero Flow CRM versions before 5.15.9. The issue involves hard-coded credentials where the employee save controller defaults to the literal password "changeme" during onboarding, allowing unauthenticated remote attackers to authenticate as any employee if they know the employee's email address. This occurs because the onboarding form does not require a password field, enabling attackers to bypass authentication controls.
A vulnerability was identified in Webkul Bagisto up to 2.4.4. Affected by this vulnerability is an unknown functionality of the component Customer Item Deletion Endpoint. Such manipulation leads to improper access controls. The attack can be launched remotely. The exploit is publicly available and might be used. The vendor confirms: "The reported issues were already identified through our internal security assessment process prior to this notification and are being handled through our established internal security and development lifecycle. Some of these items have already been addressed, while the remaining items are planned for resolution in upcoming product releases."
**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.
A flaw in Elasticsearch allows an authenticated user holding only read privileges to submit a small search request containing a crafted user-supplied input. Processing that input causes a specific internal component to allocate memory without any upper bound, and the allocation occurs outside the scope of the existing memory accounting controls that were intended to constrain it. The resulting out-of-memory condition is fatal and terminates the affected node process, causing a denial of service.
h11 versions up to 0.14.0 improperly parse HTTP/1.1 chunked transfer encoding by accepting any two bytes as the chunk terminator instead of strictly requiring \r\n. This leniency can cause request smuggling vulnerabilities when combined with a proxy that parses chunked bodies differently. An attacker can craft requests that are interpreted inconsistently by h11 and the proxy, potentially bypassing security controls or causing session key leakage. The issue is fixed in h11 version 0.15.0.
OpenClaw CLI had an issue where authenticated non-owner users in direct message sessions could invoke certain owner-only gateway actions through a narrow tool invocation path. This vulnerability does not allow unauthenticated access or direct code execution. The root cause was inconsistent enforcement of owner-only access controls, relying on tool-name checks rather than comprehensive metadata-driven scopes. The issue affects openclaw versions up to 2026.2.17 and was fixed in version 2026.2.19 by refactoring scope mappings and centralizing owner-only enforcement.
A vulnerability in openclaw-cli's node host system.run handler allows bypassing allowlist enforcement and approval prompts due to a mismatch between rawCommand and command[]. This affects deployments using node host execution with allowlist-based exec policy and approval prompting on allowlist misses. An attacker invoking system.run can supply an allowlisted rawCommand but execute a different command[], bypassing security controls. The issue affects openclaw versions from 2026.1.29 up to but not including 2026.2.14. A patch is planned in version 2026.2.14 to enforce consistency between rawCommand and command[].
OpenClaw CLI versions from 2026.1.29 up to but not including 2026.2.14 contain a critical remote code execution vulnerability (CVE-2026-28466) in the gateway-to-node invocation path. An authenticated gateway client could bypass node exec approval controls by injecting internal approval fields into the node.invoke parameters, enabling arbitrary command execution on connected node hosts. This can lead to full compromise of developer workstations, CI runners, and servers running the node host. The vulnerability is patched in OpenClaw version 2026.2.14.
The python-multipart library improperly handles RFC 2231/5987 extended parameters in Content-Disposition headers for multipart/form-data. It prioritizes extended parameters (e.g., filename* or name*) over plain parameters, which conflicts with RFC 7578 that forbids these extended forms in multipart/form-data. This discrepancy can be exploited to smuggle different field names or filenames past upstream inspectors, potentially bypassing access controls or causing path traversal if filenames are unsafely used. The issue affects several parsing APIs and frameworks like Starlette/FastAPI. A fix is available in python-multipart version 0.21.1_8 and later, which ignores these extended parameters to comply with RFC 7578.
urllib3, when used in a Pyodide runtime environment such as browsers or Node.js, does not enforce its redirect control parameters (`retries` and `redirect`). This is because the runtime itself controls redirect behavior, ignoring urllib3's settings. This can lead to applications relying on urllib3 for redirect control remaining vulnerable to SSRF or open redirect attacks if they depend on disabling redirects. A patched version of urllib3 is available for Node.js usage, but browsers inherently lack mechanisms to control redirects via XMLHttpRequest or the Fetch API, resulting in default redirect behavior.
AI coding tools can introduce unvetted or hallucinated open source dependencies into development pipelines faster than traditional security reviews can handle. This creates a supply chain risk known as slopsquatting, where attackers register malicious packages with names hallucinated by AI models to compromise builds. The rapid adoption of AI coding assistants has outpaced legacy ingestion controls, causing vulnerabilities to propagate through automated dependency suggestions. Securing the pipeline requires governing package selection before build time, using curated and pre-vetted repositories to block malicious or outdated dependencies. This threat highlights the operational challenge of balancing developer productivity with supply chain security in AI-assisted software development.
File Browser versions prior to 2.63.22 have a vulnerability where access rules for descendant files and directories are not properly validated during recursive copy, rename, and delete operations. This allows authenticated users to bypass path-based access controls by manipulating allowed parent directories to affect denied files, compromising confidentiality and integrity.
Jewelbug is a China-based threat actor conducting dual operations: espionage campaigns targeting foreign governments and militaries, alongside a for-profit cryptocurrency fraud business administered from the same control panel. Operating as a small development team with role-based access controls and documented roadmaps, the group recorded over one million implant check-ins, 580,000+ stolen browser cookies, and 2,300+ exfiltrated emails between February and May 2026. Espionage attacks targeted government entities in the Middle East, Southeast Asia, and South Asia with confirmed intrusions. The group deploys the Antino backdoor, a malicious Chrome/Firefox extension called 'PDF Viewer,' and a Linux implant named ClientKing targeting servers and routers. The financially motivated arm operates as a registered Hunan company running industrial-scale SEO poisoning funneling Chinese-speaking victims to fake cryptocurrency exchange sites.
Shescape is a simple shell escape library for JavaScript. Prior to 2.1.14 and 3.0.1, getEscapeFunction in src/internal/unix/dash.js fails to escape ~ after : or = when applications use the escape or escapeAll APIs on Unix with shell set to dash, or with shell set to true when Dash is the default, and interpolate the result into an assignment prefixed to a command. An attacker who controls the input can supply a value such as :~ to disclose the home-directory path and may change the location on which the command operates. This issue is fixed in versions 2.1.14 and 3.0.1.
An authorization bypass vulnerability in LXD due to a timing flaw during configuration merging allows an authenticated attacker to bypass target project restrictions during cross-project instance copies. When copying an instance to a target project, LXD performs restriction checks before configuration merging is complete, creating a time-of-check to time-of-use (TOCTOU) condition. An attacker can exploit this flaw to copy instances with disallowed high-privilege configurations into restricted projects, bypassing security controls.
CamaleonCMS contains a stored cross-site scripting vulnerability in the cama_contact_form plugin that allows low-privileged authenticated attackers to inject arbitrary HTML by submitting unsanitized content to the before_html field through the contact form edit endpoint, which lacks proper authorization controls. Attackers can persist malicious script payloads into the database that execute in victims' browsers when the contact form loads, enabling cookie theft, forged authenticated requests against the admin interface, and session takeover of viewing users.
A security advisory from Red Hat addresses vulnerabilities in the Red Hat Hardened Images RPMs, specifically updating the cosign package to version 3.1.3-0.1.hum1. One notable vulnerability (CVE-2026-72816) involves an IP spoofing flaw in the go-chi/chi RealIP middleware, which allows remote attackers to supply arbitrary IP addresses in client-controlled headers, potentially bypassing IP-based access controls, evading rate limiting, and polluting audit logs. The advisory provides guidance to mitigate this issue by avoiding the use of the vulnerable middleware when receiving traffic from untrusted networks and recommends sanitizing forwarding headers at upstream proxies. No known exploits are reported in the wild, and the update includes bug fixes and enhancements. The vulnerability is rated medium severity by Red Hat.
An authentication bypass vulnerability exists in Fortinet FortiManager versions 7.6.1, 7.4.3 through 7.4.5, and 7.2.5 through 7.2.9, including corresponding FortiManager Cloud versions. This flaw may allow an attacker to bypass access controls via an alternate path or channel, potentially leading to full compromise of confidentiality, integrity, and availability. The vulnerability is identified as CWE-288 and carries a high severity with a CVSS score of 8.1.
A survey of 200 US-based CISOs, CTOs, and other senior security leaders at large organizations reveals widespread concern about new security risks introduced by AI deployments. The majority (93%) are worried about these risks, but only a small fraction (15%) are confident their current security tools can handle them. Key issues include a growing attack surface driven by complex non-human identities and insufficient access controls for machine workloads. The survey highlights operational challenges such as lengthy network change management delays and a widening patch gap. Most organizations are actively exploring new approaches to secure non-human identities, as existing identity systems are largely deemed insufficient.