Information Disclosure

Information disclosure in Mozilla Firefox's WebGPU graphics component allows remote attackers to read sensitive data - potentially including cross-origin content or GPU memory - by luring a user to a crafted web page. Affected releases are all Firefox versions prior to 155 and Firefox ESR prior to 153.2. Vendor-released patches are available in Firefox 155 and Firefox ESR 153.2; no public exploit code has been identified and the vulnerability is not listed in the CISA KEV catalog.

Cross-origin data exposure in Mozilla Firefox arises from a site-isolation defect in the DOM Navigation component, where origin boundaries are not correctly enforced during navigation, potentially letting a malicious page access data belonging to another origin. It affects Firefox before 155 and Firefox ESR before 153.2, and was fixed by Mozilla in those releases (advisories mfsa2026-82/85/86/88). No public exploit identified at time of analysis; EPSS is low (0.14%, 4th percentile).

Sandbox escape via use-after-free in the Firefox DOM: Security component allows an attacker who lures a victim to a malicious web page to corrupt memory and break out of the browser content sandbox, potentially achieving code execution in a higher-privilege context. All Firefox release and ESR channels prior to the fixed builds are affected. No public exploit identified at time of analysis, and CISA SSVC records exploitation status as none, but the 9.6 CVSS and scope-change sandbox-escape nature make this a high-priority browser update.

Sandbox escape in Mozilla Firefox stems from a use-after-free in the DOM: Navigation component, letting a malicious web page that a user visits corrupt memory and potentially execute code outside the content sandbox. It affects Firefox before 155 and multiple ESR trains (115.x, 140.x, 153.x), carries a critical 9.6 CVSS with a scope change (browser sandbox to host), and requires the victim to load attacker-controlled content (UI:R). No public exploit identified at time of analysis and CISA SSVC lists exploitation as none.

Credential leakage in Kyverno's apiCall service mode automatically forwards the Kubernetes admission controller's ServiceAccount bearer token to any external HTTP endpoint referenced in a policy, including attacker-controlled servers. Affecting Kyverno before 1.16.4 (fix version disputed - see confidence notes), this insecure-by-default behavior requires only policy-creation privileges to exploit: a low-privileged user crafts a ClusterPolicy pointing apiCall.service.url at an attacker-controlled host, then triggers a matching admission event, causing Kyverno to self-exfiltrate its SA token. No public exploit is confirmed in CISA KEV, but a working proof-of-concept with full reproduction steps is embedded in the GitHub security advisory GHSA-8wfp-579w-6r25.

Backdoor / malicious code implant in the Silk Themes 'Newspapers X' WordPress theme (versions 1.0.46 through 1.0.48) allows remote unauthenticated attackers to gain full control of affected sites. The compromised theme distributions ship with implanted malicious software, giving attackers a hidden channel for code execution and complete confidentiality, integrity, and availability compromise (CVSS 10.0). Reported by Patchstack; no public exploit identified at time of analysis and no CISA KEV listing.

Broken authentication in RegistrationMagic WordPress plugin versions up to and including 6.0.9.8 allows unauthenticated network attackers to bypass authentication controls via an alternate path or channel, achieving high confidentiality and integrity impact without any credentials or user interaction. Classified under CWE-288, the flaw enables unauthorized access to registration and submission management functionality that should be gated behind authentication. No public exploit code or CISA KEV listing has been identified at time of analysis, though the CVSS High severity and dual C:H/I:H impact classify this as a priority remediation for any WordPress deployment running the affected plugin.

Server-Side Request Forgery and structured file disclosure in oasdiff-action prior to version 0.0.51 allows unauthenticated remote attackers to make the GitHub Actions runner fetch arbitrary URLs or read filesystem paths by embedding malicious `$ref` entries in an attacker-controlled OpenAPI spec. The vulnerability is directly exploitable via fork pull requests on public repositories, requiring no interaction from maintainers beyond the normal CI workflow execution. No public exploit has been identified, but the fix PRs (128-130) provide a clear technical blueprint of the attack surface.

Authentication bypass in the Ebyte NE2-D11 network device's vendor configuration utility allows an unauthenticated attacker on the adjacent network to reach administrative functions without proving the operator's identity. Under certain credential conditions the attacker can alter critical device settings or change access credentials, locking legitimate administrators out of their own OT/ICS equipment. No public exploit has been identified at time of analysis and the flaw is not listed in CISA KEV, but the CISA ICS advisory (ICSA-26-237-06) confirms the weakness.

Credential exposure in Ebyte NE2-D11 firmware allows an unauthenticated adjacent-network attacker to recover administrative credentials from exported configuration files. The device exports sensitive configuration data - including credentials - without adequate protection (CWE-312: Cleartext Storage of Sensitive Information), meaning any attacker positioned on the local network who can access or intercept an exported configuration file gains valid credentials. Compromised credentials enable direct device access and, where the same credentials are reused, lateral movement to similarly configured Ebyte deployments. No public exploit or CISA KEV listing has been identified at time of analysis.

Unauthenticated remote attackers can trigger a full MySQL database dump on any WordPress site running Keep Backup Daily before version 2.1.4 by invoking the publicly exposed `kbd_cron_process` parameter with no credentials required. The generated dump file is stored in the publicly accessible uploads directory with a partially predictable filename derived from the database name, a limited random value, and the current Unix timestamp - making retrieval via brute-force enumeration feasible. No active exploitation is confirmed in CISA KEV at time of analysis, but the attack requires no privileges or special tooling, making it an immediate data-exposure priority for affected deployments.

Server-side template injection in the Qute template engine's ReflectionValueResolver allows authenticated remote attackers with the ability to influence template content to bypass Java sandbox restrictions and execute arbitrary OS commands on the server. Affected Red Hat products include Red Hat Build of Quarkus, Red Hat Build of Apache Camel 4 for Quarkus 3, and the JBoss EAP Expansion Pack. No public exploit code or CISA KEV entry has been identified at time of analysis, but the CVSS score of 8.8 and full C/I/A impact make this a high-priority patching target for any Quarkus deployment exposing user-influenced template rendering.

Firmware signature verification bypass in Phison PS3111-S11 SATA SSD controller firmware allows an attacker to load arbitrary, attacker-signed firmware onto the drive. Because the controller validates RSA signatures against a public modulus stored inside the firmware image itself instead of an immutable hardware root of trust, an attacker can generate their own RSA key pair, sign malicious firmware, embed the matching modulus, and have the controller accept it as authentic. Publicly available exploit code exists (VulnCheck advisory and the 'psychite' toolkit); there is no public exploit identified as being used in active attacks at time of analysis.

