Curated security, hosting and development news with vulnerability warnings from fixed trusted sources.
CISA KEVGHSACERT.atHosting
Updated
About these news
Articles are collected periodically from a fixed source list. D4rC Tools stores the headline, source summary and source link only; linked articles are not fetched on page view.
Hosting & NetworkFrom dashboard
How Cloudflare WAF protects against ruby2shell (CVE-2026-132825)
·Cloudflare
ruby2shell lets attackers corrupt memory in default Rails and Sinatra apps without logging in. Cloudflare WAF blocks it for every customer, including Free plans. Upgrade Ruby now, and use the WAF to cover the gap.
How Cloudflare WAF helps protect against phpAfterShell and other critical PHP flaws
·Cloudflare
phpAfterShell is a critical flaw in PHP's default session handler that can lead to code execution. Cloudflare WAF blocks it for all customers, including Free plans, and adds new rules for other PHP flaws fixed in the same release.
WhatsApp Patches 3 Security Flaws, Including Android Bug Suspected of Use in Scams
·The Hacker News
Meta-owned WhatsApp has addressed security vulnerabilities, including one impacting its Android app that it suspects may have been exploited in connection with scam messages. The vulnerability, tracked as CVE-2026-23871, has been described as a case of incomplete validation of external ad-reply URLs in WhatsApp for Android and WhatsApp Business for Android before 2.26.17.4. The issue could
Bazuka Android Malware Uses Fake Screen Overlays to Hide Credential Theft and Device Control
·The Hacker News
Cybersecurity researchers have disclosed details of a previously unknown Android malware framework called Bazuka that offers large language model (LLM) integration for victim management and control at scale. Dutch mobile security company ThreatFabric said it discovered the threat in late October 2026 during an investigation into an NFC-relay banking Trojan. "Bazuka is a full malware framework,
chcon: recursive relabel not anchored to traversal dirfd (TOCTOU)
·GitHub Advisories
chcon resolved recursive targets from fts_accpath with a fresh path lookup, so traversal and the SELinux get/set were not bound to traversal directory state. A privileged recursive relabel can be redirected to unintended objects under rename/symlink races. Fix opens targets with openat against the traversal cwd fd before the SELinux operation. **Fixed in 0.10.0** (PR #12566, commit 7cfc74e47ffab452663be6842d788a5164d9688b): recursive relabel resolution is anchored to the traversal dirfd. --- _Zellic private finding (zellic-ext/coreutils-private PR #120). Reported in the Zellic *uutils coreutils Program Security Assessment* (for Canonical, Jan 2026), audited commit 3a07ffc5a9bd4c283e75afa548ba1f1957bad242._
uu_env incorrectly rejects backslashes within single-quoted strings accepted by GNU env
·GitHub Advisories
In env -S, GNU keeps backslashes literal inside single quotes (except \\ and \'); uutils errors on sequences like \a. This is the backslash-handling issue of the broader -S/--split-string parsing divergence. `` env -S"printf %s '\''\\x'\''" # GNU prints \x ; uutils: invalid sequence '\x' in -S (125) `` --- _Zellic private finding (zellic-ext/coreutils-private PR #117). Reported in the Zellic *uutils coreutils Program Security Assessment* (for Canonical, Jan 2026), audited commit 3a07ffc5a9bd4c283e75afa548ba1f1957bad242._
split: TOCTOU output-open allows truncating a swapped file
·GitHub Advisories
split checks input/output identity by path before opening the output, then opens with truncation, leaving a race window on mutable path components. GNU opens first and compares the opened output inode against the input before truncating. The race can cause split to truncate/write a file different from the one validated — including the input file or another file the process can access. **Fixed in 0.10.0** (PR #12565, commit 58040feb5c66fce588a7ffac299b3a23bd55cd81): the output open path is hardened against TOCTOU target swaps. --- _Zellic private finding (zellic-ext/coreutils-private PR #119). Reported in the Zellic *uutils coreutils Program Security Assessment* (for Canonical, Jan 2026), audited commit 3a07ffc5a9bd4c283e75afa548ba1f1957bad242._
## Description Web user registration form is vulnerable to session fixation if the site is configured with server-side session storage (CKAN uses cookie-based session storage by default). The attacker would need to either set a cookie on the victim's browser or steal the victim's currently valid session. Session identifiers are now regenerated after registration. ## Patches This vulnerability has been fixed in CKAN 2.10.11, 2.11.6 and 2.12.0 ## Workarounds switch to cookie-based session storage (the default) or disable web user registration by setting ckan.auth.create_user_via_web to false (the default)
## Summary: OHttpClientCodec and OHttpServerCodec retain the encrypted outer HttpContent in a handler-level cumulationBuffer. After a valid OHTTP exchange completes, the OHTTP request/response context is destroyed, but the outer cumulationBuffer is not released or reset. It remains referenced by the codec until a later inbound content frame replaces it or the handler is removed/channel is closed. This can pin attacker-influenced pooled/direct buffer capacity on idle keep-alive channels. Across many long-lived idle connections, this can create availability pressure. Affected components: * codec-ohttp/src/main/java/io/netty/incubator/codec/ohttp/OHttpClientCodec.java * codec-ohttp/src/main/java/io/netty/incubator/codec/ohttp/OHttpServerCodec.java * codec-ohttp/src/main/java/io/netty/incubat…
Git LFS may execute arbitrary commands via crafted Git LFS configurations
·GitHub Advisories
### Impact When fetching objects from a malicious repository, Git LFS may execute an arbitrary command or binary after failing to sufficiently restrict the set of configuration options defined in an .lfsconfig file in the repository. Git LFS permits a limited set of configuration options to be defined in an .lfsconfig file at the root of a Git repository, but does not filter these options correctly if their keys contain certain additional components, which allows an attacker to mimic options that configure Git LFS to use a custom command to transfer objects. An attacker can then provide an arbitrary command which Git LFS will invoke when fetching objects. Git LFS has resolved this issue by correctly restricting the configuration of custom object transfer commands to local Git configur…
Git LFS may execute arbitrary commands via crafted Git configurations
·GitHub Advisories
### Impact When fetching objects from a malicious repository, Git LFS may execute an arbitrary command or binary after incorrectly parsing the Git configuration options defined for a submodule. Git LFS reads Git configuration options without checking for embedded line-ending control characters. By inserting control characters such as line feed (LF) into certain values, an attacker may be able to mimic options that cause Git LFS to execute an arbitrary command when fetching or adding objects. Git LFS has resolved this issue by always using an unambiguous format to read and parse Git configuration options. ### Patches This problem exists in all versions since 0.6.0 and is patched in v3.8.1. All users should upgrade to v3.8.1. ### Workarounds To work around the problem, users should prevent…
OpenRemote: Cross-realm MQTT session disconnect without authorization
·GitHub Advisories
### Summary Cross-realm MQTT session disconnect without authorization ## Vulnerability The disconnectUserSession endpoint in UserResourceImpl.java (line 443) accepts a realm path parameter but ignores it entirely, performing no authorization or realm-boundary check before force-disconnecting an MQTT session. Any authenticated user from any realm can disconnect MQTT broker sessions belonging to users in other realms by supplying the target session ID. File: manager/src/main/java/org/openremote/manager/security/UserResourceImpl.java, lines 443-447 ``java @Override public void disconnectUserSession(RequestParams requestParams, String realm, String sessionID) { if (!mqttBrokerService.disconnectSession(sessionID)) { throw new NotFoundException("User session not found"); } } `` The RE…
Paymenter: Unauthenticated arbitrary method invocation in Livewire components
·GitHub Advisories
### Summary A Livewire function allowed attackers to call any public function, allowing attackers to call any public method on the component. Because an attacker can call any function, they can also overwrite locked data. ### Technical Details app/Livewire/Traits/HasConfirmation.php exposed a public Livewire action that dispatches to any method that exists on the component: ``php public function executeConfirmedAction($action, $parameters = []) { if (method_exists($this, $action)) { return $this->{$action}(...$parameters); } throw new \Exception("Method {$action} does not exist"); } `` The trait is applied on the base component, app/Livewire/Component.php (use Disabled, HasConfirmation, HasNotifications;), so it is present on all 36 client-facing components. `executeConfirmedActio…
storyblok-backup: Stored path traversal via unsanitized Storyblok component names in backup output
·GitHub Advisories
### Summary storyblok-backup writes files using unsanitized names for Storyblok components, which are content type or schema definitions. This allows a component name containing path traversal sequences to cause backup files to be written outside the intended backup directory. Anyone with component management access in the source Storyblok space, not server access, can plant a malicious component name that causes arbitrary file writes on the machine of anyone who later runs a backup against that space. ### Details The writeJson function, which takes a folder, a file name, and content, builds the output file path by directly concatenating the backup directory, the folder, and the file name as strings, with no path sanitization or containment check. For the components resource type specific…
aMQTT: Denial of Service (DoS) via Memory Leak in Unmanaged QoS 2 Session Handshakes
·GitHub Advisories
### Impact amqtt is vulnerable to a remote denial of service caused by incomplete MQTT QoS 2 transactions remaining allocated after the associated client disconnects. MQTT QoS 2 uses a four-step handshake to provide exactly-once delivery. If a client begins a QoS 2 transaction but disconnects before the handshake completes, amqtt retains the associated transaction state and packet identifier without an expiration mechanism to remove it. QoS 1 transactions are protected by a timeout mechanism, which defaults to 5 seconds, allowing abandoned state to be released. Equivalent timeout handling was not applied to incomplete QoS 2 transactions. An attacker can repeatedly connect to the broker, initiate QoS 2 transactions, and disconnect before completing the handshake. Each incomplete transa…
Poweradmin: The email second factor is an mt_rand() six-digit code verified with no attempt limit or lockout, so an attacker holding the password can brute-force it within the validity window
·GitHub Advisories
### Summary The email second factor is an mt_rand() six-digit code verified with no attempt limit or lockout The email second factor is a six-digit code drawn from mt_rand() and verified with no attempt limit, so an attacker who already has the password can brute-force it inside its validity window. lib/Domain/Service/MfaService.php, in generateEmailVerificationCode(): ``php $numericCode = mt_rand(100000, 999999); `` That is a 900,000-value space, and mt_rand() is a Mersenne Twister rather than a CSPRNG, so it is not appropriate for a security token in the first place. PHP provides random_int() for exactly this. The bigger problem is that nothing limits guesses. lib/Application/Controller/MfaVerifyController.php calls: ```php $isValid = $this->mfaService->verifyCode($userId,…
Fabio: Access-control bypass through unnormalized request paths
·GitHub Advisories
## Summary Route selection uses the raw un-normalized request path, and the per-route ACL and basic-auth gates hang off that selection, so a dot-segment, encoded-dot, or double-slash variant of a protected path selects a different route, skips both gates, and is forwarded to the backend which normalizes and serves the protected resource. Unauthenticated; complete bypass of the access control the operator configured. Confirmed at HEAD b841544. Direct peers: Traefik CVE-2023-47106, Envoy CVE-2019-9901. ## The defect fabio never normalizes the request path. A repository-wide search for path.Clean returns zero results. Route selection uses the raw path (route/table.go line 487: if target = t.lookup(h, req.URL.Path, pick, match); target != nil {). Both access-control gates are properties of…
### Impact After receiving an HTTP redirection, Git LFS may forward certain HTTP headers to a host other than the one for which they were intended. While Authorization headers are never forwarded to inappropriate hosts, Cookie headers may be forwarded incorrectly. Git LFS has resolved this issue by never forwarding Cookie headers to hosts other than the ones for which they were intended. In particular, after an HTTP redirection is received to a URL with a different scheme, host, or port than found in the URL of the current request, any Authorization and Cookie headers from the current request will not be sent in the redirected request. ### Patches This problem exists in all versions since 0.5.0 and is patched in v3.8.1. All users should upgrade to v3.8.1. ### Workarounds No sing…
Git LFS may attempt arbitrary remote commands via crafted SSH URLs
·GitHub Advisories
### Impact When Git LFS makes object transfer or authentication requests to a remote host via SSH, it passes the path component of the remote's SSH URL as part of a command to be executed, but does not properly format the URL's path component as a single argument. By inserting shell meta-characters into the SSH URL, an attacker may be able to execute arbitrary commands on the remote host, if the host passes the commands to a shell without sanitizing them first. Git LFS has resolved this problem by fully quoting the arguments of the remote commands it sends via SSH. As well, Git LFS has resolved a problem with the default HTTPS URLs used when an SSH URL is configured for a remote host and the host either does not support Git LFS remote commands sent via SSH or supports HTTP authentication…
## Summary Missing authorization in the update_folder action: any authenticated non-read-only user can rename, re-parent and convert to personal any folder in the instance, moving another team's credential subtree into their own personal space and removing it from the organization. Confirmed at HEAD 2f271cdd (3.2.1.1), and present at 3.1.3.1 and 3.1.7.6. ## The defect The folder-management endpoint dispatches an update_folder action that renames and re-parents a folder. Unlike its sibling actions in the same file, it never checks the edited folder id or the submitted parent id against the caller's accessible-folder set, and the file itself performs no session/authorization gate at all. By pointing the new parent at their own personal folder, an authenticated low-privilege user takes owner…
aMQTT: Inefficient Regular Expression Complexity and Uncontrolled Resource Consumption and Improper Input Validation
·GitHub Advisories
### Impact amqtt is vulnerable to a remote denial of service caused by improper MQTT topic-filter validation combined with catastrophic regular-expression backtracking. A single client can freeze the entire broker by sending one specially crafted SUBSCRIBE packet followed by one PUBLISH packet. The vulnerability is caused by two defects: 1. add_subscription() validates the placement of the single-level wildcard + using substring checks for /+ and +/, rather than verifying that each /-delimited level containing + is exactly +. This allows malformed filters such as "+/" + "+" * 60 to be accepted instead of rejected with return code 0x80, as required by MQTT-4.7.1-3. 2. _matches() converts every + character into the greedy regular-expression fragment [^/]* and e…
go-guerrilla crashes on a bare XCLIENT command (7-byte slice off-by-one panic)
·GitHub Advisories
The defect ---------- Confirmed at HEAD. server.go: cmdXCLIENT = []byte("XCLIENT") is 7 bytes (line 78), so the dispatch match cmdXCLIENT.match(cmd) only guarantees len(input) >= 7. The handler then slices input[8:] (line 586): case sc.XClientOn && cmdXCLIENT.match(cmd): if toks := bytes.Split(input[8:], []byte{' '}); len(toks) > 0 { // line 586 A client sending the bare command XCLIENT (exactly 7 bytes) hits input[8:7] and panics runtime error: slice bounds out of range [8:7]. handleClient runs in the per-connection goroutine (server.go:391) which has no recover(); the only recover() calls are in the backend mail-processing workers (a different goroutine never reached during command parsing), so the unrecovered panic crashes the whole SMTP daemon. Input and attacker ------------------- C…
pREST _groupby function-expression SQL injection (incomplete fix of CVE-2025-58450)
·GitHub Advisories
What the fix did and the gap ---------------------------- The v2.3.0 fix (commit e88dabb) routed the _select field through a strict new gate, sanitizeSelectField (postgres.go:947/1003/2097). The sibling _groupby path was left on the far weaker isSafeSQLExpression. adapters/postgres/postgres.go, GroupByClause (line 1946): a _groupby field that contains balanced parens takes the raw-SQL-expression branch (around lines 1999-2006), gated only by isSafeSQLExpression (line 2001, defined at 2043). That gate validates only the OUTERMOST function name against a 13-entry allowlist and uses a character allowlist that permits spaces, single quotes and parens. It blocks ;, --, /* , unbalanced parens and an outer pg_ prefix, but NOT a trailing UNION SELECT ..., a nested (SELECT ...) subquery, or an inn…
js-toml allows uncontrolled recursion in `load()` leading `RangeError` (stack exhaustion) on deeply nested input
·GitHub Advisories
## Summary load() parses untrusted TOML using a recursive-descent parser (Chevrotain) and a recursive tree-walking interpreter. Neither the parser nor the interpreter enforces a maximum nesting / key depth. A small, attacker-controlled document with deep nesting (arrays, inline tables) or a long dotted key drives recursion past the V8 call-stack limit, and load() throws an **uncaught RangeError: Maximum call stack size exceeded**. This is a problem for two reasons: 1. **Denial of Service.** A tiny payload (≈2 KB) reliably aborts parsing. In any service that parses user-supplied TOML, an unhandled RangeError can crash the worker/process (500 / restart loop). 2. **Error-contract violation.** The library signals invalid input via SyntaxParseError (see src/load/exception.ts; the e…
Refitter: Unrestricted OpenAPI references permit build-host SSRF and file inclusion
·GitHub Advisories
### Summary Refitter (the refitter dotnet tool, built on NJsonSchema for $ref resolution) fetches remote http(s) URLs and reads local files (including absolute paths and ../ traversal outside the input directory), inlining the referenced schema into the generated Refit interface/contracts. Running refitter --output Out.cs on a spec whose $ref points at an attacker/internal URL or an arbitrary local file yields SSRF, remote file inclusion, and local file inclusion. Verified on Refitter 2.0.0. ### Details - $ref: http://attacker-or-internal/evil.json#/... -> build host fetches (SSRF) and inlines the remote schema (RFI); confirmed property REMOTE_REFIT_PROP. - $ref: /abs/path.json#/... or ../../secret.json#/... -> out-of-tree local file read + inlined (LFI); confirmed pro…
appium allows unauthenticated arbitrary file/directory deletion in @appium/storage-plugin
·GitHub Advisories
## Summary The Appium storage plugin exposes an HTTP endpoint POST /storage/delete that takes a user-supplied name and deletes it from the server storage folder. The handler passes name straight into path.join(storageRoot, name) and then fs.rimraf() **without any path sanitization**. By sending a name containing ../ sequences, an unauthenticated remote client can escape the storage root and **recursively delete arbitrary files and directories** that the Appium process user can write, anywhere on the host filesystem. The same plugin's *upload* path validates the name via fs.sanitizeName (requireValidItemOptions), but the *delete* path does not an asymmetry that makes the missing validation unambiguous. ### Details Published build (`node_modules/@appium/storage-plugin/buil…
Linux KVM Flaw CVE-2026-99312 Lets Guest VMs Access Host Memory on AMD Hosts
·The Hacker News
A flaw in KVM, the hypervisor built into the Linux kernel, let researchers read about 127 GB of a cloud server's memory from inside a virtual machine of their own on DigitalOcean. On a shared server, that memory can include other customers' virtual machines. The flaw, tracked as CVE-2026-99312, affects only hosts with AMD processors and nested virtualization enabled. Fixed kernels shipped
Security leaders are about to hand AI agents a lot more authority. In a recent a16z survey of CISOs at organizations with more than 1,000 employees, 36% said they are comfortable today letting AI agents act autonomously on low-risk security actions. In 12 months from now, 60% expect to be comfortable at that level. Overall, AI SOC was the highest ranking initiative for 2027. The pressure
SonicWall Warns Gen 6 Firewalls Won't Get Security Patches, Even for Critical Flaws
·The Hacker News
SonicWall has urged all customers still running Generation 6 firewalls to retire and replace them immediately and stop exposing the devices on the internet edge, citing security risks fueled by AI-assisted attacks. "Attackers now use automation and AI to find and exploit unsupported edge devices faster than ever," SonicWall said. "We expect internet-facing Gen 6 firewalls to be actively
Hackers Exploit Critical Cisco Expressway Flaw, Breach Four Devices and Reach Internal Network
·The Hacker News
Threat actors have been observed exploiting a recently disclosed critical security flaw in Cisco Expressway to breach a Russian organization shortly after the public release of a proof-of-concept (PoC) exploit. The activity involves the exploitation of CVE-2026-76466 (CVSS score: 9.8), a vulnerability that could allow an unauthenticated, remote attacker with network access to a Cisco Expressway
ROMULUS ClickFix Attacks Deliver RAT That Can Spy on Users and Control PCs
·The Hacker News
Threat actors have been observed using the ROMULUS ClickFix malware delivery platform to deliver a previously undocumented remote access trojan (RAT) that shares similarities with CNCMachineRMS. "ROMULUS likely operates as a delivery service, distributing CNCMachineRMS and Legion Loader through separate chains while retaining ClickFix and signed binary sideloading techniques," Blackpoint
China-Linked Hackers Exploit Critical VMware vCenter Zero-Day to Gain Admin Access and Steal Data
·The Hacker News
The suspected China-nexus cyber espionage group known as Armory Castle (formerly UNC5221) has been attributed to the zero-day exploitation of a critical security flaw in VMware vCenter Server in early September 2026. The vulnerability, tracked as CVE-2026-123890 (CVSS score: 9.8), is a case of authentication bypass in the VMware Directory Service that could be exploited to gain unauthorized
New Unpatched Windows 0-Day FastUnlock Lets Someone Holding a Locked PC Run Programs on It
·The Hacker News
A newly disclosed unpatched zero-day technique called FastUnlock lets someone with physical access to a locked Windows computer start programs without signing in. Whoever uses it gets only a limited account, not administrator control of the machine. The method was posted yesterday by a researcher who uses the handles MSNightmare and Nightmare Eclipse, and the endpoint-security firm ThreatLocker
nginx2root: Five new nginx vulnerabilities, and how Cloudflare protects origins from the worst of them
·Cloudflare
Five memory corruption bugs in nginx, called nginx2root, can let an unauthenticated attacker run code on a server. Here’s how they work, and why origins behind Cloudflare's proxy are shielded from the most serious of these bugs.
### Summary An unauthenticated path‑traversal / arbitrary file read vulnerability in Etherpad's /static/* handler allows any remote, unauthenticated user to read any file on the server's filesystem (e.g. GET /static/plugins/ep_etherpad-lite/static/..%5C..%5C..%5C..%5C..%5C..%5C..%5Cetc/passwd returns /etc/passwd) available to the user running the etherpad software. Because the endpoint is mounted before the authentication middleware, no credentials, session, or configuration change are required. The read primitive could escalate to a full server compromise: on a typical deployment by disclosing settings.json / credentials.json / /proc/self/environ, which contain the admin password, giving an attacker an admin session and, through the admin plugin installer, remote code execution. ### Deta…
ALTCHA: Nil-map panic (pre-verification DoS) in v1 parseServerSignature on malformed VerificationData
·GitHub Advisories
### Summary parseServerSignature in the v1 module only initializes ServerSignatureVerificationData.Extra inside the if err == nil branch after url.ParseQuery(parsedPayload.VerificationData). Go's url.ParseQuery returns the successfully-parsed pairs together with a non-nil error when the query string contains a malformed percent-escape. A subsequent loop unconditionally writes unknown keys into Extra, regardless of err, causing a nil-map write panic (assignment to entry in nil map) whenever an attacker supplies a VerificationData string with a bad %-escape (e.g. x=1&%zz=2). This is reachable pre-authentication: parseServerSignature is called by the exported VerifyServerSignature / VerifyServerSignatureSafe before any HMAC/signature check, and VerificationData is a…
A crafted PNG can make imagemeta.Decode allocate memory far in excess of the input file's size, leading to memory exhaustion. Two separate paths in the zTXt "Raw profile type iptc" branch are affected: the declared chunk length drives an allocation directly, and the embedded zlib stream is decompressed without an output bound. A 42-byte file allocated 256 MB, and a 127 KB file allocated 460 MB. ### Impact Denial of service by memory exhaustion against any application that decodes untrusted PNG images with this library. The decompression bomb is the more reliable vector, since it produces genuinely resident memory; the effect of the oversized make depends on the platform's overcommit behavior and any configured GOMEMLIMIT or cgroup limit. ### Patches Fixed in v0.17.3. ### Workaroun…
Aether Project amf: panic on an unrecovered NGAP goroutine
·GitHub Advisories
## Summary HandlePathSwitchRequest guards the UESecurityCapabilities IE for presence but never for length, and the extensible APER type silently yields an empty bit string, so six unguarded index-zero reads panic on an unrecovered goroutine and terminate the AMF. The AMF is the control-plane entry point for a 5G core, so terminating it drops mobility management for every subscriber. Confirmed at HEAD daed5a2 (present in v3.1.5). ## The defect ngap/handler.go: ``go if uESecurityCapabilities != nil { // line 3267, PRESENCE only amfUe.UESecurityCapability.SetEA1_128_5G((uESecurityCapabilities.NRencryptionAlgorithms.Value.Bytes[0] & 0x80) >> 7) // line 3268 ... (five more Bytes[0] reads, lines 3269-3273) } `` Six index-zero reads, all guarded only by a nil check on the containing IE. Why th…
baserCMS administrative API authorization bypass through session fallback
·GitHub Advisories
### Summary An authorization bypass occurs against the API endpoint /baser/api/admin/ by abusing the session authentication fallback. ### Details The mail settings are used here as an example. Admin side: https://github.com/baserproject/basercms/blob/master/plugins/baser-core/config/permission.php#L100 With auth => false, it is not accessible with operator privileges. API side: https://github.com/baserproject/basercms/blob/master/plugins/baser-core/config/permission.php#L286 With auth => true, it is accessible even with operator privileges. --- First, the default group for operators has auth_prefix = 'Admin', which does not include Api/Admin. https://github.com/baserproject/basercms/blob/master/plugins/baser-core/src/Model/Table/UsersTable.php#L389 Because of this condition, whe…
baserCMS: Path Traversal Bypass via realpath() in BcThemeFileService (CVE-2026-30940 Patch Bypass)
·GitHub Advisories
### Summary The security patch introduced in baserCMS 5.2.3 to address CVE-2026-30940 / [GHSA-c5c6-37vq-pjcq](https://github.com/baserproject/basercms/security/advisories/GHSA-c5c6-37vq-pjcq) is **incomplete**. The patch added a realpath()-based directory traversal check in BcThemeFileService::getFullpath(), but the check is **entirely skipped** when realpath($baseDir) returns false — which occurs whenever the target subdirectory does not physically exist on disk. An authenticated administrator can bypass the patch by supplying a type value (e.g., js) that maps to a non-existent directory in the theme. The absence of the directory causes realpath() to return false, the validation block is skipped, and the raw path parameter containing ../ sequences is returned unvalida…
falcon-rust: Discrete-Gaussian sampler runs at 2^-33 precision, far below Falcon's requirement (reference KAT vectors no longer pass)
·GitHub Advisories
**Reporter:** Connor Webber **Package:** falcon-rust (crates.io), repository github.com/aszepieniec/falcon-rust **Affected:** v0.1.3 and the current master (HEAD cfa1b35). Regression introduced in commit bf2cf00. **Component:** discrete-Gaussian sampler, src/samplerz.rs (approx_exp, ber_exp, sampler_z) **Status:** Confirmed by source review and by empirical measurement of the crate's own compiled code. ## Summary falcon-rust's discrete-Gaussian rejection sampler evaluates its exp() acceptance step at only 32 bits of fractional precision. Measured directly against the crate's own compiled code, approx_exp has a maximum relative error of 2^-33. For comparison, the Falcon reference implementation achieves about 2^-63, and the f64 code this crate replaced achieved about…
### Impact SQL Injection in ListFormatHelper allows authenticated users with the upload permission to execute arbitrary SQL queries and exfiltrate sensitive database contents through the /async/select-options endpoint when general/caching/list_format is enabled. ### Patches This has been patched in Bolt 6.1.4.
Bolt: Prevent SSRF due to unchecked followed redirects
·GitHub Advisories
### Impact The /bolt/async/upload-url and /bolt/async/embed endpoints validated only the **submitted** URL before fetching it server-side, but the fetch then **followed redirects to destinations that were never re-validated**. This allowed an authenticated user to bypass the SSRF guard (UrlSafetyChecker) and make the server issue requests to internal/cloud-metadata addresses. ### Patches This issue has been patched with Bolt 6.1.5.
Bolt: Information disclosure through unfiltered public relation API endpoint
·GitHub Advisories
### Impact A missing access-control filter in the public Relation API allowed unauthenticated users to discover metadata about unpublished, draft, and viewless content through REST and GraphQL endpoints. ### Patches This has been patched in Bolt 6.1.4.
Bolt: Server-Side Request Forgery (SSRF) in URL-upload and embed endpoints
·GitHub Advisories
### Impact Two authenticated backend endpoints fetched a user-supplied URL server-side with no protection against internal targets. ### Patches This has been patched in Bolt 6.1.4.
Bolt: Open redirect enables post-authentication redirection to arbitrary domains
·GitHub Advisories
### Impact Open redirect vulnerabilities in LoginFormAuthenticator allow attackers to redirect users to attacker-controlled domains after login success or login failure, enabling phishing attacks and potential token theft. ### Patches This has been patched in Bolt 6.1.4.
Daptin: Broken Access Control (IDOR) in the generic YJS collaboration endpoint
·GitHub Advisories
### Summary Daptin registers a generic WebSocket endpoint, GET /yjs/:documentName, for real-time collaborative document editing (YJS/CRDT). Unlike its purpose-built sibling route, this generic endpoint performs no per-resource authorization check - it only verifies that *some* user session exists. Because the document store parses :documentName as typename.referenceId.columnName and fetches that row's real column content unconditionally, any authenticated user (including a brand-new, zero-privilege, self-registered account) can read - and, since YJS sync is bidirectional, also write - the content of any file.*-typed column on any row of any table, including tables that are admin-only by default. ### Details InitializeYjsResources (server/endpoint_yjs.go) registers two routes.…
Daptin: Unauthenticated SQL Injection via the `sort` query parameter on every entity list endpoint
·GitHub Advisories
### Summary An unauthenticated attacker can inject arbitrary SQL through the sort query parameter accepted by Daptin's generic entity list endpoint (GET /api/), which every table in a Daptin instance exposes. The parameter is concatenated into raw SQL identifiers with no validation that the referenced column exists, unlike a sibling code path in the same file that received exactly this validation as the fix for a previously published advisory ([GHSA-rw2c-8rfq-gwfv](https://github.com/daptin/daptin/security/advisories/GHSA-rw2c-8rfq-gwfv)). Impact ranges from unauthenticated denial of service (a single crafted request 500s the query) to blind/error-based extraction of data from tables the requester has no permission to read. ### Details PaginatedFindAllWithoutFilters in `server/resou…
Jupyter MCP Server: Browser DNS rebinding can hijack the Jupyter backend through management routes
·GitHub Advisories
Standalone streamable-http mode in datalayer/jupyter-mcp-server rejects forged Host and Origin headers on /mcp, but custom management routes mounted on the same application do not get the same browser-origin protection. A malicious website can keep an attacker origin while its hostname resolves to 127.0.0.1 or a private target address, then send PUT /api/connect to replace the MCP server's active Jupyter backend. The route accepts the browser-shaped request and makes the server start a kernel client against attacker-controlled infrastructure. The protected /mcp endpoint shows the intended browser-origin boundary. With MCP_TOKEN configured, /mcp rejects forged browser headers: ```text POST /mcp with Authorization: Bearer SCAN_MCP_TOKEN Host: attacker.example:8142 Origin…
Jupyter MCP Server: Unauthenticated management routes can hijack the Jupyter backend in standalone HTTP mode
·GitHub Advisories
Standalone streamable-http mode in datalayer/jupyter-mcp-server requires MCP_TOKEN for /mcp, but the custom management routes mounted on the same application do not enforce that token. An unauthenticated network caller can invoke PUT /api/connect, choose the Jupyter backend URL and token fields, reset the server context, and make the MCP server start a kernel client against attacker-controlled infrastructure. The same missing authentication affects the state-changing DELETE /api/stop route. The intended authentication boundary is documented in the security guide and enforced during startup: ```text docs/docs/reference/security/index.mdx:15 All MCP endpoints require Bearer token authentication. docs/docs/reference/security/index.mdx:25 Starting with version 1.0.0, MCP client au…
Flyto2 Core: SSRF guard bypass via DNS rebinding (validate_url_ssrf resolves-then-connects without pinning)
·GitHub Advisories
# [MEDIUM] SSRF guard bypass via DNS rebinding — validate_url_ssrf resolves-then-connects without pinning - **CWE:** CWE-918 (SSRF) / CWE-367 (TOCTOU). - **CVSS v3.1:** AV:N/AC:H/PR:L/UI:N/S:C/C:H/I:L/A:N = **6.8 Medium** (AC:H — needs attacker-controlled DNS with a low/zero TTL and to flip the answer between the guard's lookup and the connection's lookup; S:C — reaches internal/metadata services the guard is meant to block; C:H — e.g. cloud metadata credentials at 169.254.169.254). - **Affected component:** flyto-core (PyPI flyto-core), HEAD ae2b38e (v2.26.7). src/core/utils.py::validate_url_ssrf (resolution at getaddrinfo ~L512, is_private_ip check ~L515) and every consumer: guarded_aiohttp_request(), enforce_outbound_url()/validate_url_with_env_config() — i.e. `http…
## Summary http.paginate validates only the initial base_url, then follows server-supplied pagination targets (RFC 5988 Link: rel="next" headers, cursor/offset URLs) in a loop **without revalidating each follow-up URL**. An attacker's first-page response can point next at an internal address, causing a second-order SSRF whose internal body is aggregated into the returned items. ## Root Cause src/core/modules/atomic/http/paginate.py:495 validates base_url (first URL only). The pagination loop _paginate_link_header reads next_url via _parse_link_header (:203), sets url=next_url (:208), and calls session.request(method, url) (:196) with NO validate call in the loop (:186-208 has zero guard calls). ## Impact Readable second-order SSRF that bypasses the SSRF control; inte…
Flyto2 Core: SSRF guard validates the resolved IP but connects by hostname, allowing DNS-rebinding TOCTOU
·GitHub Advisories
## Summary validate_url_ssrf resolves the hostname, checks the IP against private ranges, then **discards the IP and returns the hostname URL string**. aiohttp performs a fresh, independent DNS resolution at connect time. An attacker controlling DNS for a hostname (TTL 0, alternating public IP and internal IP) passes validation on the first lookup and connects to the internal IP on the second — a classic check-then-use race. SECURITY_SSRF.md line 63 explicitly claims DNS-rebinding is prevented; it is not. ## Root Cause src/core/utils.py:523 returns the hostname URL after validation; the resolved IP is never pinned. A repo grep of http/ and utils.py for TCPConnector / resolver / response.history / on_request_redirect / IP-pinning returns NONE. Each module builds a fresh `Cl…
Flyto2 Core: Arbitrary file write via unguarded data.*/file.* modules (incomplete fix of CVE-2026-67429)
·GitHub Advisories
# [CRITICAL] Arbitrary file write via unguarded data.* / file.* write modules — incomplete fix of GHSA-2956 - **CWE:** CWE-22 (Path Traversal) / CWE-73 (External Control of File Name or Path); impact reaches CWE-94 (code execution via file overwrite). - **CVSS v3.1:** AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H = **9.3 Critical** (S:C because a write escapes the intended sandbox confinement into the host filesystem / other components). - AV:N — reachable via the MCP server / recipe engine (execute_module). AC:L — deterministic. PR:L — any client able to run a module/recipe (the same attacker model as GHSA-2956; unauthenticated on the HTTP MCP surface per CVE-2026-55786). UI:N. S:C — escapes FLYTO_SANDBOX_DIR. C/I/A:H — arbitrary-content write to any absolute path → overwrite app code /…
django-docutils unsafe Docutils defaults allow local file disclosure, SSRF, and stored XSS
·GitHub Advisories
## Summary django-docutils before 0.30.0 rendered reStructuredText through Docutils without protected web-safe defaults. Public rendering paths, including publish_doctree, publish_html_from_source, publish_html_from_doctree, publish_parts_from_doctree, the {% rst %} template tag, the rst template filter, DocutilsTemplates, and DocutilsView, could process attacker-controlled RST with Docutils directives that read local files, fetch URL-backed content, or emit raw HTML. The issue is fixed in 0.30.0 by disabling Docutils file insertion, raw directives, local docutils.conf processing, and unsafe URI schemes by default, and by sanitizing doctrees before HTML is emitted. Applications are affected when they render attacker-controlled or lower-trust RST through django-docuti…
Refitter allows arbitrary code execution through unescaped OpenAPI content-type values
·GitHub Advisories
### Summary Refitter emits the spec's content-type key (content map key in requestBody/responses) verbatim into a Refit [Headers("Accept: ", "Content-Type: ")] attribute string without escaping ". A crafted value survives Refitter's default OpenAPI validation, breaks out of the attribute and the enclosing interface + namespace, injects a top-level file class with a [ModuleInitializer] method, and reopens so the file stays valid. .NET runs [ModuleInitializer] methods at assembly load, so the attacker's code executes at application startup. Verified on Refitter 2.0.0 / .NET 8. The malicious input is a content-type KEY such as: content: { 'application/': {schema} }. No --skip-validation is required. ### PoC reproduce.sh (+ make_spec.py) attached: generates with default valida…
Refitter allows code execution through unescaped OpenAPI header parameter names
·GitHub Advisories
### Summary Refitter emits the spec's header parameter name (parameters[].name with in: header) verbatim into a Refit [Header("")] attribute string without escaping ". A crafted value survives Refitter's default OpenAPI validation, breaks out of the attribute and the enclosing interface + namespace, injects a top-level file class with a [ModuleInitializer] method, and reopens so the file stays valid. .NET runs [ModuleInitializer] methods at assembly load, so the attacker's code executes at application startup. Verified on Refitter 2.0.0 / .NET 8. Notable: the breakout starts from a PARAMETER-LIST position (it closes the params and method first). The malicious input is a header parameter name. No --skip-validation is required. The query AliasAs and value sinks (enum, default)…
Refitter allows arbitrary code execution through unescaped OpenAPI paths
·GitHub Advisories
### Summary Refitter emits each OpenAPI path (the paths-object key) verbatim into a Refit [Get("")] attribute string, without escaping " or restricting characters. A crafted single-line, /-prefixed path survives Refitter's default OpenAPI validation yet closes the attribute string and the enclosing interface + namespace, injects a top-level file class with a [ModuleInitializer] method, and reopens a namespace + interface so the file stays valid. .NET runs [ModuleInitializer] methods when the generated assembly is loaded, so the attacker's code executes at application startup. Verified on Refitter 2.0.0 / .NET 8. ### Details ``` [Get("/p")] Task Dummy(); } } file class Evil { [System.Runtime.CompilerServices.ModuleInitializer] internal static void Init(){ /* attacker code */ } }…
NATS Server: MQTT-over-WebSocket Path Can Crash WebSocket-Only JetStream Servers Before MQTT Is Enabled
·GitHub Advisories
### Background NATS.io is a high performance open source pub-sub distributed communication technology, built for the cloud, on-premise, IoT and edge computing. The NATS Server can accept client connections over WebSocket and can also support MQTT over WebSocket when MQTT is configured. ### Problem Description A WebSocket listener could route requests for the MQTT-over-WebSocket path into MQTT handling even when MQTT was not configured. On affected deployments, an unauthenticated client with access to the WebSocket listener could reach uninitialized MQTT state and crash the server process. This affects deployments that enable WebSocket while leaving MQTT disabled. Deployments where MQTT is intentionally configured initialize the MQTT state and are not affected in the same way. ### Affected…
NATS Server allows unauthenticated memory exhaustion through incomplete MQTT CONNECT packets
·GitHub Advisories
### Background NATS.io is a high performance open source pub-sub distributed communication technology, built for the cloud, on-premise, IoT and edge computing. The NATS Server supports MQTT clients, including authentication and parsing of MQTT CONNECT packets. ### Problem Description An unauthenticated MQTT client could cause the server to retain large incomplete MQTT CONNECT packets before authentication completed. The parser retained partial pre-authentication packet data while waiting for the advertised MQTT packet length to be completed. An attacker could therefore consume server memory until authentication timeouts closed the connections. ### Affected Versions Versions v2.14.2, v2.12.11 and below are vulnerable. The issue is fixed in v2.14.3 and v2.12.12. ### Workarounds Deployme…
NATS Server MQTT retained messages and QoS replay bypass subscription deny rules
·GitHub Advisories
### Background NATS.io is a high performance open source pub-sub distributed communication technology, built for the cloud, on-premise, IoT and edge computing. The NATS Server MQTT support includes retained messages and QoS1+ durable delivery. NATS subscription permissions can allow broad wildcard subscriptions while denying more sensitive subjects. ### Problem Description MQTT retained message delivery and QoS1+ durable replay could deliver messages whose original topics matched a subscriber's configured subscribe deny rules. Normal live delivery applied the delivery-time deny check. These MQTT delivery paths did not consistently recheck the concrete original topic before sending the MQTT PUBLISH to the subscriber. The issue affects MQTT subscribers with broad wildcard subscribe permis…
snark-verifier: Halo 2 aggregation circuit mishandles point-at-infinity proof elements
·GitHub Advisories
### Summary The Halo 2 aggregation circuit could mishandle proof elements encoded as the point at infinity. When an assigned proof point appeared in an MSM term with constant scalar one, the Halo 2 loader used a scalar-one shortcut that passed the assigned point directly into the EC sum helper. The EC sum implementation used by that path assumed its inputs were non-identity points, while assigned proof points could represent the encoded identity (0, 0). ### Details EcPointLoader::multi_scalar_multiplication partitions MSM terms by scalar and base type. For (Value::Constant(ONE), Value::Assigned(_)), the loader placed the assigned base into the non-scaled variable-base list and later passed those points to sum_with_const. The default Halo 2 shim delegates sum_with_const to halo2-…
NLTK: ZIP package extraction follows in-root hardlinks and overwrites files outside the NLTK data root
·GitHub Advisories
## Summary NLTK ships a security wrapper, nltk.pathsec.ZipFile, that is meant to confine archive extraction to trusted data roots and to block link-based escapes. When nltk.download() installs a package, the extraction write opens each member's target path without checking whether that path is a hardlink to a file located outside the data root. A local actor who can write inside a shared or predictable NLTK data root (for example ~/nltk_data, a group-writable /usr/share/nltk_data, or a shared container volume) can pre-plant an in-root hardlink at a member path that a soon-to-be-installed package will write. When the victim later runs the download, extraction truncates and overwrites the outside-root target through that hardlink. This is the same weakness class as the previously fi…
NLTK: AllowlistUnpickler does not deny numpy submodule-local file-I/O sinks
·GitHub Advisories
### Summary nltk.picklesec.allowlisted_pickle_load keyed its denylist of dangerous globals by export name, so numpy's file-I/O callables that live in submodules and are not re-exported under __module__ == "numpy" were never matched. Under the broad allowed_modules=("numpy", "scipy", "sklearn") allowance that TransitionParser.parse(depgraphs, modelFile) granted for model files, a crafted protocol 4 pickle could name numpy.lib._npyio_impl.recfromtxt (arbitrary file read, result returned to the caller of allowlisted_pickle_load) or numpy.lib.format.open_memmap (attacker-chosen file create), and the REDUCE opcode invoked them during the load. ### Affected nltk >= 3.10.0 and
NLTK corpus-reader view methods bypass the scoped root sandbox via intermediate-directory symlinks
·GitHub Advisories
> **affected**: PyPI nltk>= 3.9.4 — CorpusReader.abspaths()/abspath() and the PlaintextCorpusReader / SyntaxCorpusReader view methods > **dynamically reproduced**: nltk3.9.4 (8/9, scoped-escape checks), 3.10.3 (wheel, 9/9 checks) and master6818767b9 (9/9 checks) --- _Source references (file:line) are to commit 303f6e2b (release tag v3.10.3). Line numbers in the released nltk wheel match this tag exactly; master6818767b9 contains the same code (pathsec.py renumbered by +44 lines from added hardening comments). In 3.9.4 the same logic exists at earlier line numbers (api.py:222-236 for open(), api.py:161-203 for abspath()/abspaths(), data.py:382-388 for the pointer open, pathsec.py:105-114 for the scoped branch); the affected code is iden…
NLTK incomplete fix: additional JVM/JAR sandbox bypass through unvalidated launcher tokens in java() command arguments
·GitHub Advisories
## Summary NLTK 3.10.3 contains security hardening intended to close JVM argument-injection and untrusted JAR/classpath execution paths in nltk.internals.java(), including the issue published as GHSA-m4rf-3fr8-xwx3. The patched options channel correctly rejects Java argument-file references such as @/path/to/args and launcher modes such as -jar. However, an additional argument channel remains: the caller-provided cmd sequence is appended to the Java command after the validated option and classpath channels, without enforcing that its first item is a Java main-class name. I am reporting this as an additional post-fix bypass / incomplete-fix path affecting the 3.10.3 remediation, rather than as an unrelated vulnerability family. As a result, the same launcher token that is rejecte…
NLTK: XMLCorpusView comment and CDATA parsing permits quadratic CPU denial of service
·GitHub Advisories
> **affected**: PyPI nltk>= 3.6 — nltk.corpus.reader.xmldocs.XMLCorpusView streaming read (and the nps_chat / framenet readers built on it) > **dynamically reproduced**: 3.6 (6/6 checks), 3.9.2 (6/6), 3.10.3 (6/6) and develop6818767b9 (6/6) --- _Source references (nltk/corpus/reader/xmldocs.py:NNN) are to commit 6818767b99c24659107eb2be9bccd32a3d4bf045 (develop, v3.10.3-15-g6818767b9). The released v3.10.3 wheel's xmldocs.py is byte-identical to that commit, so the same line numbers apply to the released wheel._ ### Summary **An attacker who can make a victim read a well-formed XML corpus file whose body contains one large comment or CDATA section can pin a CPU core for a time quadratic in the file size, because XMLCorpusView._read_xml_fragment (`nltk/c…
NLTK: Downloader cyclic collection indices cause an infinite closure walk
·GitHub Advisories
> **affected**: PyPI nltk>= 3.6.7 — nltk.downloader index parsing (Downloader._update_index) > **dynamically reproduced**: nltk3.6.7 (4/4 checks), 3.9.2 (4/4), 3.10.3 (4/4), and develop6818767b9 (4/4) --- _Source references (nltk/downloader.py:NNN) are to commit 6818767b9 (develop, v3.10.3-15-g6818767b9). The v3.10.3 tag and the released 3.10.3 wheel carry the identical code at the identical line numbers (the vulnerable closure BFS sits at downloader.py:1300-1310). Dynamically verified wheels additionally show the same defect at downloader.py:972 (3.9.2) and downloader.py:987 (3.6.7)._ ### Summary Downloader._update_index (nltk/downloader.py:1253-1313) is the mandatory first step of every downloader operation (download(), info(), `packa…
NLTK: ARFF_Formatter Injects Weka ARFF Schema Directives via Attacker-Controlled Class Labels
·GitHub Advisories
## Description ### Summary nltk.classify.weka.ARFF_Formatter writes class labels directly into the Weka ARFF @ATTRIBUTE '-label-' {...} declaration without any ARFF quoting or escaping. An attacker who can contribute class labels to a training dataset can include ARFF metacharacters such as }, newlines, @ATTRIBUTE, and @DATA to break out of the nominal label list and inject attacker‑controlled ARFF schema and data directives. This vulnerability is reachable in any application that calls WekaClassifier.train() or ARFF_Formatter.from_train() with attacker‑influenced training data. The victim does not need to manually edit the ARFF file; the normal training workflow writes the malformed ARFF automatically. ### Technical Details The vulnerable code path is: 1. `WekaClassifier.tr…
Natural Language Toolkit (NLTK): Uncontrolled recursion (crash DoS) in DependencyGraph.tree()/triples()
·GitHub Advisories
### Summary DependencyGraph.tree()/triples() walk the parsed dependency structure using plain, unbounded Python recursion — one stack frame per edge in the graph — and never use the class's own cycle detector. A crafted dependency-parse file with a few thousand chained tokens (an entirely ordinary-looking long sentence) crashes the process with an unhandled RecursionError the moment .tree() or .triples() is called — which is NLTK's own documented usage pattern immediately after loading such a file. ### Details DependencyGraph._tree() (~lines 393-406), .tree() (~408-417), and .triples() (~419-432) in nltk/parse/dependencygraph.py rebuild/walk the graph with Tree(word, [self._tree(dep) for dep in deps]) and yield from self.triples(node=dep) — ordinary recursive calls, one per ed…
Natural Language Toolkit (NLTK): Uncontrolled recursion (crash DoS) in Synset.tree()/acyclic_tree() via WordNet relation traversal
·GitHub Advisories
### Summary The recursive traversal engines behind WordNetCorpusReader's Synset.tree() and Synset.acyclic_tree() have no maximum call-depth safeguard and default to unlimited depth. They guard against literal cycles, but not against a long, genuinely acyclic relation chain — which exhausts the Python call stack the same way as the sibling DependencyGraph finding I reported separately. Real-world exploitability requires the host application to load a custom/foreign WordNet-format lexical resource rather than NLTK's bundled default corpus — flagging that narrower scope honestly up front since it affects severity, not validity. ### Details nltk/util.py's acyclic_depth_first() (~lines 471-541) and acyclic_branches_depth_first() (~lines 544-625) recurse once per graph edge, default to `d…
NLTK: Uncontrolled recursion in CCG lexicon parser causes denial of service via deeply nested category input
·GitHub Advisories
## Root Cause The CCG lexicon parser recurses on nested parenthesised categories without any depth bound. matchBrackets (nltk/ccg/lexicon.py:154) calls itself once per nested (, and augParseCategory (nltk/ccg/lexicon.py:228,242) recurses once per bracketed sub-category. Neither function tracks recursion depth nor checks sys.getrecursionlimit(), and the public entry point fromstring (nltk/ccg/lexicon.py:252, also re-exported via nltk.ccg.chart.fromstring) applies no length or nesting cap before handing the text to the parser. ## Impact An application that parses an untrusted lexicon string aborts with an unhandled RecursionError, terminating the affected parse operation or request worker (denial of service, CWE-674). The recursion is pure Python, so CPython raises a cat…
NLTK: Uncontrolled recursion in DependencyGraph traversal causes denial of service via deep dependency chains
·GitHub Advisories
## Root Cause The dependency-graph traversal helpers recurse over dependency links without any depth bound or visited set. DependencyGraph._tree (nltk/parse/dependencygraph.py:404) recurses once per dependency link, triples (nltk/parse/dependencygraph.py:432) is a recursive generator, and get_cycle_path (nltk/parse/dependencygraph.py:520) recurses over dependencies. The neighbouring contains_cycle method was deliberately rewritten as an iterative depth-first search, but these sibling helpers on the public traversal path were left recursive with no depth counter. ## Impact An application that parses an untrusted CoNLL/Malt-TAB dependency structure and then walks it via tree() or triples() aborts with an unhandled RecursionError, terminating the affected operation or req…
NLTK: Uncontrolled recursion in semantic-logic type parser causes denial of service via nested type strings
·GitHub Advisories
## Root Cause The semantic-logic type parser read_type (nltk/sem/logic.py:866) recurses on both halves of every `` complex type (nltk/sem/logic.py:882-884) with no depth or length bound — only an isinstance assertion and a parenthesis-balance assertion. The LogicParser.MAX_PARSE_DEPTH guard (nltk/sem/logic.py:107,294) protects the expression parser but never runs on the read_type path, which is reached directly by the public Type.fromstring classmethod and by signature-string type checking. ## Impact An application that parses an untrusted type string, or type-checks an expression against an attacker-influenced signature, aborts with an unhandled RecursionError, terminating the affected operation or request worker (denial of service, CWE-674). The recursion is pure Pytho…
NLTK: Uncontrolled recursion in Tree.fromlist causes denial of service via deeply nested list input
·GitHub Advisories
## Root Cause Tree.fromlist (nltk/tree/tree.py:767) converts a nested list into a Tree by recursing once per nesting level (nltk/tree/tree.py:780) with no depth bound — its only validation is type(l) == list and len(l) > 0. The sibling constructor Tree.fromstring was hardened with a MAX_TREE_DEPTH cap (nltk/tree/tree.py:31,695) that rejects adversarially deep input with a bounded ValueError, but that guard was not applied to fromlist, which builds Tree objects identically. ## Impact An application that builds a Tree from an attacker-controlled nested list — for example Tree.fromlist(json.loads(untrusted)) — aborts with an unhandled RecursionError, terminating the affected operation or request worker (denial of service, CWE-674). Any later recursive traversal of…
NLTK: Uncontrolled recursion in Toolbox settings helpers causes denial of service via deeply nested input
·GitHub Advisories
## Root Cause The Toolbox settings-tree helpers recurse over the parsed element tree without any depth bound. _to_settings_string (nltk/toolbox.py:418), remove_blanks (nltk/toolbox.py:432), add_default_fields (nltk/toolbox.py:451), _sort_fields (nltk/toolbox.py:484), and add_blank_lines (nltk/toolbox.py:502,516) each recurse once per element level with no depth counter or explicit stack. The producer ToolboxSettings.parse builds the element tree iteratively, so nesting depth is driven entirely by attacker-supplied \+marker / \-marker pairs. ## Impact An application that parses an untrusted Toolbox settings file and then serialises or transforms it through any of the public helper functions aborts with an unhandled RecursionError, terminating the affected operat…
NLTK: Compile-time regex DoS in NLTK search/tokenizer sinks: quadratic regex-engine compile bypasses the match-only timeout
·GitHub Advisories
## Summary NLTK exposes a compile-time regular-expression denial of service in its regex-search helpers. When an application passes untrusted text as the search pattern to TokenSearcher.findall() / Text.findall(), or as the tokenizer pattern to RegexpTokenizer, the pattern is handed to the third-party regex engine, whose compilation cost is roughly quadratic in the number of capturing groups. A short pattern of the form () repeated many times (for example "()" * 25000, about 50 KB) forces tens of seconds of synchronous CPU work before any match begins. The wall-clock timeout that NLTK added to guard matching does not apply during compilation, so a single small request pins a CPU core, and repeated or concurrent requests exhaust all cores and deny service. ## Root Cause The rem…
NLTK: Uncontrolled recursion in WordNet Synset hypernym walkers (max_depth/min_depth/hypernym_paths/hypernym_distances) causes DoS
·GitHub Advisories
## Summary Four hypernym-walking methods on the WordNet Synset class in nltk/corpus/reader/wordnet.py (max_depth, min_depth, hypernym_paths, and hypernym_distances) traverse the hypernym pointer graph by direct recursion with no visited-node set and no depth cap. WordNet data. file content is untrusted corpus input in NLTK, the same trust boundary the project already treats as attacker-controlled across its corpus-content hardening work. When the parsed hypernym graph contains a cycle, or a chain deeper than the interpreter recursion limit, these methods recurse without bound and raise an uncaught RecursionError, aborting the traversal and any worker that does not catch it. No special privileges are needed; the victim only has to load an attacker-supplied corpus and call a…
NLTK: Quadratic-time DoS in SeekableUnicodeStreamReader.readline on an unterminated corpus line via per-iteration full-buffer rescan
·GitHub Advisories
## Summary SeekableUnicodeStreamReader.readline in nltk/data.py assembles a line by repeatedly reading a block, appending it to a growing chars buffer, and recomputing chars.splitlines(True) over the entire buffer on every loop iteration. The read block size doubles only until it caps at 8000 characters, so for a single unterminated line of N characters the loop runs about N/8000 iterations and iteration k re-scans roughly 8000*k characters, giving O(N^2) total work. The default size=None used on the line-oriented corpus-reader read path means the early break never fires before end of file. An attacker who supplies a corpus file containing one very long line with no newline can force quadratic CPU consumption in the reader's process. This is the same growing-buffer re-scan algor…
NLTK: Quadratic CPU exhaustion in NLTK XMLCorpusView.read_block via deeply nested XML corpus tags
·GitHub Advisories
## Summary NLTK's XMLCorpusView.read_block rebuilds the full root-to-node context path with "/".join(context) on every start tag while it is still searching for a matching element. Because the context stack grows with XML nesting depth and the join is repeated once per start tag, a single corpus file containing deeply nested tags forces O(n^2) pure-Python work, where n is the number of nested elements. Any application that parses attacker-influenced XML corpus data through an XMLCorpusView subclass (for example the nps_chat, framenet, bnc, mte, nkjp, or semcor readers) can be driven to exhaust a CPU core for an extended period, producing a denial of service without any authentication or special privilege. ## Root Cause read_block maintains a context list that is appe…
## Summary StreamBackedCorpusView, a public API in nltk/corpus/reader/util.py, applies the pathsec sandbox to the file content it reads but not to the file metadata it probes in its constructor. When the view is created with a plain string fileid, __init__ calls os.stat(self._fileid).st_size with no pathsec validation, so an application that passes an attacker influenced path to the constructor discloses whether an arbitrary out of root file exists and, if it does, its exact byte size and modification time, even when nltk.pathsec.ENFORCE is True. This is the residual metadata channel left open by the fix for CVE-2026-63312 (GHSA-x5ph-mj9p-rfr8), which closed arbitrary content read on the same code path but did not bring the sibling os.stat under the sandbox. ## Root Cause Th…
NLTK: Untrusted search path in prover9/mace4 config allows local code execution via relative binary_location
·GitHub Advisories
## Summary Prover9Parent.config_prover9(binary_location=...) (and Mace, which inherits it) accepts a relative binary_location and passes it as path_to_bin to find_binary, which disables the CWD-relative rejection guard. Unlike the boxer/senna/malt/repp siblings, prover9/mace apply no os.path.isabs() filter, so the resolved relative program path (e.g. ./prover9) is executed from the current working directory via subprocess.Popen. A local attacker who can plant ./prover9 (or ./mace4) in the resolved directory achieves local code execution. ## Root Cause nltk/inference/prover9.py:121-135 calls find_binary(name, path_to_bin=binary_location, env_vars=["PROVER9"], ...). A truthy path_to_bin sets searching_bare_name = not path_to_bin and ... → False (`internals.py:935…
Apache Roller: Apache Roller Deserialization of Untrusted Data Vulnerability
·CISA KEV
Apache Roller contains a deserialization of untrusted data vulnerability that allows an unauthenticated remote attacker to execute arbitrary code via the XML-RPC endpoint, which accepts and deserializes vendor extension types before authentication. This CVE covers the same underlying vulnerability as CVE-2026-82384 but applies to a broader range of affected versions.
Required action: Apply mitigations in accordance with vendor instructions, ensuring compliance with CISA’s BOD 26-04 Prioritizing Security Updates Based on Risk (see URL in Notes) guidance and CISA’s “Forensics Triage Requirements” (see URL in Notes). Follow applicable BOD 26-04 guidance for cloud services or discontinue use of the product if mitigations are unavailable. Stakeholders are responsible for evaluating each asset's internet exposure and ensuring adherence to BOD 26-04 patching guidelines.
Broadcom VMware vCenter: VMWare vCenter Authentication Bypass Using an Alternate Path or Channel Vulnerability
·CISA KEV
Broadcom VMware vCenter contains an authentication bypass using an alternate path or channel vulnerability in the VMware Directory Service that allows an unauthenticated attacker with network access to vCenter to bypass authentication and gain unauthorized access to the system.
Required action: Apply mitigations in accordance with vendor instructions, ensuring compliance with CISA’s BOD 26-04 Prioritizing Security Updates Based on Risk (see URL in Notes) guidance and CISA’s “Forensics Triage Requirements” (see URL in Notes). Follow applicable BOD 26-04 guidance for cloud services or discontinue use of the product if mitigations are unavailable. Stakeholders are responsible for evaluating each asset's internet exposure and ensuring adherence to BOD 26-04 patching guidelines
SAP NetWeaver: SAP NetWeaver Improper Neutralization of Special Elements in Data Query Logic Vulnerability
·CISA KEV
SAP NetWeaver Enterprise Portal contains an improper neutralization of special elements in data query logic vulnerability that allows an unauthenticated attacker to disclose or modify server information via injected JNDI environment properties or a URL used during JNDI lookup operations.
Required action: Apply mitigations in accordance with vendor instructions, ensuring compliance with CISA’s BOD 26-04 Prioritizing Security Updates Based on Risk (see URL in Notes) guidance and CISA’s “Forensics Triage Requirements” (see URL in Notes). Follow applicable BOD 26-04 guidance for cloud services or discontinue use of the product if mitigations are unavailable. Stakeholders are responsible for evaluating each asset's internet exposure and ensuring adherence to BOD 26-04 patching guidelines.
Cisco Expressway Series: Cisco Expressway Series Use of Hard-coded Credentials Vulnerability
·CISA KEV
Cisco Expressway Series contains a use of hard-coded credentials vulnerability that allows an unauthenticated, remote attacker with persistent cookies and network access to execute commands as root on a clustered device via the database service.
Required action: Apply mitigations in accordance with vendor instructions, ensuring compliance with CISA’s BOD 26-04 Prioritizing Security Updates Based on Risk (see URL in Notes) guidance and CISA’s “Forensics Triage Requirements” (see URL in Notes). Follow applicable BOD 26-04 guidance for cloud services or discontinue use of the product if mitigations are unavailable. Stakeholders are responsible for evaluating each asset's internet exposure and ensuring adherence to BOD 26-04 patching guidelines.
Guard Core: Unvalidated X-Forwarded-For-derived string used as a Redis key component and interpolated into a KEYS glob pattern
·GitHub Advisories
### Summary _extract_from_forwarded_header() (guard_core/utils.py:172-181 in 3.12.0; :179 on master 08780f1) returns the selected X-Forwarded-For entry **without any ipaddress validation**. When that entry is attacker-controlled, an arbitrary string becomes client_ip and flows into BehaviorTracker (guard_core/handlers/behavior_handler.py:83-102), which interpolates it verbatim into both a Redis key name and a KEYS glob pattern: ``python key = f"behavior:usage:{endpoint_id}:{client_ip}" await self.redis_handler.set_key("behavior_usage", f"{key}:{current_time}", "1", ttl=rule.window) pattern = f"behavior_usage:{key}:*" keys = await self.redis_handler.keys(pattern) # blocking KEYS, O(N) over keyspace `` Same shape in track_return_pattern() (`behavior_handler.py:135-14…
Guard Core: Whitespace-collapse preprocessing permanently disables the CRLF-anchored http-splitting and command-injection detectors in the default detection mode
·GitHub Advisories
### Summary In the default "enhanced" detection mode, ContentPreprocessor.preprocess() collapses all whitespace (re.sub(r"\s+", " ", content), guard_core/detection_engine/preprocessor.py:137 on master 08780f1; :384 in the 3.12.0 sdist) **before** pattern matching. This erases every \r and \n from the scanned value, rendering two built-in detectors structurally unmatchable regardless of input: - http_split — guard_core/handlers/suspatterns_handler.py:540: r"[\r\n]\s*(?:HTTP\/[0-9.]+|Location:|Set-Cookie:)" requires a literal \r or \n, which no longer exists after preprocessing; - cmd_injection — r"\n\s*(?:bash|sh|...)\s+-c\b" — same structural death. The downstream application receives the **raw** value with CRLF intact (Starlette percent-decodes %0d%0a in query p…
Guard Core: Quadratic ReDoS in built-in detection pattern freezes the event loop with a single request
·GitHub Advisories
### Summary A polynomial (quadratic) regular-expression denial of service in guard-core's built-in penetration-detection patterns allows any unauthenticated remote client to freeze **every** endpoint of an application for seconds per request, using only the default configuration. The triggering request completes without any detection match — no ban counter increments, no rate-limit violation is recorded — so it can be repeated indefinitely. Since guard-core 3.5.0, only *custom* patterns are executed through the compiler's timeout-protected create_safe_matcher(); all built-in patterns run as a bare, inline pattern.search(content) directly on the asyncio event loop. guard-core ≤ 3.4.0 ran built-ins through the safe matcher (verified in the 3.4.0 wheel, _check_regex_pattern), so this i…
k8s-mcp-server: Missing authentication on default SSE/HTTP transport allows unauthenticated Kubernetes tool execution
·GitHub Advisories
## Summary When k8s-mcp-server runs in its default SSE transport mode, the MCP tools/call endpoint is dispatched with no authentication, session token, or Origin check. Any client that can reach the listening port can enumerate and invoke the server's Kubernetes tools (including destructive/write tools) without credentials, executing with the server's configured cluster privileges. ## Affected Commit be87a6dd72bb6ec1d4886b8548843b99a4638b12 (Merge PR #130) MCP library: github.com/mark3labs/mcp-go v0.57.0 Default mode: sse (SERVER_MODE default), default port 8080, bind 0.0.0.0 ## Root cause (static trace: handleSSE -> handleMessage -> tools/call) - main.go L129: server.NewSSEServer(s) is created with no auth option and no contextFunc; L130 sse.Start(":"+port) binds all interfaces (0.…
### Maintainer resolution The CodeWhale maintainers validated this report. CodeWhale 0.8.67 and earlier are affected. Version 0.9.0 contains the fix in commit 208421b9d23d81cea3311a1eeb2a2ea81d637686. Users should upgrade to 0.9.0 or later. The original reporter analysis is preserved below. ## Summary The interactive Agent profile of DeepSeek-TUI (CodeWhale) is explicitly documented to gate **every** shell command behind an approval prompt (config.rs:3725-3736). However, ExecShellTool::approval_requirement_for(&tool_input) downgrades the requirement from Required to Auto for any command the classifier deems "parallel read-only" (shell.rs:2314-2320). registered_tool_approval_required returns false for Auto **before** the auto_approve check runs (turn_loop.rs:37-38), so no pro…
CodeWhale: Automation auto_approve defaults to true, bypassing the task-path hardening fix for silent recurring agent execution
·GitHub Advisories
### Maintainer resolution The CodeWhale maintainers validated this report. CodeWhale 0.8.67 and earlier are affected. Version 0.9.0 contains the fix in commit 208421b9d23d81cea3311a1eeb2a2ea81d637686. Users should upgrade to 0.9.0 or later. The original reporter analysis is preserved below. ## Summary CVE-2026-45374 (GHSA-72w5-pf8h-xfp4) hardened the task path so auto-approval must be opted into explicitly: add_task uses req.auto_approve.unwrap_or(false) (task_manager.rs:868). The automation subsystem was not hardened in kind. AutomationRecord::task_auto_approve() resolves an omitted auto_approve to DEFAULT_AUTOMATION_AUTO_APPROVE = true (automation_manager.rs:29, 101-103), and enqueue_run_task builds the NewTaskRequest with `auto_approve: Some(automation.task_auto_approve()…
eml_parser: Algorithmic-complexity DoS (O(n^4) regex backtracking) in Received-header parsing
·GitHub Advisories
### Summary eml_parser.routing.parserouting() dynamically builds a regex from up to four greedy .* groups (from (?P.*)by (?P.*)with (?P.*)for (?P.*)) terminated by an escaped literal of the date extracted from a **normalized** copy of the Received header. Because the date literal comes from the normalized text but is searched in the original line, a crafted header can make the trailing literal unmatchable; the search then fails at every start position only after exhaustively backtracking the four nested greedy groups — **O(n^4)** in header length. A single ~5.9 KB email pins one CPU core for ~12 seconds; doubling the input multiplies the cost ~25x, so a ~13 KB header takes minutes and a ~25 KB header effectively hangs the parse worker. ### Details Root cause: `eml_parser/routing.p…
containerd image-triggered daemon crash via malformed digest in subject-annotated descriptor
·GitHub Advisories
### Impact A bug in containerd's image manifest processing causes an unrecovered panic when a child descriptor contains the io.containerd.manifest.subject annotation and a malformed digest. Pulling or importing such an image through the transfer service (including default CRI PullImage requests) crashes the containerd daemon. In Kubernetes environments, kubelet retries failed image pulls with backoff, allowing a pod referencing an untrusted image to repeatedly crash containerd and disrupt container operations on the worker node. ### Patches This bug has been fixed in containerd 2.4.2, 2.3.7, and 2.2.10. Users should update to these versions to resolve the issue. ### Workarounds Restrict pod image references to trusted registries (for example, using a Kubernetes `ValidatingAdmissionP…
Model Context Protocol Python SDK: OAuth client could send credentials to an authorization server chosen by the MCP server
·GitHub Advisories
### Summary In affected versions, the SDK's OAuth client support (mcp.client.auth) let the MCP server a client connected to decide where the client's OAuth credentials were sent: - the authorization server metadata issuer was not validated on every discovery path, and - stored or pre-provisioned client credentials were not bound to the authorization server they belong to. A malicious or compromised MCP server could therefore direct them to a token endpoint of its choosing: - by naming its own authorization server in its protected resource metadata, or - by publishing none and serving metadata that presents the user's real authorization server as the issuer. It would then receive the client_secret, authorization code and PKCE code_verifier meant for that real server (or, with `Pr…
Mistune: Quadratic-time DoS in parse_link_href via unbounded parenthesis scan on empty-label links
·GitHub Advisories
## Resolution **Fixed in Mistune 3.3.4.** Upgrade to 3.3.4 or later. - Affected versions: < 3.3.4 - First patched version: 3.3.4 - Fix: https://github.com/lepture/mistune/compare/v3.3.3...v3.3.4 The reported payload was reproduced against the 3.3.3 release tag and verified to scale approximately linearly against the 3.3.4 release tag. ## Original report The following report describes the issue before the fix. ## Summary parse_link_href in mistune performs an unbounded parenthesis-balancing scan that runs to end-of-document on each unmatched (. Because the empty label [] bypasses the no_close_bracket_before high-water-mark guard, a single small document of the form "[](" * N causes O(N) openers to each drive an O(N) scan, producing O(N²) CPU on the **default** `mistune.html()…
Mistune: Quadratic-time DoS in inline image parsing (precedence_scan) bypasses not-is-image guards
·GitHub Advisories
## Resolution **Fixed in Mistune 3.3.4.** Upgrade to 3.3.4 or later. - Affected versions: < 3.3.4 - First patched version: 3.3.4 - Fix: https://github.com/lepture/mistune/compare/v3.3.3...v3.3.4 The reported payload was reproduced against the 3.3.3 release tag and verified to scale approximately linearly against the 3.3.4 release tag. ## Original report The following report describes the issue before the fix. ## Summary mistune's inline image parsing reaches precedence_scan for ![ openers because the two guards that keep the link path linear are both gated behind not is_image. A small default-renderer document of the form "![" * N + "x" + "]" * N produces O(N²) CPU with no plugins. ## Root Cause For ![ openers, is_image is True, so both linearizing guards are skipped: `if…
tiny-secp256k1: Stale buffer after ignored wasm failure accepts invalid infinity tweak
·GitHub Advisories
### Summary The three-argument xOnlyPointAddTweakCheck path ignores the wasm failure return and compares an unchanged input buffer. When the tweak result is the point at infinity, this stale-buffer comparison can return true for an invalid derivation. ### Details xOnlyPointAddTweakCheck in index.ts has two code paths. The path taken when the caller omits tweakParity discards the return value of the wasm call and compares whatever the shared input buffer holds. ```ts try { X_ONLY_PUBLIC_KEY_INPUT.set(point); X_ONLY_PUBLIC_KEY_INPUT2.set(resultToCheck); TWEAK_INPUT.set(tweak); if (hasParity) { return wasm.xOnlyPointAddTweakCheck(tweakParity) === 1; } else { wasm.xOnlyPointAddTweak(); const newKey = X_ONLY_PUBLIC_KEY_INPUT.slice( 0, validate.X_ONLY_PUBLIC_KEY_SIZE ); return compare…
fzf: Predictable FIFO path in zsh completion allows local symlink attack / arbitrary file overwrite as the victim user (_fzf_feed_fifo)
·GitHub Advisories
### Summary shell/completion.zsh feeds every trigger-driven zsh completion through a FIFO at a predictable, PID-based path in shared /tmp (fzf-complete-fifo-$$), without checking the failure of rm -f/mkfifo. On a multi-user host, another local user can pre-create that path as a symlink to a victim-writable file (e.g. ~/.bashrc), causing the victim's own completion to overwrite it with the completion stream — with attacker-influenced content (e.g. via process names in ps output), escalating to code execution at the victim's next login. A pre-created plain FIFO instead leaks/blocks on the completion stream. ### Reporter / Credits: Sai Sreewathsa Kovalluri, Shon Babu and Kannan K (Researchers), Innspark Solutions https://innspark.in/ ### Details shell/completion.zsh (tag 0.74…
fzf: Arbitrary command execution via bash arithmetic expansion on unvalidated layout size in fzf-tmux (-l/-u attached value)
·GitHub Advisories
### Summary bin/fzf-tmux fails to validate layout size values given in the *attached* form (e.g. -l50). For -l/-u these values reach bash arithmetic expansion ($(( max - size ))), where an operand like a[$(cmd)] executes cmd as the invoking user during option parsing — before any tmux interaction and even outside tmux. A second sink embeds unvalidated popup geometry (-x/-y/-w/-h/-p) into an unquoted tmux popup ... $opt ... invocation, allowing injection of tmux flags such as -e BASH_ENV= (command execution via non-interactive bash sourcing $BASH_ENV). ### Reporter / Credits: Sai Sreewathsa Kovalluri, Shon Babu and Kannan K (Researchers), Innspark Solutions https://innspark.in/ ### Details In bin/fzf-tmux (tag 0.74.4, commit a140afeb), the option parser validates si…
sqlite-mcp: Read-only mode bypass via statement chaining and SQL injection in describe_table
·GitHub Advisories
### Summary In read-only mode (the default), a client that can call the MCP tools can write to the database the server is meant to expose read-only, read other SQLite files, and create new SQLite files anywhere the server process can write. There are two ways in: statement chaining through execute_query, and SQL injection through describe_table. ### Details - **Statement chaining in execute_query.** The only check was that the query starts with SELECT. The modernc.org/sqlite driver runs every ;-separated statement in one call, so anything after SELECT 1; ran unchecked. - **SQL injection in describe_table.** The table_name argument was interpolated into PRAGMA table_info(%s) with no guard. - **Escaping read-only mode.** Through either path, ATTACH DATABASE opens a fil…
Next.js: HttpOnly cookie exposure through internal response header on Next.js Edge runtime routes
·GitHub Advisories
Next.js applications that set cookies through NextResponse on Edge runtime routes — App Router route handlers and Pages Router Edge API routes — send an internal x-middleware-set-cookie header in the public response, duplicating the cookie value and its attributes. This makes HttpOnly cookies, such as session tokens, readable by JavaScript running on the same origin when an application sets a sensitive cookie on an affected response.
Next.js: SVG rejection bypass in the image optimization
·GitHub Advisories
On self-hosted deployments, the Next.js image optimizer (/_next/image) can be made to process an attacker-supplied SVG even when SVG support is disabled with dangerouslyAllowSVG: false (the default). This reaches an SVG parser the application intended to keep disabled, increasing exposure to denial of service and SVG decoder vulnerabilities.
Next.js: Cross-client response injection and disclosure in self-hosted Next.js applications forwarding fetched responses
·GitHub Advisories
Self-hosted Next.js applications (App Router route handlers and the fetch cache) that return a fetched upstream response unchanged can emit a response whose declared framing does not match the body actually sent. When such an application sits behind an HTTP/1.1 reverse proxy that permits pipelined response queueing, a crafted upstream response can desynchronize responses between clients, enabling response injection and disclosure of other clients' responses.
Next.js: Cross-user cache disclosure and poisoning in Next.js use cache with binary arguments
·GitHub Advisories
Next.js App Router applications that pass binary arguments (such as Uint8Array or Blob values) to functions using the use cache directive can produce identical cache keys for distinct arguments, allowing cached results to be shared across users — cross-user disclosure of cached data or cache poisoning. This affects applications using use cache with binary arguments.
Next.js: Cache poisoning of shared fallback shells in Cache Components via request-supplied placeholder route params
·GitHub Advisories
Self-hosted Next.js applications served with next start and built with cacheComponents: true but without Partial Prefetching accept a request-supplied route param value as a prerender placeholder. One unauthenticated GET request can poison the fallback shell cache entry that a family of routes shares. Such a route is served from a shell that keeps its never-prerenderable params as placeholders, so every value of those params shares one cache entry. A path segment equal to the percent-encoded, bracketed name of its own route param is treated as an unresolved placeholder, and only that param is deferred. A layout above it then renders its concrete value into the shell during the blocking render, and the result, including its HTTP status, is stored under the shared key. Depending on the…
Safari MCP: JavaScript injection through single-quoted tool arguments (backslash not escaped)
·GitHub Advisories
### Impact Sixteen places in safari.js placed a tool argument inside a single-quoted JavaScript string literal and escaped the single quote without first escaping backslashes. An argument containing a backslash followed by a quote therefore closed the literal, and the rest of the argument ran as JavaScript in the page. Seven of the affected arguments belong to read-only tools that are exempt from the tab-ownership check: filter in safari_network_details and safari_extract_links, level in safari_console_filter, selector in safari_snapshot, safari_accessibility_snapshot and safari_extract_tables, and dbName / storeName in safari_get_indexed_db. An MCP client limited to read-only tools (with safari_evaluate and safari_run_script excluded from its allowlist) coul…
Effect: ReDoS in Schema.TemplateLiteral compiled regex
·GitHub Advisories
### Impact Schema.TemplateLiteral compiles each Schema.String span to the lazy wildcard [\s\S]*? and decodes input by running the resulting regular expression against it. When a template has two or more Schema.String spans, for example: ``ts Schema.TemplateLiteral(Schema.String, ":", Schema.String, ":", Schema.String, "X") `` the regex contains several ambiguous wildcards. A non-matching input makes the backtracking engine try combinations across all of them, so matching time grows cubically with input length. A 5,000-character string of : characters blocks the event loop for about 15 seconds. Applications that decode untrusted input with such a schema are affected. That includes Schema.decodeUnknown, Schema.decodeUnknownSync and Schema.is, and anything built on them, su…
iSponsorBlockTV: SSRF via Malicious SSDP Response Spoofing in Local Device Discovery
·GitHub Advisories
### Summary iSponsorBlockTV discovers local smart TV devices via SSDP (Simple Service Discovery Protocol). The LOCATION URL from SSDP responses is used to fetch device capabilities without URL validation. A local network attacker can craft a malicious SSDP response with a LOCATION pointing to any internal HTTP service, causing SSRF when the application fetches device information. ### Details In src/iSponsorBlockTV/dial_client.py:92-96, upon receiving an SSDP M-SEARCH response, the code extracts the LOCATION header and makes an HTTP GET request to that URL to retrieve DIAL device description XML. The URL is not validated against expected device IP ranges, expected schemes, or private/internal IP blocklists. Any device on the LAN (or a rogue WiFi access point) can respond to SSDP M-…
gosaml2: Unauthenticated panic decrypting an EncryptedAssertion with a short or empty CipherValue
·GitHub Advisories
### Summary An attacker who can supply a crafted SAML Response for parsing can crash a gosaml2 service provider by sending an EncryptedAssertion with AES-GCM encryption metadata and a CipherValue shorter than the GCM nonce size (12 bytes). The library panics with slice bounds out of range before any validation completes. This is a **distinct issue from [GHSA-hwqm-qvj9-4jr2](https://github.com/russellhaering/gosaml2/security/advisories/GHSA-hwqm-qvj9-4jr2)**, which addressed panics in the AES-CBC decryption path (commit [3418f9ae09063ff8df0ce1bd93f24e538e614def](https://github.com/russellhaering/gosaml2/commit/3418f9ae09063ff8df0ce1bd93f24e538e614def), included in v0.10.0). That fix added a block-size check for CBC but left the AES-GCM path completely unprotected. ### Details `…
### Impact An unauthenticated request can occupy one synchronous application worker for seconds. Concurrent requests add CPU cost and can keep all workers busy, sustaining denial of service without user interaction. ### Patches The issue has been patched in versions 9.0.967 and 9.1.968-beta. ### Workarounds Disallow the style attribute.
Doorkeeper: When using public clients, any client can revoke any access token
·GitHub Advisories
### Summary An improper authorization issue affects Doorkeeper's OAuth token revocation flow when public (non-confidential) clients are in use. This vulnerability can lead to tokens being revoked without correct authorization. The issue is fixed in Doorkeeper 5.9.1.
OmniFaces: SSE push channels are not bound to their owning HTTP session
·GitHub Advisories
## Summary [GHSA-fp43-vj7g-pg92](https://github.com/omnifaces/omnifaces/security/advisories/GHSA-fp43-vj7g-pg92) (fixed 5.4.2) bound session- and view-scoped **WebSocket** (o:socket) push channels to the HTTP session that registered them, so a leaked channel ID can no longer be connected to from a foreign or absent HTTP session. The fix ([d5cae243c4](https://github.com/omnifaces/omnifaces/commit/d5cae243c4692555efaa4ba774e0f8f60e3f4db5)) touched only the Socket* classes. The parallel **SSE** (o:sse, added in 5.2) push transport was left unchanged. SseEndpoint.doGet accepts a connection whenever the presented channel ID is in the application-wide registry, without ever checking that the caller's HTTP session owns it. A leaked session/view-scoped SSE channel ID can therefore be re…
October: Media Library Crop Handler Bypasses Upload Extension Allowlist
·GitHub Advisories
The Media Library upload handler validates the destination filename against an extension allowlist (default_extensions), rejecting types such as php, phtml, html, and htm. The image crop handler (MediaManager::onCropImage / cropImage) did not perform this check. The destination filename was taken from user input, the extension was extracted from it, and the staged bytes were written to the public media folder under that attacker-chosen extension. Combined with the fact that upload accepts any file contents under an allowlisted extension (a PHP payload disguised as .jpg), and that the zero-dimension crop branch performs a byte-for-byte File::copy rather than re-encoding the pixels, an authenticated backend user with the media.library.create permission could write a file…
Servo Sandbox bypass: declarative refresh can auto-navigate a sandboxed iframe
·GitHub Advisories
A sandboxed iframe can auto-navigate itself via declarative refresh even when automatic features should be blocked. This allows attacker-controlled embedded content to redirect itself without user action. ### Summary Servo allows a sandboxed iframe to auto-navigate itself via declarative refresh in configurations that should block automatic features. The issue reproduces in the must-block rows of the matrix: - sandbox="" - sandbox="allow-same-origin" - sandbox="allow-forms" - sandbox="allow-same-origin allow-forms" This is a client-side sandbox-policy bypass. It does not by itself prove script execution or parent DOM access, but it does let attacker-controlled sandboxed content redirect itself without user action. ### Details The declarative refresh path is missing sandbox enforce…
XWiki Platform: HQL injection in search allows unauthenticated database extraction including password hashes
·GitHub Advisories
### Impact The query REST API allows executing HQL queries to filter the listed pages. While this properly checks access rights for the current user, the query can be used to combine when clauses and blind queries, to recover values, through FROM clause injection to join BaseObject and StringProperty tables, bypassing the HQL validator's SELECT column whitelist. This allows recovering any data that is stored in the database, including data from inaccessible pages, password hashes and passwords stored in configuration properties. For a typical password hash, this requires about 800 requests to the REST API (about one per bit). It should be assumed that when using more complex techniques, this even works when the attacker cannot read any wiki page. Password hashes use salted SHA1 in XWiki w…
SharpIppNext: Unbounded IPP Document Stream Buffering Leads to Denial of Service
·GitHub Advisories
### Summary SharpIppNext's IppProtocol.ReadIppRequestAsync() unconditionally copies the entire attacker-supplied IPP document payload into an unbounded MemoryStream with no size limit. Because this behavior is enabled by default (ReadDocumentStream = true) and the official server documentation shows HttpContext.Request.Body being passed directly to ReceiveRequestAsync() without authentication, an unauthenticated remote attacker can exhaust the server process's memory by sending an arbitrarily large IPP request body, causing an Out-Of-Memory (OOM) condition and denial of service. > [!NOTE] > This vulnerability only affects server-side implementations (using SharpIppServer to parse incoming IPP requests). It does not affect client-side implementations using SharpIppClient or c…
obsidian-sync-mcp: Missing Host/Origin validation lets a public website drive a victim's Obsidian vault via DNS rebinding (no-auth mode)
·GitHub Advisories
When obsidian-sync-mcp runs without MCP_AUTH_TOKEN (the documented no-auth mode for local use), the HTTP MCP endpoint does not validate the Host or Origin header before dispatching MCP methods (CWE-350). The no-auth mode's "local network only" assumption therefore does not hold: a malicious web page the operator visits can use DNS rebinding to resolve an attacker-controlled hostname to 127.0.0.1 (or the operator's LAN/VPN/Docker-published address) and issue requests the server accepts as trusted local calls, reaching the full tool surface (read_note, write_note, edit_note, delete_note, move_note, list_notes, list_folders, list_tags, get_note_metadata). Affected versions:
Tapir: Construction/decode RCE via property name -> raw case-class field (tapir-openapi-codegen)
·GitHub Advisories
The OpenAPI code generator (tapir-openapi-codegen-core) builds Scala source by string templating and emitted several names/values from the (untrusted) OpenAPI document without escaping or validation, allowing injection of arbitrary Scala that runs at generated-code compile time and/or endpoint-assembly time (build/codegen-time RCE from an attacker-controlled spec). This advisory covers the full class of sinks, all sharing one root cause and one fix (PR #5395, commit e015939b7): object property names (-> case-class fields), query/header/path parameter names (-> endpoint input DSL), and operation tags (-> .tags(List(...))). The fix routes identifier-position names through validation/quoting and string-literal values through JavaEscape.escapeString. Consolidates the separately-reported query…
Todoist MCP Server: Browser DNS rebinding lets websites write and delete Todoist data through local MCP server
·GitHub Advisories
The self-hosted todoist-mcp-http server accepts browser-origin MCP requests with attacker-controlled Host and Origin headers. A malicious website can use DNS rebinding to route its own origin to a victim's local 127.0.0.1 MCP server, then invoke Todoist MCP tools without a caller credential. This affects github.com/Doist/todoist-mcp at commit d2903e0d945d2a559d71c091337ad6380511e62f, package version 10.3.1, when the optional Streamable HTTP server is running. The stdio entrypoint is not browser-reachable. The vulnerable browser-reachable component is todoist-mcp-http. The documented HTTP server mode runs all MCP tools with the operator's TODOIST_API_KEY and binds to loopback by default: ``bash TODOIST_API_KEY=your-key npx -p @doist/todoist-mcp todoist-mcp-http `` `src/…
### Summary Gortex is an MCP server exposing write_file, edit_file, and move_inline tools. resolveFilePath **exempts absolute paths** from confinement, and the write handlers — unlike read_file / get_symbol_source — **never call guardSymlinkWithinRepo**. A single MCP write_file call with an absolute path writes any file the daemon user can, **outside every indexed repo root** (AtomicWriteFile's MkdirAll auto-creates missing parents). Writing ~/.zshrc, ~/.bashrc, .git/hooks/pre-commit, or a cron/systemd unit yields code execution on the next shell/commit. This directly violates the project's own SECURITY.md invariant *"File-path resolution is **confined to indexed repository roots**"* ### Affected internal/mcp/tools_fileops.go (+ tools_move_inline.go), HEAD…
OpenID4VP: X.509 chain validation accepts a forged certificate that reuses a trusted anchor's Subject DN without verifying its signature
·GitHub Advisories
## Summary ChainBuilder (the private RFC 5280 validator behind TrustEvaluator and the public credential-parsing API) terminated chain building on **Subject Distinguished Name string equality** rather than on cryptographic closure to a trust anchor. A certificate whose Subject DN string matched a trusted anchor's Subject DN was accepted as the chain terminus **with no signature verification** against the anchor's public key. An attacker who mints a self-signed certificate and copies a trusted anchor's Subject DN string onto it can therefore have that certificate — and any credential signed with its private key — accepted as issued under a trusted authority. ## Impact A relying party using @openeudi/openid4vp to verify OpenID4VP presentations (mdoc / SD-JWT VC) could be induced to acc…
keystore-go: Keystore integrity and password verification bypass via stripped trailing digest in Decode()
·GitHub Advisories
### Summary keystore.Decode() fails to check the error returned when reading the trailing SHA-1 integrity digest of a JKS keystore. If an attacker removes the final 20 bytes from a .jks file, the digest read returns an empty slice and the byte-comparison loop never executes, so Decode() returns the parsed keystore with err == nil. This defeats both tamper detection and — for certificate-only truststores — the password check itself, allowing an attacker with write access to a keystore file (but without knowledge of the keystore password) to silently inject or replace trusted CA certificates. ### Details **Affected versions:** github.com/pavel-v-chernykh/keystore-go ≤ v2.1.0+incompatible (the final release on this module path). v3 and v4 releases are not impacted. In `decoder.go…
Axon: Download of Code Without Integrity Check in axon-mcp
·GitHub Advisories
### Summary axon rtk-install downloads a pre-built rtkx binary from GitHub releases and executes it via subprocess.run() on every text-compression call, without verifying its integrity — no checksum, signature, or attestation check anywhere in the download/install path. If the release pipeline or a maintainer token for sammyjdev/rtkx were ever compromised, every axon user who installs or auto-bootstraps rtkx would silently download and execute an unverified binary with the same privileges as the axon process. ### Details The download path lives in src/axon/context/rtk_bootstrap.py: - _http_download() fetches the release archive over HTTPS via urllib.request.urlopen() and writes the raw response bytes to disk — no hash comparison against any published value. - _extract_binary() unpacks the…
The easiest way to fool someone is to give them something they already expect. A job offer. A message about a service outage. A familiar app. Nothing looks strange at first. And that's the problem. This week's stories show how ordinary things are being used to steal data, spread malware, and get people to hand over access. There's another shift worth watching. AI is making some attacks easier
phpAfterShell Explained: How Hackers Could Turn a PHP Session Flaw Into Code Execution
·The Hacker News
PHP's default file-based session storage can be made to return objects an attacker chose, by cutting off a session write at the right moment. When combined with a second weakness, such as a suitable gadget chain in the app, those objects can allow the attacker to run code on the server. Today's PHP releases fix the flaw, called phpAfterShell. The flaw is tracked as CVE-2026-126714 and rated
Jane: Instantiation RCE via query parameter name -> raw PHPDoc */ breakout (jane-php/open-api-3)
·GitHub Advisories
### Summary jane-php (open-api-3) builds PHP via nikic/php-parser (AST), so string literals are escaped -- but PHPDoc comment text is emitted RAW. The generated Client/Endpoint method docblocks embed the query parameter name verbatim in a @param array{ ""?: ... } block. A */ in the query name closes the /** ... */ docblock early and lands in class-body position; because the name is a raw string key (not identifier-mangled), the */ and following PHP survive. Injecting */ public function __construct(){ } /* adds an attacker-controlled __construct to the generated Client class, which runs when the client is instantiated -> RCE (CWE-94). Verified 7.11.2/PHP8.1. ### Impact Generating a client from an attacker-influenced OpenAPI document and using the generated SDK (instantiating the…
Jane: Instantiation RCE via header parameter name -> raw PHPDoc */ breakout (jane-php/open-api-3)
·GitHub Advisories
### Summary jane-php (open-api-3) builds PHP via nikic/php-parser (AST), so string literals are escaped -- but PHPDoc comment text is emitted RAW. The generated Client/Endpoint method docblocks embed the header parameter name verbatim in a @param array{ ""?: ... } block. A */ in the header name closes the /** ... */ docblock early and lands in class-body position; because the name is a raw string key (not identifier-mangled), the */ and following PHP survive. Injecting */ public function __construct(){ } /* adds an attacker-controlled __construct to the generated Client class, which runs when the client is instantiated -> RCE (CWE-94). Verified 7.11.2/PHP8.1. ### Impact Generating a client from an attacker-influenced OpenAPI document and using the generated SDK (instantiating th…
Jane: Instantiation RCE via parameter description -> raw PHPDoc */ breakout (jane-php/open-api-3)
·GitHub Advisories
### Summary jane-php (open-api-3) builds PHP via nikic/php-parser (AST), so string literals are escaped -- but PHPDoc comment text is emitted RAW. The generated Client/Endpoint method docblocks embed the parameter description verbatim in a @param array{ ""?: ... } block. A */ in the parameter description closes the /** ... */ docblock early and lands in class-body position; because the name is a raw string key (not identifier-mangled), the */ and following PHP survive. Injecting */ public function __construct(){ } /* adds an attacker-controlled __construct to the generated Client class, which runs when the client is instantiated -> RCE (CWE-94). Verified 7.11.2/PHP8.1. ### Impact Generating a client from an attacker-influenced OpenAPI document and using the generated SDK (instan…
DOMShell: domshell_eval classified as read-tier can execute side-effecting JavaScript without --allow-write
·GitHub Advisories
### Summary The domshell_eval MCP tool (and the eval command inside domshell_execute) was classified as **read-tier**, allowing it to run without the --allow-write server flag. However, eval and the write-tier js command dispatch to the same handler in the extension and call CDP Runtime.evaluate with the raw expression string and no side-effect gate. Any JavaScript expression could therefore mutate DOM, window, or global state through domshell_eval without the operator's --allow-write authorization. The tool description explicitly promised "(read-only) ... always available in read-only mode" — the misclassification contradicted the documented contract, not just an implicit one. ### Impact No new capability was exposed — the same write access was already available via `do…
djangocms-moderation: Moderation comments disclosed to non-participant staff via the admin changelist
·GitHub Advisories
## Summary The Django admin views for moderation comments (CollectionCommentAdmin and RequestCommentAdmin) render the full comment body but scope access only by an attacker-controlled id in the URL and Django's model-level view_*comment permission. They perform no per-object participant check. As a result, any authenticated staff user who holds the comment *view* permission can read the comments of **any** collection or moderation request — including ones they are not a participant of — simply by supplying the target object's id. Comments are documented and intended to be private to the participants of a collection (its author and the moderators assigned to its workflow). This advisory concerns a read/write authorization asymmetry: the write paths already enforced `request.user ==…
Mareforma: Unsigned Claims Can Be Promoted to REPLICATED via Missing Signature Enforcement in Convergence Path
·GitHub Advisories
### Summary mareforma 0.3.3 contains a critical integrity flaw in the REPLICATED convergence logic (_maybe_update_replicated_unlocked() in mareforma/db/core.py:1300-1319). The peer-selection SQL query that determines whether two independent claims "agree" on the same anchor does not verify that either claim carries a valid cryptographic signature from an enrolled validator key. Because rekor_enabled=False is the default and automatically sets transparency_logged=1 at insert time, every claim — signed or not — immediately satisfies the convergence precondition. An attacker with no Mareforma key can write an unsigned claim to a shared graph, cause it to converge with a legitimate signed peer claim, and have it promoted to REPLICATED status. The forged REPLICATED row is then re…
Mareforma: transparency_logged trusts the unsigned rekor block
·GitHub Advisories
## What's wrong During restore, transparency_logged is recomputed as 1 if (toml_logged is not False and bundle_has_rekor) else 0, where bundle_has_rekor comes only from a rekor.uuid field inside signature_bundle. That derivation is wrong in both directions. First, the rekor block is metadata attached after signing (attach_rekor_entry in mareforma/signing/rekor.py leaves the payload and signatures untouched), so it is not covered by the Ed25519 signature. A hand-edited claims.toml can add "rekor": {"uuid": "x"} to any claim's bundle and forge the "publicly witnessed by Rekor" state. The claim signature still verifies, and restore never cross-checks the block against [rekor_inclusions] or the log. Tampering with claims.toml is the exact threat model restore defends aga…
Mareforma: invalidated claims still promote to REPLICATED
·GitHub Advisories
## What's wrong _maybe_update_replicated_unlocked never checks t_invalid, so a claim that a signed contradiction verdict has marked invalid can still climb to REPLICATED through convergence detection, and it pulls an honest peer up with it. Three gaps line up: - The new-claim short-circuit reads only status and asserter_keyid (core.py:1339-1352); an invalidated but still-open new claim passes. - The candidate-peer SELECT filters status = 'open', unresolved = 0, and transparency_logged = 1 but has no t_invalid predicate (core.py:1390-1410), so an invalidated existing claim qualifies as a convergence partner. - The promotion UPDATE gates only on status = 'open' (core.py:1422-1426), leaving a TOCTOU window even after the SELECT is fixed. A signed contradiction verdi…
Mareforma: verify_bundle never checks a per-claim signature
·GitHub Advisories
## What's wrong verify_bundle documents that it verifies "a bundle's DSSE envelope AND each per-claim signature", lists "per-claim signature failure" among its raised errors, and promises that partial verification never surfaces "an authenticated bundle that contains some invalid claims" as success. The code does not do this. The JSON-LD predicate built by JSONLDExporter._claim_node carries no signature material (there is no signatureBundle field on the node), so the verify loop has nothing cryptographic to check per claim. It only re-derives each claim's canonical-statement digest from the node fields and compares it to the signed subject list: ```python chain_input = _signing.canonical_statement({...node fields...}, node.get("evidence") or {}) expected = hashlib.sha256(chain_input…
## What's wrong search_claims never calls _row_verified_on_read. Its row loop applies only the PRELIMINARY-unenrolled filter, then appends the row. query_claims runs the same projection but additionally re-verifies REPLICATED/ESTABLISHED signatures on read (line 4023) and drops any row that fails, per the documented tamper guarantee in the comment block above it: a high-trust row whose signature does not verify is excluded from query results entirely. So a tampered or forged high-trust row splits the two read paths. Any process with DB write access, or an attacker copying a genuine validation envelope onto a fresh row, can flip a row to ESTABLISHED. query() drops it; search() serves it at its persisted trust level. Verified in a runtime check against a forged ESTABLISHED row: ``…
### Background NATS.io is a high performance open source pub-sub distributed communication technology, built for the cloud, on-premise, IoT and edge computing. The NATS Server MQTT support uses internal $MQTT.* subjects to implement MQTT protocol features such as QoS handling. ### Problem Description An authenticated MQTT client could subscribe to an internal MQTT delivery subject that was not intended to be available to clients. This bypassed configured subscribe permissions for that internal subject family and exposed MQTT QoS2 protocol metadata for sessions in the account. Message payloads were not exposed through this path. This issue was related to an incomplete restriction on internal MQTT subjects. It affected MQTT users whose ordinary subscribe permissions would not otherwise al…
### Background NATS.io is a high performance open source pub-sub distributed communication technology, built for the cloud, on-premise, IoT and edge computing. The NATS Server supports MQTT clients and can bridge MQTT activity into NATS subjects across routes and leafnode connections. ### Problem Description An MQTT client could include protocol control characters in subscription filters that were later forwarded as NATS protocol data to route or leafnode connections. This could corrupt the forwarded protocol stream and allow injection of unintended NATS protocol operations, potentially across cluster nodes or accounts where route or gateway connections are present. Anonymous MQTT deployments are higher risk because no credentials are required to reach the affected parser. Authenticated d…
Kritische Sicherheitslücken in PHP - Updates verfügbar
·CERT.at
19. November 2026 Beschreibung Das PHP-Projekt hat am 19. November 2026 Sicherheitsupdates veröffentlicht, die unter anderem sieben als kritisch eingestufte Sicherheitslücken beheben. Die Schwachstellen betreffen die Session-Verwaltung (ext-session), die Datums-Erweiterung (ext-date), PHP-FPM sowie die Zend Engine und können unter bestimmten Konfigurationsvoraussetzungen zur Ausführung von beliebigem Code führen. CVE-Nummer(n): CVE-2026-115560, CVE-2026-126714, CVE-2026-129182, CVE-2026-129289, CVE-2026-129474, CVE-2026-129481, CVE-2026-129496 CVSS v4.0 Base Score: jeweils 9.2 (kritisch) Auswirkungen Bei erfolgreicher Ausnutzung können Angreifer:innen beliebigen Code mit den Rechten des PHP-Worker-Prozesses ausführen. Zudem sind Speicherkorruption, Abstürze von Worker-Prozessen (Denial-of…
A critical flaw in VMware vCenter lets an attacker with network access bypass authentication and gain unauthorized access to the system, Broadcom, which owns VMware, said in an advisory published today. Fixed versions are out for all supported branches, and the company lists no workaround. vCenter is the central console for managing an organization's ESX hosts and virtual machines. The
PHP Fixes 7 Critical Flaws, Including Bugs That Could Allow Remote Code Execution
·The Hacker News
The PHP Foundation has released security updates to address multiple critical security flaws that could be exploited to achieve remote code execution on affected deployments, including CVE-2026-115560. The list of vulnerabilities is as follows - CVE-2026-115560 (CVSS score: 9.2) - An improper input validation vulnerability that could result in remote code execution, file modification,
Drupal Patches Critical Installer Flaw That Could Give Unauthenticated Attackers Control of Sites
·The Hacker News
Under specific conditions, a critical vulnerability in Drupal core can allow an attacker without login credentials to use the built-in installer to attempt to reinstall a site. That can lead to a site takeover or remote code execution, and the project rates the vulnerable configurations as uncommon. Fixed releases for all supported branches shipped yesterday. The Drupal Security Team disclosed