A static buffer overflow in ZoneMinder's Remote HTTP camera response parser (RemoteCameraHttp::GetResponse()) affects all versions before 1.38.4 and lets a malicious or compromised HTTP camera - or an on-path attacker able to modify the camera's traffic - corrupt fixed-size buffers by sending oversized HTTP status messages, Connection headers, Content-Type values, or multipart boundaries. Successful abuse corrupts parser state and can crash the capture process or corrupt memory; integrity impact is limited (VI:L) while availability impact is high (VA:H), and no public exploit has been identified at time of analysis. Exploitation is unauthenticated but conditional: it requires a monitor configured for a remote HTTP camera source and attacker positioning on the camera side of the connection rather than against ZoneMinder's own listening interface.
Prototype-pollution gadget in the Axios promise-based HTTP client for Node.js and the browser lets a separate, pre-existing prototype-pollution flaw in the same JavaScript process steer how ToFormData serializes outgoing request bodies in Axios 0.28.0 through 0.33.x and 1.15.1 through 1.19.x. Inherited dots, indexes, metaTokens, maxDepth, visitor, or Blob values planted on Object.prototype silently rename or reinterpret serialized fields, or make requests fail outright via a polluted maxDepth; a polluted visitor only executes when the attacker already possesses a stronger function-injection primitive, so Axios adds no new code-execution capability on its own. Remote unauthenticated exploitation is inert without that chained second bug, and no public exploit identified at time of analysis, with no confirmed actively exploited (CISA KEV) status; vendor-released patches ship in 0.34.0 and 1.20.0.
An authenticated user with access to the EmailTask component in Google Cloud Application Integration (versions prior to 2026-06-30) can exploit a confused deputy weakness to read and exfiltrate arbitrary Google-internal files by supplying a crafted attachment file path. The flaw requires low-privilege authentication (PR:L) and no user interaction, with high confidentiality impact (C:H) on both the service and a subsequent system (SC:H). No public exploit code or active exploitation has been identified at time of analysis; the issue was patched server-side on 2026-06-30, so no customer action is required.
Authenticated federation peers can cause denial of service and broker state manipulation in Apache ActiveMQ Artemis before 2.34.0 by sending a crafted FEDERATION_DOWNSTREAM_CONNECT packet that forces the broker to load and instantiate arbitrary classes visible to the Artemis module classloader. The vulnerability arises from unsafe reflection (CWE-470) in FederationStreamConnectMessage.getFederationPolicy(), which passes an unvalidated class name from the CORE protocol wire buffer to Class.forName(). Although the original CVSS 3.1 vector reports PR:N (8.2 High), the described authentication requirement means the practical severity is lower; the authoritative assessment uses PR:L. No public exploit code has been identified at time of analysis.
Denial of service in the Axios HTTP client affects Node.js deployments running versions 1.15.0 through 1.19.x, where a crafted redirect Location hostname triggers quadratic regular-expression backtracking inside the proxy-bypass check and blocks the Node.js event loop. Successful exploitation requires an unusually specific combination - HTTP_PROXY/HTTPS_PROXY set, a non-empty NO_PROXY/no_proxy value, redirect following enabled, and requests reaching an attacker-influenced server that can return the malicious redirect - so exposure is narrow, and the reverse-trust nature of the attack means the adversary must control or compromise the redirect target rather than simply send a request to the victim. No public exploit code has been identified at time of analysis, and there is no confirmed active exploitation (CISA KEV) for CVE-2026-101906; the high vendor CVSS 4.0 score of 8.2 largely reflects the VA:H availability weighting rather than ease of exploitation, as reflected in our independent assessment of CVSS 3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H.
Axios versions 1.13.0 through 1.19.x can crash a Node.js process because the HTTP/2 adapter installs no error handler on a ClientHttp2Session created for a request made with httpVersion: 2, so a session-level 'error' event emitted during session initialization or reuse escapes normal Promise rejection handling and becomes an uncaught exception that terminates the process, producing a denial of service. Only applications that explicitly opt into HTTP/2 are affected; the browser build and the default HTTP/1.x path are not, and the attacker must additionally be able to induce a genuine HTTP/2 session error (for example via a peer or intermediary), which is why the independent assessment rates this as high complexity rather than trivially triggerable. Impact is availability-only - no data exposure, no code execution, and no privilege requirement (unauthenticated). No public exploit code was identified at time of analysis and the issue is not confirmed actively exploited (no CISA KEV listing).
Axios 1.16.1 through 1.19.x can be driven into catastrophic regular-expression backtracking through its data-URI parser, letting an unauthenticated remote attacker stall the Node.js event loop and cause a denial of service. The trigger is an attacker-controlled, malformed RFC 2397 data URL containing many slash characters on both sides of the media-type separator and no comma, which the fromDataURI / DATA_URL_PATTERN logic must exhaustively re-split before rejecting; because the parse is synchronous, the whole single-threaded process is blocked. Exploitation requires that the application actually route untrusted input into Axios's data: parsing path, so services that only make ordinary HTTP requests are not exposed; there is no confidentiality or integrity impact, authentication is not required, and no public exploit identified at time of analysis. Severity is rated 8.2 under the supplied CVSS 4.0 vector, while our independent CVSS 3.1 assessment (AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H) treats it as availability-only and high-complexity given the deployment prerequisite, and the vendor-released patch is Axios 1.20.0.
Token exposure in the Network UPS Tools GitHub Actions tarball-preparation workflow allows an attacker submitting a fork pull request to cause the job to run with a single-use write-permission GITHUB_TOKEN that is reachable by untrusted PR-source-branch content, letting the attacker extract the token. Because the vector is AV:N/AC:H/PR:N/UI:R/S:C, exploitation is unauthenticated at the network level but requires user interaction (the workflow must actually run on the malicious fork PR) and is confined to the short window while the GHA job and token remain valid; within that window the token's write scopes permit manipulation of repository contents, commit checks/statuses, or issue/PR comments. GHSA-w6wj-3r73-fxmh documents the flaw, which is fixed by commits 658b24e and 1aa31d1; no public exploit identified at time of analysis. This affects only the NUT project's CI supply chain - installed NUT UPS/PDU monitoring deployments are not affected.
Memory exhaustion denial-of-service in Elixir Mint affects versions 1.1.0 through 1.10.x and allows a malicious or compromised HTTP/2 server to force a client application to allocate roughly 1 GB per response by abusing HPACK indexed header fields and cookie handling, potentially exhausting the BEAM VM. The vulnerability requires the application to initiate an outbound HTTP/2 connection to an attacker-influenced endpoint (reverse-trust), and no public exploit code or confirmed active exploitation is identified at time of analysis. Downstream clients such as Finch and Req that use Mint are also affected when making outbound HTTP/2 requests to untrusted servers.
Remote attackers holding a previously issued Rancher session token can retain access even after the legitimate user logs out in SUSE Rancher 2.15 before 2.15.2, because the server fails to clear credentials on logout (CWE-613). This session persistence flaw carries a CVSS 3.1 base score of 8.1 (High) with network reach, low complexity, no attacker privileges (PR:N), and required user interaction (UI:R) for the logout. No public exploit identified at time of analysis; exploitation is limited to scenarios where the attacker already possesses a valid token, such as shared-device or stolen-session situations.
Authorization bypass in Enocta Platform (all versions through 2026-09-28) lets an authenticated low-privilege user read or alter other users' records by tampering with a user-controlled identifier in requests. With a CVSS 3.1 base score of 8.1 (High), the flaw yields high confidentiality and integrity impact but no availability impact. No public exploit code has been identified and the issue is not in CISA KEV; exploitation requires a valid low-privilege account on the platform.
Local privilege escalation in Extegrity Exam4 on macOS lets any unprivileged local user escalate to full root by abusing command injection in the root-running com.extegrity.LogTool privileged helper, which is reachable over XPC. An attacker with a low-privileged local session (PR:L, AV:L, no user interaction required, UI:N) can send crafted XPC messages that reach [ConsoleLogHelper copyConsoleIntoFileFromStartDate:], where attacker-controlled parameters are passed into a syslog command without sanitization and executed with root privileges via LaunchSynchronous, yielding complete confidentiality, integrity, and availability impact (CVSS 3.1 base 7.8, HIGH). Exploitation requires the helper to be installed, registered, and reachable on the host; remote exploitation is not possible, and no public exploit code was identified at time of analysis.
Command injection in the Windows DNS Query Resolution Policy name field of ManageEngine DDI Central versions below 6201 enables an authenticated high-privilege administrator to run arbitrary operating-system commands, resulting in remote code execution on the DDI Central host. The CVSS 3.1 vector (7.2 HIGH, AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H) reflects a network-reachable, low-complexity attack that nonetheless requires privileged console access and the ability to create or edit a Windows DNS Query Resolution Policy, and no public exploit has been identified at time of analysis. The vulnerability is fixed in version 6201, so affected deployments that manage Windows DNS should be prioritized for upgrade, especially since a successful exploit yields full confidentiality, integrity, and availability impact on the compromised server.
An insufficient buffer-size validation defect in Zephyr RTOS's ADI MAX32 ADC driver (drivers/adc/adc_max32.c) allows a local, low-privileged user-mode thread to write up to twice the length of its supplied buffer into kernel memory, producing attacker-controlled out-of-bounds writes at an attacker-chosen offset. Exploitation requires a build compiled with CONFIG_USERSPACE running on ADI MAX32 hardware where the calling thread has already been granted access to a MAX32 ADC device object; on such a build the attacker fully controls channels, buffer, buffer_size and options->extra_samplings, and the resulting corruption of adjacent memory, kernel data or thread stacks is a plausible local privilege-escalation and denial-of-service primitive (CVSS 7.8, AV:L/PR:L). The flaw is not remotely exploitable, and builds without CONFIG_USERSPACE are reduced to a caller-side robustness defect since the application supplies its own buffer; no public exploit code was identified at time of analysis and the issue is not confirmed actively exploited (CISA KEV).
An out-of-bounds kernel-mode write in Zephyr RTOS's NXP MCUX LPADC driver (drivers/adc/adc_mcux_lpadc.c) lets an unprivileged user-mode thread corrupt memory outside its own partition, providing a genuine local privilege-escalation and denial-of-service primitive rather than an inflated high-severity score. The bug affects builds compiled with CONFIG_USERSPACE that use the MCUX LPADC driver in interrupt-driven mode (or DMA-driven mode on releases carrying the DMA path), where adc_read()/adc_read_async() are system calls: a thread already granted access to the LPADC device object controls channels, buffer, buffer_size and options->extra_samplings, and can demand up to channels × 65536 samples into a tiny buffer, causing the driver's ISR or DMA callback to walk past the buffer while running in kernel mode where the MPU does not confine it. No public exploit code or confirmed active exploitation has been identified at time of analysis, but the CVSS vector (7.8, AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) reflects high confidentiality and integrity impact from an authenticated local attacker, and upstream fixes are available.
Kernel memory corruption in Zephyr RTOS arises from the RTIO userspace syscall verifier z_vrfy_rtio_sqe_copy_in_get_handles(), which validates the RTIO object handle and the incoming sqes array but never checks that the caller-supplied handle out-parameter is writable before executing *handle = sqe in supervisor mode. Any user-mode thread that has been granted a struct rtio kernel object - the normal situation for applications using sensor_read_async_mempool() or the async ADC helpers, which call rtio_sqe_copy_in_get_handles() internally - can supply an arbitrary destination address and thereby obtain a write-what-where primitive that stores a pointer to attacker-controlled ring data at any kernel location, corrupting function pointers, thread structures or memory-domain partition tables and breaking the CONFIG_USERSPACE isolation boundary. The issue is local-only and build-gated (CVSS 7.8, AV:L/PR:L, CWE-787), requires both CONFIG_USERSPACE and CONFIG_RTIO, and no public exploit code has been identified at time of analysis, although an upstream vendor fix and GitHub security advisory are available.
Memory corruption in Wind River VxWorks 7 occurs when a task passes crafted arguments to a specific system call, causing an out-of-bounds write inside the RTOS memory-management subsystem and giving the caller full confidentiality, integrity, and availability impact on the running instance (CVSS 3.1 7.8 HIGH). The flaw is local in nature - per the vector (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) the attacker must already execute code on the device as at least a low-privileged task, so only VxWorks 7 deployments that run untrusted or lower-trust code are realistically exposed; locked-down devices that execute only vendor-signed firmware are not remotely reachable through this bug. All VxWorks 7 builds prior to version 26.09 are affected, and there is no public exploit code or CISA KEV entry identified at time of analysis.
Cross-weblog authorization bypass in Apache Roller 6.1.5 lets an authenticated user holding authoring rights on one weblog read, modify, or delete resources belonging to another weblog - bookmarks, bookmark folders, media files and directories, entries, categories, and comments - by supplying identifiers that are resolved without being scoped to the acting weblog. The same flaw allows a user with administrator rights on their own weblog to overwrite a victim weblog's Velocity template, whose content is then evaluated when that weblog renders, giving code-in-context execution within the victim's blog. Rated CVSS 7.7 High (CVSS:3.1/AV:N/AC:H/PR:L/UI:N/S:C/C:L/I:H/A:L), exploitation requires an authenticated author-level account and knowledge or enumeration of valid foreign resource identifiers; no public exploit was identified at time of analysis. Multi-user shared-hosting installations where weblogs are meant to be isolated are affected, while single-user or single-tenant deployments are not meaningfully exposed.
Command injection in the FreePBX Music on Hold (MoH) module lets anyone holding an existing FreePBX administrator account run arbitrary system commands with the privileges of the Asterisk service, because a POST parameter that defines a custom Asterisk application is stored in the database unsanitized and later written verbatim into musiconhold_additional.conf, which Asterisk loads and executes. Deployments running FreePBX prior to 16.0.4 or 17.0.6 with the MoH module enabled and a functioning Asterisk backend are exposed; the vendor has patched the issue in 16.0.4 and 17.0.6. The required admin credentials (PR:L in the published CVSS 4.0 vector, PR:H in the independent CVSS 3.1 assessment) make this a post-authentication privilege-to-code-execution flaw rather than a pre-auth remote takeover, so realistic risk is confined to insider misuse, credential theft, or chaining from another auth bypass; no public exploit code and no confirmed active exploitation (CISA KEV) are identified in the available intelligence.
XML external entity (XXE) injection in Apache Roller 6.1.5 lets an authenticated user who holds entry-editing rights on any weblog force the server to fetch and parse an attacker-influenced trackback response with an XML parser that resolves external entities, disclosing files readable by the Roller process account. The Trackback control is hidden in the standard UI, but its Struts2 action remains directly reachable over HTTP and no non-default server configuration is required, so the practical prerequisite is a valid low-privileged account plus a host the attacker controls to serve the malicious trackback XML (CVSS 3.1 7.7 High, AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:N/A:N, scope change reflecting reads outside the application's own data). No public exploit code was identified at the time of analysis, and the vendor-released fix is Apache Roller 6.1.6, which eliminates the outbound trackback response parser.
Incorrect authorization in Canonical LXD 5.0.0 through versions before 5.0.10, 5.21.8, and 6.10 allows an authenticated client with permission to create custom storage volumes in one project to copy and read any custom volume, including its snapshots and configuration, from any other project on the same server. The flaw resides in the custom storage volume creation endpoint, where a crafted request that sets a source volume and source.project but omits source.type bypasses the cross-project authorization check. This affects multi-project LXD deployments only, requires low privileges (PR:L), and yields high confidentiality impact (CVSS 7.7, AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:N/A:N); no public exploit code or confirmed active exploitation was identified at time of analysis.
Hardcoded root SSH access in F&F Filipowski's mH-DEVELOPER smart home module allows anyone who obtains the matching private key to log in as root over the always-running SSH daemon and fully compromise the device. The key is baked into /root/.ssh/authorized_keys, cannot be deleted without remounting the filesystem, and survives a factory reset, so the exposure persists until firmware 3.0.30 is installed. Attack surface is adjacent/local rather than Internet-wide (CVSS 4.0 7.7, AV:A/AC:H) and the private key is not published in the available sources, which is the main practical barrier; no public exploit code or confirmed active exploitation was identified at time of analysis. Vendor-released patch: 3.0.30.
Credential and response tampering in Axios's Node HTTP adapter (lib/adapters/http.js) affects versions 1.15.2 through 1.19.x when a separate, same-process prototype-pollution flaw plants a function on Object.prototype.createConnection: because the adapter supplies request options without an own createConnection property, Node resolves and invokes the inherited function as the socket factory, redirecting the transport to an attacker-controlled endpoint that receives request headers and bodies (including credentials) and returns forged responses while the requested URL still appears legitimate. This is a confused-deputy gadget rather than a self-contained flaw - it is inert without a co-resident pollution primitive that can write a function onto Object.prototype, which is why the vendor CVSS 4.0 vector carries AT:P and why our independent assessment (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:N) treats exploitation as contingent on that chain. The issue is fixed in Axios 1.20.0; there is confirmed actively exploited (CISA KEV) status absent and no public exploit code identified at time of analysis.
Server-side request forgery in Stringer, a self-hosted RSS reader, allows an authenticated low-privileged user to make the server issue arbitrary HTTP/HTTPS requests to internal network hosts, loopback services, and cloud metadata endpoints such as AWS IMDS at 169.254.169.254. The CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:L/A:L, base 7.6) confirms a network-reachable, low-complexity attack requiring only an authenticated account - a barrier that collapses to near-anonymous when self-service signup (Setting::UserSignup) is enabled, since any visitor can register. Impact ranges from internal port and service scanning to theft of cloud IAM credentials when Stringer runs on a cloud instance with an attached role reachable via IMDSv1; there is no public exploit identified at time of analysis and no confirmed CISA KEV active exploitation, though the attack surface is trivial to exercise for anyone holding a valid session.
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.
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.