Incomplete CloudTrail event-selector tampering detection in @hulumi/baseline before 1.3.2 (CWE-778: Insufficient Logging) creates blind spots in AWS audit trail monitoring, allowing threat actors who have already modified CloudTrail event selectors to evade detection by the library's checks. The affected npm package misses specific forms of event-selector manipulation, reducing coverage for changes to audit logging configuration - a technique commonly used to suppress evidence of adversarial cloud activity. No active exploitation is confirmed (not in CISA KEV) and no public exploit code has been identified, but the risk is real for security teams relying on this package as a primary CloudTrail integrity control.

Unreviewed code execution in Google Cloud Build (GitHub-triggered builds prior to the 2026-06-24 fix) allowed a remote attacker to bypass the GitHub Trigger Comment Control approval gate via webhook suppression and run attacker-supplied code inside the build environment. The Comment Control feature is meant to require a maintainer's approval comment before a pull request from an outside contributor triggers a build; the flaw let that check be evaded so unapproved code executed. No public exploit identified at time of analysis, and Google states the issue was patched server-side with no customer action required.

Cookie shadowing via unanchored regex in AshAdmin (versions 0.9.1-1.3.0) allows an attacker who controls a sibling subdomain to inject state cookies that rebind an administrator's LiveSocket session to an arbitrary actor, tenant, or authorization mode - effectively bypassing the admin panel's authorization controls. The client-side JavaScript cookie parser used `new RegExp(name + "=([^;]+)")`, which matches any cookie whose name merely ends with the target name, enabling a shadowing cookie (e.g., `xactor_authorizing` over `actor_authorizing`) set from a sibling subdomain with `Domain=.example.com` to silently win. No public exploit or CISA KEV listing exists at time of analysis, but the integrity impact is high for any multi-subdomain deployment.

Credential leakage in ash_ai (versions 0.1.0 through before 1.0.0) exposes embedding provider API keys and request internals to authenticated API callers via unsanitized error messages. In AshAi.Changes.Vectorize, a failed embedding provider call caused the raw Elixir error struct - which HTTP clients commonly populate with the outbound Authorization header, request URL, and provider response body - to be passed through inspect/1 directly into a user-facing changeset error. AshJsonApi and AshGraphql serialize these changeset errors into API responses, making the full credential material readable by any caller who can trigger a provider failure. No public exploit has been identified at time of analysis, but the trigger condition (oversized or malformed vectorized content) is trivially reachable by any authenticated user of an exposed endpoint.

Silent schema cross-contamination in ash_postgres multi-tenancy allows a low-privileged user who can trigger a tenant rename to gain unauthorized read and write access to a different tenant's PostgreSQL schema. Affected versions span 0.25.0 through 2.13.0 of the ash-project/ash_postgres Elixir library. When PostgreSQL rejects the ALTER SCHEMA rename due to a name collision, the library silently reports success, causing the tenant metadata row to be committed pointing at the victim's live schema - routing all subsequent reads and writes for the attacker's tenant against the victim's data. No public exploit code or CISA KEV listing has been identified at time of analysis.

Unauthenticated information disclosure in Admidio before 5.0.12 exposes private forum and announcement content through unprotected RSS feed endpoints. Remote attackers with no credentials can retrieve full post text, titles, author names, and timestamps from modules explicitly configured as login-only, bypassing the intended access restriction entirely. No public exploit code has been identified and the CVE is not in CISA KEV, but the attack requires nothing more than a standard HTTP GET request, making it trivially executable against any reachable instance.

Unauthenticated stream credential disclosure in AVideo (WWBN, commit e01e41ecc and earlier) lets remote attackers retrieve any user's restream stream_key and stream_url for external platforms like YouTube, Facebook, and Twitch. The getLiveKey.json.php endpoint accepts a 'token' parameter that bypasses both the Live::canRestream() access gate and the restream ownership check, and the token is merely AES-256-CBC encryptString() of an integer id with no user binding, expiry, or authentication tag. Because a public encryption oracle (view/url2Embed.json.php) lets anyone encrypt arbitrary values, valid tokens can be forged with no authentication; no public exploit is identified at time of analysis but the technique is fully described.

Credential exfiltration in NextChat 2.15.8-2.16.1 allows unauthenticated network attackers to steal the server's OpenAI API key by exploiting flawed URL validation in the proxy endpoint. The x-base-url header is checked using substring matching rather than hostname parsing, so any URL containing the string 'api.openai.com' - including attacker-controlled domains like 'evil.attacker.com/api.openai.com' - passes validation and causes NextChat to forward the OpenAI API key in the Authorization header to the attacker's server. No public exploit identified at time of analysis, though a GitHub issue documenting the flaw is publicly accessible.

Authentication bypass in oidcc (Erlang/Elixir OpenID Connect library) versions 3.2.0-beta.1 through before 3.9.0 allows unauthenticated attackers to impersonate arbitrary users by presenting a JWE-encrypted ID token or JARM response that wraps unsigned claims, which the library incorrectly accepted as fully validated. The relying party's public encryption key - typically published at a well-known JWKS endpoint - is all an attacker needs to forge tokens with arbitrary sub, iss, and aud values, bypassing provider signing-key possession entirely. No public exploit has been identified at time of analysis, and this CVE is not listed in CISA KEV; however, the impact for affected deployments using encrypted ID tokens or JARM is complete authentication bypass.

Privilege escalation in su-exec through version 0.3 allows local attackers with low-privilege access to execute arbitrary programs as root by supplying crafted oversized numeric user or group identifiers. The root cause is an unchecked integer truncation: strtol() returns a 64-bit long on modern Linux, but su-exec assigns the result directly to uid_t and gid_t (32-bit unsigned integers) without range validation - values like 4294967296 (2^32) silently truncate to UID/GID 0, the root account. A public proof-of-concept is available and no vendor-released patch has been identified at time of analysis, making this an active remediation gap for container deployments dependent on su-exec.

Unauthenticated remote control of Argo CD in argocd-mcp 0.8.0, the Model Context Protocol server for Argo CD, arises because the HTTP transport binds to all network interfaces and accepts MCP sessions without any caller credential once ARGOCD_API_TOKEN is set. Any attacker with network reach to the listener can drive the full MCP tool surface under the operator's stored token to create applications, trigger syncs, and mutate Argo CD resources. Rated CVSS 10.0 by VulnCheck; no public exploit identified at time of analysis, and it is not listed in CISA KEV.

