exploit

CVE-2026-32604 is a critical command injection flaw in Spinnaker’s Clouddriver service that arises when handling gitrepo artifact types. The vulnerability

How CVE-2026-20133 Works CVE-2026-20133 is an information disclosure vulnerability affecting Cisco Catalyst SD-WAN Manager. The flaw stems from insufficient file

How the mentioned CVE works (around 20 lines): The vulnerability resides in the SAML-based SSO authentication handler of Quest KACE

How the mentioned CVE works (technical details): CVE-2023-27350 is an authentication bypass vulnerability in PaperCut NG prior to version 22.0.8.

The vulnerability resides in Zimbra Collaboration Suite’s Classic UI, affecting versions 8.8.15, 9.0, 10.0, and 10.1. It is a stored

How the Mentioned CVE Works The vulnerability is an authenticated remote code execution (RCE) flaw in the Kentico Xperience CMS.

The vulnerability exists in the Data Collection Agent (DCA) feature of Cisco Catalyst SD-WAN Manager. An unauthenticated remote attacker can

The vulnerability resides in JetBrains TeamCity versions before 2023.11.4, specifically within internal REST API endpoints that process file path parameters.

How CVE-2026-24765 works: PHPUnit forwards PHP INI settings to isolated child processes using `-d name=value` command-line arguments without sanitizing INI

How the mentioned CVE works: The vulnerability exists in the `orchard` crate used by Zebra nodes to verify Orchard transactions.

The vulnerability exists in YesWiki bazar module, specifically in tools/bazar/services/EntryManager.php at line 704. The function formatDataBeforeSave() processes user-supplied data from

How the mentioned CVE works (around 20 lines) The vulnerability exists in the DuckDB, Snowflake, BigQuery, and DeltaLake I/O managers

How the mentioned CVE works (technical details, ~20 lines): The vulnerability resides in the deserialization of `addr` and `addrv2` network

How the CVE Works: The vulnerability resides in Nhost’s OAuth identity linking logic. When a user signs in with a

How the mentioned CVE works (technical details): The pretalx backend organiser search uses `innerHTML` string interpolation to render submission s,

How the mentioned CVE works: The vulnerability exists in `fileSystemHandler.prefixed()` at scp/filesystem.go:42-48. This method attempts to confine file operations to

How the CVE Works Zebra’s JSON-RPC HTTP middleware treats a failure to read the incoming HTTP request body as an

How the mentioned CVE works (technical details): The vulnerability resides in Zebra’s transaction verification cache optimization. This cache assumes that

How the CVE works (around 20 lines): The vulnerability stems from a refactoring in Zebra (a Zcash node implementation) that

How the Mentioned CVE Works This vulnerability exists in the deprecated `OpenTelemetry.Exporter.Jaeger` package for .NET. The core issue resides in

How the vulnerability works The vulnerability lies in the email template rendering logic of pretalx, where user-controlled placeholders are interpolated

The vulnerability exists because the `Stream` property in SmtpStream, ImapStream, and `Pop3Stream` is an auto-property with no buffer reset when

