Command injection in NooBaa's cluster_internal_api (set_hostname_internal function) allows an authenticated attacker holding NooBaa administrative privileges on a Red Hat OpenShift Data Foundation 4 Multi-Cloud Object Gateway to execute arbitrary shell commands in the context of the NooBaa process by supplying a hostname value containing shell metacharacters. The flaw carries a CVSS 3.1 base score of 7.2 (AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H), and the high-privilege prerequisite means it is not reachable by unauthenticated users; realized impact is bounded by the privileges of the NooBaa pod rather than guaranteed node-level root. No public exploit code or confirmed active exploitation (CISA KEV) was identified at time of analysis.
Unauthenticated attackers can amplify outbound HTTP traffic from any application that validates JWTs with PyJWT's PyJWKClient against a remote JWKS endpoint, because prior to 2.14.0 an unknown 'kid' in the token header forces a full JWKS refresh on every call with no negative cache or minimum refresh interval. One attacker request produces one outbound JWKS fetch plus full JSON parsing on the victim server, and because the 'kid' is read from the unverified token header, no valid token or authentication is required - even enabling key caching does not help, since a repeated identical unknown 'kid' re-fetches every time. A verified proof-of-concept exists (CISA SSVC records exploitation as 'poc', no CISA KEV listing), so this is treated as publicly available exploit code; EPSS is low (0.35%, 27th percentile). The issue is fixed in 2.14.0, which introduces a 30-second cooldown between forced refreshes.
Stored cross-site scripting in Regular Labs Tabs & Accordions Pro versions 2.3.0 through 3.1.0 lets an authenticated Joomla user who can author or edit articles plant a JavaScript-executing browser URL scheme in a tab/accordion item's url option; the extension writes that value into a generated data-rlta-url attribute and the browser code later passes it to window.open() when the item is activated. Because the payload is stored as ordinary plugin syntax at save time, Joomla's article filtering does not catch it, and the executable behavior only materializes at render/interaction time. The vendor vector (CVSS 4.0 7.5, AV:N/AC:L/AT:P/PR:H/UI:N) and our independent assessment (CVSS 3.1 AV:N/AC:L/PR:L/UI:R/S:C/C:L/I:L/A:N) agree that exploitation requires privileged, authenticated content-authoring access and a victim who actively activates the affected item, so this is a genuinely moderate, not high, real-world risk; no public exploit code has been identified at time of analysis.
Type confusion in XS::Parse::Infix versions 0.40 through 0.49 - the Perl XS module distributed as part of XS-Parse-Keyword - lets an attacker who can influence a list handed to a list-associative infix operator (for example the zip operator from Syntax::Operator::Zip) make the interpreter dereference an address of the attacker's choosing. Supplying a bare number where an array reference is expected reliably segfaults the process (denial of service), while a crafted string carrying 0x0b at byte 12 slips past the faulty reference guard and is treated as an AV head, so bytes 16-23 are used as AvARRAY and its entries are pushed onto the Perl stack as live SVs, yielding a limited out-of-bounds read / information-disclosure primitive. Publicly available exploit code exists (a minimal zip-based proof-of-concept is described by the reporter), but there is no confirmed active exploitation (no CISA KEV listing) and EPSS is low at 0.18% (7th percentile); this is a library flaw with no standalone attack surface, so real-world risk depends entirely on whether a consuming application passes untrusted, attacker-influenced data into such an operator.
Use-after-free in Meta's Proxygen HTTP library (v2024.10.28.00 through v2026.09.28.00) lets remote, unauthenticated attackers provoke the invocation of a freed read callback during WebTransport session teardown, because WebTransportImpl::terminateSessionStreams (named WebTransportImpl::destroy in releases before v2025.08.18.00) destroys streams without first unregistering their read callbacks. Only deployments that actually enable WebTransport over HTTP/3 are exposed, and the independent assessment rates this AV:N/AC:H/PR:N/UI:N with high availability impact and low confidentiality impact, since the attacker must open WebTransport streams and drive the session into the specific stream-close/teardown ordering. No public exploit code and no confirmed active exploitation were identified at time of analysis, and EPSS is low (0.14%, 3rd percentile), so the practical risk is concentrated in services that both use Proxygen and enable WebTransport.
Use-after-free in Meta's experimental moxygen Media-over-QUIC (MoQ) library (MoQSession::dataStreamReadLoop) lets a remote, unauthenticated peer corrupt memory and crash an endpoint that accepts MoQ sessions over proxygen's WebTransport API. The flaw is triggered when a data stream names an unknown/unresolved track alias and carries the FIN flag in the same write, so the stream read handle is invalidated by the FIN before the read loop finishes using it; affected builds are those from b24f8e65cb83ebe5f3880cc4e3a4c8f64e1882f9 up to (excluding) the fix commit 004123dd24c30dad6b649163575145f240dabc94. Exploitation requires only that the target runs a vulnerable commit and exposes an accepting MoQ endpoint; there is no public exploit identified at time of analysis (EPSS 0.14%, third percentile; CISA SSVC exploitation:none), and the vendor fix is available as upstream commit 004123dd24c30dad6b649163575145f240dabc94.
Improper authentication in @grpc/grpc-js causes servers to surface unauthorized TLS peer certificates as valid authentication context when requireClientCertificate is set to false, letting applications that consume that context for access control treat an untrusted client as authorized. Affected releases are those before 1.13.6 and before 1.14.5; @grpc/grpc-js-xds can reach the same condition when RBAC authentication is enabled. The vector is network-reachable with no privileges or user interaction required (AV:N/PR:N/UI:N), though high attack complexity (AC:H) reflects that a specific mTLS configuration and application reliance on getAuthContext are prerequisites; no public exploit has been identified at time of analysis, and vendor patches exist in 1.13.6 and 1.14.5.
Token forgery in PyJWT 2.13.x lets unauthenticated remote attackers mint tokens that the library will accept as authentic: when a public JWK is prefixed with a UTF-8 byte-order mark and passed directly as the raw HMAC secret inside a mixed-algorithm verification path, HMACAlgorithm.prepare_key fails to recognize the material as an asymmetric key and uses the publicly known JWK bytes as the shared secret, so anyone who knows the public key can sign arbitrary claims that verify successfully. The flaw carries an assessed CVSS of 7.4 (integrity-only impact, AC:H, PR:N) and per our independent assessment is conditionally scoped: it requires PyJWT 2.13.0 through 2.13.x, an application that permits HMAC alongside asymmetric algorithms, code that hands a raw public JWK to prepare_key instead of loading it via PyJWK/HMACAlgorithm.from_jwk, and BOM-prefixed key material. No public exploit code was identified at time of analysis and the issue is not in CISA KEV; the vendor-released patch is 2.14.0.
Signature forgery in PyJWT 2.13.0 lets an attacker forge arbitrary JWT claims when an application verifies tokens using both HMAC and asymmetric algorithms and hands a public JWK container (a JWKS document, a bare array, a nested array, or a BOM-prefixed variant) directly to the library as the raw key. Because the version 2.13.0 HMAC key guard only recognizes top-level public JWK objects and misses these container wrappers, public asymmetric key material - which is not secret - is accepted as the HMAC secret, so anyone who knows the target's public key can sign a token with any claims and have it validate. The flaw is an improper-signature-verification issue (CWE-347) rated CVSS 3.1 7.4 (AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:N) and unauthenticated in the sense that no credentials are needed, but real-world urgency is lower than the headline score: exploitation requires a non-default application design that mixes algorithm families and passes container-form keys, and no public exploit code or confirmed active exploitation was identified at time of analysis. Vendor-released patch: PyJWT 2.14.0.
Signature forgery in the PyJWT Python library (versions 2.4.0 through 2.13.x) lets a remote, unauthenticated attacker mint forged HMAC tokens whenever an application is misconfigured to accept both HMAC and asymmetric algorithms and passes a DER-encoded public key as the shared verification secret. PyJWT's HMACAlgorithm.prepare_key only rejected PEM- and SSH-formatted asymmetric keys using textual markers, so a DER public key (SubjectPublicKeyInfo, PKCS1, or a DER x509 certificate) slipped through and its public bytes were used directly as the HMAC secret - meaning anyone who knows the public key can sign valid tokens. The flaw is rated CVSS 7.4 with High attack complexity precisely because it requires that specific non-default application configuration; no public exploit code has been identified at time of analysis, and the vendor-released patch is PyJWT 2.14.0.
Server-side request forgery in Apache Roller 6.1.5 allows an authenticated user holding entry-editing rights on a weblog to force the server to issue outbound HTTP requests to attacker-chosen destinations via the legacy outbound Trackback action and entry enclosure handling. No non-default configuration is required because the default Trackback allow-list is empty and therefore permits every destination, and although the Trackback control is hidden in the standard UI its Struts2 action remains directly reachable; requests can be aimed at loopback and private-network addresses, while the enclosure path additionally exposes response status, content type and length. CVE-2026-82375 carries a CVSS 3.1 score of 7.4 (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:L/I:L/A:L, CWE-918) and no public exploit code was identified at time of analysis, with no confirmed active exploitation (CISA KEV); upgrading to Apache Roller 6.1.6 or later removes the outbound Trackback action and stops dereferencing enclosure URLs.
LDAP filter injection in Apache Karaf before 4.4.12 allows a crafted login name to alter the structure of LDAP search filters built by LDAPCache and LDAPBackingEngine, potentially matching an unintended directory entry, over-granting roles, or changing which account a login resolves to. The unescaped value only reaches the filter through two call paths - the GSSAPILdapLoginModule (Kerberos/SPNEGO), which passes the NameCallback name through unescaped, and the LDAPBackingEngine.listRoles path, which passes principal.getName() unescaped - because the default LDAPLoginModule and LDAPPubkeyLoginModule both pre-escape the login name via Util.doRFC2254Encoding(). The issue is remote and unauthenticated per the assessed vector (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:L/A:L, score 7.3), but real-world impact is bounded by the administrator-configured userFilter/roleFilter templates; there is no confirmed active exploitation (not in CISA KEV), no public exploit code identified at time of analysis, and EPSS is low at 0.25% (14th percentile). A vendor patch is available in Apache Karaf 4.4.12.
Use-after-free in Meta's proxygen C++ networking library (versions v2026.04.06.00 up to but not including v2026.09.28.00) lets unauthenticated remote clients trigger memory corruption during the teardown of a QUIC WebTransport session, reachable through QuicWtSession::closeSession on deployments that actually serve WebTransport. Per the vector (PR:N) no credentials are needed, but the independent assessment rates the attack complexity as high because exploitation depends on winning the destruction/reference-release sequencing inside the session-close path; practical impact is most likely a denial-of-service crash of the affected service, with partial confidentiality, integrity, and availability effects possible. There is no confirmed active exploitation and no public exploit code identified at time of analysis, and EPSS is correspondingly low at 0.14% (3rd percentile), with CISA SSVC recording Exploitation: none and Technical Impact: partial.
Path traversal in Flatpak's app deployment handling of the exported files/etc directory allows a malicious Flatpak application to empty or replace host files such as /etc/passwd, /etc/group, /etc/machine-id, or /etc/resolv.conf with a symlink when that app is installed or upgraded; on system-wide installations the write is carried out as root. Exploitation is gated on user interaction: the victim must choose to install or upgrade the attacker-supplied app from an untrusted source (CVSS 3.1 base 7.1, AV:N/AC:L/PR:N/UI:R with high availability and low integrity impact), making this a genuine but moderate-priority integrity/availability issue rather than a critical remote code execution flaw. No public exploit code and no confirmed active exploitation (CISA KEV) were identified at time of analysis.
Path traversal in Flatpak's handling of the export/bin directory during application deployment allows a malicious Flatpak app to delete attacker-chosen files outside the deployment directory when that app is installed or upgraded; on system-wide installations the deletions are carried out with root privileges, so a crafted package can remove arbitrary files anywhere the deployer can reach. The flaw affects Flatpak releases before 1.18.4 and is triggered by a user or administrator installing or upgrading an attacker-supplied app, which supplies the required user interaction rather than a network-based trigger; the CVSS vector carries PR:N, so no prior authentication is needed beyond that install action. No public exploit code has been identified at time of analysis and there is no evidence of confirmed active exploitation, though the integrity and availability impact is high (arbitrary file deletion) and the flaw crosses a privilege boundary on system-wide installs.
SiYuan versions before v3.8.4 contain a SQL injection vulnerability (CWE-89) in block query embed blocks that allows remote, unauthenticated attackers to execute arbitrary SQL against the local siyuan.db database, but exploitation requires the victim to import a malicious .sy document (UI:R). Successful exploitation enables high confidentiality impact (e.g., data exfiltration via VACUUM INTO) and low integrity impact (data tampering), with no availability impact, per the independent CVSS 3.1 assessment. No public exploit or CISA KEV entry is currently known, but a vendor patch (v3.8.4) is available.
Broken access control in Nginx Proxy Manager through 2.16.0 lets a non-administrative user who has been granted 'manage' permissions over one or more hosts write arbitrary nginx directives into the advanced_config field, which the backend renders verbatim into the generated proxy host configuration. Because directives such as alias can be injected, an attacker can serve files from arbitrary paths or manipulate routing for the hosts they are assigned, changing the content (C:H) and, to a lesser degree, the integrity of what the proxy returns (I:L), though this is confined to that user's assigned hosts and no victim interaction is required. Exploitation requires an authenticated account with delegated manage rights (PR:L, AV:N), so single-admin deployments are not exposed to a lower-privileged attacker; there is no public exploit code identified and no confirmed active exploitation at time of analysis, and the issue is rated 7.1 on the CVSS 4.0 vector supplied alongside the advisory. An upstream fix exists (PR #5908) that gates advanced_config changes behind an isAdmin check, but no tagged patched release has been independently confirmed.
Server-side request forgery in fast-mcp-telegram prior to version 30.1 allows an authenticated MCP client (CVSS PR:L) to make the server fetch arbitrary internal HTTP(S) endpoints and receive the response body back as a Telegram file attachment. The send_message and send_message_to_phone tools accept URL lists that the server downloads via httpx.AsyncClient.get, but the _validate_url_security guard only inspects the literal hostname string and never resolves DNS, so any attacker-controlled domain that resolves to a loopback, private, or link-local address passes validation - even with the secure defaults block_private_ips=True and allow_http_urls=False. Because the fetched content is exfiltrated through the Telegram attachment rather than merely observed, this is a full-read SSRF; exploitation requires an authorized MCP session and a resolving hostname (raw private-IP literals remain blocked), and no public exploit code was identified at time of analysis.
DOM-based cross-site scripting in Laravel's built-in exception debug renderer (Laravel framework before 12.69.0 and 13.30.0) lets attacker-influenced data be rendered as HTML inside a Tippy.js tooltip on the debug page, so script executes in the browser of anyone who views that page and hovers the affected tooltip. The issue is reachable unauthenticated over the network (CVSS vector PR:N) but requires user interaction (UI:R) and only manifests when the application is running with APP_DEBUG=true - a configuration Laravel does not recommend for production - which is the principal limiting factor and keeps the overall severity at Low (CVSS 3.1). No public exploit code has been identified at time of analysis, and vendor-released patches exist in 12.69.0 and 13.30.0.
An out-of-bounds read in libXtst's RECORD reply parser (CWE-126) allows a malicious or compromised X server to crash attached X clients that link the library and use the XTEST/RECORD extension, affecting all versions before 1.2.6. The assessed vector is CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:L/I:N/A:L, meaning unauthenticated attackers in the network position of the rogue server can trigger a low-integrity information leak and a denial of service, but only if the victim voluntarily connects to that server (UI:R). This is a reverse-trust scenario: it is not exploitable against clients that connect only to trusted local or remote X servers, and the X server itself is unaffected. There is no public exploit identified at time of analysis and the issue is not in CISA KEV; vendor patch data indicates a fix is available, with the upstream correction landing in the libXtst 1.2.6 line.
Arbitrary code execution on an operator's workstation is achievable through kube-compare when it processes a 'container://' reference path pointing at an untrusted container image, because the tool launches that image's entrypoint instead of only reading data out of a stopped container. Exploitation is locally scoped and gated: per the assessed vector CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, an unauthenticated (PR:N) attacker must convince the operator to invoke the tool against the malicious reference (UI:R), so the victim's own action is the trigger. This is a genuine but conditionally-gated risk - escalation to full root-mediated impact occurs only where the local Docker daemon runs with elevated privileges - and no public exploit code or confirmed active exploitation (CISA KEV) has been identified at time of analysis; EPSS data was not supplied. The tool is distributed in Red Hat OpenShift Container Platform 4 and the 'Pen Drive Powered by Red Hat Lightspeed' offering.
Cross-tenant authorization bypass in SUSE Rancher Fleet allows a party who can perform agent-initiated cluster registration into a Fleet workspace namespace shared with other tenants to inject attacker-controlled cluster labels - including reserved management.cattle.io/ labels such as the cluster display name - that are then persisted onto the upstream Cluster object. Because Fleet resolves GitRepo and Bundle targeting from those labels, the attacker's own cluster can be made to satisfy targeting rules administrators intended for a different tenant's cluster, causing content such as Git repos and bundles to be deployed to the wrong cluster. The flaw affects Fleet 0.16 before 0.16.1, 0.15 before 0.15.6, 0.14 before 0.14.10, 0.13 before 0.13.15, 0.12 before 0.12.19 and older releases; exploitation is conditional on a multi-tenant deployment with a shared workspace namespace and label-based targeting, requires a low-privileged authenticated position (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:L/A:N, 7.1), and no public exploit code has been identified at time of analysis.
A supervisor-mode out-of-bounds write exists in the Zephyr RTOS 802.15.4 L2 transmit path: ieee802154_send() copies packet data into a fixed 125-byte frame buffer without validating the packet length on the unfragmented code path. On builds with CONFIG_NET_L2_IEEE802154_FRAGMENT (enabled by default with CONFIG_NET_6LO), local code that opens a NET_AF_PACKET socket (NET_SOCK_RAW, which skips the 6LoWPAN encoder, or NET_SOCK_DGRAM, which returns early on the address-family check) bound to an 802.15.4 interface can send a payload larger than IEEE802154_MTU and corrupt memory adjacent to the transmit buffer pool, causing a crash or further compromise of kernel state. The flaw is not reachable from the radio because ieee802154_6lo_encode_pkt() length-checks IPv6 packets and forces fragmentation; in a CONFIG_USERSPACE build an unprivileged thread can reach it through the zsock_socket()/zsock_sendto() syscalls, though the overrun is bounded to roughly ll_hdr_len + 3 bytes with the default fixed-size net_buf configuration. No public exploit code was identified at time of analysis and the vendor patch is available (commit 3d4c6177d2dbd77d12d9b14cd75a00cdbd826227).
Axios versions 1.13.0 through 1.19.x on Node.js can silently bypass a configured HTTP(S) proxy or a caller-supplied DNS lookup policy for requests that opt into HTTP/2, because the HTTP/2 adapter calls http2.connect() without consistently applying config.proxy, environment-derived proxy settings, or config.lookup before the connection is established. This is a defense-in-depth control bypass (CWE-918, SSRF-adjacent): confidentiality and integrity impacts fall on the systems the bypassed egress or DNS control was meant to protect, not on the local vulnerable host, and exploitation is gated by non-default configuration - the application must explicitly set httpVersion: 2 and must actually depend on the proxy or lookup policy as a security boundary. Unauthenticated remote reachability is indicated by the CVSS vectors, but practical risk is moderate given the narrow affected version band and the opt-in requirement; no public exploit identified at time of analysis.
Authenticated path traversal in Logsign SIEM versions 6.4.101 through 6.4.116 allows a low-privileged user to write arbitrary files to the underlying filesystem. The vulnerability (CWE-22) is reachable over the network via the web/API interface with no user interaction, and the CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:H/A:L) indicates high integrity impact and low availability impact but no confidentiality impact, consistent with an arbitrary file write primitive rather than file read. No public exploit code has been identified at time of analysis, and the issue is fixed in version 6.4.117; the vendor advisory is available via Turkish CERT (TR-26-1202). EPSS score was not provided.
Incorrect permission assignment in ABB Protection and Control IED Manager (PCM600) through version 2.14 leaves a critical application resource on the Windows engineering workstation protected by weak access controls, letting a local user read and alter protected PCM600 data with high impact to confidentiality, integrity, and availability. Exploitation requires the attacker to already have local access to the host running PCM600 - the vendor vector describes a local attack (AV:L) with high privileges required (PR:H) and high attack complexity (AC:H), while our independent assessment scores it as a low-complexity local issue requiring only low privileges (CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), so a lower-privileged local account may be sufficient in practice. No public exploit code has been identified at time of analysis and there is no CISA KEV confirmation of active exploitation; ABB published the vendor advisory (document 2NGA003170), and this is a genuine but low-urgency issue.
Unauthenticated access to the backup function on the Kaon AR2140X router allows an attacker on an adjacent network segment to trigger a configuration export without any credentials and download the resulting file, which is protected only by a device-specific encryption key. The same action drives the router into an inoperable state for a substantial period, making availability loss the dominant realistic impact, while the device-specific backup encryption limits direct confidentiality exposure. Affected firmware is reported up to version 4.2.17, with the status of newer releases unknown; exploitation requires network adjacency (same LAN, Wi-Fi, or adjacent ISP access segment) rather than internet exposure, no authentication or user interaction is needed, and no public exploit code was identified at time of analysis.
Redirect-policy bypass in Axios 1.17.0 up to (but not including) 1.20.0 causes the fetch adapter to follow HTTP 3xx redirects even when the application explicitly sets maxRedirects: 0, so a redirect-blocking control that developers rely on as a security boundary is silently ignored. The flaw is a confused-deputy issue (CWE-441): an attacker positioned to control a redirect response from a server the application calls can push the request to internal responses or state-changing internal endpoints that should have been unreachable. Exploitation requires three simultaneous conditions - use of the fetch adapter (not the default http/xhr adapters), an explicit maxRedirects: 0 setting used as a security control, and an attacker-influenced redirect target - and per the independent assessment it is unauthenticated (CVSS PR:N) with only a single additional precondition (AT:P), yielding no direct impact on the axios host (VC/VI/VA:N) but high confidentiality and integrity impact on the subsequent internal systems reached (SC:H/SI:H). There is no public exploit identified at time of analysis and no confirmed active exploitation (CISA KEV).
Privilege destruction in InvoicePlane 1.7.2 allows an authenticated secondary administrator to demote the primary administrator account (user_id = 1) to a read-only Guest role by exploiting a missing object-level authorization check in the Users::form() endpoint. This locks the legitimate owner out of the instance. The vulnerability requires an attacker who already holds a secondary admin account (user_type = 1) and a deployment with more than one administrator; no public exploit code or active exploitation has been identified at time of analysis, and no vendor patch is currently available.
Use-after-free in GCC's libstdc++ handling of erase_if on a binary-heap priority queue (std::priority_queue) allows unauthenticated remote attackers to crash applications, and potentially corrupt memory, when the application invokes that operation with attacker-influenced contents that force a storage reallocation; the assessed CVSS:3.1 vector AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:L/A:H (7.0 High) reflects high attack complexity and low confidentiality/integrity impact against high availability impact. Exploitation is conditional rather than self-contained: the flaw is a library primitive, so reachability depends entirely on whether the consuming application exposes the erase_if code path to external input, and the demonstrated outcome is a crash with memory corruption described only as 'potential.' No public exploit identified at time of analysis and the issue is not in CISA KEV; this is a genuine but conditional memory-safety flaw whose real-world priority is moderate, not urgent.
Axios 1.12.0 through 1.19.x can be tricked into merging attacker-supplied HTTP headers into a fetch adapter request when the surrounding Node.js or browser application is already vulnerable to a separate, same-process prototype-pollution flaw. The polluted value must be an array or a non-plain class instance that masquerades as FormData via inherited append, getHeaders, or Symbol.toStringTag properties; plain objects are explicitly blocked, and the resulting header injection can alter authorization, cache, metadata-service, or application-specific request semantics. This is a defense-in-depth integrity gadget rather than a standalone remotely exploitable bug - exploitation is unauthenticated (PR:N) but conditional on a pre-existing pollution primitive (AT:P), no public exploit code was identified at time of analysis, and the flaw is fixed in Axios 1.20.0.
An unauthenticated attacker (CVSS PR:N) who obtains physical access to the on-chip debug and test interface of the SMCU on Dell 17G BOSS-N1 controllers can bypass the intended access controls and gain unauthorized access to the controller before firmware version 2.2.13.2038 is applied. Exploitation is constrained by the need for direct hardware contact - typically an opened chassis and a debug connection - plus high attack complexity and a required interaction step (AV:P/AC:H/UI:R), so the practical risk is LOW despite the HIGH 7.0 base score with scope change and full confidentiality, integrity, and availability impact on the component. No public exploit code has been identified and there is no confirmed active exploitation (not listed in CISA KEV); realistic exposure is limited to insider, supply-chain, in-transit, decommissioned/RMA, or unattended data-center scenarios.
Axios versions 1.0.0 through 1.19.x can leak attacker-controlled headers - including authorization-related values - into outgoing HTTP requests, but only as a secondary gadget in a chain: a separate same-process prototype-pollution flaw must first set Object.prototype.headers, and the application must use trusted request interceptors that return a fresh ordinary configuration object without its own headers property, causing dispatchRequest's normalization step to fall through to the inherited prototype value. The issue is fixed in Axios 1.20.0, which filters shared-prototype-inherited values during config merging and interceptor replacement; no public exploit code has been identified at time of analysis and the defect is inert in isolation, making this a defense-in-depth hardening fix rather than a standalone exploitable vulnerability. Authentication requirements are unauthenticated per the CVSS vector (PR:N), but exploitation is gated by the AT:P attack-requirements flag and the pre-existing pollution primitive.
Header sanitization bypass in the Axios fetch adapter (npm axios 1.7.0 through 1.19.x) allows attacker-controlled request headers - such as Authorization, caching directives, or metadata-service targeting values - to be applied after Axios has already built a sanitized Request object, enabling scope-changed integrity impact (assessed CVSS 3.1: AV:N/AC:H/PR:N/UI:N/S:C/C:L/I:H/A:N). Exploitation is not standalone: it is a gadget that requires a separate same-process prototype-pollution flaw capable of writing Object.prototype.headers, plus use of the fetch-based transport rather than the default Node HTTP adapter. No public exploit code is identified at time of analysis, but the fix and code change are public in the Axios v1.20.0 release, pull request #11141, and commit d19040bd, so the affected range should be treated as patch-now.
Axios versions 0.27.2 through below 0.34.0, and 1.0.0 through below 1.20.0, can silently upgrade an intended GET into a state-changing HTTP method when a request is sent through the default instance without an explicit method. The flaw is a read-side gadget, not a pollution source: calls such as axios({ url }) or axios.request({ url }) omit a method, so dispatch looks up the method on the prototype chain and honours an Object.prototype.method value planted by an unrelated prototype-pollution vulnerability in the same process. Because a separate pollution primitive must already exist, this is only exploitable as part of a chain, which is why the vendor CVSS 4.0 vector carries AT:P; no public exploit code was identified at time of analysis and the issue is not listed in CISA KEV. The vendor scores it 6.9 (AV:N/AC:L/AT:P/PR:N/UI:N, SI:H only), while our independent assessment rates it CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:H/A:N, treating the unauthenticated network-reachable integrity impact as high but gated on the pollution prerequisite.
Unauthenticated remote attackers can repeatedly invoke the revalidateProducts Server Action in the MarcosCamara01 Ecommerce Template (all revisions before commit ec97209) to forcibly expire the entire storefront product cache, driving near-zero-cost cache thrash and availability degradation. The action lives in src/app/actions.ts under a file-scope "use server" directive and calls updateTag("products") with no session or role check, unlike the read-only actions in the same file; because two client components under src/components/admin import it, its Server Action id is compiled into a public /_next/static chunk that the proxy.ts admin middleware does not gate, so any remote user can harvest the id and POST it directly. Impact is strictly availability-scoped (CVSS 4.0 base 6.9; assessed CVSS 3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L) and the reachable condition is deployment-dependent: it matters when cacheComponents is enabled and storefront pages are served from 'use cache' entries tagged 'products' with an hours-long cacheLife, an open-source self-hosted template configuration chosen by each operator. No public exploit code was identified at time of analysis and there is no KEV confirmation of active exploitation.
Information disclosure in SiYuan before v3.8.4 allows publish readers to retrieve image asset paths and filenames from attribute-view (database) rows that the publish configuration should have hidden. The getCurrentAttrViewImages endpoint skips the database-level publish-access check that its sibling rendering endpoint enforces, so an attacker who first obtains an unrendered database identifier from a related endpoint can supply it as avID and receive asset paths for detached rows. The flaw is remotely reachable without authentication (CVSS PR:N) and rated CVSS 6.9 (confidentiality-only, low impact); no public exploit code was identified at time of analysis and the issue is not in CISA KEV, though the vendor has released v3.8.4 to correct it.
Information disclosure in PMWeb v7.x, v8.x, and v2025.x allows a remote, unauthenticated attacker to extract sensitive data by manipulating an unspecified function inside the encryptionhelper.dll library. The vulnerability was disclosed to the vendor, who did not respond, so no vendor-released patch has been identified at the time of analysis and no public exploit code was identified either. The confidentiality impact is limited (VC:L) with no integrity or availability effect, making this a low-priority issue in practice - real-world exposure depends on whether a given PMWeb instance is reachable from untrusted networks, since the product is normally deployed behind corporate access controls.
The F&F Filipowski mH-DEVELOPER smart home module ships production firmware built on end-of-life Debian 8 and Node.js 17.0.1, both of which are past their support lifecycles and carry publicly documented, permanently unpatched vulnerabilities. Rather than containing one discrete exploitable flaw, the product is exposed because it bundles obsolete, unsupported third-party components (CWE-1104); an attacker who can reach and correctly trigger one of the known component CVEs in this firmware could achieve arbitrary code execution, data disclosure, or denial of service, and the network-reachable services require no authentication (CVSS vector signals PR:N). No public exploit identified at time of analysis, and no KEV listing, so this is best treated as a software-composition hygiene finding whose real-world risk is contingent on how exposed the device's services are; F&F addressed the issue in firmware 3.0.30.
Unauthenticated remote attackers can call the cleanCache handler in NotionNext's pages/api/cache.js to force cache invalidation, degrading availability for sites built on the framework. Every release from 4.1.0 through 4.10.10 is affected: versions 4.1.0-4.9.5.2 perform no HTTP method or authentication check on the endpoint at all, while 4.9.5.7-4.10.10 add a guard that is only enforced when the CACHE_REVALIDATION_TOKEN environment variable is explicitly set, so default deployments remain exposed. Impact is confined to availability (assessed CVSS 3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L) with no data read or write and no code execution; no public exploit code or active exploitation has been identified at time of analysis, and the vendor was contacted but did not respond, so no fix has been confirmed.
Dell BOSS-N1 controllers running firmware prior to 2.2.13.2038 expose an unprotected on-chip debug and test interface on the SMCU, allowing anyone with physical access to bypass authentication and read or write protected controller memory, yielding high confidentiality, integrity, and availability impact (CVSS 6.8, AV:P/AC:L/PR:N/UI:N). The attack surface is strictly local: exploitation requires hands-on connection to the debug interface of the SMCU on a 17th-generation PowerEdge server, so remote or network attack is impossible and realistic exposure is limited to insiders, hardware in transit or during servicing, decommissioned or resold units, and evil-maid/supply-chain scenarios. No public exploit code or confirmed active exploitation has been identified at time of analysis, and the physical-access prerequisite keeps practical priority low despite the Medium base score.
ServiceAccount token exfiltration in the StreamsHub Console for Apache Kafka lets a user who already holds RBAC permission to create or modify the Console custom resource point the console-api AdminClient at an attacker-controlled broker. Tenant-supplied Kafka client properties are copied into the AdminClient configuration without filtering security-sensitive keys, so setting config.providers and bootstrap.servers causes the console-api ServiceAccount token to be read and leaked off-cluster. The issue is rated CVSS 6.5 (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N, CWE-470) and is a moderate-severity, privilege-dependent information disclosure: it requires an authenticated, semi-trusted role with write access to Console CRs (PR:L), so clusters with tight RBAC on those resources are substantially less exposed, and unauthenticated external actors cannot trigger it. No public exploit code has been identified at time of analysis and the flaw is not confirmed actively exploited (not in CISA KEV); no EPSS score was provided.
Relative path traversal (CWE-23) in SUSE Rancher Fleet allows an authenticated attacker with either Git push access to a repository referenced by a GitRepo resource or Kubernetes RBAC permission to create or modify a GitRepo (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N) to read files from the filesystem of the bundle-processing environment and have their contents emitted into the generated Bundle resource. The most valuable target is Helm registry credential material that Fleet makes available to the bundle-processing job when per-path Helm credentials are configured, letting the attacker exfiltrate secrets they have no Kubernetes RBAC permission to read. All Fleet branches below 0.16.2, 0.15.7, 0.14.11, 0.13.16 and 0.12.20 are affected; there is no public exploit identified at time of analysis and no evidence of confirmed active exploitation, so this is a moderate privilege-boundary-crossing disclosure rather than an emergency.
Arbitrary file write via path traversal in the kubectl client on Windows allows a malicious tar binary inside an untrusted container to place files at attacker-chosen locations on the operator's workstation, limited only by the permissions of the local user running kubectl. Exploitation requires victim interaction: the user must run `kubectl cp` to copy files FROM an attacker-controlled container, and only affects kubectl clients on Windows (v1.34.0-1.34.11, v1.35.0-1.35.8, v1.36.0-1.36.4) - Linux and macOS clients are explicitly unaffected. The Kubernetes Security Response Committee rated this Medium at CVSS 6.5, our independent assessment concurs at CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:N/I:H/A:N (unauthenticated, user-interaction required, high integrity impact only), and no public exploit code was identified at time of analysis.
Remote, unauthenticated attackers who control an X server can crash X clients linked against libX11 before 1.8.14 by returning crafted XIM (X Input Method) attribute data, because the parser performs an out-of-bounds read (CWE-125). This is an availability-only denial-of-service (CVSS 6.5, AV:N/AC:L/PR:N/UI:R/S:U/C:N/I:N/A:H) limited by an inverted trust relationship: the victim's client must attach to the attacker's display, so exploitation requires the user to connect to a malicious, compromised, or spoofed X server. No public exploit code has been identified at time of analysis, and the issue is not listed in CISA KEV.
SUSE Rancher Fleet versions 0.16 before 0.16.2, 0.15 before 0.15.7, 0.14 before 0.14.11, and 0.13 before 0.13.16 allow an attacker with low-privilege bundle deployment rights to modify labels and annotations on Kubernetes namespaces that the bundle's pinned identity is not authorized to change. The flaw arises from inconsistent authorization checks when a bundle requests namespace metadata updates via the namespaceLabels and namespaceAnnotations options. No public exploit code has been identified at time of analysis, and the CVSS 3.1 score of 6.5 reflects integrity-only impact (C:N/I:H/A:N) requiring existing low privileges on the network.
Authenticated path traversal in Bimser eBA Plus Document and Workflow Management System (versions 6.7.141 up to but not including 10.0.11) allows a remote attacker holding a valid low-privilege account to read files outside the intended restricted directory, resulting in high confidentiality impact with no integrity or availability effect (CVSS 3.1 base 6.5, AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N). The vulnerability is a CWE-22 improper limitation of a pathname to a restricted directory, reported by TR-CERT, and exploitation requires an authenticated session - anonymous access is not indicated by the assessed vector. No public exploit code has been identified at time of analysis, and the flaw is not listed in CISA KEV, so this is a moderate-severity, credentialed information-disclosure issue rather than a top-priority emergency; because the vector is PR:L, only confirmed as an authenticated attack path. Deployments on 10.0.11 or later are not affected.
Missing authentication in the mH-DEVELOPER smart home module lets any device on the same LAN query its HTTP API and WebSocket endpoints and issue raw control commands to building-automation hardware, because the authorization middleware never verifies tokens. The flaw maps to CWE-306 (Missing Authentication for Critical Function) and affects every release prior to 3.0.30, the version in which the vendor fixed it; no public exploit code has been identified at time of analysis. The vendor CVSS 4.0 vector (AV:A/AC:L/PR:N/UI:N, base 6.4) and our independent CVSS 3.1 assessment agree that exploitation is trivial but gated by network adjacency: the attacker must already be on the same local or building network, and no authentication or user interaction is required beyond that.
Trust-boundary bypass in the ip-address JavaScript library (all versions prior to 10.5.1) lets a remote, unauthenticated attacker who can supply or influence the IPv6 address being validated slip an address within the full fe80::/10 link-local range past Address6.isLinkLocal(), which only matched the narrower fe80::/64. Applications that use isLinkLocal() as an SSRF or on-link filter - the sole prerequisite for exploitation, reflected as AT:P in the CVSS 4.0 vector and AC:H in the independent assessment - may then be steered to reach a link-local host outside the intended trust boundary, with impact limited to confidentiality and reachability (C:L, S:C) and no integrity or availability effect. No public exploit code identified at time of analysis; the vendor fix is version 10.5.1.
HTTP/1 response smuggling in the Elixir Mint client (0.1.0 through 1.10.x) allows a malicious or attacker-influenced origin server to desynchronize Mint from an upstream intermediary on a pooled keep-alive connection, so that bytes following a crafted response are parsed as the answer to a subsequent request, poisoning that request's response. The root cause is that Mint's message_body/1 selects chunked framing whenever 'chunked' is the FIRST coding in a Transfer-Encoding header (e.g. 'Transfer-Encoding: chunked, gzip') instead of requiring it to be the final coding, and additionally keeps the connection open after an HTTP/1.0 response - final or 1xx - that carries Transfer-Encoding with 'Connection: keep-alive', both contrary to RFC 9112. Exploitation is a reverse-trust scenario: the attacker must control or inject server response framing and the client must reuse an HTTP/1 connection; HTTP/2 and non-pooled connections are unaffected, and no public exploit code or active exploitation was identified at time of analysis. The issue is fixed in Mint 1.11.0.