Cleartext password storage in rust-iot-platform (through commit 5df942ab) enables unauthenticated network attackers to harvest plaintext credentials for every registered account by querying standard user retrieval and listing API routes. The root cause is CWE-256: the user model persists passwords without hashing, and those fields are then serialized into API responses without sanitization. No public exploit code or CISA KEV listing has been identified at time of analysis, but the triviality of exploitation - a plain HTTP GET to an exposed endpoint - makes CVSS 4.0's 8.7 score a credible reflection of real-world risk for any internet-exposed deployment.

Unauthenticated information disclosure in the HEL Online Classroom WordPress plugin (versions ≤ 1.0.3) exposes the BigBlueButton shared secret through an unprotected REST API route, enabling any remote attacker to retrieve stored plugin settings without credentials. With the exposed shared secret, an attacker can forge valid HMAC-signed API requests directly against the connected BigBlueButton server, allowing unauthorized access to or disruption of virtual classroom sessions. No public KEV confirmation exists, but a public exploit is available via WPScan; EPSS is low at 0.14%, consistent with the plugin's niche footprint.

Improper certificate validation in Cloud Foundry's bosh-vsphere-cpi-release exposes vCenter administrator credentials to any attacker with a network position between the BOSH Director and vCenter. The vSphere CPI transmits credentials via HTTP Basic authentication on every routine cloud infrastructure operation and fails to enforce TLS certificate authenticity, allowing a rogue endpoint to impersonate the vCenter REST API and silently capture those credentials. Successful interception yields full administrative control over every virtual machine, datastore, and network segment managed by the compromised vCenter instance. No public exploit code has been identified at time of analysis, and this CVE does not appear in the CISA KEV catalog.

Log-record tampering in Graylog's FortiGate syslog parser enables unauthenticated network senders to overwrite or erase critical security-log fields - including srcip, dstip, date, time, and tz - or cause entire log messages to be silently discarded, creating a viable log-evasion primitive. Affected are Graylog Server versions prior to 6.3.12, 7.0.7, and 7.1.2 (all branches), and Graylog Forwarder prior to version 7.3, on any deployment ingesting FortiGate key-value syslog. No public exploit code exists and this is not in CISA KEV, but the attack requires no authentication and minimal crafting skill, making it a realistic threat to security-monitoring integrity in FortiGate-centric environments.

Privilege escalation via session fixation in IBM Administration Runtime Expert (ARE) for i, version 1R1M0, lets a remote attacker cause actions to run under another user's authenticated profile through flawed handling in the ARE GUI component, yielding elevated privileges on the IBM i host. The description characterizes the attacker as unauthenticated, though the CVSS 3.1 vector (PR:L) implies some low-privilege foothold - this signal conflict should be confirmed with IBM. No public exploit identified at time of analysis, and it is not on CISA KEV; EPSS was not provided.

Unauthenticated connection exhaustion in MongoDB Connector for BI allows any network-reachable client to hold authentication sessions open indefinitely by initiating a SASL login exchange and then withholding further data. The absence of a wall-clock timeout on the negotiation loop and no read deadline on the client socket means each such session permanently occupies a worker thread, a connection slot, and associated backend MongoDB handles until the process is restarted. Sustained repetition of this pattern can exhaust the configured connection pool capacity entirely, denying service to all legitimate BI tool users; no public exploit has been identified at time of analysis.

Mongosqld in the MongoDB BI Connector requests but does not enforce client certificates during the TLS handshake when configured with a CA file, silently accepting connections from clients that present no certificate at all. Deployments that rely on client certificate authentication as the sole means of identifying users are fully exposed - any remote party with network access to the listener can establish a session and read all MongoDB data surfaced through the SQL interface. The CVSS 4.0 score of 8.7 reflects the network-accessible, zero-privilege nature of the flaw; no public exploit code or CISA KEV listing has been identified at time of analysis, and real-world impact is bounded by a specific non-default configuration prerequisite.

Log storage exhaustion in MongoDB Connector for BI (mongosqld) allows any unauthenticated network peer to crash the shared process by generating sufficient connection log volume to fill the configured log path's backing storage. When a subsequent log write or rotation operation fails, an uncaught exception (CWE-248) terminates the mongosqld process, immediately denying SQL service to all connected clients. The process cannot recover autonomously - it continues to fail on startup until an operator manually reclaims disk space - and the diagnostic message explaining the condition is never persisted, compounding operational triage difficulty. No active exploitation has been identified at time of analysis.

Credential disclosure in the MariaDB Connector for Node.js (npm: mariadb) exposes plaintext database passwords to active network attackers when SSL/TLS is configured without a CA or server certificate. Fingerprint-based server identity validation is sequenced after the authentication exchange, so a man-in-the-middle presenting any certificate receives the password before the connection is ultimately rejected and closed. Affected branches span all releases below 3.2.4, 3.3.3, 3.4.6, and 3.5.3; no CISA KEV entry or public proof-of-concept exists at time of analysis, though the flaw is structurally exploitable by any on-path attacker against the specific misconfiguration.

Credential store overwrite in NousResearch Hermes Agent versions 0.16.0 through pre-0.17.0 is achievable by any attacker who can inject content into messages ingested by the agent, exploiting a gap in the sensitive-path guard (CWE-552) that failed to properly exclude auth.json from the file-write tool's reachable paths. By crafting malicious message payloads, an attacker bypasses the path restriction and overwrites the credential store without triggering any protection, resulting in credential tampering and potential unauthorized access to all identities stored therein. No public exploit has been identified at time of analysis, and a vendor-released patch (v0.17.0) is available.

Privilege escalation in piccolo_admin 1.13.0 and earlier allows any non-superuser admin to permanently elevate to superuser by exploiting a two-flaw chain: the `superuser_validators` access-control function uses a deny-list that omits GET, and the `SessionsBase.token` column is stored as plaintext Varchar without `secret=True`, causing it to appear in every GET /api/tables/sessions/ response. An authenticated low-privilege admin can harvest the superuser's live session token in a single unauthenticated-to-superuser GET request, replay it to issue a PATCH that sets `superuser=true` on their own row, and permanently retain elevated access - the stolen cookie is then discarded. A publicly available proof-of-concept with full reproduction steps was included in the GitHub security advisory (GHSA-2gh4-jmwq-rr8w); no CISA KEV listing is present at time of analysis.