How the mentioned CVE works: The vulnerability exists in openclaw versions below 2026.4.9. It allows browser interaction routes (e.g., act/evaluate

How the mentioned CVE works: The vulnerability arises because browser-based interactions such as pressKey and type submit flows lack complete

The vulnerability resides in OpenClaw’s outbound host‑media attachment read helper (src/outbound/media.ts and src/policy/tools.ts). 1. Policy mismatch – The system enforces

The vulnerability stems from two critical flaws in the Java agent injection logic of the OpenTelemetry eBPF Instrumentation (OBI) component.

How the mentioned CVE works (approx. 20 lines): The vulnerability resides in openclaw’s Matrix integration, specifically in how profile configuration

The vulnerability arises because openclaw implements two types of browser interaction routes: “guarded” routes that enforce SSRF navigation policies (e.g.,

The vulnerability arises in OpenClaw versions 2026.4.7 through 2026.4.14 where the webchat tool-result media normalization fails to enforce the configured

The vulnerability exists in the QMD backend’s `memory_get` read path of OpenClaw versions prior to 2026.4.15. When the QMD backend

The vulnerability arises from how openclaw handles exec routing for sandboxed agents. When an agent runs inside a sandbox, it

The vulnerability arises because the OpenClaw gateway, upon startup, resolves the bearer authentication configuration from the secret reference (SecretRef) and

The vulnerability exists in the legacy API authentication mechanism used by Kimai versions prior to 2.x. The `TokenAuthenticator` class handles

The vulnerability exists in the `parse_mcp_command()` function inside src/praisonai/praisonai/cli/features/mcp.py. This function is responsible for parsing MCP server command strings into

How the CVE Works (Approx. 20 lines): Vulnerable Component: The PHP connector of elFinder versions prior to 2.1.48. Trigger Command:

The vulnerability resides in how `math-codegen` processes string literals. When an application passes user‑controlled input to cg.parse(), the library does

The vulnerability exists in openclaw’s handling of Chrome DevTools Protocol (CDP) endpoints. When a browser profile connects to a CDP

How GHSA-85gx-3qv6-4463 Works Dapr supports access control policies (ACL) for service invocation, restricting which methods an app may call on

The vulnerability arises from how go-git handles HTTP redirects during smart-HTTP clone and fetch operations. When a remote repository responds

How the CVE Works (around 20 lines): The vulnerability resides in OpenClaw’s Matrix integration, specifically in how room control-command authorization

The vulnerability exists in Feishu webhook mode of OpenClaw versions prior to 2026.4.15. Two fail-open flaws combine to allow unauthenticated

How the mentioned CVE works: CVE-2026-40315 was initially patched by adding input validation (regex ^[a-zA-Z0-9_]$) to `table_prefix` in `sqlite.py` only.

On Windows, Claude Code versions before 2.1.75 loaded system-wide default configuration from `C:\ProgramData\ClaudeCode\managed-settings.json` without validating directory ownership or access permissions.

How the mentioned CVE works: The vulnerability exists in the GET /api/v1/public-chatflows/:id endpoint. When a public chatflow is requested, the

How the mentioned vulnerability works (around 20 lines): The `read_only` mode in `mcp-neo4j-cypher` versions before 0.6.0 is designed to prevent

How the mentioned CVE works: The voice-call realtime WebSocket endpoint in openclaw versions prior to 2026.4.10 accepts oversized frames without

How the CVE works (technical details): The vulnerability resides in openclaw’s heartbeat owner downgrade mechanism for versions 2026.4.7 through 2026.4.13.

How the mentioned CVE works: The vulnerability resides in openclaw’s collect-mode queue batching mechanism (npm package before version 2026.4.14). When

How CVE-2025-12345 Works: The vulnerability stems from a Mass Assignment flaw in the DocumentStore creation endpoint. The entity uses a

The vulnerability (no assigned CVE in the ) allows an authenticated gateway client with config read access to retrieve unredacted

How the mentioned CVE works: The vulnerability resides in openclaw’s delivery queue recovery mechanism for outbound media messages. When the

How the mentioned CVE works: Microsoft Teams SSO invoke handler within openclaw (npm package) lacks sender authorization checks before processing

The vulnerability arises because openclaw’s browser snapshot, screenshot, and tab routes do not re-validate the final browser target after a

The vulnerability exists in the text-to-speech generation endpoint POST /api/v1/text-to-speech/generate, which is whitelisted in `packages/server/src/utils/constants.ts` (line 41) – meaning no

How CVE-2026-24884 Works The vulnerability is a Partial Fix Bypass of CVE-2026-24884 in the `compressing` npm package (tested on v2.1.0).

How this CVE Works The vulnerability arises from improper handling of a configuration constant during the ODT to PDF conversion

The vulnerability arises from how Sentry handles SAML SSO authentication in multi-tenant environments. Insecure user identity linking allows an attacker

How the mentioned CVE works: The vulnerability exists in the sandbox noVNC helper route of openclaw versions between 2026.2.21 and

How the mentioned CVE works The workspace runtime service fails to sanitize user‑supplied commands. An attacker with agent access (e.g.,

The vulnerability exists in _url_to_size(), a helper function used by `get_num_tokens_from_messages()` to count tokens for image inputs. The function first

How the mentioned CVE works (two HIGH severity flaws): The mapping engine’s `DefaultMaxCollectionItems` cap is silently bypassed when calling `IMapper.Map(source,

How the mentioned vulnerabilities work (technical details): The platform runs in “authenticated” mode but fails to enforce auth on several

How the CVE Works The OAuth provider exposes a `clientPrivileges` authorization hook whose documented action set includes create, as shown

How the mentioned CVE works The vulnerability exists due to a discrepancy between how Fastify’s router handles percent‑encoded characters and

The vulnerability exists in `HTMLHeaderTextSplitter.split_text_from_url()` which validates the initial URL with `validate_safe_url(allow_private=False)` to block internal/private IPs. However, the actual HTTP

The vulnerability stems from missing company‑scope checks in three agent‑key management routes: GET /agents/:id/keys, POST /agents/:id/keys, and DELETE /agents/:id/keys/:keyId. The

How the CVE works (around 20 lines): The vulnerability exists in Paperclip AI v2026.403.0 within the execution workspace lifecycle. The

The vulnerability stems from a fundamental oversight in how Authlib’s cache-backed state storage binds an OAuth flow to a user’s

The flaw resides in the directory listing mechanism of @fastify/static. When the `list` option is enabled, the plugin uses the

The vulnerability exists in Paperclip’s authenticated mode where three API endpoints (POST /api/agents/:id/keys, GET /api/agents/:id/keys, DELETE /api/agents/:id/keys/:keyId) only call `assertBoard(req)`

How the mentioned CVE works (technical details): The vulnerability exists in `PaddingFreeSponge` hashing when input length is not a multiple

The vulnerability exists because @fastify/middie versions 9.3.1 and earlier fail to properly register inherited middleware on child plugin engine instances.

The vulnerability arises from improper input validation when processing attacker-controlled protobuf definitions. Specifically, when the application compiles protobuf definitions into

The vulnerability arises from an inadequate validation function, is_relative_url(), which is intended to only allow same-origin redirects after a user

How CVE-2023-38491 works: The authenticated middleware in Budibase uses unanchored regular expressions to match public (no‑auth) endpoint patterns against ctx.request.url.

The vulnerability resides in the `setSafeProperty` function of the mathjs expression parser. Before patching, this function did not adequately restrict

How the CVE works (technical details): The `MarkdownBody` component (shared across issues, comments, chat, approvals, etc.) passes `urlTransform={(url) => url}`

How the mentioned CVE works: The vulnerability allows an attacker with an Agent API key to execute arbitrary OS commands

How the CVE Works The vulnerability exists in Saltcorn’s mobile-sync routes (POST /sync/load_changes and POST /sync/deletes). The `getSyncRows()` function (lines

How the CVE Works: The vulnerability stems from insufficient separation between agent-controlled configuration and server filesystem access. Attackers with an

How the mentioned CVE works The vulnerability resides in `@angular/platform-server` due to improper URL handling during Server-Side Rendering (SSR). When

How CVE-2026-28208 Works The vulnerability exists in the `LocalFolderExtractor` component of Junrar, a Java RAR extraction library. It stems from

How the mentioned CVE works (technical details): The vulnerability resides in Flowise’s Faiss and SimpleStore (LlamaIndex) vector store implementations. Both

How the Mentioned CVE Works Two command injection flaws exist in the `npm/install.js` script of the electerm terminal emulator. The

Permitted subtree name constraints for DNS names were incorrectly accepted for certificates that assert a wildcard name. In X.509 PKI,

The vulnerability resides in the `CustomMCP` node, which is designed to connect to external Model Context Protocol (MCP) servers. When

How the CVE works: Weblate uses string prefix checks (startswith) on resolved absolute paths to enforce repository boundaries. This check

The vulnerability exists in Hot Chocolate’s Utf8GraphQLParser, which implements a recursive descent parser without any recursion depth limit. An attacker

The vulnerability exists in Mojic v2.1.3’s `CipherEngine.js` during HMAC-SHA256 verification. The decryption routine compares the computed HMAC digest (calcDigest) with

The vulnerability arises from improper sanitization of the `cloneSiteURL` parameter in the `cloneClient.json.php` endpoint of the CloneSite plugin. At line

The vulnerability resides in the `/api/v1/loginmethod` endpoint. The API is designed to manage SSO configurations for organizations. However, it suffers

The vulnerability exists in `controller/unaccess.go` within the `unaccessHandler.Handle` function (line 56). The ownership guard contains a logical error: when a

How CVE works (around 20 lines): Commit 49d0bb7 introduced a regression in sanitize-html. The vulnerable code at `packages/sanitize-html/index.js:569-573` assumes `htmlparser2`

The vulnerability stems from the `proxyUi` template engine using Go’s `text/template` (which performs no HTML escaping) instead of html/template. The

The vulnerability exists in OpenClaw’s `exec` script preflight validator. The vulnerable code path performed two distinct operations on a file

The vulnerability exists in the upload PATCH flow under /files/:uploadId. The outer middleware validates the request path using the still-encoded

This vulnerability arises from weak hardcoded default secrets for JWT authentication. In the affected code (packages/server/src/enterprise/middleware/passport/index.ts:29-34), the application defines `jwtAudience`

How CVE-2026-40303 Works The vulnerability resides in the `GetSessionCookie` function, which handles “striped” (chunked) session cookies. It parses an attacker-controlled

How the mentioned CVE works: The vulnerability resides in the token encryption mechanism when the TOKEN_HASH_SECRET environment variable is absent.

The vulnerability arises because the Express.js session secret defaults to the hardcoded string ‘flowise’ when the environment variable `EXPRESS_SESSION_SECRET` is