Information Disclosure

Deserialization of untrusted data in NVIDIA Megatron Bridge enables a local, low-privileged attacker to achieve code execution, data tampering, and information disclosure on the affected host. The vulnerability carries a CVSS 3.1 score of 7.8 with a local attack vector, indicating that an attacker with an existing foothold on the system can escalate impact significantly. No public exploit code or CISA KEV listing has been identified at time of analysis, but the full CIA triad impact (High/High/High) makes this a high-priority remediation target for any organization running Megatron Bridge in research or production AI training environments.

Deserialization of untrusted data in NVIDIA Megatron Bridge allows a local attacker with low-privilege access to execute arbitrary code, tamper with application data, and exfiltrate sensitive information. The CVSS vector (AV:L/AC:L/PR:L/UI:N) confirms exploitation is bounded to local authenticated users or processes, but the full C:H/I:H/A:H impact triad makes successful exploitation highly damaging within that local scope. No public exploit has been identified at time of analysis, and no CISA KEV listing has been observed.

Deserialization of untrusted data in NVIDIA Megatron Bridge allows a local, low-privileged attacker to achieve code execution, data tampering, and information disclosure on the affected host. The local attack vector (AV:L) and low-privilege requirement (PR:L) limit the attack surface to users or processes with existing system access, yet the full C:H/I:H/A:H impact triad makes successful exploitation highly consequential. No public exploit code and no CISA KEV listing have been identified at time of analysis, though the NVIDIA PSIRT has published a security advisory via their product-security GitHub repository.

Deserialization of untrusted data in NVIDIA Megatron Bridge allows a local attacker with low privileges to achieve arbitrary code execution, data tampering, and sensitive information disclosure on the affected system. The CVSS 7.8 base score reflects a local attack vector requiring only low-privilege access with no user interaction, producing full high-impact compromise across confidentiality, integrity, and availability. No public exploit has been identified at time of analysis and the vulnerability is not listed in the CISA KEV catalog, but the severity of potential impact warrants prompt patching in AI training environments.

Sensitive data disclosure in TMT Machine Industry and Trade's Talassoft Industrial Management Software (versions V.4 through pre-V.16) stems from hard-coded credentials embedded in the application, allowing remote attackers to retrieve protected sensitive data without authentication. The flaw was reported by Turkey's national CERT (TR-CERT/USOM) and carries a CVSS 9.1 rating. There is no public exploit identified at time of analysis, and it is not listed in CISA KEV.

Authentication bypass in Erlang/OTP inets httpd allows remote unauthenticated attackers to read files inside mod_auth-protected directories across OTP 17.0 through 29.0 by prefixing the request URI with an extra slash. The inets URI normalizer preserves doubled slashes that RFC 3986 dot-segment removal does not collapse, causing mod_auth's directory-protection regex to silently fail to match while the OS transparently serves the protected file. No CISA KEV listing or public exploit code has been identified at time of analysis; CVSS 4.0 scores this 8.2 with high confidentiality impact contingent on mod_auth being explicitly configured.

Unauthenticated file disclosure in Erlang/OTP's inets httpd allows remote attackers on case-insensitive filesystem deployments to read files inside mod_auth-protected directories by requesting them with differently-cased path segments. The flaw spans OTP 17.0 through 29.x (inets 5.10 through 9.7.x) and stems from mod_auth's path-matching regex omitting the caseless flag, causing authentication checks to be silently bypassed when request path casing differs from the configured directory name while the filesystem resolves both to the same file. No public exploit code or active exploitation has been identified at time of analysis, and deployments on case-sensitive filesystems - the default on Linux - are fully unaffected by this vulnerability.

Request smuggling in Erlang OTP inets (versions 17.0 through 29.x) arises when the httpd server sits behind a Content-Length-preferring reverse proxy: inets frames the request body by chunked Transfer-Encoding and silently discards a co-present Content-Length header, while the front-end proxies request boundaries by Content-Length, producing a classic CL.TE desync. An unauthenticated network attacker in this topology can inject a crafted prefix into a subsequent victim's HTTP request, potentially enabling session hijacking, credential theft, or cache poisoning against other users of the same back-end. No public exploit has been identified at time of analysis, the vulnerability is not listed in CISA KEV, and vendor patches are available for the OTP 27.x, 28.x, and 29.x release branches.