Missing function-level access control in Yamcs Core's REST API allows any authenticated user - including completely unprivileged 'Guest' accounts - to bypass the platform's RBAC system across three distinct API controllers. Affected endpoints in IndexesApi, Cop1Api, and TimeApi omit authorization checks entirely, enabling telemetry metadata exfiltration, disruption of COP-1 satellite telecommand protocols, and manipulation of global simulation time. Publicly available exploit code (curl-based PoC) confirms exploitability; the vulnerability is not currently listed in CISA KEV, though the spacecraft operations context elevates real-world impact severity.

Cross-tenant IDOR in Vikunja's kanban task-placement endpoint (POST /api/v1/projects/{project}/views/{view}/buckets/{bucket}/tasks) allows any authenticated user to read the complete contents of any task on the instance and partially mutate its state, defeating Vikunja's project-isolation model. The authorization check in TaskBucket.CanUpdate validates only the URL-scoped project and bucket, never the attacker-controlled task_id supplied in the JSON body; because task IDs are a global sequential integer space, brute-force enumeration of all instance tasks is trivial. This is the fifth documented instance of the same missing-authorization-on-task-child class in Vikunja (siblings: CVE-2026-33676, CVE-2026-33678, CVE-2026-33313, CVE-2026-35598); the vendor-confirmed fix ships in v2.4.0 and no public exploit beyond the detailed advisory proof-of-concept has been identified at time of analysis.

Cross-origin credential exposure in HeyForm before 3.0.0-rc.8 allows any attacker-controlled web page visited by a logged-in user to make fully authenticated GraphQL API requests against the HeyForm server. The server's default CORS configuration (`origin: true, credentials: true`) unconditionally echoed the request Origin header back as `Access-Control-Allow-Origin` while also asserting `Access-Control-Allow-Credentials: true`, defeating the browser's same-origin policy for all origins. This exposes workspaces, projects, forms, submissions, and respondent data to exfiltration and permits account settings modification; no public exploit has been identified at time of analysis.

Credential disclosure in AUTOMATIC1111 Stable Diffusion WebUI through version 1.10.1 exposes configured authentication credentials to unauthenticated network attackers via the `/sdapi/v1/cmd-flags` REST endpoint. The endpoint serializes all runtime command-line arguments - including `gradio_auth` and `api_auth` values - into a cleartext JSON response with no access control, directly nullifying the authentication protection those flags are meant to provide. No public exploit or active exploitation has been confirmed, but the attack path is a single unauthenticated HTTP request to a known endpoint, making this a high-priority finding for any publicly reachable deployment.

AES-GCM nonce reuse in wolfEngine before 1.4.1 allows a network-positioned passive adversary to fully recover encrypted plaintext and forge authentication tags across all TLS 1.2 and DTLS 1.2 sessions. The 8-byte explicit nonce is generated once at TLS write-key setup and never incremented per record, meaning every GCM record within a connection shares an identical (key, nonce) pair - a catastrophic misuse of authenticated encryption. AES-CCM cipher suites, TLS 1.3, and non-TLS uses of AES-GCM are explicitly unaffected; no public exploit identified at time of analysis.

Nonce reuse in wolfProvider before 1.2.2 completely breaks AES-GCM confidentiality and integrity guarantees for every TLS 1.2 and DTLS 1.2 connection using that cipher suite. Because the 8-byte explicit nonce is set once at key establishment and never incremented, every record in a session is encrypted under an identical (key, nonce) pair - the classical 'forbidden attack' condition where XORing two ciphertexts yields the XOR of the plaintexts, and the GHASH authentication key can be algebraically recovered to enable tag forgery. No active exploitation is confirmed in CISA KEV, and no public proof-of-concept has been identified at time of analysis; however, the attack is well-understood cryptography with no special tooling required beyond captured traffic.

Improper access control (CWE-305) in the PaperCut MF and PaperCut NG web management interface allows unauthenticated remote attackers to trigger backend administrative operations before access validation completes, enabling unauthorized modification of system configurations. The CVSS 4.0 vector rates this AV:N/AC:L/PR:N/UI:N with high integrity impact, indicating network-exploitable, zero-authentication exploitation with no user interaction required. No public exploit code or CISA KEV listing has been identified at time of analysis, though PaperCut products have historically been high-value ransomware targets.

Credential theft in gitoxide's curl-based HTTP transport backend allows attackers to capture authentication tokens (passwords, OAuth tokens) by exploiting a URL validation flaw during HTTP redirects. Affected are gitoxide versions 0.25.4 through 0.55.0 using the curl backend; the reqwest backend implements correct cross-domain redirect blocking and is not affected. An attacker who controls or can influence a redirect response from a git server can cause gitoxide to send the victim's full credentials to an attacker-controlled host on subsequent POST requests. No public exploit code has been identified at time of analysis, and the vulnerability is not listed in CISA KEV.

Denial-of-service in gitoxide's gix-pack crate before 0.69.0 exposes Rust Git clients to remote process crashes during clone or fetch operations via two distinct attack vectors. Unchecked array indexing in the delta application routine causes index-out-of-bounds panics on truncated pack data, while uncapped buffer allocation from attacker-controlled LEB128 size headers allows a 10-byte crafted pack entry to trigger an immediate out-of-memory process kill - both exploitable by any Git server the victim connects to. No active exploitation has been confirmed (not in CISA KEV), but the unauthenticated, network-reachable attack surface with trivial complexity makes this a high-priority patch for any environment running automated clone or fetch workflows against external remotes.

Index-out-of-bounds panic in gitoxide's gix-packetline library (versions before 0.21.5) allows a malicious Git server to abort the client process during fetch operations by sending a crafted side-band packet line with an empty payload. The TextRef implementation fails to handle zero-length payloads, triggering an unconditional Rust panic that terminates the connecting client. No authentication is required on the attacker's side; the victim need only initiate a fetch or clone against a hostile server. No public exploit code or CISA KEV listing identified at time of analysis.

Credential exfiltration in gitoxide's gix-transport crate allows a server controlling an HTTP redirect response to steal the caller's HTTP Basic Authorization credentials by exploiting a hand-rolled URL parser in gix-url that misidentifies the authority component of crafted redirect URLs. Affected are gix-url versions ≤ 0.32.0 and gix-transport versions ≤ 0.49.0; the redirect identity guard `can_reuse_identity` fails open when the parser does not treat '?' or '#' as authority terminators per RFC 3986, causing credentials to be forwarded to an unintended host. No public exploit has been identified at time of analysis, though the CVSS 4.0 score of 8.7 reflects a full confidentiality impact with no authentication prerequisites.

