Canonical
Monthly
Improper certificate validation in the HTTPS API listener of Canonical LXD lets an unauthenticated remote attacker present a crafted certificate chain that is accepted as an already-trusted client, granting full access to the LXD cluster and the virtual machines it manages. Affected builds are 4.0.14, 5.0.10, 5.21.8, and 6.9 and earlier within each branch; the fixed releases are 4.0.15, 5.0.11, 5.21.9, and 6.10.1. Exploitation requires that the HTTPS listener be enabled and network-reachable, so installations restricted to the local Unix socket are not remotely exposed; clustered LXD and MicroCloud deployments, which depend on this listener, carry the most risk. The vulnerability is rated 10.0 under CVSS 4.0 with no privileges or user interaction required (PR:N/UI:N), and no public exploit code was identified at time of analysis, though the vendor rates the issue as requiring immediate action.
Forged Reject PDUs can crash the Linux kernel's libiscsi initiator, corrupt task refcounts, or falsely complete an in-flight SCSI command as successful. The issue carries a critical CVSS 9.8 vector (AV:N/AC:L/PR:N/UI:N), but EPSS is only 0.18% and no public exploit was identified at time of analysis; exploitation requires an established iSCSI session to an attacker-controlled, compromised, or on-path target, so only hosts using the in-kernel iSCSI client are exposed. No CISA KEV confirmation was present in the supplied data, and the vuln.today decision label is act_now.
Denial of service in the Linux kernel iSCSI initiator (libiscsi over iscsi_tcp) lets a malicious or compromised iSCSI target crash the host by naming an out-of-use task slot in an unsolicited NOP-In or in a Text, Logout, Login or TMF response. The bug is a NULL pointer dereference reachable from the network without credentials (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, 7.5), but it is only exploitable where the initiator actually has an active session to an attacker-controlled target; hosts not using iSCSI, or only attaching to trusted storage, are not realistically exposed. No public exploit code was identified at time of analysis and EPSS is low (0.18%, 8th percentile), although vendor fixes are available and the issue is scored for handling in this week's patch cycle.
The RISC-V futex implementation in the Linux kernel fails to strip address tags from user-supplied pointers before executing atomic operations, allowing a local unprivileged process to make FUTEX_WAKE_OP write to an arbitrary kernel address. Affected systems must run RISC-V with CONFIG_RISCV_ISA_SUPM, have the tagged-address ABI enabled via PR_SET_TAGGED_ADDR_CTRL with a non-zero PMLEN, and use Sv57 paging with PMLEN=16 so that tag bits overlap canonical kernel address bits - on such configurations the flaw yields both kernel memory corruption and, through the FUTEX_OP_CMP_* result, a read oracle that discloses kernel memory. The vendor has published fixes in Linux 6.18.57, 7.2.11 and 7.3 (commits 8e48d8d51ab37b7decfbff3e2844e027a52ad6ea, 405290be962b32eec842776fbe3bdf81f15b1676 and 2e5c80bbc062a8dda33e687ebf7be8f074ee4f7d); no public exploit has been identified at time of analysis and EPSS is low at 0.21% (10th percentile), reflecting the narrow hardware/configuration prerequisites rather than the severity of the outcome.
Canonical Juju 4.0 through 4.0.15 leaves the model unit-resources download route without an authorization check, so any principal already authenticated to the controller - a unit agent, or a human user holding only 'login' permission with no access to the target model - can request an arbitrary unit in an arbitrary model and read that application's charm resources, including container-registry credentials. The fix in Juju 4.0.16 binds the unit named in the request URL to the authenticated identity, refusing cross-unit and cross-model access. No public exploit code was identified at time of analysis, and the flaw requires a valid controller credential, though one at the lowest privilege tier and against default deployments.
Severity signals and exploitation signals diverge here: Splunk SOAR deployments below 8.7.0 permit an authenticated low-privilege user to bypass authorization by supplying requests whose URL path is non-canonical, so the path used for the access-control decision differs from the path the application ultimately services (CWE-647), with CVSS 3.1 scoring the issue 8.8 and high confidentiality, integrity and availability impact. The exposure is limited to holders of valid SOAR credentials on the web interface (PR:L, AV:N, UI:N) and does not extend to anonymous remote attackers. No public exploit code or active exploitation has been identified at time of analysis (SSVC exploitation: none), and Cisco/Splunk has shipped a hardened 8.7.0 release that resolves the flaw.
Node.js TLS certificate validation can accept a peer certificate that presents an IP address in a non-canonical representation instead of rejecting it, undermining identity checks for IP-addressed TLS peers; affected versions are 26.12.0, 24.22.0, and 22.23.3 and earlier on those branches. An attacker positioned to intercept the TLS path and able to supply a crafted certificate could exploit this to impersonate an IP-identified peer, with high confidentiality and integrity impact but no authentication or user interaction required. The vendor fixed the issue in the 2026-10-21 security release v26.12.1; a public PoC reference exists but is not verified as working exploit code, and no confirmed active exploitation is reported in the supplied intelligence.
Improper input validation in Node.js DNS resolution functions lets hostname or address strings containing null bytes reach dns.resolve/dns.lookup, which the 26.12.1 security release fixes by adding explicit null-byte validation of resolve inputs. Node.js 22.x through 22.23.3, 24.x through 24.22.0, and 26.x through 26.12.0 are affected, with the vendor patch shipped in Node.js 26.12.1. The assessed vector (AV:N/AC:H/PR:N/UI:N, C:H/I:H) means unauthenticated remote reach is possible but exploitation is conditional on the target application passing attacker-influenced strings into DNS resolution, and the exact trigger mechanism is not described in the available sources; a public PoC reference exists but is not verified as working exploit code, and there is no CISA KEV listing.
Remote code execution is possible in Node.js releases that bundle a vulnerable Brotli decoder: a malformed brotli-compressed stream can trigger an out-of-bounds write when decompressed, corrupting memory in the process handling the data. Exposure is limited to deployments that actually pass attacker-controlled brotli data into the decoder - for example services honouring Content-Encoding: br on untrusted requests or responses, or applications calling zlib.brotliDecompress/BrotliDecompress on untrusted input - and no authentication or user interaction is required in that scenario. The flaw is rated High with a CVSS 4.0 score of 9.2 (assessed CVSS 3.1: AV:N/AC:H/PR:N/UI:N/C:H/I:H/A:H), no CISA KEV listing confirms active exploitation, and a public PoC reference exists but is not verified as working exploit code; the vendor fix is Node.js v26.12.1, released 2026-10-21.
Node.js TLS certificate validation in versions 26.12.0 and 24.22.0 can mishandle non-canonical IP address representations, potentially causing IP-based certificate identity checks to be evaluated incorrectly. A network-positioned attacker who can influence the certificate presented during TLS peer validation of an IP address may exploit this to affect confidentiality and integrity, though exploitation requires a man-in-the-middle or malicious-endpoint position and a suitably crafted certificate. No CISA KEV active-exploitation confirmation is provided, but a public PoC reference exists and is not verified as working exploit code.
Canonical JSON encoding in Cpanel::JSON::XS 4.43 through 4.79 can produce non-deterministic output, because the UTF-16 key comparator in utf16_cmp decodes every byte-string key as UTF-8 once any key in the same hash carries the UTF-8 flag, so byte-string keys whose bytes happen to be valid UTF-8 are sorted out of order and two keys that encode differently can compare equal and be left in hash order. The same data structure can therefore serialize to different canonical documents across processes, which matters only where reproducible canonical output is security-relevant, such as signatures over canonical JSON, deduplication, and cache or content-addressing keys; applications that do not depend on canonical determinism are functionally unaffected. No public exploit identified at time of analysis, there is no CISA KEV entry, and EPSS is low at 0.17% (6th percentile), which together with an assessed vector of AC:H and integrity-only impact places this at a low-to-moderate real-world priority to be scheduled this week rather than treated as an emergency.
Out-of-bounds memory writes in Cpanel::JSON::XS 4.20 through 4.79 can crash a Perl process that canonically encodes a tied or threads::shared hash whose key count grows between encode_hv's two passes, corrupting a fixed 64-entry stack array or a heap array sized from the first count before the counts are ever compared. The prerequisites are narrow: the caller must use the ->canonical option and must encode a tied or threads::shared hash whose keys actually increase mid-encode, so plain hashes and non-canonical encoding are unaffected and the assessed vector carries AC:H despite the 7.5 base score. EPSS is low at 0.17% (6th percentile), no public exploit code was identified at time of analysis, and the vendor has released 4.80 with a fix that croaks on unstable key counts instead of writing out of bounds.
Out-of-bounds reads in the Linux kernel's SMB client (cifs module) let a malicious or compromised SMB2/SMB3 server leak kernel memory or crash the client host when a user or an automated mount connects to its share. The parser smb2_parse_contexts() validates the create-context area as a whole but does not clamp each record to its Next field, so a malformed chain can hand bytes beyond the current context to a handler; the same canonical-offset assumption in the SMB2/SMB3 lease parsers and a full-structure cast in the QFid handler widen the exposure, and a valid non-canonical DataOffset with a short DataLength is still accepted. Only hosts that mount SMB shares through the kernel client are affected, impact is read-only (information disclosure or denial of service, no integrity or code execution), and the attack requires the victim to initiate a session to an attacker-controlled endpoint. No public exploit code has been identified at time of analysis, EPSS is 0.17% (6th percentile), and the issue is not in CISA KEV; vendor patches are available and the priority guidance is to remediate this week.
Unauthenticated authorization bypass in the OpenNMS Meridian and Horizon REST API lets any remote attacker who can reach /rest/** read the monitored inventory and create, modify, or delete resources without credentials. The flaw arises because the Spring Security intercept-url rules match the HTTP method as a case-sensitive uppercase token and the filter chains terminate without a deny rule, so a request using a non-canonical method token (for example 'get' or 'put' instead of 'GET'/'PUT') matches no rule and is served without authentication; the /rest/alarms chain additionally leaks whether a specific alarm exists via a difference in the response. All pre-fix Meridian and Horizon versions in default configuration are affected, the vendor-supplied CVSS 3.1 base score is 9.1 (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N, i.e. unauthenticated and low complexity), and no public exploit code was identified at time of analysis; the practical limiting factor is deployment posture, since the vendor states these products belong on private networks and should not be Internet-facing.
Driver-specialized BPF metadata kfuncs can be executed against the wrong driver's XDP buffer in the Linux kernel's BPF offload matching logic, producing an out-of-bounds read and a kernel panic (observed as a KASAN null-ptr-deref in veth_xdp_rx_timestamp when a veth-bound program is run on a tun device). The flaw requires local access with both CAP_BPF and CAP_NET_ADMIN, plus an offload/dev-bound BPF program configuration, so exposure is concentrated on hosts that delegate these capabilities to containers or namespaces; the assessed vector is CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H (7.8). No public exploit code was identified at time of analysis and the issue is not in CISA KEV, with EPSS at 0.16% (4th percentile); vendor patches are available in the stable branches listed in the advisories.
Checksum verification bypass in the Go toolchain (cmd/go) versions 1.27.0 before 1.27.2 and before 1.26.9 allows a malicious Go project with a forged golang.org/toolchain go.sum entry, combined with a user-selected attacker-controlled GOMODPROXY, to substitute a tampered toolchain that cmd/go would otherwise reject. Exploitation requires local access and user interaction (CVSS 7.8, AV:L/UI:R) and two attacker-controlled preconditions the victim must opt into: operating inside the crafted project and using the malicious proxy. No public exploit code identified at time of analysis, and EPSS is 0.13% (2nd percentile), indicating low predicted exploitation likelihood.
Denial of service in Progressive Robot hMailServer 6.0.0 through 6.3.5 lets a remote unauthenticated attacker stall mail delivery and SMTP service by sending a single crafted message. The root cause is inefficient algorithmic complexity (CWE-407) in inbound DKIM and ARC signature verification: assembling the canonical header and resolving the header names listed in a signature's h= tag grows quadratically with header size, so a message with very many header fields - or one field folded over very many continuation lines - holds a worker thread busy for tens of seconds per signature, and up to ten signatures are evaluated per message by both the DKIM and DMARC tests on the threads that serve delivery and SMTP. CVSS 3.1 rates this 7.5 (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H) with no confidentiality or integrity impact; no confirmed active exploitation (CISA KEV) or public exploit code was identified at time of analysis, and the vendor has published a fixed release, v6.3.6.
Privilege escalation in HashiCorp Vault and Vault Enterprise allows an authenticated principal with delegated permissions to bypass explicit deny ACL rules by referencing a resource or policy name in non-canonical form, potentially reaching a protected resource or assigning a denied policy. Affected are Vault Community Edition before 2.1.2 and Vault Enterprise before 2.1.2, 1.21.12, 1.20.17, and 1.19.23, rated CVSS 3.1 7.2 (AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H). Exploitation requires an already high-privileged, delegated user (PR:H) operating in a policy model that depends on explicit deny rules, and no public exploit code or confirmed active exploitation was identified at time of analysis (no EPSS data was provided), so this is best handled as a defense-in-depth hardening fix rather than an emergency.
Signature-verification bypass in Bouncy Castle for Java before 1.86 lets a phantom signer be accepted in BLS12-381 aggregate signature verification. The faulty BLS12_381BasicScheme.keyValidate() trusts the public key's own ECCurve object during the prime-order subgroup check, so an attacker-supplied ECPoint built on a foreign curve that merely shares BLS12-381's field characteristic - with its cofactor forged to 1 - passes validation despite not being a G1 point; in the pairing implementation such a point contributes the identity in the target group, so an aggregate signature verifies even though it contains no signature for that key/message pair. The issue is reachable only where an application constructs an ECPoint on an explicit, non-canonical curve and accepts it as an authority-bearing key, since the standard 48-byte compressed-point decoder always supplies the canonical curve; no public exploit has been identified at time of analysis, and the assessed impact is high integrity compromise without confidentiality or availability loss (CVSS:4.0 base 7.1, network vector, no privileges required).
Denial of service in the Zcash Foundation's Zebra full node before 6.1.0 lets remote unauthenticated peers stall node synchronization by poisoning the stale parent_error_map used by the state write task, after which the next canonical block is rejected for roughly 2,000 blocks. Exploitation is gated by a narrow race window: the attacker must act as a network peer and deliver a coinbase-malleated block that shares a legitimate canonical block's hash before that canonical block propagates, an AC:H/AT:P timing condition, so reliable on-demand abuse is materially limited. Impact is availability-only (CVSS 4.0 8.2, VA:H with no confidentiality or integrity effect), unauthenticated per the PR:N vectors, and no public exploit code has been identified at time of analysis; a vendor-released patch is available in Zebra 6.1.0.
Block-sync denial of service in Zebra (zebrad), the Rust implementation of a Zcash full node, affects all versions before 6.3.0. During block download, a malicious peer can repeatedly serve a canonical block whose coinbase scriptSig is rewritten to claim height 1 while preserving the requested block hash - an evasion made possible because V5 transaction IDs exclude the scriptSig - causing the node to discard the block as too far behind the tip and repeatedly refetch it instead of advancing to the newest chain tip. The attacker remains unauthenticated (CVSS vector PR:N) and must simply be an accepted block-supplying peer; the flaw is an insufficient verification of data authenticity issue (CWE-345) whose impact our assessment bounds to availability only (VA:H in the CVE 4.0 score, but no confidentiality or integrity loss), so real-world severity is a sync delay rather than node compromise. No public exploit code was identified at time of analysis and the issue is not confirmed actively exploited (CISA KEV).
Arbitrary file write as root in Canonical LXD 4.0 and later (before 4.0.14, 5.0.10, 5.21.8 and 6.10) on Linux lets an authenticated client with permission to create instances or custom storage volumes in a project - or a malicious migration source server - plant a symlink inside a transferred volume and then write through it to any path on the target host, resulting in full host compromise. Exploitation requires triggering a volume migration receive and supplying a crafted rsync or btrfs send stream that plants a symlink at a name such as rootfs or root.img; the flaw is an improper link resolution issue (CWE-59) in the receive path that does not confine link targets to the volume. No public exploit code or confirmed active exploitation (CISA KEV) was identified at time of analysis, though the independent assessment rates this a genuine high-priority vulnerability rather than a CVSS-inflated one given the authenticated, low-privilege path to root.
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.
Path traversal in the btrfs storage driver of Canonical LXD 4.0.2 and later allows an authenticated client that holds project-scoped permission to create instances to delete arbitrary files on the host as root by supplying a crafted subvolume path containing ../ sequences, and on hosts whose root filesystem is itself btrfs the same primitive escalates to placing attacker-controlled content at arbitrary host paths for full host compromise. The issue is rated CVSS v3.1 9.6 (AV:N/AC:L/PR:L/UI:N/S:C/C:N/I:H/A:H), reflecting a scope-changing breakout from a restricted tenant role into the host root context rather than a CVSS-inflated score, since a legitimate but limited project credential is the only prerequisite. No CISA KEV listing and no public exploit code were identified at time of analysis; vendor fixes are available in LXD 4.0.14, 5.0.10, 5.21.8 and 6.10.
Path traversal in Canonical LXD's Btrfs storage driver allows an authenticated user with instance-creation privileges to escape the intended backup import target and delete or replace arbitrary files and directories on the host as root, by supplying a crafted subvolumes[].path value in backup/optimized_header.yaml during a btrfs 'optimized' backup import. The assessed vector (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H, 9.9) reflects high confidentiality, integrity and availability impact with a scope change because the traversed write lands outside the LXD daemon's own container boundary; exploitation requires valid low-privilege API credentials and a Btrfs-backed host, not anonymous access. No public exploit code has been identified at time of analysis, and the issue is not confirmed actively exploited (CISA KEV), but the low attack complexity and root-level file-system effect make it a genuine high-priority fix rather than a CVSS-inflated score.
GitPython before 3.1.62 is vulnerable to a path traversal (CWE-22) in Submodule.update() that allows unauthenticated remote attackers to create, populate from a submodule URL, and potentially delete directories outside the repository working tree when an application updates submodules at a non-HEAD (historical) commit. The flaw stems from the `path` field in an untrusted .gitmodules file being used without the _to_relative_path() containment guard that is applied in add() and move(). Exploitation requires an application flow that checks out submodules at a historical commit and an attacker-controlled repository; the standard clone-then-update flow re-derives the path from a canonical tree lookup and is not affected. No public exploit code or confirmed active exploitation (CISA KEV) exists at time of analysis, and the independent assessment rates real-world priority as low-to-medium despite the vendor's CVSS 4.0 score of 8.7.
Signature-verification bypass in MinIO (all releases through commit 7aac2a2) and in the pgsty/silo fork (before commit 1233254) lets an attacker who holds a valid SigV4 presigned PUT URL - one scoped to a single object - append an unsigned x-amz-copy-source header to the otherwise unmodified URL and cause a server-side CopyObject executed with the signer's credentials, converting a write grant into reads of every object that signing key can reach. The root cause is a CWE-347 improper-verification-of-signature error: extractSignedHeaders() in cmd/signature-v4-utils.go iterates only the client-claimed X-Amz-SignedHeaders list and never enumerates the x-amz-* headers that actually arrived, so an unsigned header is neither hashed into the canonical request nor rejected, while cmd/api-router.go dispatches CopyObject purely on the presence of x-amz-copy-source. Amazon S3 rejects the equivalent request with HTTP 403 AccessDenied; exploitation here requires a delegated presigned URL plus a signing key with broader read permission, making this a privilege escalation from a delegated credential rather than unauthenticated access, with no public exploit code or confirmed active exploitation identified at time of analysis.
Gerrit Code Review 2.16.0-3.12.9, 3.13.0-3.13.8, and 3.14.0-3.14.2 mishandle project-name normalization, allowing an authenticated user (or an unauthenticated user when the repository was previously public) to keep reading private repository content and to durably restore revoked project-owner administrative privileges. Requests that reference a project with repeated terminal .git suffixes (for example project.git.git) are cached under a different key than the canonical project, so revoking read access or removing owner rules on the canonical name never evicts the stale alias ProjectState during the ProjectCache validity window, permitting reads of newly created private commits and writes to refs/meta/config. No public exploit code has been identified at time of analysis; exploitation requires the attacker to have previously held access to the project and to act before the stale cache entry would naturally expire.
Authenticated remote code execution in OpenC3 COSMOS (Ruby gem 'openc3' versions 5.1.0 through 7.2.1) lets any logged-in user, including one with only low-tier permissions, execute arbitrary Ruby and Python code on the COSMOS server and its per-target decom microservices. COSMOS reads configuration from a user-writable overlay (targets_modified/) before its read-only targets/ tree and then executes that content - rendering it as ERB, eval-ing GENERIC_READ/WRITE_CONVERSION blocks, or require-ing Script Runner procedure files - so an attacker who can write to the overlay via the screen-save or storage-upload endpoints achieves code execution as the openc3 user, which holds Redis and object-store credentials and sits on the internal service network. A working proof-of-concept is published in the vendor GitHub advisory, and the vendor has released 7.3.0 as the fix; no confirmed active exploitation (CISA KEV) has been reported. Reachability is limited on default single-host installs because the shipped docker-compose binds Traefik to 127.0.0.1:2900, so exploitation is realistic on multi-user deployments that expose the web port.
Unauthenticated remote attackers can invoke sensitive financial and record-disclosure methods inside WeGIA's contribution dispatcher and, using a traversal-shaped controller name, force require_once to load PHP or configuration files from outside the intended controller directory. Because the pre-3.8.5 dispatcher in web/html/contribuicao/controller/control.php hardcoded an authentication exemption for ContribuicaoLogController and enforced no controller/method allowlist, methods such as getContribuicoesLogJSON, sincronizarStatus and registrarFaturas are reachable by anyone with HTTP access, leaking contribution and donation records or triggering financial workflow operations. Rated CVSS 9.1 (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N), this is a genuine high-priority issue; no public exploit identified at time of analysis, and it is fixed in version 3.8.5.
A race in the Linux kernel's iSER (IB/isert) iSCSI target transport lets an initiator on an RDMA fabric crash the target host: the final iSCSI Login Response is put on the wire before __transport_register_session() has populated the session's se_tpg, so a SCSI command issued immediately after the initiator sees login success reaches target_submit() against a half-initialized se_session and the ib-comp-wq worker oopses on a NULL/non-canonical pointer dereference (KASAN null-ptr-deref at offset 0x78). Only LIO/TCM iSCSI targets using the isert RDMA transport over InfiniBand, RoCE, or iWARP are affected; plain iscsi-TCP and cxgbit are not, because they already pull PDUs from iscsi_target_rx_thread. Exploitation is a probabilistic race (the maintainer reproduced the oops in 10 of 20 unpatched runs over rxe), vendor CVSS is 7.5 while our assessed vector is AV:A/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H given the RDMA-fabric adjacency requirement and timing difficulty; there is no public exploit code and no CISA KEV listing at time of analysis.
Sandbox escape in the vm2 Node.js library through 3.11.6 lets untrusted code running inside a NodeVM instance reach the host's child_process builtin and execute operating-system commands whenever the embedding application configures a wildcard builtin require policy containing a node:-prefixed deny entry. The affected configuration (for example new NodeVM({ require: { builtin: ['*', '-node:child_process'] } })) fails to deny the canonical child_process module, so sandboxed code can obtain execSync and spawn via require('child_process') or require('node:child_process'), giving host command-execution capability to code that was supposed to be isolated (CVSS 4.0 base 9.4; assessed CVSS 3.1 AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H). Exploitation requires PR:L privileges in the sense that the attacker must already be able to run attacker-controlled JavaScript inside the sandbox, and it only works under that specific deny-list form; a correctly spelled '-child_process' entry, a non-wildcard allow-list, or not exposing child_process at all avoids the flaw. No public exploit code or confirmed active exploitation was identified at time of analysis.
A memory-corruption flaw in the Linux kernel's vfio-pci driver (vfio/pci/vfio_pci_config.c) allows a local user holding access to a VFIO passthrough device node (typically /dev/vfio/*) to trigger a use-after-free and subsequent double-free of the per-device MSI permission table (vdev->msi_perm). Exploitation requires attacker-induced failure of the allocation path (init_pci_cap_msi_perm()/alloc_perm_bits() returning -ENOMEM during a failed device open, e.g. under memory pressure or fault injection), after which re-opening the same persistent vfio_pci_core_device reuses the freed perm_bits object - dereferencing its readfn/writefn function pointers inside vfio_pci_config_rw_single() - while closing it hits kfree() on an already-freed object in vfio_config_free(). There is no public exploit code identified and no indication of active exploitation at time of analysis; EPSS is low (0.21%, ~11th percentile), and the memory-pressure precondition plus the requirement for VFIO passthrough privileges materially limits real-world reliability, even though the assessed CVSS:3.1:AV:L/AC:H/PR:L/UI:N/S:C/C:H/I:H/A:H score is high.
Out-of-bounds slab write in the Linux kernel's libceph/CRUSH map decoder (crush_decode) lets a malformed CRUSH map corrupt kernel memory on any RADOS client (Ceph RBD or CephFS). Because crush_decode() stores buckets by array slot while the mapper derives each bucket's workspace index from its decoded id, a map encoding an id different from '-1 - slot' makes one bucket alias another's kvmalloc'd workspace; a uniform bucket's second-replica permutation then overflows the smaller aliased buffer, producing a 4-byte OOB write in bucket_perm_choose() confirmed by KASAN. EPSS is low (0.17%, 6th percentile) and there is no public exploit identified at time of analysis; the CRUSH map is delivered from the Ceph monitor/OSD map, so exploitation requires a malicious or compromised monitor rather than an arbitrary internet attacker.
Arbitrary file deletion in UsersWP ≤ 1.2.70 for WordPress allows authenticated Subscriber-level users to delete any file on the server - including wp-config.php - via a path traversal bypass in the upload_file_remove() AJAX handler. The exploit exploits a two-phase validation failure: validate_file() only rejects literal '../' sequences, but the uwp_get_file_relative_url() helper later performs a global str_replace() that collapses crafted embedded tokens into directory traversal sequences after the final validation gate, with the result passed directly to wp_delete_file() without canonical containment. No public exploit code or CISA KEV listing is confirmed at time of analysis; however, the low privilege requirement and precise Wordfence source-level write-up substantially reduce the research barrier for threat actors.
Fastify's route schema compilation silently nullifies conditional header requirements declared via the JSON Schema Draft 7 `dependencies` keyword, enabling unauthenticated remote clients to bypass schema-enforced authorization checks. Versions before 5.12.2 lowercase header property keys and the root `required` array during schema compilation but leave trigger and dependent names inside `dependencies` in their original casing; since Node.js stores all incoming request header names in lowercase, those case-sensitive dependency references never match and the conditional requirement is invisibly skipped. An attacker can present a privileged-operation header while omitting the authentication or authorization header the dependency was intended to mandate, causing the application's privileged branch to execute as though the guard had passed. No public exploit has been identified at time of analysis.
Craft CMS versions 5.0.0-RC1 through 5.10.10 allow an authenticated low-privileged contributor to permanently delete canonical entry content by exploiting a broken authorization chain in ElementsController::actionDeleteForSite(). The method authorizes deletion against the user's provisional draft rather than the canonical element, then propagates the destructive action to the canonical record without re-verifying deleteEntriesForSite permission. Deleted content bypasses the recycle bin and is unrecoverable, making this an integrity-destroying flaw despite its mid-range CVSS score. No public exploit code is identified at time of analysis.
SSRF in the Bifrost AI gateway's multimodal URL-fetch path permits any client that can submit a Bedrock or Vertex provider request to reach internal network services - including cloud instance-metadata endpoints - by supplying IPv6 transition-form addresses (6to4, NAT64) or CGNAT addresses that the `isPublicIP` deny-list in `core/providers/utils/fetch.go` incorrectly classifies as routable public IPs. All releases of the `github.com/maximhq/bifrost/core` Go module prior to v1.5.17 are affected, confirmed on dev HEAD f415c14 (core/version 1.5.15). Publicly available exploit code exists in the GHSA advisory as a runnable Go test; no CISA KEV listing at time of analysis.
Memory corruption in the Linux kernel's net/sched fq_codel queueing discipline lets a local actor with traffic-control privileges trigger a wild kernel memory access and crash. When fq_codel drops packets during a peek operation, it calls qdisc_tree_reduce_backlog before restoring qlen; if qlen momentarily hits zero while peek still holds an skb, the parent class (e.g. qfq) is wrongly deactivated, producing a general-protection fault against a poisoned list pointer (0xdead000000000100 range) as seen under KASAN. No public exploit identified at time of analysis, EPSS is low (0.18%), and it is not in CISA KEV.
Path traversal in IzPack's UnpackerBase.unpack() enables arbitrary file writes under victim privileges when a user executes a trojanized installer JAR. The unpacking pipeline calls IoHelper.translatePath(), which performs only file-separator substitution with no canonical-path check, no startsWith(installDir) containment guard, and no normalization of '../' sequences, allowing attacker-controlled PackFile entries to escape the install directory entirely. Because IzPack JARs are standard unsigned ZIPs with no integrity protection, any legitimate IzPack installer can be silently repackaged with malicious entries; a publicly available proof-of-concept confirms the escape. The CVE is not listed in CISA KEV, but the trivial repacking method and social-engineering distribution vector make this a credible supply-chain threat to organizations consuming IzPack-packaged software from untrusted sources.
Path traversal in RansomLook's GroupPost.get API handler allows an attacker controlling a malicious upstream instance to exfiltrate arbitrary files readable by the RansomLook process, including configuration secrets and API credentials. The screen field stored in the database is concatenated directly with the application's source/ directory path without boundary validation, enabling traversal sequences such as ../config/generic.json to escape the intended directory. No public exploit code has been identified at time of analysis and the vulnerability is not listed in CISA KEV, but the federation import mechanism means a compromised upstream instance can poison a victim's database without holding any account on the victim system.
Host root code execution in Canonical LXD arises from a path-traversal flaw in instance template processing, letting an attacker with container edit permissions - or any user who launches a maliciously crafted image - overwrite arbitrary root-owned files on the host. The root cause is a validate-then-open mismatch: LXD checks template target paths against a confined os.Root handle but then creates the file via os.Create using the raw, unconfined string path. No public exploit has been identified at time of analysis, but the CVSS 9.9 rating and container-to-host scope change make this a critical container-escape.
Null-pointer dereference and promiscuity counter underflow in the Linux kernel bonding driver's ALB monitor can crash the kernel or permanently pin a network interface in promiscuous mode. The bond_alb_monitor() workqueue function reads primary_is_promisc under RCU, drops that lock, then acquires RTNL - allowing the active slave to be removed or changed in the intervening window, leaving the monitor to act on stale state. Linux systems from kernel 2.6.24 through unpatched stable branches (5.10.x, 5.15.x, 6.1.x, 6.6.x, 6.12.x, 6.18.x, 7.1.x, 7.2) with network bonding explicitly configured in ALB mode are affected. No public exploit identified at time of analysis.
Reference imbalance in the Linux kernel's BPF conntrack kfuncs allows a local attacker with BPF privileges to trigger an unmatched put_net() call that can destroy a live network namespace and cause kernel panic. The flaw affects __bpf_nf_ct_lookup() and __bpf_nf_ct_alloc_entry(), where opts->netns_id is read non-atomically from a shared BPF map value during both namespace acquisition and release. No public exploit code exists and EPSS is low (0.20%, 10th percentile), but the kernel panic outcome is confirmed by a crash trace in the advisory. Exploitation requires local BPF capability and a concurrent writer to the shared map.
Unverified password change in Laravel Backpack CRUD's account-info endpoint allows any authenticated Backpack admin to permanently take over their own or a hijacked session's account by mass-assigning the `password` field without supplying the current password. Affected versions are backpack/crud < 6.8.11 and 7.0.0-alpha.1 through 7.0.33, running on Laravel 11 with the default `App\Models\User` model whose `$fillable` includes `password`. The attack converts time-limited stolen session access into permanent credential control, bypassing the dedicated change-password flow that enforces `old_password` verification. No public exploit code or CISA KEV listing has been identified at time of analysis, but the attack is trivially constructable given full public advisory detail.
Privilege escalation in Ubuntu's accountsservice package allows a local low-privileged user to execute arbitrary shell commands as root (real UID 0) by injecting a GNU sed 'e' flag payload into their ~/.pam_environment LANGUAGE entry, which is then processed unsanitized by Ubuntu-specific helper scripts (save-to-pam-env, update-langlist) when the SetLanguage D-Bus method is invoked. All Ubuntu accountsservice packages before version 23.13.9-8ubuntu7 are affected; this is a Ubuntu-specific packaging defect, not an upstream accountsservice issue. No public exploit code or CISA KEV listing has been identified at time of analysis, though the attack path is well-described and technically straightforward.
Local privilege escalation in Ubuntu's AccountsService (before 23.13.9-8ubuntu7) lets any low-privileged local user gain full root access by exploiting an incomplete privilege-drop in a Canonical-specific patch. The patch sets the effective UID/GID to the target user before launching language helper scripts but neglects to change the real UID, leaving ruid=0. Any shell spawned by a helper script can call setuid(0) to restore root effective privileges, granting complete system compromise. No public exploit has been identified at time of analysis, and this vulnerability is not listed in the CISA KEV catalog.
Grafana OSS's Unified Alerting component allows a low-privileged authenticated organization member to query any datasource - including those they are explicitly denied access to - by setting the client-controlled queryType field to the reserved value __expr__ while supplying the UID of a real datasource in an alert rule. Authorization skips the datasources:query permission check when it sees __expr__, but the evaluator subsequently resolves and executes the query against the real datasource identified by datasourceUid, resulting in full data exfiltration through Grafana's configured credentials. Affected versions span Grafana OSS 8.4.0 through 13.1.1; no public exploit code or CISA KEV listing has been identified at the time of analysis, but the low attack complexity and confirmed reproduction under default OSS permissions make this a credible insider-threat and privilege-escalation vector.
Availability disruption in stigmem-node 0.9.0a1 (pip package by eidetic-labs) allows authenticated federation peers to have their valid peer tokens incorrectly rejected as expired due to a timestamp-handling mismatch in the federation peer-token validation logic. Impacted deployments are Stigmem nodes operating federation peer authentication paths, where authenticated federation flows may fail non-deterministically depending on which token-minting path was used. No active exploitation has been identified (no KEV listing, no public exploit), and the fix is available in 0.9.0a2.
Zip Slip path traversal in Notepad++'s bundled WinGup update component (versions prior to 8.9.7) allows network-delivered malicious ZIP archives to overwrite DLL files outside the intended extraction directory, enabling arbitrary code execution when Notepad++ next loads the affected plugin. The attack requires user interaction to trigger the update workflow (CVSS UI:R) but demands no authentication on the target system. No public exploit code or CISA KEV listing has been identified at time of analysis; the vulnerability is fixed in the vendor-released 8.9.7 build.
Use-After-Free in the Linux kernel's mm/page_reporting subsystem triggers a General Protection Fault during PM suspend and hibernation on systems running virtio_balloon with page reporting enabled. When the PM freezer initiates a suspend or S4 hibernation cycle, the virtio_balloon driver tears down its virtqueues via del_vqs(), but page_reporting_process - scheduled on the non-freezable system_wq workqueue - remains active. If the buddy allocator frees pages during this window (e.g., the balloon shrinker runs during S4 image saving), the reporting worker calls virtballoon_free_page_report() on already-deleted virtqueues, causing kernel memory corruption. No public exploit has been identified at time of analysis; EPSS is 0.18% (8th percentile), reflecting minimal exploitation probability, though this is a confirmed kernel UAF with crash-level impact validated by Google in production virtualization infrastructure.
OCFS2 cluster filesystem dinode validation in the Linux kernel fails to reject inodes with non-canonical i_mode type bits, allowing forged on-disk metadata to propagate into in-core kernel inode structures. Affected kernels accept any non-zero i_mode value and pass it verbatim into ocfs2_populate_inode(), where an unrecognized S_IFMT type falls through to ocfs2_special_file_iops and init_special_inode() - a code path not designed for arbitrary mode inputs. No public exploit has been identified at time of analysis and EPSS sits at only 0.22%, but the kernel-level impact (C:H/I:H/A:H) and the shared-storage attack surface of OCFS2 clusters warrant priority patching on affected systems.
Memory corruption in the Linux kernel network scheduler (net/sched/sch_codel) allows a privileged local user to trigger a wild/dangling pointer dereference by mis-accounting queue length during the CoDel peek operation. When CoDel drops packets during peek it calls qdisc_tree_reduce_backlog before re-incrementing qlen; if qlen momentarily hits zero while peek still returns an skb, the parent qdisc's qlen_notify prematurely deactivates the class, corrupting scheduler state (demonstrated as a KASAN wild-memory-access in qfq_deactivate_agg when qfq parents a codel child). No public exploit identified at time of analysis; EPSS is low (0.21%, 12th percentile) and this is not in CISA KEV.
Integer overflow in the Linux kernel's BPF sockmap helper `bpf_msg_pop_data()` enables a local privileged attacker to bypass scatterlist bounds checks, causing an out-of-bounds traversal that dereferences a null or non-canonical page pointer and crashes the kernel. Affected are all kernel stable series from 5.10 through pre-7.2, with patches confirmed across eight stable branches. No public exploit has been identified at time of analysis and the EPSS score of 0.21% (12th percentile) indicates negligible current exploitation activity, though the confirmed kernel crash impact and High CVSS score warrant prompt patching on systems using BPF sockmap.
The regulator subsystem in the Linux kernel contains a deadlock-handling defect where `regulator_lock_two()` compares the return value of `ww_mutex_lock()` against `-EDEADLOCK` instead of the correct `-EDEADLK` constant. On MIPS architecture - the only platform where the regulator core is active and these two error constants carry different numeric values - the mismatch causes the kernel to skip the mandatory unlock-and-retry backoff sequence, fire `WARN_ON`, and return to the caller with only one of the two regulators locked, producing corrupted locking state. No public exploit has been identified and EPSS is very low (0.22%, 13th percentile), but the high CVSS impact ratings (C:H/I:H/A:H) reflect the potential for kernel panic or local privilege escalation on affected MIPS systems.
Privilege escalation to host root in Canonical LXD occurs when the container manager unpacks crafted image or backup archives, because it follows a symbolic link where the backup.yaml metadata file should be and then processes attacker-controlled configuration outside its intended confinement. A low-privileged LXD user who can import a malicious archive can execute arbitrary commands as root on the underlying host, breaking the container/host trust boundary (scope change). Rated CVSS 9.9; no public exploit identified at time of analysis and not listed in CISA KEV, but the fix is coordinated through GitHub advisory GHSA-fv82-v4fj-mm4m.
Arbitrary host file read and write in Canonical LXD occurs because the image import/unpack routine does not verify whether the bundled metadata.yaml entry is a symbolic link, letting an authenticated user with image-import rights supply a crafted archive whose symlinked metadata.yaml resolves to sensitive host paths. Rated CVSS 9.9 with a scope change (S:C), successful exploitation crosses the container/management boundary to read or overwrite files as the LXD daemon (typically root) on the host. There is no public exploit identified at time of analysis and the issue is not listed in CISA KEV; details are published only in Canonical advisory GHSA-j825-cg34-5fr5.
Path traversal in Canonical LXD's image metadata template processing enables an authenticated low-privilege attacker to read arbitrary host files or create files in arbitrary host filesystem locations. The flaw resides in the virtual machine/QEMU driver execution path, where LXD fails to sanitize template file paths from escaping the designated instance templates directory. Exploitation crosses the container/VM boundary to the host (scope change, S:C), making this high-severity in environments where host isolation is a security assumption. No public exploit code or CISA KEV listing has been identified at time of analysis.
Path traversal in Canonical's LXD container and VM manager allows a user with backup import/restore privileges to write or read files outside the intended restore directory by embedding traversal sequences in the instance or storage-volume names stored in a crafted backup archive's metadata. Because LXD does not validate these names on import/restore, an attacker can corrupt or overwrite host files, potentially leading to full host compromise. There is no public exploit identified at time of analysis, and it is not listed in CISA KEV; the very high CVSS (9.9) is driven by the scope-changing, high-integrity/availability impact on the host.
Authorization bypass in Canonical LXD lets an authenticated user with instance-migration privileges smuggle high-privilege instance configurations into restricted projects. When an instance is migrated to a target project, LXD applies caller-supplied configuration overrides without re-validating them against the destination project's enforced restrictions, so security controls such as privileged-container or device limits can be defeated. Rated CVSS 9.9 (CWE-863) with a scope-changing impact; no public exploit has been identified at time of analysis.
Authorization bypass in Canonical LXD lets an authenticated user with copy privileges smuggle instances carrying disallowed high-privilege configurations into restricted projects, defeating per-project security controls. The root cause is a time-of-check to time-of-use race in which LXD validates project restrictions before configuration merging finishes during cross-project instance copies. Rated CVSS 9.9 with a scope change; there is no public exploit identified at time of analysis and it is not listed in CISA KEV.
Canonical LXD's NVIDIA GPU passthrough configuration handler fails to sanitize newline characters in user-supplied `nvidia.driver.capabilities` and `nvidia.require.*` instance config values, enabling an authenticated attacker to inject arbitrary directives into the generated `lxc.conf` file. Any LXD user with instance-creation or configuration-modification privileges can exploit this to escape the container boundary and execute arbitrary commands on the host with the full privileges of the LXD daemon - effectively achieving complete host compromise. No public exploit code or CISA KEV listing exists at time of analysis, but the network-accessible, low-privilege attack path and scope-changed CVSS vector reflect an elevated real-world threat for shared or multi-tenant LXD deployments.
Storage quota bypass in Canonical LXD (5.0.x before 5.0.8, 5.21.x before 5.21.6, and 6.0 before 6.10) lets an authenticated user exceed the disk and volume limits an administrator configured on a project. The flaw stems from two code paths - cross-project volume moves (storagePoolVolumeTypePostMove) and volume snapshot restores with a nil config - that skip the AllowVolumeCreation/AllowVolumeUpdate limit checks, enabling over-allocation of storage. Reported by Canonical with a patch available; no public exploit identified at time of analysis and it is not listed in CISA KEV.
Authorization bypass in Canonical LXD (6.0 before 6.10, 5.21.x before 5.21.6, 5.0.x before 5.0.8) lets an authenticated user smuggle disallowed instance configurations into a restricted project by triggering a cross-project, cross-cluster-member migration. Because the migration arrives at the destination node as an internal cluster notification, the destination skips all target-project restriction checks (CWE-863), so limits and security restrictions on the target project are not enforced. Rated CVSS 9.9; reported by Canonical with a vendor patch available, but no public exploit identified at time of analysis and it is not listed in CISA KEV.
Project-confinement bypass in Canonical LXD lets an authenticated user holding can_create_instances on a restricted project escape that project's security policy by migrating an instance into it. Because instancePostMigration never re-validated the incoming instance against the target project's enforced restrictions, an attacker could build a high-privilege or otherwise disallowed instance inside an unrestricted project and relocate it into the restricted one, inheriting capabilities (low-level container access, arbitrary devices, unrestricted network access) that the project was configured to forbid. Rated CVSS 9.9 by the vendor; no public exploit identified at time of analysis and it is not in CISA KEV.
URLSecurityValidator SSRF bypass in compliance-trestle <= 4.0.3 allows a network-positioned attacker to reach cloud metadata services, loopback admin interfaces, and RFC 1918 internal networks by embedding IPv4-mapped IPv6 literals (e.g., [::ffff:169.254.169.254]) or the unspecified address 0.0.0.0 in OSCAL artifact import references processed by HTTPSFetcher or SFTPFetcher. Python's ipaddress module silently returns False - rather than raising TypeError - when comparing IPv6Address objects against IPv4Network ranges, so the validator's membership checks pass these forms through to requests.get unchanged. A publicly available proof-of-concept reproduces end-to-end IMDS credential exfiltration; no active exploitation is listed in CISA KEV and EPSS stands at 0.42%.
Portainer CE through 2.44.0 exposes root-level Docker host access to any authenticated low-privileged user via a URL path normalization flaw in the Docker proxy endpoint. The authorization middleware evaluates a non-canonical request path (e.g., percent-encoded slashes, double slashes, or traversal sequences) differently from the proxy layer that ultimately forwards it to the Docker daemon - allowing crafted requests to bypass all access controls while executing with full Docker API privileges. No active exploitation has been confirmed (no CISA KEV listing) and no public exploit code has been identified at time of analysis; EPSS data was not provided in the source intelligence.
Use-after-free in the Linux kernel's drm/xe Intel Xe GPU driver allows a local low-privileged user to trigger kernel memory corruption with potential for full system compromise (C:H/I:H/A:H). The bug arises because an imported dma-buf buffer object (BO) is created with its reservation object (resv) pointing to the exporter's dma_buf->resv before the importer acquires a reference on that dma-buf - leaving a window in which the exporter can be freed while the TTM workqueue asynchronously accesses the now-dangling pointer. Vendor-released patches are available for Linux 6.12.103, 6.18.42, and 7.1.6; no public exploit has been identified at time of analysis.
Pre-authentication out-of-bounds kernel memory read in the Linux kernel's CephFS client (ceph_handle_caps) allows a malicious or compromised Ceph Metadata Server (MDS) to read beyond the message front buffer. By sending a CEPH_CAP_OP_IMPORT caps message with hdr.version set to 1 and an oversized snap_trace_len (e.g. 0xFFFFFFFF), the server bypasses all version-gated decoders and drives ceph_update_snap_trace() to decode a fake snap realm past the buffer, cascading into further OOB reads via attacker-controlled num_snaps/num_prior_parent_snaps counts. The flaw is present in every kernel since ceph_handle_caps() was introduced; it carries a CVSS 9.8 but currently has no public exploit and a low EPSS score (0.22%), and it is not on CISA KEV.
Route guard bypass in @fastify/static before 10.1.3 exposes protected static files to unauthenticated remote attackers without requiring any credentials. The plugin failed to canonicalize non-standard path forms - including dot segments, duplicate slashes, percent-encoded dots, and backslashes - before matching the request path against route-based guards, allowing crafted URLs to evade the guard while the underlying send layer resolves and serves the protected file. This is an incomplete fix for a prior vulnerability in the same component; no public exploit identified at time of analysis, though the technique is a textbook path normalization bypass requiring no advanced skills.
Path traversal in rclone's `serve restic` REST API allows any attacker with network access to the endpoint to read, create, overwrite, or delete objects outside the operator-configured backend directory. The flaw spans rclone v1.40 through v1.74.4 and affects WebDAV, FTP, SFTP, HTTP, and Memory backends - but not S3-compatible or local filesystem backends, which encode `..` as literal filename characters. A fully functional, step-by-step proof of concept has been publicly released; no CISA KEV listing exists at time of analysis.
Use-after-free race condition in the Linux kernel's RDMA/rxe (SoftRoCE) subsystem allows a local unprivileged user to trigger a kernel crash or achieve page-level memory corruption. The race occurs between rxe_mmap() - which releases pending_lock while a rxe_mmap_info kref is still live - and a concurrent DESTROY_CQ ioctl that drops the kref to zero, causing vfree() to clear vmalloc PTEs mid-walk in remap_vmalloc_range_partial(). No CISA KEV listing exists and EPSS is 0.16% (5th percentile), reflecting the race's very narrow exploitation window; however, the C:H/I:H/A:H impact and confirmed upstream patch make this a priority update for any environment with RDMA/rxe loaded.
Uninitialized stack memory dereference in the Linux kernel's IPv4 nexthop subsystem (net/ipv4/nexthop.c) enables local low-privileged attackers to cause kernel panic or leak sensitive stack contents on systems built with CONFIG_INIT_STACK_NONE. Versions from 5.13 through stable branches prior to 6.6.148, 6.12.101, 6.18.42, 7.1.6, and 7.2-rc5 are affected. No public exploit code has been identified and EPSS stands at 0.16% (5th percentile), placing this in the low-urgency tier despite a CVSS 7.1 score driven by dual high-impact outcomes.
Use-after-free in the Linux kernel mac80211 MLO (Multi-Link Operation) subsystem allows a local attacker with low privileges to corrupt kernel memory by reading stale debugfs entries after a failed ieee80211_vif_update_links() operation. Systems running kernel 6.4 or later with WiFi 7 (IEEE 802.11be) MLO-capable hardware are within the affected code path; patched releases are available across all active stable branches. No public exploit or CISA KEV listing exists and EPSS is 0.16%, but CVSS impact metrics of C:H/I:H/A:H indicate full kernel compromise potential if the vulnerability is successfully triggered, as confirmed by a KASAN slab-use-after-free trace referencing a task named 'exploit/145'.
Use-after-free in the Linux kernel TCP Authentication Option (TCP-AO
Heap-based out-of-bounds read in the Linux kernel's nvmet discovery log page handler allows unauthenticated remote attackers to leak kernel memory or crash the host. Any system acting as an NVMe over Fabrics target with a discovery service exposed via TCP, RDMA, or FC is vulnerable. No active exploitation or public exploit code is reported at this time, and EPSS probability is low (0.25%), but the impact and ease of exploitation make remediation urgent for affected storage targets.
Heap out-of-bounds write in FFmpeg's native PNG and APNG encoders (all versions through 8.1.2) allows remote attackers who can supply a crafted PNG image to cause deterministic heap corruption and a potential arbitrary code execution primitive. The root cause is `add_exif_profile_size()` underestimating the required output buffer when multiple EXIF IFD entries share a large value payload - canonical serialization expands the deduplicated entries back to full size, causing `png_write_chunk()` to write tens of thousands of bytes past the allocated boundary. No public exploit exists and EPSS places exploitation probability at 0.55%, but VulnCheck reports the heap corruption is deterministic, elevating the eventual RCE risk.
Unauthenticated denial of service in Gitea's Locale middleware allows any remote attacker to consume ~2 seconds of server CPU per HTTP request by crafting a ~1 MiB Accept-Language header composed of underscore separators, bypassing the existing CVE-2022-32149 guard in golang.org/x/text which only counts dash characters. All Gitea releases from 1.22.x through 1.26.x are affected because the middleware at modules/web/middleware/locale.go:38 passes the raw, unfiltered header directly to the quadratic-time ParseAcceptLanguage parser; ten concurrent attackers consuming ~10 MiB/s of upstream bandwidth can saturate all cores of a ten-core host indefinitely. Publicly available exploit code exists in the GHSA advisory; no active exploitation has been confirmed by CISA KEV at time of analysis.
Local privilege escalation in snap-confine - the SUID/set-capabilities helper snapd uses to build the confinement sandbox for snap applications - lets an unprivileged local user on Ubuntu 22.04, 24.04, and 26.04 LTS gain full root. The flaw only manifests where snap-confine is deployed with file capabilities (set-capabilities) instead of the traditional set-uid-root binary, where incorrect handling of ambient capabilities lets an attacker escape intended privilege boundaries and run arbitrary code as root. Reported by Canonical; no public exploit identified at time of analysis and it is not listed in CISA KEV.
Sandbox confinement bypass in Canonical snapd (snap-confine) affects all supported Ubuntu LTS releases (16.04 through 26.04) because the default seccomp templates fail to block system calls that create or set set-user-ID flags on files. A process already running inside a strictly confined snap can compile or drop a binary, mark it setuid, and then execute it to escape confinement assumptions and perform privileged actions within the container namespace. There is no public exploit identified at time of analysis and the issue is not listed in CISA KEV, but the CVSS 8.4 (scope-changed) rating reflects a genuine confinement-escape primitive.
Use-after-free in the Linux kernel netfilter ipset subsystem allows a local user with Netlink privilege to corrupt kernel memory by racing dump operations against a concurrent ip_set_list array resize. The dump callbacks ip_set_dump_do() and ip_set_dump_done() dereference the inst->ip_set_list array pointer outside any RCU read-side critical section; a concurrent ip_set_create() publishes a new array, calls synchronize_net(), and then frees the old array - but synchronize_net() does not wait for the unprotected dump readers, resulting in a slab use-after-free. No public exploit has been confirmed at time of analysis, though the KASAN trace embedded in the CVE description references a task named 'exploit/150', indicating a functional proof-of-concept was used to produce the report during responsible disclosure.
Remote denial of service in the Linux kernel's ksmbd in-kernel SMB3 server allows an attacker to trigger a NULL-pointer dereference and kernel panic during SMB2 CREATE lease processing. After a SESSION_LOGOFF, a stale opinfo remains linked in the per-ClientGuid lease list with its conn pointer cleared; a subsequent session reusing the same ClientGuid and taking a lease on a different inode causes compare_guid_key() to dereference the NULL conn->ClientGUID. Exploitation requires only a successful SMB2 SESSION_SETUP against a share with 'durable handles = yes'; no public exploit is identified at time of analysis and EPSS risk is low (0.17%).
Kernel-panic denial of service in the Linux kernel's in-kernel SMB server (ksmbd) allows the file-pointer table to retain a durable-handle file object with a NULL tcon after a client issues SMB2 SESSION_LOGOFF; any subsequent read of /proc/fs/ksmbd/files then dereferences the NULL fp->tcon in proc_show_files() and crashes the host. Affected are kernels running ksmbd on shares configured with 'durable handles = yes'. There is no public exploit identified at time of analysis and EPSS is low (0.16%, 6th percentile), consistent with a stability/robustness bug rather than a weaponizable RCE.
Kernel-level out-of-bounds write in the Linux octeontx2-af driver (Marvell OcteonTX2 admin function) lets a low-privileged VF whose parent PF is in switchdev representor mode corrupt kernel memory. The rvu_mbox_handler_rep_event_notify() handler queues a sender-controlled REP_EVENT_NOTIFY body whose nested event->pcifunc is never bounds-checked, so an out-of-range index reaches rvu_get_pfvf()/rvu_get_pf() and, on RVU_EVENT_MAC_ADDR_CHANGE, becomes a six-byte attacker-chosen OOB ether_addr_copy() write in the AF worker (KASAN slab-out-of-bounds in rvu_rep_wq_handler). No public exploit identified at time of analysis and EPSS is low (0.19%, 9th percentile), consistent with niche Marvell SmartNIC hardware rather than mass exposure.
Local privilege escalation or denial of service in the Linux kernel's Intel i915 GPU driver stems from a use-after-free in the TTM object purge path (i915_ttm_purge), where the bo->ttm page-vector container can be replaced by ttm_bo_validate() during eviction, leaving a stale i915_tt pointer that is later dereferenced. A user on DG2 (Intel Arc/discrete) hardware reproduced this as a general protection fault under heavy GPU load during buffer-object eviction. There is no public exploit identified at time of analysis and it is not in CISA KEV, with a low EPSS (0.21%), but the CVSS 7.8 local vector reflects high confidentiality, integrity, and availability impact if the freed memory is groomed and reclaimed.
Extension-denylist bypass in the Flask-Reuploaded (flask_uploads) Python library allows an attacker who controls the name override passed to UploadSet.save() to store dangerous script files by varying letter case (e.g. shell.PHP, evil.pHp), defeating the very script-blocking denylist the library documents. This is an incomplete-fix variant of CVE-2026-27641: the v1.5.0 fix re-validated overridden names through the case-preserving extension() helper instead of the case-normalizing lowercase_ext() used by the default path, so uppercase extensions slip past a lowercase-tokened denylist. Publicly available exploit code exists (a self-contained PoC verified against Flask-Reuploaded==1.5.0), though there is no evidence of active exploitation and no EPSS score was provided.
Unauthenticated Server-Side Request Forgery in the meta-ads-mcp Python package (versions <= 1.0.114) lets remote attackers coerce the server into fetching arbitrary attacker-chosen URLs via the upload_ad_image MCP tool's image_url parameter. The flaw is reachable when the server runs with the officially supported --transport streamable-http mode, because the pre-fetch authorization check only requires a non-empty Bearer token while real Meta credential validation happens after the outbound fetch. Publicly available exploit code exists (a working Docker PoC); this is not in CISA KEV and no EPSS score was provided, so real-world exploitation is unconfirmed, but the vulnerability enables reaching localhost services, RFC 1918 hosts, and cloud metadata endpoints such as 169.254.169.254.
Root-level remote code execution in Canonical's ubuntu-pro-client (formerly ubuntu-advantage-tools) allows an attacker who can spoof or tamper with the Ubuntu Pro contract server response to inject arbitrary APT source lines and install malicious root-owned packages. The client builds /etc/apt/sources.list.d entries from the server's directives.suites[] and directives.aptURL fields via Python str.format() without escaping or newline filtering, and passes additionalPackages[] positionally into a root-run apt-get install. Because the component is preinstalled on supported Ubuntu Server releases and auto-attaches on cloud Ubuntu Pro images the exposure is broad; there is no public exploit identified at time of analysis and it is not listed in CISA KEV.
Stored CSV formula injection in FacturaScripts (all versions through 2026.1) lets an authenticated low-privilege user plant spreadsheet formula payloads in ordinary text fields (customer/supplier/product names, contacts) that execute when an administrator opens a routine list export. Because Core/Lib/Export/CSVExport.php::writeData() wraps values without neutralising leading =,+,-,@,tab, or carriage-return characters, and Tools::noHtml() only strips HTML metacharacters, the payload reaches the CSV verbatim and Excel/LibreOffice run it (including DDE process spawning) in the admin's OS context. A live PoC was verified on 2026-04-30, so publicly available exploit code exists, though there is no active exploitation confirmed (not in CISA KEV).
Unauthenticated arbitrary file read in FacturaScripts (all versions through v2026.2) lets remote attackers retrieve protected documents by abusing the static file controllers Files.php and Myfiles.php, which authorize requests on the raw URL prefix rather than the resolved filesystem path. A request such as /Plugins/../MyFiles/Private/invoice.pdf passes the prefix allow-list yet resolves to a private file, leaking customer/supplier invoices, attachments, and .sql database backups. A detailed, reproducible exploit is publicly available in the GitHub Security Advisory; there is no vendor-released patch identified at time of analysis and no evidence of active exploitation.
Improper certificate validation in the HTTPS API listener of Canonical LXD lets an unauthenticated remote attacker present a crafted certificate chain that is accepted as an already-trusted client, granting full access to the LXD cluster and the virtual machines it manages. Affected builds are 4.0.14, 5.0.10, 5.21.8, and 6.9 and earlier within each branch; the fixed releases are 4.0.15, 5.0.11, 5.21.9, and 6.10.1. Exploitation requires that the HTTPS listener be enabled and network-reachable, so installations restricted to the local Unix socket are not remotely exposed; clustered LXD and MicroCloud deployments, which depend on this listener, carry the most risk. The vulnerability is rated 10.0 under CVSS 4.0 with no privileges or user interaction required (PR:N/UI:N), and no public exploit code was identified at time of analysis, though the vendor rates the issue as requiring immediate action.
Forged Reject PDUs can crash the Linux kernel's libiscsi initiator, corrupt task refcounts, or falsely complete an in-flight SCSI command as successful. The issue carries a critical CVSS 9.8 vector (AV:N/AC:L/PR:N/UI:N), but EPSS is only 0.18% and no public exploit was identified at time of analysis; exploitation requires an established iSCSI session to an attacker-controlled, compromised, or on-path target, so only hosts using the in-kernel iSCSI client are exposed. No CISA KEV confirmation was present in the supplied data, and the vuln.today decision label is act_now.
Denial of service in the Linux kernel iSCSI initiator (libiscsi over iscsi_tcp) lets a malicious or compromised iSCSI target crash the host by naming an out-of-use task slot in an unsolicited NOP-In or in a Text, Logout, Login or TMF response. The bug is a NULL pointer dereference reachable from the network without credentials (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, 7.5), but it is only exploitable where the initiator actually has an active session to an attacker-controlled target; hosts not using iSCSI, or only attaching to trusted storage, are not realistically exposed. No public exploit code was identified at time of analysis and EPSS is low (0.18%, 8th percentile), although vendor fixes are available and the issue is scored for handling in this week's patch cycle.
The RISC-V futex implementation in the Linux kernel fails to strip address tags from user-supplied pointers before executing atomic operations, allowing a local unprivileged process to make FUTEX_WAKE_OP write to an arbitrary kernel address. Affected systems must run RISC-V with CONFIG_RISCV_ISA_SUPM, have the tagged-address ABI enabled via PR_SET_TAGGED_ADDR_CTRL with a non-zero PMLEN, and use Sv57 paging with PMLEN=16 so that tag bits overlap canonical kernel address bits - on such configurations the flaw yields both kernel memory corruption and, through the FUTEX_OP_CMP_* result, a read oracle that discloses kernel memory. The vendor has published fixes in Linux 6.18.57, 7.2.11 and 7.3 (commits 8e48d8d51ab37b7decfbff3e2844e027a52ad6ea, 405290be962b32eec842776fbe3bdf81f15b1676 and 2e5c80bbc062a8dda33e687ebf7be8f074ee4f7d); no public exploit has been identified at time of analysis and EPSS is low at 0.21% (10th percentile), reflecting the narrow hardware/configuration prerequisites rather than the severity of the outcome.
Canonical Juju 4.0 through 4.0.15 leaves the model unit-resources download route without an authorization check, so any principal already authenticated to the controller - a unit agent, or a human user holding only 'login' permission with no access to the target model - can request an arbitrary unit in an arbitrary model and read that application's charm resources, including container-registry credentials. The fix in Juju 4.0.16 binds the unit named in the request URL to the authenticated identity, refusing cross-unit and cross-model access. No public exploit code was identified at time of analysis, and the flaw requires a valid controller credential, though one at the lowest privilege tier and against default deployments.
Severity signals and exploitation signals diverge here: Splunk SOAR deployments below 8.7.0 permit an authenticated low-privilege user to bypass authorization by supplying requests whose URL path is non-canonical, so the path used for the access-control decision differs from the path the application ultimately services (CWE-647), with CVSS 3.1 scoring the issue 8.8 and high confidentiality, integrity and availability impact. The exposure is limited to holders of valid SOAR credentials on the web interface (PR:L, AV:N, UI:N) and does not extend to anonymous remote attackers. No public exploit code or active exploitation has been identified at time of analysis (SSVC exploitation: none), and Cisco/Splunk has shipped a hardened 8.7.0 release that resolves the flaw.
Node.js TLS certificate validation can accept a peer certificate that presents an IP address in a non-canonical representation instead of rejecting it, undermining identity checks for IP-addressed TLS peers; affected versions are 26.12.0, 24.22.0, and 22.23.3 and earlier on those branches. An attacker positioned to intercept the TLS path and able to supply a crafted certificate could exploit this to impersonate an IP-identified peer, with high confidentiality and integrity impact but no authentication or user interaction required. The vendor fixed the issue in the 2026-10-21 security release v26.12.1; a public PoC reference exists but is not verified as working exploit code, and no confirmed active exploitation is reported in the supplied intelligence.
Improper input validation in Node.js DNS resolution functions lets hostname or address strings containing null bytes reach dns.resolve/dns.lookup, which the 26.12.1 security release fixes by adding explicit null-byte validation of resolve inputs. Node.js 22.x through 22.23.3, 24.x through 24.22.0, and 26.x through 26.12.0 are affected, with the vendor patch shipped in Node.js 26.12.1. The assessed vector (AV:N/AC:H/PR:N/UI:N, C:H/I:H) means unauthenticated remote reach is possible but exploitation is conditional on the target application passing attacker-influenced strings into DNS resolution, and the exact trigger mechanism is not described in the available sources; a public PoC reference exists but is not verified as working exploit code, and there is no CISA KEV listing.
Remote code execution is possible in Node.js releases that bundle a vulnerable Brotli decoder: a malformed brotli-compressed stream can trigger an out-of-bounds write when decompressed, corrupting memory in the process handling the data. Exposure is limited to deployments that actually pass attacker-controlled brotli data into the decoder - for example services honouring Content-Encoding: br on untrusted requests or responses, or applications calling zlib.brotliDecompress/BrotliDecompress on untrusted input - and no authentication or user interaction is required in that scenario. The flaw is rated High with a CVSS 4.0 score of 9.2 (assessed CVSS 3.1: AV:N/AC:H/PR:N/UI:N/C:H/I:H/A:H), no CISA KEV listing confirms active exploitation, and a public PoC reference exists but is not verified as working exploit code; the vendor fix is Node.js v26.12.1, released 2026-10-21.
Node.js TLS certificate validation in versions 26.12.0 and 24.22.0 can mishandle non-canonical IP address representations, potentially causing IP-based certificate identity checks to be evaluated incorrectly. A network-positioned attacker who can influence the certificate presented during TLS peer validation of an IP address may exploit this to affect confidentiality and integrity, though exploitation requires a man-in-the-middle or malicious-endpoint position and a suitably crafted certificate. No CISA KEV active-exploitation confirmation is provided, but a public PoC reference exists and is not verified as working exploit code.
Canonical JSON encoding in Cpanel::JSON::XS 4.43 through 4.79 can produce non-deterministic output, because the UTF-16 key comparator in utf16_cmp decodes every byte-string key as UTF-8 once any key in the same hash carries the UTF-8 flag, so byte-string keys whose bytes happen to be valid UTF-8 are sorted out of order and two keys that encode differently can compare equal and be left in hash order. The same data structure can therefore serialize to different canonical documents across processes, which matters only where reproducible canonical output is security-relevant, such as signatures over canonical JSON, deduplication, and cache or content-addressing keys; applications that do not depend on canonical determinism are functionally unaffected. No public exploit identified at time of analysis, there is no CISA KEV entry, and EPSS is low at 0.17% (6th percentile), which together with an assessed vector of AC:H and integrity-only impact places this at a low-to-moderate real-world priority to be scheduled this week rather than treated as an emergency.
Out-of-bounds memory writes in Cpanel::JSON::XS 4.20 through 4.79 can crash a Perl process that canonically encodes a tied or threads::shared hash whose key count grows between encode_hv's two passes, corrupting a fixed 64-entry stack array or a heap array sized from the first count before the counts are ever compared. The prerequisites are narrow: the caller must use the ->canonical option and must encode a tied or threads::shared hash whose keys actually increase mid-encode, so plain hashes and non-canonical encoding are unaffected and the assessed vector carries AC:H despite the 7.5 base score. EPSS is low at 0.17% (6th percentile), no public exploit code was identified at time of analysis, and the vendor has released 4.80 with a fix that croaks on unstable key counts instead of writing out of bounds.
Out-of-bounds reads in the Linux kernel's SMB client (cifs module) let a malicious or compromised SMB2/SMB3 server leak kernel memory or crash the client host when a user or an automated mount connects to its share. The parser smb2_parse_contexts() validates the create-context area as a whole but does not clamp each record to its Next field, so a malformed chain can hand bytes beyond the current context to a handler; the same canonical-offset assumption in the SMB2/SMB3 lease parsers and a full-structure cast in the QFid handler widen the exposure, and a valid non-canonical DataOffset with a short DataLength is still accepted. Only hosts that mount SMB shares through the kernel client are affected, impact is read-only (information disclosure or denial of service, no integrity or code execution), and the attack requires the victim to initiate a session to an attacker-controlled endpoint. No public exploit code has been identified at time of analysis, EPSS is 0.17% (6th percentile), and the issue is not in CISA KEV; vendor patches are available and the priority guidance is to remediate this week.
Unauthenticated authorization bypass in the OpenNMS Meridian and Horizon REST API lets any remote attacker who can reach /rest/** read the monitored inventory and create, modify, or delete resources without credentials. The flaw arises because the Spring Security intercept-url rules match the HTTP method as a case-sensitive uppercase token and the filter chains terminate without a deny rule, so a request using a non-canonical method token (for example 'get' or 'put' instead of 'GET'/'PUT') matches no rule and is served without authentication; the /rest/alarms chain additionally leaks whether a specific alarm exists via a difference in the response. All pre-fix Meridian and Horizon versions in default configuration are affected, the vendor-supplied CVSS 3.1 base score is 9.1 (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N, i.e. unauthenticated and low complexity), and no public exploit code was identified at time of analysis; the practical limiting factor is deployment posture, since the vendor states these products belong on private networks and should not be Internet-facing.
Driver-specialized BPF metadata kfuncs can be executed against the wrong driver's XDP buffer in the Linux kernel's BPF offload matching logic, producing an out-of-bounds read and a kernel panic (observed as a KASAN null-ptr-deref in veth_xdp_rx_timestamp when a veth-bound program is run on a tun device). The flaw requires local access with both CAP_BPF and CAP_NET_ADMIN, plus an offload/dev-bound BPF program configuration, so exposure is concentrated on hosts that delegate these capabilities to containers or namespaces; the assessed vector is CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H (7.8). No public exploit code was identified at time of analysis and the issue is not in CISA KEV, with EPSS at 0.16% (4th percentile); vendor patches are available in the stable branches listed in the advisories.
Checksum verification bypass in the Go toolchain (cmd/go) versions 1.27.0 before 1.27.2 and before 1.26.9 allows a malicious Go project with a forged golang.org/toolchain go.sum entry, combined with a user-selected attacker-controlled GOMODPROXY, to substitute a tampered toolchain that cmd/go would otherwise reject. Exploitation requires local access and user interaction (CVSS 7.8, AV:L/UI:R) and two attacker-controlled preconditions the victim must opt into: operating inside the crafted project and using the malicious proxy. No public exploit code identified at time of analysis, and EPSS is 0.13% (2nd percentile), indicating low predicted exploitation likelihood.
Denial of service in Progressive Robot hMailServer 6.0.0 through 6.3.5 lets a remote unauthenticated attacker stall mail delivery and SMTP service by sending a single crafted message. The root cause is inefficient algorithmic complexity (CWE-407) in inbound DKIM and ARC signature verification: assembling the canonical header and resolving the header names listed in a signature's h= tag grows quadratically with header size, so a message with very many header fields - or one field folded over very many continuation lines - holds a worker thread busy for tens of seconds per signature, and up to ten signatures are evaluated per message by both the DKIM and DMARC tests on the threads that serve delivery and SMTP. CVSS 3.1 rates this 7.5 (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H) with no confidentiality or integrity impact; no confirmed active exploitation (CISA KEV) or public exploit code was identified at time of analysis, and the vendor has published a fixed release, v6.3.6.
Privilege escalation in HashiCorp Vault and Vault Enterprise allows an authenticated principal with delegated permissions to bypass explicit deny ACL rules by referencing a resource or policy name in non-canonical form, potentially reaching a protected resource or assigning a denied policy. Affected are Vault Community Edition before 2.1.2 and Vault Enterprise before 2.1.2, 1.21.12, 1.20.17, and 1.19.23, rated CVSS 3.1 7.2 (AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H). Exploitation requires an already high-privileged, delegated user (PR:H) operating in a policy model that depends on explicit deny rules, and no public exploit code or confirmed active exploitation was identified at time of analysis (no EPSS data was provided), so this is best handled as a defense-in-depth hardening fix rather than an emergency.
Signature-verification bypass in Bouncy Castle for Java before 1.86 lets a phantom signer be accepted in BLS12-381 aggregate signature verification. The faulty BLS12_381BasicScheme.keyValidate() trusts the public key's own ECCurve object during the prime-order subgroup check, so an attacker-supplied ECPoint built on a foreign curve that merely shares BLS12-381's field characteristic - with its cofactor forged to 1 - passes validation despite not being a G1 point; in the pairing implementation such a point contributes the identity in the target group, so an aggregate signature verifies even though it contains no signature for that key/message pair. The issue is reachable only where an application constructs an ECPoint on an explicit, non-canonical curve and accepts it as an authority-bearing key, since the standard 48-byte compressed-point decoder always supplies the canonical curve; no public exploit has been identified at time of analysis, and the assessed impact is high integrity compromise without confidentiality or availability loss (CVSS:4.0 base 7.1, network vector, no privileges required).
Denial of service in the Zcash Foundation's Zebra full node before 6.1.0 lets remote unauthenticated peers stall node synchronization by poisoning the stale parent_error_map used by the state write task, after which the next canonical block is rejected for roughly 2,000 blocks. Exploitation is gated by a narrow race window: the attacker must act as a network peer and deliver a coinbase-malleated block that shares a legitimate canonical block's hash before that canonical block propagates, an AC:H/AT:P timing condition, so reliable on-demand abuse is materially limited. Impact is availability-only (CVSS 4.0 8.2, VA:H with no confidentiality or integrity effect), unauthenticated per the PR:N vectors, and no public exploit code has been identified at time of analysis; a vendor-released patch is available in Zebra 6.1.0.
Block-sync denial of service in Zebra (zebrad), the Rust implementation of a Zcash full node, affects all versions before 6.3.0. During block download, a malicious peer can repeatedly serve a canonical block whose coinbase scriptSig is rewritten to claim height 1 while preserving the requested block hash - an evasion made possible because V5 transaction IDs exclude the scriptSig - causing the node to discard the block as too far behind the tip and repeatedly refetch it instead of advancing to the newest chain tip. The attacker remains unauthenticated (CVSS vector PR:N) and must simply be an accepted block-supplying peer; the flaw is an insufficient verification of data authenticity issue (CWE-345) whose impact our assessment bounds to availability only (VA:H in the CVE 4.0 score, but no confidentiality or integrity loss), so real-world severity is a sync delay rather than node compromise. No public exploit code was identified at time of analysis and the issue is not confirmed actively exploited (CISA KEV).
Arbitrary file write as root in Canonical LXD 4.0 and later (before 4.0.14, 5.0.10, 5.21.8 and 6.10) on Linux lets an authenticated client with permission to create instances or custom storage volumes in a project - or a malicious migration source server - plant a symlink inside a transferred volume and then write through it to any path on the target host, resulting in full host compromise. Exploitation requires triggering a volume migration receive and supplying a crafted rsync or btrfs send stream that plants a symlink at a name such as rootfs or root.img; the flaw is an improper link resolution issue (CWE-59) in the receive path that does not confine link targets to the volume. No public exploit code or confirmed active exploitation (CISA KEV) was identified at time of analysis, though the independent assessment rates this a genuine high-priority vulnerability rather than a CVSS-inflated one given the authenticated, low-privilege path to root.
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.
Path traversal in the btrfs storage driver of Canonical LXD 4.0.2 and later allows an authenticated client that holds project-scoped permission to create instances to delete arbitrary files on the host as root by supplying a crafted subvolume path containing ../ sequences, and on hosts whose root filesystem is itself btrfs the same primitive escalates to placing attacker-controlled content at arbitrary host paths for full host compromise. The issue is rated CVSS v3.1 9.6 (AV:N/AC:L/PR:L/UI:N/S:C/C:N/I:H/A:H), reflecting a scope-changing breakout from a restricted tenant role into the host root context rather than a CVSS-inflated score, since a legitimate but limited project credential is the only prerequisite. No CISA KEV listing and no public exploit code were identified at time of analysis; vendor fixes are available in LXD 4.0.14, 5.0.10, 5.21.8 and 6.10.
Path traversal in Canonical LXD's Btrfs storage driver allows an authenticated user with instance-creation privileges to escape the intended backup import target and delete or replace arbitrary files and directories on the host as root, by supplying a crafted subvolumes[].path value in backup/optimized_header.yaml during a btrfs 'optimized' backup import. The assessed vector (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H, 9.9) reflects high confidentiality, integrity and availability impact with a scope change because the traversed write lands outside the LXD daemon's own container boundary; exploitation requires valid low-privilege API credentials and a Btrfs-backed host, not anonymous access. No public exploit code has been identified at time of analysis, and the issue is not confirmed actively exploited (CISA KEV), but the low attack complexity and root-level file-system effect make it a genuine high-priority fix rather than a CVSS-inflated score.
GitPython before 3.1.62 is vulnerable to a path traversal (CWE-22) in Submodule.update() that allows unauthenticated remote attackers to create, populate from a submodule URL, and potentially delete directories outside the repository working tree when an application updates submodules at a non-HEAD (historical) commit. The flaw stems from the `path` field in an untrusted .gitmodules file being used without the _to_relative_path() containment guard that is applied in add() and move(). Exploitation requires an application flow that checks out submodules at a historical commit and an attacker-controlled repository; the standard clone-then-update flow re-derives the path from a canonical tree lookup and is not affected. No public exploit code or confirmed active exploitation (CISA KEV) exists at time of analysis, and the independent assessment rates real-world priority as low-to-medium despite the vendor's CVSS 4.0 score of 8.7.
Signature-verification bypass in MinIO (all releases through commit 7aac2a2) and in the pgsty/silo fork (before commit 1233254) lets an attacker who holds a valid SigV4 presigned PUT URL - one scoped to a single object - append an unsigned x-amz-copy-source header to the otherwise unmodified URL and cause a server-side CopyObject executed with the signer's credentials, converting a write grant into reads of every object that signing key can reach. The root cause is a CWE-347 improper-verification-of-signature error: extractSignedHeaders() in cmd/signature-v4-utils.go iterates only the client-claimed X-Amz-SignedHeaders list and never enumerates the x-amz-* headers that actually arrived, so an unsigned header is neither hashed into the canonical request nor rejected, while cmd/api-router.go dispatches CopyObject purely on the presence of x-amz-copy-source. Amazon S3 rejects the equivalent request with HTTP 403 AccessDenied; exploitation here requires a delegated presigned URL plus a signing key with broader read permission, making this a privilege escalation from a delegated credential rather than unauthenticated access, with no public exploit code or confirmed active exploitation identified at time of analysis.
Gerrit Code Review 2.16.0-3.12.9, 3.13.0-3.13.8, and 3.14.0-3.14.2 mishandle project-name normalization, allowing an authenticated user (or an unauthenticated user when the repository was previously public) to keep reading private repository content and to durably restore revoked project-owner administrative privileges. Requests that reference a project with repeated terminal .git suffixes (for example project.git.git) are cached under a different key than the canonical project, so revoking read access or removing owner rules on the canonical name never evicts the stale alias ProjectState during the ProjectCache validity window, permitting reads of newly created private commits and writes to refs/meta/config. No public exploit code has been identified at time of analysis; exploitation requires the attacker to have previously held access to the project and to act before the stale cache entry would naturally expire.
Authenticated remote code execution in OpenC3 COSMOS (Ruby gem 'openc3' versions 5.1.0 through 7.2.1) lets any logged-in user, including one with only low-tier permissions, execute arbitrary Ruby and Python code on the COSMOS server and its per-target decom microservices. COSMOS reads configuration from a user-writable overlay (targets_modified/) before its read-only targets/ tree and then executes that content - rendering it as ERB, eval-ing GENERIC_READ/WRITE_CONVERSION blocks, or require-ing Script Runner procedure files - so an attacker who can write to the overlay via the screen-save or storage-upload endpoints achieves code execution as the openc3 user, which holds Redis and object-store credentials and sits on the internal service network. A working proof-of-concept is published in the vendor GitHub advisory, and the vendor has released 7.3.0 as the fix; no confirmed active exploitation (CISA KEV) has been reported. Reachability is limited on default single-host installs because the shipped docker-compose binds Traefik to 127.0.0.1:2900, so exploitation is realistic on multi-user deployments that expose the web port.
Unauthenticated remote attackers can invoke sensitive financial and record-disclosure methods inside WeGIA's contribution dispatcher and, using a traversal-shaped controller name, force require_once to load PHP or configuration files from outside the intended controller directory. Because the pre-3.8.5 dispatcher in web/html/contribuicao/controller/control.php hardcoded an authentication exemption for ContribuicaoLogController and enforced no controller/method allowlist, methods such as getContribuicoesLogJSON, sincronizarStatus and registrarFaturas are reachable by anyone with HTTP access, leaking contribution and donation records or triggering financial workflow operations. Rated CVSS 9.1 (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N), this is a genuine high-priority issue; no public exploit identified at time of analysis, and it is fixed in version 3.8.5.
A race in the Linux kernel's iSER (IB/isert) iSCSI target transport lets an initiator on an RDMA fabric crash the target host: the final iSCSI Login Response is put on the wire before __transport_register_session() has populated the session's se_tpg, so a SCSI command issued immediately after the initiator sees login success reaches target_submit() against a half-initialized se_session and the ib-comp-wq worker oopses on a NULL/non-canonical pointer dereference (KASAN null-ptr-deref at offset 0x78). Only LIO/TCM iSCSI targets using the isert RDMA transport over InfiniBand, RoCE, or iWARP are affected; plain iscsi-TCP and cxgbit are not, because they already pull PDUs from iscsi_target_rx_thread. Exploitation is a probabilistic race (the maintainer reproduced the oops in 10 of 20 unpatched runs over rxe), vendor CVSS is 7.5 while our assessed vector is AV:A/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H given the RDMA-fabric adjacency requirement and timing difficulty; there is no public exploit code and no CISA KEV listing at time of analysis.
Sandbox escape in the vm2 Node.js library through 3.11.6 lets untrusted code running inside a NodeVM instance reach the host's child_process builtin and execute operating-system commands whenever the embedding application configures a wildcard builtin require policy containing a node:-prefixed deny entry. The affected configuration (for example new NodeVM({ require: { builtin: ['*', '-node:child_process'] } })) fails to deny the canonical child_process module, so sandboxed code can obtain execSync and spawn via require('child_process') or require('node:child_process'), giving host command-execution capability to code that was supposed to be isolated (CVSS 4.0 base 9.4; assessed CVSS 3.1 AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H). Exploitation requires PR:L privileges in the sense that the attacker must already be able to run attacker-controlled JavaScript inside the sandbox, and it only works under that specific deny-list form; a correctly spelled '-child_process' entry, a non-wildcard allow-list, or not exposing child_process at all avoids the flaw. No public exploit code or confirmed active exploitation was identified at time of analysis.
A memory-corruption flaw in the Linux kernel's vfio-pci driver (vfio/pci/vfio_pci_config.c) allows a local user holding access to a VFIO passthrough device node (typically /dev/vfio/*) to trigger a use-after-free and subsequent double-free of the per-device MSI permission table (vdev->msi_perm). Exploitation requires attacker-induced failure of the allocation path (init_pci_cap_msi_perm()/alloc_perm_bits() returning -ENOMEM during a failed device open, e.g. under memory pressure or fault injection), after which re-opening the same persistent vfio_pci_core_device reuses the freed perm_bits object - dereferencing its readfn/writefn function pointers inside vfio_pci_config_rw_single() - while closing it hits kfree() on an already-freed object in vfio_config_free(). There is no public exploit code identified and no indication of active exploitation at time of analysis; EPSS is low (0.21%, ~11th percentile), and the memory-pressure precondition plus the requirement for VFIO passthrough privileges materially limits real-world reliability, even though the assessed CVSS:3.1:AV:L/AC:H/PR:L/UI:N/S:C/C:H/I:H/A:H score is high.
Out-of-bounds slab write in the Linux kernel's libceph/CRUSH map decoder (crush_decode) lets a malformed CRUSH map corrupt kernel memory on any RADOS client (Ceph RBD or CephFS). Because crush_decode() stores buckets by array slot while the mapper derives each bucket's workspace index from its decoded id, a map encoding an id different from '-1 - slot' makes one bucket alias another's kvmalloc'd workspace; a uniform bucket's second-replica permutation then overflows the smaller aliased buffer, producing a 4-byte OOB write in bucket_perm_choose() confirmed by KASAN. EPSS is low (0.17%, 6th percentile) and there is no public exploit identified at time of analysis; the CRUSH map is delivered from the Ceph monitor/OSD map, so exploitation requires a malicious or compromised monitor rather than an arbitrary internet attacker.
Arbitrary file deletion in UsersWP ≤ 1.2.70 for WordPress allows authenticated Subscriber-level users to delete any file on the server - including wp-config.php - via a path traversal bypass in the upload_file_remove() AJAX handler. The exploit exploits a two-phase validation failure: validate_file() only rejects literal '../' sequences, but the uwp_get_file_relative_url() helper later performs a global str_replace() that collapses crafted embedded tokens into directory traversal sequences after the final validation gate, with the result passed directly to wp_delete_file() without canonical containment. No public exploit code or CISA KEV listing is confirmed at time of analysis; however, the low privilege requirement and precise Wordfence source-level write-up substantially reduce the research barrier for threat actors.
Fastify's route schema compilation silently nullifies conditional header requirements declared via the JSON Schema Draft 7 `dependencies` keyword, enabling unauthenticated remote clients to bypass schema-enforced authorization checks. Versions before 5.12.2 lowercase header property keys and the root `required` array during schema compilation but leave trigger and dependent names inside `dependencies` in their original casing; since Node.js stores all incoming request header names in lowercase, those case-sensitive dependency references never match and the conditional requirement is invisibly skipped. An attacker can present a privileged-operation header while omitting the authentication or authorization header the dependency was intended to mandate, causing the application's privileged branch to execute as though the guard had passed. No public exploit has been identified at time of analysis.
Craft CMS versions 5.0.0-RC1 through 5.10.10 allow an authenticated low-privileged contributor to permanently delete canonical entry content by exploiting a broken authorization chain in ElementsController::actionDeleteForSite(). The method authorizes deletion against the user's provisional draft rather than the canonical element, then propagates the destructive action to the canonical record without re-verifying deleteEntriesForSite permission. Deleted content bypasses the recycle bin and is unrecoverable, making this an integrity-destroying flaw despite its mid-range CVSS score. No public exploit code is identified at time of analysis.
SSRF in the Bifrost AI gateway's multimodal URL-fetch path permits any client that can submit a Bedrock or Vertex provider request to reach internal network services - including cloud instance-metadata endpoints - by supplying IPv6 transition-form addresses (6to4, NAT64) or CGNAT addresses that the `isPublicIP` deny-list in `core/providers/utils/fetch.go` incorrectly classifies as routable public IPs. All releases of the `github.com/maximhq/bifrost/core` Go module prior to v1.5.17 are affected, confirmed on dev HEAD f415c14 (core/version 1.5.15). Publicly available exploit code exists in the GHSA advisory as a runnable Go test; no CISA KEV listing at time of analysis.
Memory corruption in the Linux kernel's net/sched fq_codel queueing discipline lets a local actor with traffic-control privileges trigger a wild kernel memory access and crash. When fq_codel drops packets during a peek operation, it calls qdisc_tree_reduce_backlog before restoring qlen; if qlen momentarily hits zero while peek still holds an skb, the parent class (e.g. qfq) is wrongly deactivated, producing a general-protection fault against a poisoned list pointer (0xdead000000000100 range) as seen under KASAN. No public exploit identified at time of analysis, EPSS is low (0.18%), and it is not in CISA KEV.
Path traversal in IzPack's UnpackerBase.unpack() enables arbitrary file writes under victim privileges when a user executes a trojanized installer JAR. The unpacking pipeline calls IoHelper.translatePath(), which performs only file-separator substitution with no canonical-path check, no startsWith(installDir) containment guard, and no normalization of '../' sequences, allowing attacker-controlled PackFile entries to escape the install directory entirely. Because IzPack JARs are standard unsigned ZIPs with no integrity protection, any legitimate IzPack installer can be silently repackaged with malicious entries; a publicly available proof-of-concept confirms the escape. The CVE is not listed in CISA KEV, but the trivial repacking method and social-engineering distribution vector make this a credible supply-chain threat to organizations consuming IzPack-packaged software from untrusted sources.
Path traversal in RansomLook's GroupPost.get API handler allows an attacker controlling a malicious upstream instance to exfiltrate arbitrary files readable by the RansomLook process, including configuration secrets and API credentials. The screen field stored in the database is concatenated directly with the application's source/ directory path without boundary validation, enabling traversal sequences such as ../config/generic.json to escape the intended directory. No public exploit code has been identified at time of analysis and the vulnerability is not listed in CISA KEV, but the federation import mechanism means a compromised upstream instance can poison a victim's database without holding any account on the victim system.
Host root code execution in Canonical LXD arises from a path-traversal flaw in instance template processing, letting an attacker with container edit permissions - or any user who launches a maliciously crafted image - overwrite arbitrary root-owned files on the host. The root cause is a validate-then-open mismatch: LXD checks template target paths against a confined os.Root handle but then creates the file via os.Create using the raw, unconfined string path. No public exploit has been identified at time of analysis, but the CVSS 9.9 rating and container-to-host scope change make this a critical container-escape.
Null-pointer dereference and promiscuity counter underflow in the Linux kernel bonding driver's ALB monitor can crash the kernel or permanently pin a network interface in promiscuous mode. The bond_alb_monitor() workqueue function reads primary_is_promisc under RCU, drops that lock, then acquires RTNL - allowing the active slave to be removed or changed in the intervening window, leaving the monitor to act on stale state. Linux systems from kernel 2.6.24 through unpatched stable branches (5.10.x, 5.15.x, 6.1.x, 6.6.x, 6.12.x, 6.18.x, 7.1.x, 7.2) with network bonding explicitly configured in ALB mode are affected. No public exploit identified at time of analysis.
Reference imbalance in the Linux kernel's BPF conntrack kfuncs allows a local attacker with BPF privileges to trigger an unmatched put_net() call that can destroy a live network namespace and cause kernel panic. The flaw affects __bpf_nf_ct_lookup() and __bpf_nf_ct_alloc_entry(), where opts->netns_id is read non-atomically from a shared BPF map value during both namespace acquisition and release. No public exploit code exists and EPSS is low (0.20%, 10th percentile), but the kernel panic outcome is confirmed by a crash trace in the advisory. Exploitation requires local BPF capability and a concurrent writer to the shared map.
Unverified password change in Laravel Backpack CRUD's account-info endpoint allows any authenticated Backpack admin to permanently take over their own or a hijacked session's account by mass-assigning the `password` field without supplying the current password. Affected versions are backpack/crud < 6.8.11 and 7.0.0-alpha.1 through 7.0.33, running on Laravel 11 with the default `App\Models\User` model whose `$fillable` includes `password`. The attack converts time-limited stolen session access into permanent credential control, bypassing the dedicated change-password flow that enforces `old_password` verification. No public exploit code or CISA KEV listing has been identified at time of analysis, but the attack is trivially constructable given full public advisory detail.
Privilege escalation in Ubuntu's accountsservice package allows a local low-privileged user to execute arbitrary shell commands as root (real UID 0) by injecting a GNU sed 'e' flag payload into their ~/.pam_environment LANGUAGE entry, which is then processed unsanitized by Ubuntu-specific helper scripts (save-to-pam-env, update-langlist) when the SetLanguage D-Bus method is invoked. All Ubuntu accountsservice packages before version 23.13.9-8ubuntu7 are affected; this is a Ubuntu-specific packaging defect, not an upstream accountsservice issue. No public exploit code or CISA KEV listing has been identified at time of analysis, though the attack path is well-described and technically straightforward.
Local privilege escalation in Ubuntu's AccountsService (before 23.13.9-8ubuntu7) lets any low-privileged local user gain full root access by exploiting an incomplete privilege-drop in a Canonical-specific patch. The patch sets the effective UID/GID to the target user before launching language helper scripts but neglects to change the real UID, leaving ruid=0. Any shell spawned by a helper script can call setuid(0) to restore root effective privileges, granting complete system compromise. No public exploit has been identified at time of analysis, and this vulnerability is not listed in the CISA KEV catalog.
Grafana OSS's Unified Alerting component allows a low-privileged authenticated organization member to query any datasource - including those they are explicitly denied access to - by setting the client-controlled queryType field to the reserved value __expr__ while supplying the UID of a real datasource in an alert rule. Authorization skips the datasources:query permission check when it sees __expr__, but the evaluator subsequently resolves and executes the query against the real datasource identified by datasourceUid, resulting in full data exfiltration through Grafana's configured credentials. Affected versions span Grafana OSS 8.4.0 through 13.1.1; no public exploit code or CISA KEV listing has been identified at the time of analysis, but the low attack complexity and confirmed reproduction under default OSS permissions make this a credible insider-threat and privilege-escalation vector.
Availability disruption in stigmem-node 0.9.0a1 (pip package by eidetic-labs) allows authenticated federation peers to have their valid peer tokens incorrectly rejected as expired due to a timestamp-handling mismatch in the federation peer-token validation logic. Impacted deployments are Stigmem nodes operating federation peer authentication paths, where authenticated federation flows may fail non-deterministically depending on which token-minting path was used. No active exploitation has been identified (no KEV listing, no public exploit), and the fix is available in 0.9.0a2.
Zip Slip path traversal in Notepad++'s bundled WinGup update component (versions prior to 8.9.7) allows network-delivered malicious ZIP archives to overwrite DLL files outside the intended extraction directory, enabling arbitrary code execution when Notepad++ next loads the affected plugin. The attack requires user interaction to trigger the update workflow (CVSS UI:R) but demands no authentication on the target system. No public exploit code or CISA KEV listing has been identified at time of analysis; the vulnerability is fixed in the vendor-released 8.9.7 build.
Use-After-Free in the Linux kernel's mm/page_reporting subsystem triggers a General Protection Fault during PM suspend and hibernation on systems running virtio_balloon with page reporting enabled. When the PM freezer initiates a suspend or S4 hibernation cycle, the virtio_balloon driver tears down its virtqueues via del_vqs(), but page_reporting_process - scheduled on the non-freezable system_wq workqueue - remains active. If the buddy allocator frees pages during this window (e.g., the balloon shrinker runs during S4 image saving), the reporting worker calls virtballoon_free_page_report() on already-deleted virtqueues, causing kernel memory corruption. No public exploit has been identified at time of analysis; EPSS is 0.18% (8th percentile), reflecting minimal exploitation probability, though this is a confirmed kernel UAF with crash-level impact validated by Google in production virtualization infrastructure.
OCFS2 cluster filesystem dinode validation in the Linux kernel fails to reject inodes with non-canonical i_mode type bits, allowing forged on-disk metadata to propagate into in-core kernel inode structures. Affected kernels accept any non-zero i_mode value and pass it verbatim into ocfs2_populate_inode(), where an unrecognized S_IFMT type falls through to ocfs2_special_file_iops and init_special_inode() - a code path not designed for arbitrary mode inputs. No public exploit has been identified at time of analysis and EPSS sits at only 0.22%, but the kernel-level impact (C:H/I:H/A:H) and the shared-storage attack surface of OCFS2 clusters warrant priority patching on affected systems.
Memory corruption in the Linux kernel network scheduler (net/sched/sch_codel) allows a privileged local user to trigger a wild/dangling pointer dereference by mis-accounting queue length during the CoDel peek operation. When CoDel drops packets during peek it calls qdisc_tree_reduce_backlog before re-incrementing qlen; if qlen momentarily hits zero while peek still returns an skb, the parent qdisc's qlen_notify prematurely deactivates the class, corrupting scheduler state (demonstrated as a KASAN wild-memory-access in qfq_deactivate_agg when qfq parents a codel child). No public exploit identified at time of analysis; EPSS is low (0.21%, 12th percentile) and this is not in CISA KEV.
Integer overflow in the Linux kernel's BPF sockmap helper `bpf_msg_pop_data()` enables a local privileged attacker to bypass scatterlist bounds checks, causing an out-of-bounds traversal that dereferences a null or non-canonical page pointer and crashes the kernel. Affected are all kernel stable series from 5.10 through pre-7.2, with patches confirmed across eight stable branches. No public exploit has been identified at time of analysis and the EPSS score of 0.21% (12th percentile) indicates negligible current exploitation activity, though the confirmed kernel crash impact and High CVSS score warrant prompt patching on systems using BPF sockmap.
The regulator subsystem in the Linux kernel contains a deadlock-handling defect where `regulator_lock_two()` compares the return value of `ww_mutex_lock()` against `-EDEADLOCK` instead of the correct `-EDEADLK` constant. On MIPS architecture - the only platform where the regulator core is active and these two error constants carry different numeric values - the mismatch causes the kernel to skip the mandatory unlock-and-retry backoff sequence, fire `WARN_ON`, and return to the caller with only one of the two regulators locked, producing corrupted locking state. No public exploit has been identified and EPSS is very low (0.22%, 13th percentile), but the high CVSS impact ratings (C:H/I:H/A:H) reflect the potential for kernel panic or local privilege escalation on affected MIPS systems.
Privilege escalation to host root in Canonical LXD occurs when the container manager unpacks crafted image or backup archives, because it follows a symbolic link where the backup.yaml metadata file should be and then processes attacker-controlled configuration outside its intended confinement. A low-privileged LXD user who can import a malicious archive can execute arbitrary commands as root on the underlying host, breaking the container/host trust boundary (scope change). Rated CVSS 9.9; no public exploit identified at time of analysis and not listed in CISA KEV, but the fix is coordinated through GitHub advisory GHSA-fv82-v4fj-mm4m.
Arbitrary host file read and write in Canonical LXD occurs because the image import/unpack routine does not verify whether the bundled metadata.yaml entry is a symbolic link, letting an authenticated user with image-import rights supply a crafted archive whose symlinked metadata.yaml resolves to sensitive host paths. Rated CVSS 9.9 with a scope change (S:C), successful exploitation crosses the container/management boundary to read or overwrite files as the LXD daemon (typically root) on the host. There is no public exploit identified at time of analysis and the issue is not listed in CISA KEV; details are published only in Canonical advisory GHSA-j825-cg34-5fr5.
Path traversal in Canonical LXD's image metadata template processing enables an authenticated low-privilege attacker to read arbitrary host files or create files in arbitrary host filesystem locations. The flaw resides in the virtual machine/QEMU driver execution path, where LXD fails to sanitize template file paths from escaping the designated instance templates directory. Exploitation crosses the container/VM boundary to the host (scope change, S:C), making this high-severity in environments where host isolation is a security assumption. No public exploit code or CISA KEV listing has been identified at time of analysis.
Path traversal in Canonical's LXD container and VM manager allows a user with backup import/restore privileges to write or read files outside the intended restore directory by embedding traversal sequences in the instance or storage-volume names stored in a crafted backup archive's metadata. Because LXD does not validate these names on import/restore, an attacker can corrupt or overwrite host files, potentially leading to full host compromise. There is no public exploit identified at time of analysis, and it is not listed in CISA KEV; the very high CVSS (9.9) is driven by the scope-changing, high-integrity/availability impact on the host.
Authorization bypass in Canonical LXD lets an authenticated user with instance-migration privileges smuggle high-privilege instance configurations into restricted projects. When an instance is migrated to a target project, LXD applies caller-supplied configuration overrides without re-validating them against the destination project's enforced restrictions, so security controls such as privileged-container or device limits can be defeated. Rated CVSS 9.9 (CWE-863) with a scope-changing impact; no public exploit has been identified at time of analysis.
Authorization bypass in Canonical LXD lets an authenticated user with copy privileges smuggle instances carrying disallowed high-privilege configurations into restricted projects, defeating per-project security controls. The root cause is a time-of-check to time-of-use race in which LXD validates project restrictions before configuration merging finishes during cross-project instance copies. Rated CVSS 9.9 with a scope change; there is no public exploit identified at time of analysis and it is not listed in CISA KEV.
Canonical LXD's NVIDIA GPU passthrough configuration handler fails to sanitize newline characters in user-supplied `nvidia.driver.capabilities` and `nvidia.require.*` instance config values, enabling an authenticated attacker to inject arbitrary directives into the generated `lxc.conf` file. Any LXD user with instance-creation or configuration-modification privileges can exploit this to escape the container boundary and execute arbitrary commands on the host with the full privileges of the LXD daemon - effectively achieving complete host compromise. No public exploit code or CISA KEV listing exists at time of analysis, but the network-accessible, low-privilege attack path and scope-changed CVSS vector reflect an elevated real-world threat for shared or multi-tenant LXD deployments.
Storage quota bypass in Canonical LXD (5.0.x before 5.0.8, 5.21.x before 5.21.6, and 6.0 before 6.10) lets an authenticated user exceed the disk and volume limits an administrator configured on a project. The flaw stems from two code paths - cross-project volume moves (storagePoolVolumeTypePostMove) and volume snapshot restores with a nil config - that skip the AllowVolumeCreation/AllowVolumeUpdate limit checks, enabling over-allocation of storage. Reported by Canonical with a patch available; no public exploit identified at time of analysis and it is not listed in CISA KEV.
Authorization bypass in Canonical LXD (6.0 before 6.10, 5.21.x before 5.21.6, 5.0.x before 5.0.8) lets an authenticated user smuggle disallowed instance configurations into a restricted project by triggering a cross-project, cross-cluster-member migration. Because the migration arrives at the destination node as an internal cluster notification, the destination skips all target-project restriction checks (CWE-863), so limits and security restrictions on the target project are not enforced. Rated CVSS 9.9; reported by Canonical with a vendor patch available, but no public exploit identified at time of analysis and it is not listed in CISA KEV.
Project-confinement bypass in Canonical LXD lets an authenticated user holding can_create_instances on a restricted project escape that project's security policy by migrating an instance into it. Because instancePostMigration never re-validated the incoming instance against the target project's enforced restrictions, an attacker could build a high-privilege or otherwise disallowed instance inside an unrestricted project and relocate it into the restricted one, inheriting capabilities (low-level container access, arbitrary devices, unrestricted network access) that the project was configured to forbid. Rated CVSS 9.9 by the vendor; no public exploit identified at time of analysis and it is not in CISA KEV.
URLSecurityValidator SSRF bypass in compliance-trestle <= 4.0.3 allows a network-positioned attacker to reach cloud metadata services, loopback admin interfaces, and RFC 1918 internal networks by embedding IPv4-mapped IPv6 literals (e.g., [::ffff:169.254.169.254]) or the unspecified address 0.0.0.0 in OSCAL artifact import references processed by HTTPSFetcher or SFTPFetcher. Python's ipaddress module silently returns False - rather than raising TypeError - when comparing IPv6Address objects against IPv4Network ranges, so the validator's membership checks pass these forms through to requests.get unchanged. A publicly available proof-of-concept reproduces end-to-end IMDS credential exfiltration; no active exploitation is listed in CISA KEV and EPSS stands at 0.42%.
Portainer CE through 2.44.0 exposes root-level Docker host access to any authenticated low-privileged user via a URL path normalization flaw in the Docker proxy endpoint. The authorization middleware evaluates a non-canonical request path (e.g., percent-encoded slashes, double slashes, or traversal sequences) differently from the proxy layer that ultimately forwards it to the Docker daemon - allowing crafted requests to bypass all access controls while executing with full Docker API privileges. No active exploitation has been confirmed (no CISA KEV listing) and no public exploit code has been identified at time of analysis; EPSS data was not provided in the source intelligence.
Use-after-free in the Linux kernel's drm/xe Intel Xe GPU driver allows a local low-privileged user to trigger kernel memory corruption with potential for full system compromise (C:H/I:H/A:H). The bug arises because an imported dma-buf buffer object (BO) is created with its reservation object (resv) pointing to the exporter's dma_buf->resv before the importer acquires a reference on that dma-buf - leaving a window in which the exporter can be freed while the TTM workqueue asynchronously accesses the now-dangling pointer. Vendor-released patches are available for Linux 6.12.103, 6.18.42, and 7.1.6; no public exploit has been identified at time of analysis.
Pre-authentication out-of-bounds kernel memory read in the Linux kernel's CephFS client (ceph_handle_caps) allows a malicious or compromised Ceph Metadata Server (MDS) to read beyond the message front buffer. By sending a CEPH_CAP_OP_IMPORT caps message with hdr.version set to 1 and an oversized snap_trace_len (e.g. 0xFFFFFFFF), the server bypasses all version-gated decoders and drives ceph_update_snap_trace() to decode a fake snap realm past the buffer, cascading into further OOB reads via attacker-controlled num_snaps/num_prior_parent_snaps counts. The flaw is present in every kernel since ceph_handle_caps() was introduced; it carries a CVSS 9.8 but currently has no public exploit and a low EPSS score (0.22%), and it is not on CISA KEV.
Route guard bypass in @fastify/static before 10.1.3 exposes protected static files to unauthenticated remote attackers without requiring any credentials. The plugin failed to canonicalize non-standard path forms - including dot segments, duplicate slashes, percent-encoded dots, and backslashes - before matching the request path against route-based guards, allowing crafted URLs to evade the guard while the underlying send layer resolves and serves the protected file. This is an incomplete fix for a prior vulnerability in the same component; no public exploit identified at time of analysis, though the technique is a textbook path normalization bypass requiring no advanced skills.
Path traversal in rclone's `serve restic` REST API allows any attacker with network access to the endpoint to read, create, overwrite, or delete objects outside the operator-configured backend directory. The flaw spans rclone v1.40 through v1.74.4 and affects WebDAV, FTP, SFTP, HTTP, and Memory backends - but not S3-compatible or local filesystem backends, which encode `..` as literal filename characters. A fully functional, step-by-step proof of concept has been publicly released; no CISA KEV listing exists at time of analysis.
Use-after-free race condition in the Linux kernel's RDMA/rxe (SoftRoCE) subsystem allows a local unprivileged user to trigger a kernel crash or achieve page-level memory corruption. The race occurs between rxe_mmap() - which releases pending_lock while a rxe_mmap_info kref is still live - and a concurrent DESTROY_CQ ioctl that drops the kref to zero, causing vfree() to clear vmalloc PTEs mid-walk in remap_vmalloc_range_partial(). No CISA KEV listing exists and EPSS is 0.16% (5th percentile), reflecting the race's very narrow exploitation window; however, the C:H/I:H/A:H impact and confirmed upstream patch make this a priority update for any environment with RDMA/rxe loaded.
Uninitialized stack memory dereference in the Linux kernel's IPv4 nexthop subsystem (net/ipv4/nexthop.c) enables local low-privileged attackers to cause kernel panic or leak sensitive stack contents on systems built with CONFIG_INIT_STACK_NONE. Versions from 5.13 through stable branches prior to 6.6.148, 6.12.101, 6.18.42, 7.1.6, and 7.2-rc5 are affected. No public exploit code has been identified and EPSS stands at 0.16% (5th percentile), placing this in the low-urgency tier despite a CVSS 7.1 score driven by dual high-impact outcomes.
Use-after-free in the Linux kernel mac80211 MLO (Multi-Link Operation) subsystem allows a local attacker with low privileges to corrupt kernel memory by reading stale debugfs entries after a failed ieee80211_vif_update_links() operation. Systems running kernel 6.4 or later with WiFi 7 (IEEE 802.11be) MLO-capable hardware are within the affected code path; patched releases are available across all active stable branches. No public exploit or CISA KEV listing exists and EPSS is 0.16%, but CVSS impact metrics of C:H/I:H/A:H indicate full kernel compromise potential if the vulnerability is successfully triggered, as confirmed by a KASAN slab-use-after-free trace referencing a task named 'exploit/145'.
Use-after-free in the Linux kernel TCP Authentication Option (TCP-AO
Heap-based out-of-bounds read in the Linux kernel's nvmet discovery log page handler allows unauthenticated remote attackers to leak kernel memory or crash the host. Any system acting as an NVMe over Fabrics target with a discovery service exposed via TCP, RDMA, or FC is vulnerable. No active exploitation or public exploit code is reported at this time, and EPSS probability is low (0.25%), but the impact and ease of exploitation make remediation urgent for affected storage targets.
Heap out-of-bounds write in FFmpeg's native PNG and APNG encoders (all versions through 8.1.2) allows remote attackers who can supply a crafted PNG image to cause deterministic heap corruption and a potential arbitrary code execution primitive. The root cause is `add_exif_profile_size()` underestimating the required output buffer when multiple EXIF IFD entries share a large value payload - canonical serialization expands the deduplicated entries back to full size, causing `png_write_chunk()` to write tens of thousands of bytes past the allocated boundary. No public exploit exists and EPSS places exploitation probability at 0.55%, but VulnCheck reports the heap corruption is deterministic, elevating the eventual RCE risk.
Unauthenticated denial of service in Gitea's Locale middleware allows any remote attacker to consume ~2 seconds of server CPU per HTTP request by crafting a ~1 MiB Accept-Language header composed of underscore separators, bypassing the existing CVE-2022-32149 guard in golang.org/x/text which only counts dash characters. All Gitea releases from 1.22.x through 1.26.x are affected because the middleware at modules/web/middleware/locale.go:38 passes the raw, unfiltered header directly to the quadratic-time ParseAcceptLanguage parser; ten concurrent attackers consuming ~10 MiB/s of upstream bandwidth can saturate all cores of a ten-core host indefinitely. Publicly available exploit code exists in the GHSA advisory; no active exploitation has been confirmed by CISA KEV at time of analysis.
Local privilege escalation in snap-confine - the SUID/set-capabilities helper snapd uses to build the confinement sandbox for snap applications - lets an unprivileged local user on Ubuntu 22.04, 24.04, and 26.04 LTS gain full root. The flaw only manifests where snap-confine is deployed with file capabilities (set-capabilities) instead of the traditional set-uid-root binary, where incorrect handling of ambient capabilities lets an attacker escape intended privilege boundaries and run arbitrary code as root. Reported by Canonical; no public exploit identified at time of analysis and it is not listed in CISA KEV.
Sandbox confinement bypass in Canonical snapd (snap-confine) affects all supported Ubuntu LTS releases (16.04 through 26.04) because the default seccomp templates fail to block system calls that create or set set-user-ID flags on files. A process already running inside a strictly confined snap can compile or drop a binary, mark it setuid, and then execute it to escape confinement assumptions and perform privileged actions within the container namespace. There is no public exploit identified at time of analysis and the issue is not listed in CISA KEV, but the CVSS 8.4 (scope-changed) rating reflects a genuine confinement-escape primitive.
Use-after-free in the Linux kernel netfilter ipset subsystem allows a local user with Netlink privilege to corrupt kernel memory by racing dump operations against a concurrent ip_set_list array resize. The dump callbacks ip_set_dump_do() and ip_set_dump_done() dereference the inst->ip_set_list array pointer outside any RCU read-side critical section; a concurrent ip_set_create() publishes a new array, calls synchronize_net(), and then frees the old array - but synchronize_net() does not wait for the unprotected dump readers, resulting in a slab use-after-free. No public exploit has been confirmed at time of analysis, though the KASAN trace embedded in the CVE description references a task named 'exploit/150', indicating a functional proof-of-concept was used to produce the report during responsible disclosure.
Remote denial of service in the Linux kernel's ksmbd in-kernel SMB3 server allows an attacker to trigger a NULL-pointer dereference and kernel panic during SMB2 CREATE lease processing. After a SESSION_LOGOFF, a stale opinfo remains linked in the per-ClientGuid lease list with its conn pointer cleared; a subsequent session reusing the same ClientGuid and taking a lease on a different inode causes compare_guid_key() to dereference the NULL conn->ClientGUID. Exploitation requires only a successful SMB2 SESSION_SETUP against a share with 'durable handles = yes'; no public exploit is identified at time of analysis and EPSS risk is low (0.17%).
Kernel-panic denial of service in the Linux kernel's in-kernel SMB server (ksmbd) allows the file-pointer table to retain a durable-handle file object with a NULL tcon after a client issues SMB2 SESSION_LOGOFF; any subsequent read of /proc/fs/ksmbd/files then dereferences the NULL fp->tcon in proc_show_files() and crashes the host. Affected are kernels running ksmbd on shares configured with 'durable handles = yes'. There is no public exploit identified at time of analysis and EPSS is low (0.16%, 6th percentile), consistent with a stability/robustness bug rather than a weaponizable RCE.
Kernel-level out-of-bounds write in the Linux octeontx2-af driver (Marvell OcteonTX2 admin function) lets a low-privileged VF whose parent PF is in switchdev representor mode corrupt kernel memory. The rvu_mbox_handler_rep_event_notify() handler queues a sender-controlled REP_EVENT_NOTIFY body whose nested event->pcifunc is never bounds-checked, so an out-of-range index reaches rvu_get_pfvf()/rvu_get_pf() and, on RVU_EVENT_MAC_ADDR_CHANGE, becomes a six-byte attacker-chosen OOB ether_addr_copy() write in the AF worker (KASAN slab-out-of-bounds in rvu_rep_wq_handler). No public exploit identified at time of analysis and EPSS is low (0.19%, 9th percentile), consistent with niche Marvell SmartNIC hardware rather than mass exposure.
Local privilege escalation or denial of service in the Linux kernel's Intel i915 GPU driver stems from a use-after-free in the TTM object purge path (i915_ttm_purge), where the bo->ttm page-vector container can be replaced by ttm_bo_validate() during eviction, leaving a stale i915_tt pointer that is later dereferenced. A user on DG2 (Intel Arc/discrete) hardware reproduced this as a general protection fault under heavy GPU load during buffer-object eviction. There is no public exploit identified at time of analysis and it is not in CISA KEV, with a low EPSS (0.21%), but the CVSS 7.8 local vector reflects high confidentiality, integrity, and availability impact if the freed memory is groomed and reclaimed.
Extension-denylist bypass in the Flask-Reuploaded (flask_uploads) Python library allows an attacker who controls the name override passed to UploadSet.save() to store dangerous script files by varying letter case (e.g. shell.PHP, evil.pHp), defeating the very script-blocking denylist the library documents. This is an incomplete-fix variant of CVE-2026-27641: the v1.5.0 fix re-validated overridden names through the case-preserving extension() helper instead of the case-normalizing lowercase_ext() used by the default path, so uppercase extensions slip past a lowercase-tokened denylist. Publicly available exploit code exists (a self-contained PoC verified against Flask-Reuploaded==1.5.0), though there is no evidence of active exploitation and no EPSS score was provided.
Unauthenticated Server-Side Request Forgery in the meta-ads-mcp Python package (versions <= 1.0.114) lets remote attackers coerce the server into fetching arbitrary attacker-chosen URLs via the upload_ad_image MCP tool's image_url parameter. The flaw is reachable when the server runs with the officially supported --transport streamable-http mode, because the pre-fetch authorization check only requires a non-empty Bearer token while real Meta credential validation happens after the outbound fetch. Publicly available exploit code exists (a working Docker PoC); this is not in CISA KEV and no EPSS score was provided, so real-world exploitation is unconfirmed, but the vulnerability enables reaching localhost services, RFC 1918 hosts, and cloud metadata endpoints such as 169.254.169.254.
Root-level remote code execution in Canonical's ubuntu-pro-client (formerly ubuntu-advantage-tools) allows an attacker who can spoof or tamper with the Ubuntu Pro contract server response to inject arbitrary APT source lines and install malicious root-owned packages. The client builds /etc/apt/sources.list.d entries from the server's directives.suites[] and directives.aptURL fields via Python str.format() without escaping or newline filtering, and passes additionalPackages[] positionally into a root-run apt-get install. Because the component is preinstalled on supported Ubuntu Server releases and auto-attaches on cloud Ubuntu Pro images the exposure is broad; there is no public exploit identified at time of analysis and it is not listed in CISA KEV.
Stored CSV formula injection in FacturaScripts (all versions through 2026.1) lets an authenticated low-privilege user plant spreadsheet formula payloads in ordinary text fields (customer/supplier/product names, contacts) that execute when an administrator opens a routine list export. Because Core/Lib/Export/CSVExport.php::writeData() wraps values without neutralising leading =,+,-,@,tab, or carriage-return characters, and Tools::noHtml() only strips HTML metacharacters, the payload reaches the CSV verbatim and Excel/LibreOffice run it (including DDE process spawning) in the admin's OS context. A live PoC was verified on 2026-04-30, so publicly available exploit code exists, though there is no active exploitation confirmed (not in CISA KEV).
Unauthenticated arbitrary file read in FacturaScripts (all versions through v2026.2) lets remote attackers retrieve protected documents by abusing the static file controllers Files.php and Myfiles.php, which authorize requests on the raw URL prefix rather than the resolved filesystem path. A request such as /Plugins/../MyFiles/Private/invoice.pdf passes the prefix allow-list yet resolves to a private file, leaking customer/supplier invoices, attachments, and .sql database backups. A detailed, reproducible exploit is publicly available in the GitHub Security Advisory; there is no vendor-released patch identified at time of analysis and no evidence of active exploitation.