Remote unauthenticated attackers can exploit Erlang/OTP's built-in inets HTTP server across OTP versions 22.2 through 29.0 to conduct HTTP Request Smuggling by sending headers with whitespace before the colon - a malformed construct the server silently discarded rather than rejecting as mandated by RFC 7230 Section 3.2.4. When inets is deployed behind a front-end proxy or load balancer that interprets such headers differently, the resulting parsing discordance creates a desynchronized request boundary exploitable for session hijacking, authentication bypass, or cache poisoning. No public exploit has been identified at time of analysis; vendor-released patches are available across all three affected OTP release branches.

HTTP request smuggling in Erlang/OTP's built-in inets httpd server allows unauthenticated remote attackers to inject arbitrary HTTP headers and poison request pipelines in deployments fronted by a reverse proxy. The root cause is a longstanding absence of obs-fold support: any CRLF followed by a whitespace octet (SP or TAB) is silently parsed as a new header rather than a header continuation, causing proxy-backend disagreement on request boundaries. Affected versions span OTP 17.0 through the patched releases (27.3.4.17, 28.5.0.6, 29.0.6), with vendor patches now available via the Erlang GitHub security advisory. No public exploit code or CISA KEV listing exists at time of analysis.

Source code disclosure in Manacle Technologies' Multi-Tenant ERP System allows unauthenticated remote attackers to reconstruct the application's source by downloading an exposed, web-accessible .git directory (CWE-527). Because the version-control metadata can be walked to recover full repository history, attackers can harvest hardcoded credentials, API keys, database schemas, and business logic that enable follow-on attacks. No public exploit or CISA KEV listing exists at this time, but .git exposure is trivially exploited with widely available off-the-shelf tooling.

Cross-origin data exposure in Mozilla Firefox's DOM: Navigation component stems from a site isolation failure that lets malicious web content bypass the same-origin/site boundary Firefox enforces to keep pages from different sites in separate processes. The flaw affects Firefox before version 155 and Firefox ESR before 153.2, and could allow a crafted page to read or influence data belonging to another origin. Reported and fixed by Mozilla (MFSA2026-82/-85/-86/-88); no public exploit identified at time of analysis and EPSS is low (0.14%, 4th percentile).

An improper input validation defect (CWE-20) in Firefox Focus for Android was reported and fixed by Mozilla in Firefox 155 per advisory MFSA2026-82. The public description is a placeholder-grade 'Other issue' with no technical mechanism disclosed, so the concrete impact cannot be verified; there is no public exploit identified at time of analysis and EPSS is low (0.13%, 3rd percentile). Despite a headline CVSS of 9.8, the vendor tag set and thin description leave the real-world severity for this privacy-focused mobile browser unconfirmed.

Information disclosure in Mozilla Firefox's Profile Backup component, remediated in Firefox 155 and Firefox ESR 153.2 (Mozilla advisories MFSA2026-82/85/86/88). Mozilla provides only an 'Other issue' placeholder description, so the precise mechanism is undisclosed, but the CWE-200 classification points to unintended exposure of data handled during profile backup. No public exploit or active exploitation has been identified, and EPSS is very low (0.14%, 4th percentile).

Cross-origin information disclosure in Mozilla Firefox arises from a site-isolation failure in the DOM Push Subscriptions component (CWE-346, origin validation error), allowing content from one origin to be improperly associated with or exposed to another. It affects Firefox before 155 and Firefox ESR before 153.2, and was disclosed and patched by Mozilla; there is no public exploit identified at time of analysis and EPSS is very low (0.14%, 4th percentile). The 'Information Disclosure' tag is consistent with the CWE and the likely cross-origin read impact.

Information disclosure via Firefox's Networking: HTTP component exposes sensitive data to remote unauthenticated attackers in all Firefox versions prior to 155 and all Firefox ESR versions prior to 153.2. The flaw is tracked in Mozilla Bugzilla #2063020 and addressed across four Mozilla security advisories (mfsa2026-82, -85, -86, -88), indicating backport coverage across multiple ESR branches. No public exploit code exists and EPSS probability is very low (0.14%), though the SSVC framework marks the class as automatable.

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.