vmclock in the Linux kernel exposes a shared ABI memory page that a low-privileged guest process can upgrade from read-only to writable using mprotect(), allowing direct corruption of host-maintained timekeeping fields including sequence counters, UTC time, and TSC offsets. Affected deployments are virtualized Linux guests running kernels prior to patched stable releases 6.18.47, 7.2.1, and 7.1.11, where the vmclock miscdevice driver fails to clear VM_MAYWRITE on read-only mmap paths. No public exploit code has been identified at time of analysis, and EPSS at 0.15% (5th percentile) reflects low observed exploitation pressure despite a CVSS 8.8 score driven by the scope-changing guest-to-host integrity impact.

Out-of-bounds memory write in the Linux kernel's device tree reserved memory subsystem allows an attacker with control over device tree content to corrupt kernel memory at boot time, with theoretical full kernel compromise (C:H/I:H/A:H). The fdt_scan_reserved_mem() function writes past the end of a fixed-size local array when a device tree blob defines more dynamically-placed /reserved-memory subnodes than MAX_RESERVED_REGIONS allows. Despite a CVSS score of 8.4, exploitation is heavily constrained by the requirement to modify device tree content before boot - a capability requiring privileged firmware access - and EPSS at 0.16% (5th percentile) reflects negligible observed exploitation probability. No public exploit has been identified and the vulnerability is absent from CISA KEV.

Insufficient validation of S1G (802.11ah/Wi-Fi HaLow) Target Wake Time setup frames in the Linux kernel's mac80211 subsystem allows an unauthenticated adjacent-network attacker to submit a malformed individual TWT agreement whose parameter block is shorter than the full struct ieee80211_twt_params. The driver callback drv_add_twt_setup() and associated kernel tracepoint both consume the complete parameters structure regardless of the truncated length, potentially triggering kernel memory corruption, out-of-bounds reads exposing sensitive kernel memory, or a denial-of-service crash. No public exploit code has been identified, CISA KEV listing is absent, and patches are confirmed across seven stable kernel branches; real-world exposure is substantially narrowed by the requirement for S1G hardware.

Dangling pointer dereference in the Linux kernel Bluetooth ISO subsystem exposes systems running kernel versions prior to 6.18.44, 7.1.8, and 7.2 to potential kernel memory corruption from adjacent Bluetooth attackers. After iso_conn_del() is invoked, ISO sockets may continue to dereference the freed hcon (HCI connection) pointer due to imprecise reference-counting logic, creating a use-after-free-class condition in kernel space. Despite a high NVD CVSS score of 8.8, the EPSS rating of 0.15% (5th percentile) and absence from CISA KEV indicate no public exploit or observed active exploitation at time of analysis.

Deadlock in the Linux kernel's iomap subsystem allows local attackers to cause a denial of service by exhausting the shared bioset used by both iomap_split_ioend and its input bios. The circular dependency in bioset allocation halts I/O completion on iomap-backed filesystems (XFS, ext4 direct I/O) and can hang the affected system. No active exploitation has been confirmed (not in CISA KEV) and the EPSS probability is very low at 0.15% (5th percentile), but the impact on availability is total for the affected I/O path.

Out-of-bounds read in the Linux kernel SCTP subsystem leaks up to four bytes of receive-buffer tail memory to remote unauthenticated attackers via a malformed INIT chunk. When an Adaptation Layer Indication parameter is sent with only its 4-byte header (omitting the mandatory 32-bit Adaptation Code Point), the kernel reads past the declared parameter boundary and copies those bytes into the state cookie of the INIT ACK response, exposing them to the peer. No public exploit has been identified and EPSS of 0.16% (6th percentile) indicates low exploitation probability, though the unauthenticated, network-accessible attack surface on any SCTP-enabled system warrants prompt patching.

Use-after-free in the Linux kernel ALSA PCM subsystem allows a local low-privilege attacker to corrupt kernel memory by exploiting a race between snd_pcm_drain() and snd_pcm_unlink() on linked streams. When a drain wait terminates by signal or timeout while group membership is concurrently modified by an unlink, a stack-allocated wait queue entry is left queued on a freed peer stream's sleep list; a subsequent wake_up() call then dereferences that freed stack frame. No public exploit code or CISA KEV listing exists at time of analysis; the EPSS of 0.16% (6th percentile) reflects low near-term exploitation probability.

Use-after-free in the Linux kernel's IPVS (IP Virtual Server) connection-synchronization path allows corruption of the connection hash table on backup directors running the IPVS sync daemon. When a synced connection is bound to a destination that carries the IP_VS_CONN_F_ONE_PACKET flag, expiry logic wrongly skips unlinking the conn_tab node, leaving a stale hash entry pointing at a freed struct ip_vs_conn. There is no public exploit identified at time of analysis and EPSS is very low (0.16%), so despite the auto-assigned 9.8 rating this is a memory-safety defect in a specialized load-balancing feature rather than a broadly weaponizable RCE.

Restriction bypass in the Linux kernel's io_uring subsystem allows a local low-privileged user to shed per-task io_uring security restrictions by executing exec(). When a task that has established io_uring restrictions calls exec(), the kernel's exec cancellation path invokes __io_uring_free(), which incorrectly frees both the task context and the per-task restriction simultaneously. Any io_uring ring created by the post-exec process is then entirely unrestricted, defeating sandbox and policy enforcement intended to constrain io_uring operations. No public exploit has been identified at time of analysis, but the CVSS score of 8.4 with Changed Scope (S:C) reflects that the bypass can expose confidentiality and integrity of resources guarded by the dropped restrictions.

The spi-qpic-snand NAND flash driver in Linux kernel 6.18 and later contains a command-ordering defect that causes every SET_FEATURE write to apply the previous operation's value rather than the intended one, producing an off-by-one effect. On Qualcomm IPQ5018-based hardware (confirmed on TP-Link Archer AX55 v1 with ESMT F50L1G41LB flash), this defect became destructive in v6.18 when SPI-NAND OTP support was introduced: the 'disable OTP mode' call erroneously leaves CFG_OTP_ENABLE set permanently, causing all subsequent flash reads to return OTP area content and all writes to fail with -EIO, rendering the device unbootable. No public exploit identified at time of analysis; EPSS of 0.15% (5th percentile) correctly reflects that this is a driver logic defect rather than a traditionally attacker-controllable vulnerability.

Heap out-of-bounds memory access in the Linux kernel s390/zcrypt subsystem exposes EP11 crypto card administrative paths to local low-privileged users. The flaw resides in the domain value upper-limit check processed when sending EP11 CPRBs (Control Program Request Blocks) through custom zcrypt device nodes - the missing AP_DOMAINS (256) ceiling allows an attacker-supplied domain index to reach heap memory beyond the `perms->adm` structure. No public exploit code has been identified and this is not listed in CISA KEV, but the CVSS 7.8 local vector and confirmed multi-version patch backports across stable kernel branches indicate the Linux security team treats the impact as high. EPSS at 0.16% (6th percentile) reflects the platform-specific nature of the flaw.

Uninitialized receive buffer allocation in the Linux kernel's CAN J1939 transport layer exposes residual kernel heap memory to J1939 session participants. The function j1939_session_fresh_new() allocates a buffer without zeroing it, meaning any system running a CAN-capable Linux kernel with J1939 transport support may leak prior heap contents to peers exchanging Extended Transport Protocol (ETP) messages. No public exploit has been identified at time of analysis, and EPSS sits at 0.16% (6th percentile), consistent with a low-exploitation-probability kernel information-disclosure flaw in a specialized networking subsystem.

Out-of-bounds read and write vulnerabilities in the Linux kernel's softing CAN driver `fw_parse()` function allow a local low-privileged attacker to corrupt kernel DPRAM memory by supplying a crafted firmware image. Affected kernels span from 2.6.38 through pre-patch stable branches (5.10.x, 5.15.x, 6.1.x, 6.6.x, 6.12.x, 6.18.x, 7.1.x, and 7.2), with fixes backported across all active stable trees. No public exploit or active exploitation has been identified at time of analysis.

Memory corruption in the Linux kernel's VMware graphics (vmwgfx) DRM driver allows a local, low-privileged user on a VMware guest system to corrupt MOB (Memory Object Buffer) allocation metadata, leading to out-of-bounds reads or writes with high confidentiality, integrity, and availability impact. A field-naming bug in vmwgfx_resource.c writes boolean literals (0/false and 1/true) to the guest_memory_size unsigned-long field instead of the adjacent guest_memory_dirty bitfield, causing subsequent size-dependent operations to compute zero-length or wrap-around memory ranges on the MOB bitmap. No public exploit has been identified at time of analysis; EPSS is very low at 0.17% (6th percentile), though the CVSS 7.8 score reflects meaningful severity if triggered locally on a VMware guest.

Use-after-free in the Linux kernel Bluetooth HCI sync subsystem exposes systems running vulnerable kernel versions (6.6.51-pre-6.7 and 6.8.9-pre-6.9) to potential kernel-context memory corruption from an adjacent attacker with no privileges required. The race condition occurs when hci_connect_acl/le_sync() callbacks dereference a freed hci_conn object during concurrent connection teardown, yielding a theoretical path to arbitrary code execution or kernel panic. No public exploit code has been identified at time of analysis, and EPSS at 0.15% (5th percentile) indicates very low observed exploitation activity.

Null pointer dereference in the Linux kernel's SCSI target iblock driver crashes the kernel when processing Persistent Reservation PREEMPT or RELEASE operations against storage backends with unimplemented PR hooks. Systems running the kernel as an iSCSI target are vulnerable - an attacker who can issue SCSI Persistent Reservation commands can trigger a kernel panic, causing a complete denial of service. No public exploit has been identified and EPSS sits at 0.17% (6th percentile), but patches are available across multiple stable branches and should be applied promptly on iSCSI target infrastructure.

Out-of-bounds vmemmap read in the Linux kernel's mm/util snapshot_page() crashes or leaks kernel memory during page isolation on memory-remove paths. The function incorrectly reads __page_2 when nr_pages > 1 rather than the correct threshold of nr_pages > 2, causing an illegal access into an adjacent, unmapped vmemmap section when an order-1 folio sits at a vmemmap section boundary. This was observed producing a kernel oops on ppc64le systems during DLPAR memory remove on a 22 TB LPAR. No public exploit is identified and EPSS is 0.17%, but the defect can cause a local denial-of-service or kernel memory disclosure. Patches are available across multiple stable kernel branches.

Denial-of-service in the Linux kernel's KVM subsystem on IBM Z (s390) mainframes stems from an unchecked airq_iv_create() return value in the zPCI adaptive-interrupt path. When AIBV allocation fails, zdev->aibv is left NULL and later dereferenced in kvm_zpci_set_airq(), crashing the host kernel. No public exploit identified at time of analysis and it is not in CISA KEV; EPSS is low at 0.17% (7th percentile), consistent with a hard-to-trigger, resource-exhaustion-dependent bug rather than a broadly weaponizable flaw.

Use-after-free in the Linux kernel Bluetooth SCO subsystem allows an adjacent unauthenticated attacker to corrupt freed kernel memory by exploiting a reference-counting race between socket close() and Bluetooth controller Disconnection Complete events. The race causes sco_conn_del() to perform a double put on a kref, confirmed by KASAN as slab-use-after-free, with potential to escalate privileges or crash the system. No public exploit or CISA KEV listing exists; EPSS is 0.17% (6th percentile), consistent with the race condition complexity limiting practical exploitation.

Incorrect unit conversion in the RISC-V memory management subsystem causes vmemmap_start_pfn to be computed with a physically misaligned base, violating the mask-alignment requirement for compound_info encoding in the sparse memory model. Linux kernel versions incorporating commit 476849b0fba4 on RISC-V hardware where DRAM base is not aligned to MAX_FOLIO_NR_PAGES × PAGE_SIZE are affected - a condition confirmed on QEMU virt machines and potentially other RISC-V platforms. CVSS 7.8 (AV:L/PR:L/C:H/I:H/A:H) reflects potential local privilege escalation via kernel memory corruption; EPSS of 0.17% (7th percentile) and no CISA KEV listing indicate no observed exploitation activity. No public exploit is identified at time of analysis.

Use-after-free in the Linux kernel's VXLAN transmit path (vxlan_xmit) lets a stale Ethernet header pointer be dereferenced after route_shortcircuit() calls pskb_may_pull() and reallocates skb->head, corrupting or reading freed memory when accessing eth->h_dest. The flaw affects systems using a VXLAN overlay interface and is most realistically a denial-of-service (kernel crash) with potential information disclosure; no public exploit identified at time of analysis and EPSS is low (0.18%). It is not listed in CISA KEV and no proof-of-concept is known.

Use-after-free in the Linux kernel's AMD MP2 I2C driver (i2c-amd-mp2) enables local low-privileged users to corrupt kernel memory, potentially achieving privilege escalation or system crash on AMD hardware. The flaw occurs during driver probe: when i2c_add_adapter() fails, devres frees the platform I2C context, but the MP2 PCI driver retains a stale pointer in its IRQ and system-sleep callback table, allowing subsequent dereference of freed memory. No public exploit exists and EPSS is 0.18% (7th percentile), reflecting the hardware-specific and error-path-dependent nature of this flaw; vendor-released patches are available across all major stable kernel branches.

Race condition in the Linux kernel's driver core `dev_has_sync_state()` exposes a TOCTOU (Time-of-Check Time-of-Use) flaw allowing local low-privileged users to potentially trigger kernel memory corruption, information disclosure, or a system crash. The function reads `dev->driver` twice without holding `device_lock()`, enabling a concurrent device unbind operation to clear the pointer between the NULL check and its subsequent dereference, resulting in use of a stale or NULL pointer in kernel context. No active exploitation has been identified (no CISA KEV listing, EPSS 0.18%), but the kernel-level impact class warrants prompt patching on affected stable branches.

The BPF signed loader in the Linux kernel fails to enforce map exclusivity before performing SHA-based integrity validation of metadata maps, allowing a local attacker with BPF privileges to race a mutation of the shared map's contents after the hash is computed but before validation completes. Systems running Linux kernel between commit fb2b0e290147ba01a53dfd92cf91058c9d2ee254 and the patched stable releases (6.18.40, 7.1.5, 7.2) are affected. Exploitation bypasses the integrity guarantees of the signed BPF loader, enabling the attacker to make the check pass on stale, attacker-controlled data; no public exploit exists and EPSS is 0.17% (6th percentile), indicating low current exploitation probability.

Use-after-free / stale-pointer race in the Linux kernel netfilter nf_conntrack_expect subsystem was resolved by replacing the per-expectation timer API with the conntrack garbage-collection worker. Under the old timer scheme, expectation removal could lose a race with an expiring timer (timer_del() returning false), leaving an expectation referencing an already-released exp->master conntrack, enabling stale-pointer access. The issue affects systems using connection-tracking helpers/expectations (e.g. FTP, SIP, or nft_ct expectations); no public exploit identified at time of analysis and it is not listed in CISA KEV, with a very low EPSS of 0.15% (5th percentile).

Symlink-based file clobbering in the Linux kernel's intel-speed-select daemon allows a local low-privileged user to redirect root-process writes to an attacker-chosen file by pre-positioning a symlink at the daemon's fixed /tmp pidfile path. Affected systems are those running Linux 5.18 through unpatched 6.x and 7.x branches on Intel Speed Select Technology hardware with the daemon active. No public exploit is identified at time of analysis and EPSS is low (0.17%, 7th percentile), but the attack is mechanically simple and requires only a local shell account.

Kernel stack disclosure and potential denial-of-service affect Linux systems with CXL hardware due to an off-by-8 size constant in the CXL RAS capability subsystem introduced in Linux 6.2. A local user who can trigger a CXL AER uncorrectable error and read tracefs can obtain up to 448 bytes of adjacent kernel stack data - potentially including code pointers and sensitive in-flight values - from the tracefs ring buffer. No public exploit identified at time of analysis; EPSS at 0.17% (6th percentile) reflects the niche CXL hardware dependency and local-only attack vector.

Uninitialized-value access in the Linux kernel's HFS+ filesystem driver allows a local attacker with mount privileges to trigger kernel memory corruption or information disclosure by supplying a crafted disk image containing an invalid btree node_size. The flaw is reached during the mount path - specifically in hfsplus_bnode_find() while loading the HFS+ catalog B-tree - when a corrupted node_size value (e.g., 1) causes an excessively large offset to be passed to hfs_bnode_read_u16(), resulting in use of uninitialized stack memory. No public exploit has been identified and EPSS is 0.15% (5th percentile); upstream stable patches are available at git.kernel.org.

Race condition in the Linux kernel's hisi_sas v3 hardware driver triggers a kernel WARNING and potential memory corruption when SAS phy link reset and driver removal (rmmod) execute simultaneously. Specifically, during SAS phy bring-up, device_links_driver_bound sets the link status to DL_STATE_AVAILABLE, and a concurrent rmmod then causes __device_links_no_driver() to encounter an inconsistent device-link state. No public exploit exists and EPSS sits at 0.17% (6th percentile), reflecting this is a hardware-specific, privilege-intensive, timing-dependent flaw with very low exploitation likelihood in practice.

NULL pointer dereference in the Linux kernel IPv6 subsystem - specifically in `__in6_dev_stats_get()` - can crash the kernel and cause a denial of service when a physical network device is unregistered while IPv6 statistics are being collected. The vulnerability affects a wide range of stable kernel branches, from 4.19 through 7.x, and has been patched across all active LTS trees. No active exploitation is confirmed (not in CISA KEV) and EPSS at 0.18% (7th percentile) reflects low current real-world exploitation interest, though the ubiquitous deployment of the Linux kernel makes patch cadence important.

Invalid pointer dereference in the Linux kernel's RapidIO TSI721 driver allows an unauthenticated attacker on an adjacent RapidIO network to crash the kernel or corrupt memory by sending a crafted doorbell message. The root cause is a logic error in tsi721_db_dpc(): the 'found' flag is not reset at the start of each list_for_each() iteration, causing every doorbell after the first match to be treated as found, and causing list-end traversal with an invalid iterator pointer when no match exists. No public exploit exists and EPSS is 0.18% (7th percentile), consistent with the highly constrained physical attack surface; patches are available across multiple stable kernel branches.

Out-of-bounds stack read in the Linux kernel's netfilter flowtable (nf_flow_table / nft_dev_forward_path) affects the bridge VLAN-untag fast path, where a u8 num_encaps counter can underflow from 0 to 255 and cause the kernel to walk a fixed 2-entry encap[] array far past its bounds. Affected are kernels from 5.13 onward that use netfilter flowtable offload over bridge devices; the flaw leaks adjacent kernel stack memory into a route descriptor and copies a bogus encap count. No public exploit is identified at time of analysis, EPSS is low (0.15%), and it is not in CISA KEV.

Missing dma_resv lock acquisition before dma_buf_unpin() in the Linux kernel iommufd subsystem causes a kernel WARN on every IOAS destruction or unmap path that releases the last reference to a DMABUF-backed iopt_pages object. Affected are kernel versions from the commit introducing DMABUF pinning in iommufd (8c5f9645c389) through the fix commits in the 7.1 and 7.2 stable trees, with patches confirmed at Linux 7.1.5 and 7.2. No public exploit or active exploitation has been identified; EPSS is 0.15% (5th percentile), indicating negligible automated exploitation probability 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.

Race condition in the Linux kernel's ALSA OSS sequencer layer exposes local low-privilege attackers to kernel ring-buffer state corruption via unsynchronized reset operations. Specifically, snd_seq_oss_readq_clear() modifies qlen, head, and tail fields without holding q->lock, racing against reader and producer paths that correctly acquire the spinlock, potentially leaving stale or dropped MIDI events and corrupted readiness state. No public exploit identified at time of analysis; EPSS at 0.17% (6th percentile) indicates negligible current exploitation interest despite the CVSS 7.8 score reflecting theoretical kernel memory corruption severity.

Use-after-free and race condition vulnerabilities in the Linux kernel's tlclk (Telecom Clock) character driver expose local low-privileged users to potential kernel-space memory corruption, privilege escalation, or system crash. The module cleanup function tlclk_cleanup() frees alarm_events memory before awakening blocked waitqueue readers and before the switchover_timer completes, creating a use-after-free window during concurrent module unload. Additionally, the missing .owner field in file_operations allowed module unloading while userspace held the device open. No public exploit exists and EPSS is 0.18%, but patched kernel versions are confirmed across all active stable branches.

Use-after-free in the Linux kernel AppArmor subsystem's aa_replace_profiles function exposes kernelspace memory to corruption by a local low-privileged attacker. The defect arises from reading udata->size after aa_put_loaddata(udata) has released the reference - if that release triggers a free, the subsequent read constitutes a UAF that can be leveraged for privilege escalation or arbitrary kernel memory manipulation. EPSS sits at 0.18% (7th percentile) and no CISA KEV listing exists, indicating no confirmed widespread exploitation, though the local-access, low-complexity nature makes this a realistic intrahost threat on AppArmor-enabled systems.

Use-after-free in the Linux kernel's veth driver XDP error path allows a local attacker with network interface configuration privileges to corrupt kernel memory, potentially achieving privilege escalation. The flaw stems from an off-by-one error in the rollback loop during XDP enablement: when xdp_rxq_info_reg() or xdp_rxq_info_reg_mem_model() fails, the loop skips netif_napi_del() for the failing queue index, leaving a dangling napi_struct in the device's napi_list. On subsequent device teardown, the freed - and potentially reallocated - queue memory is traversed via the stale NAPI list, resulting in UAF with full C/I/A impact. No public exploit or CISA KEV listing has been identified at time of analysis; EPSS is 0.17% (7th percentile), reflecting low current exploitation probability.

Metadata corruption in the Linux kernel's lightweight tunnel (LWT) subsystem affects forwarded packets that carry XDP/TC skb metadata when they pass through LWT encapsulation (seg6, rpl, ila, mpls, ioam6, or BPF LWT xmit). Because encapsulation prepends outer headers over the skb headroom where metadata lives, non-BPF encaps silently overwrite it while BPF LWT xmit triggers a skb_data_move() WARNING and clears it; the fix drops metadata at the three LWT dispatch chokepoints before handing the skb to the encap op. There is no public exploit identified at time of analysis, EPSS is low (0.15%), and the nominal CVSS 9.8 appears substantially overstated for what is fundamentally a kernel data-path robustness fix.

Use-after-free race condition in the Linux kernel's amdxdna AMD AI accelerator driver allows a local low-privileged user to trigger kernel memory corruption by racing device removal against GEM object deallocation, potentially achieving full kernel privilege escalation. The flaw is specific to deployments where force_iova mode is enabled in the amdxdna driver, limiting the real-world exposure to systems with AMD XDna-capable hardware. No CISA KEV listing and no public proof-of-concept exist; EPSS of 0.15% (5th percentile) confirms this remains a theoretical priority rather than an active exploitation concern.

Use-after-free in the Linux kernel's batman-adv mesh networking gateway module exposes systems on batman-adv mesh segments to kernel memory corruption via crafted Ethernet frames. The flaw occurs because pskb_may_pull(), called within batadv_get_vid(), can reallocate the socket buffer backing store, leaving the ethernet header pointer stale; the code then dereferences this freed pointer before the fix reassigns it. No public exploit exists and EPSS sits at 0.18% (7th percentile) with no CISA KEV listing, but kernel-level UAF carries theoretical escalation-to-privilege-or-crash potential on any system actively running batman-adv.

Use-after-free in the Linux kernel's batman-adv (B.A.T.M.A.N. advanced) distributed ARP table (DAT) code lets an attacker on the same mesh corrupt kernel memory: batadv_get_vid() calls pskb_may_pull(), which can reallocate the skb buffer, leaving the previously-cached ARP hardware-source pointer dangling and later dereferenced. The flaw affects systems running batman-adv mesh networking across numerous stable kernel branches; a vendor fix reorders the pointer acquisition to occur after the realloc. No public exploit is identified at time of analysis, EPSS is low (0.18%, 7th percentile), and it is not on CISA KEV.

Corrupted xattr entry handling in the Linux kernel's f2fs filesystem driver exposes local users to kernel memory disclosure and potential corruption. When f2fs_listxattr() processes a crafted or corrupted filesystem image containing malformed extended attribute entries that fall outside the valid xattr storage area, the kernel previously returned a partial success result without validating entry boundaries. This flaw affects a wide range of kernel stable branches from the commit introducing the bug (688078e7f36c293dae25b338ddc9e0a2790f6e06) through the backported fixes. No public exploit code exists and EPSS is 0.18% (7th percentile), indicating low exploitation probability at time of analysis.

Kernel panic vulnerability in the Linux kernel's IP fragment reassembly path allows an unprivileged user in their own user namespace to crash the host kernel by writing two specially crafted packets with GSO (Generic Segmentation Offload) metadata to a tun/tap device. The flaw exists because inet_frag_queue_insert() - shared by IPv4, IPv6, nf_conntrack_reasm, and 6lowpan reassembly - fails to strip GSO state from fragments before queuing, causing the reassembled skb to reach skb_segment() with SKB_GSO_DODGY state and trigger BUG_ON() assertions. The vulnerability is also reachable with CAP_NET_RAW in a netns where a defrag point precedes a GSO point, and from a guest VM whose VMM forwards virtio_net_hdr to a host tap; KEV status is unconfirmed and EPSS is low at 0.18% (7th percentile), though the CVE description contains a working reproducer.