Information Disclosure

Out-of-bounds read (CWE-125) in Microsoft SQL Server enables an authenticated network attacker with low privileges to disclose sensitive server-side information. The flaw spans SQL Server 2017 through 2025 across both Cumulative Update and General Distribution Release servicing branches, representing a broad exposure across enterprise database deployments. No public exploit code or active exploitation has been identified at time of analysis, and Microsoft has released patches across all affected servicing branches.

Out-of-bounds memory read in Microsoft SQL Server 2017 through 2025 allows network-authenticated, low-privilege database users to disclose sensitive server-side memory contents. The flaw (CWE-125) is reachable over the network with only a valid database account, requiring no user interaction, and affects all currently supported SQL Server release tracks - both Cumulative Update and General Distribution Release channels. Microsoft has released patches across all affected branches; no public exploit code has been identified at time of analysis.

Uninitialized memory exposure in Microsoft SQL Server 2017 through 2025 allows a network-authenticated low-privilege attacker to read sensitive server-side data. The root cause is CWE-908 (Use of Uninitialized Resource), where a memory region is accessed before initialization, potentially leaking residual contents from query buffers, session state, or internal structures. No public exploit code or CISA KEV listing has been identified at time of analysis; vendor patches are available across all affected version branches.

Uninitialized memory disclosure in Microsoft SQL Server 2017 through 2025 allows a low-privileged authenticated attacker to read sensitive server memory contents over a network connection. The CWE-908 flaw affects all major SQL Server release branches - 2017, 2019, 2022, and 2025 - across both GDR and Cumulative Update servicing tracks. Microsoft has released patches for all affected versions; no public exploit code or active exploitation is documented at time of analysis.

Out-of-bounds read in Microsoft SQL Server 2017 through 2025 exposes server memory contents to authenticated low-privilege network attackers, enabling information disclosure without integrity or availability impact. The flaw (CWE-125) requires only a valid low-privilege database account and network access, making it accessible to any SQL login holder - including application service accounts - against unpatched instances. No public exploit code or active exploitation (CISA KEV) has been identified at time of analysis, but the breadth of affected versions across four major SQL Server release families widens the attack surface considerably.

Out-of-bounds read (CWE-125) in Microsoft SQL Server enables an authenticated, network-adjacent attacker to disclose sensitive in-process memory contents. Affecting SQL Server versions 2017 through 2025 across both GDR and Cumulative Update servicing tracks, exploitation requires valid database credentials but no elevated privileges. Microsoft has released patched builds for all affected versions; no public exploit code or CISA KEV listing has been identified at time of analysis.

Out-of-bounds read in Microsoft SQL Server allows a low-privileged, authenticated attacker to remotely disclose sensitive memory contents over a network. Affected builds span SQL Server 2017 through 2025 across both Cumulative Update and GDR servicing branches. With a CVSS 6.5 and C:H, successful exploitation could expose confidential server-side data; no public exploit or CISA KEV listing has been identified at time of analysis.

Out-of-bounds read (CWE-125) in Microsoft SQL Server 2019, 2022, and 2025 enables an authenticated low-privilege network attacker to disclose potentially sensitive server memory contents. The flaw is exploitable over the network with low complexity and requires only a valid database login - no user interaction or elevated privileges are needed. Microsoft has released patches across all six affected servicing branches; no public exploit code or CISA KEV active exploitation has been identified at time of analysis.

Out-of-bounds read in Microsoft SQL Server 2022 and 2025 enables an authenticated, low-privileged attacker to disclose sensitive server memory contents over the network. The flaw (CWE-125) resides in the SQL Server engine and is reachable via crafted network queries, resulting in high confidentiality impact with no integrity or availability loss. No public exploit code or active exploitation has been identified at time of analysis, but a vendor-released patch is available.

Uninitialized memory disclosure in Microsoft SQL Server 2017 through 2025 allows a network-connected low-privilege authenticated attacker to read sensitive data from SQL Server memory. The flaw (CWE-908) arises when the engine allocates and uses memory without proper initialization, potentially exposing contents from adjacent queries, sessions, or internal data structures. Microsoft has released patches across all affected Cumulative Update and GDR servicing branches; no public exploit code or CISA KEV listing has been identified at time of analysis.

Information disclosure in Microsoft SQL Server 2025 allows an authenticated, low-privileged network attacker to extract sensitive data through crafted SQL error messages. Affected are the CU8 and GDR servicing branches of SQL Server 2025, with both patch channels receiving fixes. No active exploitation or public proof-of-concept has been identified at time of analysis, but the CVSS C:H rating indicates the potential for significant confidentiality breach once an attacker has any valid credential.

Out-of-bounds read (CWE-125) in Microsoft SQL Server 2025 allows an authenticated network attacker to disclose sensitive in-memory information. Affected versions span both the CU8 cumulative-update branch (below 17.0.4085.5) and the GDR branch (below 17.0.1135.8). No public exploit or CISA KEV listing exists at time of analysis; Microsoft has released patches for both branches.

Microsoft Teams for Android before build 1416/1.0.0.2026133602 inserts sensitive information into outbound network transmissions (CWE-201), enabling a low-privileged authenticated attacker to intercept and read confidential data over the network when a victim user performs an in-app action. The CVSS scope change (S:C) with high confidentiality impact (C:H) signals that the leaked data can cross trust boundaries beyond the attacker's own session, potentially exposing other users' or sessions' sensitive material. No public exploit identified at time of analysis; Microsoft has released a patch via the MSRC advisory.

Origin validation error (CWE-346) in Microsoft .NET enables network-based information disclosure where an unauthenticated remote attacker can read sensitive data from a .NET application by exploiting improper validation of request origins. Affected are multiple active .NET release trains (8.0, 9.0, 10.0, 11.0 RC1) and Microsoft Visual Studio 2022 and 2026 where bundled .NET runtimes are included. The CVSS vector (UI:R) indicates user interaction is required, consistent with a cross-origin attack pattern where a victim must visit an attacker-controlled page that triggers the malicious cross-origin request. No public exploit code or CISA KEV listing has been identified at time of analysis.

Unauthenticated information disclosure in TP-Link Omada Controller exposes an initialization API endpoint that remains reachable after setup completes, leaking account-related data to any remote unauthenticated user. The endpoint was designed for one-time use during initial controller configuration but lacks post-initialization access controls, allowing attackers to query it freely. Successful exploitation facilitates user enumeration, which can serve as a reconnaissance step toward credential-stuffing or targeted brute-force attacks against administrative accounts. No public exploit or CISA KEV listing is identified at time of analysis.

Field policy bypass in AshLua 0.1.0-0.2.1 allows authenticated Lua script executors to read actor-restricted fields by requesting them through aggregate operations (min, max, first, sum, avg, list) rather than as direct record fields, circumventing per-actor field policy authorization while remaining within the configured exposed-field allow-list. The Ash framework normally redacts forbidden fields on returned record structs with %Ash.ForbiddenField{}, but AshLua's read action did not apply this check when constructing ad-hoc Ash.Query.Aggregate instances, returning raw field values instead. No public exploit code exists and the vulnerability is not in CISA KEV; the CVSS 4.0 score of 6.0 reflects network-accessible but prerequisite-gated exploitation requiring authenticated script execution access.

Field policy bypass in ash_ai (versions 0.1.0 through < 1.0.3) allows authenticated, low-privilege actors to read per-actor-restricted fields - including sensitive PII - by invoking the aggregate result type (min, max, sum, avg) via the LLM read tool instead of direct record retrieval. Ash field policies redact forbidden fields on returned records by substituting %Ash.ForbiddenField{}, but this redaction mechanism was never applied to aggregate code paths; the tool's authorization check only tested field.public?, a static attribute orthogonal to per-actor policy evaluation. Patch version 1.0.3 is available via the vendor advisory; no CISA KEV listing or public exploit code has been identified at time of analysis.

Query statistics serialization on the MongoDB sharded cluster router (mongos) fails to apply redaction to search query literals, exposing sensitive data to holders of the monitoring privilege. An improper conditional check in the serialization logic causes the redaction mechanism to be bypassed specifically for search queries transiting the router, leaving raw query text - which may contain PII, credentials embedded in queries, or proprietary data - stored and accessible via the queryStats interface. Affected versions are MongoDB Server 8.3.0 through 8.3.8; a fix is available in 8.3.9. No public exploit code has been identified and this vulnerability is not listed in CISA KEV.

Heap out-of-bounds read in MongoDB Server's query planning component allows an authenticated database user with read/write privileges to disclose partial server heap memory contents. Crafted query operations cause the server to read beyond allocated heap buffer boundaries during query plan construction, with leaked memory fragments surfacing through diagnostic query statistics output. Affected releases span MongoDB Server 7.0.0-7.0.40, 8.0.0-8.0.29, and 8.3.0-8.3.8, with fixed versions available across all three branches per vendor advisory SERVER-131562.

Credential interception via man-in-the-middle attack is possible against Nozomi Networks Guardian sensors using the Smart Polling feature, which establishes encrypted connections to polled OT/ICS devices without validating the remote host's identity and provides no configuration option to enable such validation. An attacker with network positioning between the sensor and a target device can impersonate the device, capture the authentication credentials transmitted during polling sessions, and replay those credentials to authenticate directly against the device or other devices sharing the same credentials. This enables unauthorized access, data manipulation, and operational disruption of monitored industrial devices. No public exploit has been identified at time of analysis and the vulnerability is not listed in CISA KEV.

Unauthenticated information disclosure in XenForo before 2.3.13 exposes private content metadata through the unfurl link-preview endpoint, which performs no session, user identity, or visibility checks on retrieved records. An unauthenticated remote attacker can enumerate predictable auto-increment integer IDs to retrieve rendered preview HTML, original URLs, and query strings generated from private conversations and other access-controlled forum areas. No public exploit has been identified at time of analysis, but the attack is trivially automatable through sequential ID iteration; the issue is fixed in XenForo 2.3.13.

Xen hypervisor on x86 PV (paravirtualized) guest configurations contains a race condition in memory page lifecycle management that allows a guest to write to pages already scrubbed by Xen. When a PV guest frees a memory page, Xen defers the TLB flush until the page is re-used - but scrubbing occurs before that flush, creating a window in which the guest's stale TLB entry remains valid for a page now considered clean. This permits the attacking PV guest to inject arbitrary data into a scrubbed page, which may subsequently be allocated to another guest, undermining Xen's inter-VM memory isolation guarantee. No public exploit has been identified at time of analysis, and SSVC assessment rates exploitation as none and non-automatable.

Stack buffer over-read in PX4 Autopilot through v1.17.0 exposes stack memory via the netman system command's interface name handling. Supplying an interface name of 74 bytes or more via the -i option bypasses missing length validation, causing reads beyond allocated buffer boundaries; the over-read data leaks to console output and may also be written into persistent network configuration files, risking both information disclosure and config corruption across reboots. No public exploit or active exploitation has been identified, but the upstream fix is available as a merged GitHub PR and commit.

Sensitive credential material - including authentication tokens, query-result encryption keys, pre-signed cloud-storage URLs, and SAML assertions - was written to diagnostic log files across six Snowflake client drivers (Python, Go, JDBC, Node.js, PHP PDO, and ODBC) due to incomplete log-redaction coverage. An attacker with read access to the log destination, whether a local filesystem, a log aggregation pipeline, or a CI/CD artifact store, can extract valid credentials and decryption keys. Exploitation impact is bounded by credential lifetime and object scope, but successful use of harvested tokens provides authenticated access to the corresponding Snowflake account or cloud-storage objects. No public exploit is identified at time of analysis; vendor-released patches are available for all six drivers as of September 3, 2026.

Unstripped debug symbols in Siemens Reyrolle 7SR5 protection relay firmware (all versions prior to V2.70) expose internal function names, type definitions, and structure layouts to any party who downloads the publicly available firmware update packages. This does not directly compromise deployed devices but substantially reduces the skill and effort required for an attacker to identify exploitable weaknesses through static firmware analysis. No public exploit or active exploitation has been identified; Siemens has released firmware V2.70 as the fix per advisory SSA-142885.

Direct web-accessible SQL backup file exposure in code-projects Student Crud Operation 1.0 allows unauthenticated remote attackers to download the raw database dump `/card_activation.sql` from the web root. The file likely contains database schema and card activation records, exposing sensitive application data without any authentication. No public exploit identified at time of analysis is incorrect - publicly available exploit code exists per the referenced GitHub writeup, though no CISA KEV listing is present.

NTLM credential hash theft from Windows users running ASUS Armoury Crate is possible when a user visits an attacker-controlled web page that exploits the application's permissive cross-domain (CORS) policy. The local Armoury Crate service accepts cross-origin requests from untrusted web origins, allowing malicious JavaScript to inject a UNC path into a service call; Windows then automatically initiates SMB authentication to the attacker's server, transmitting the user's NTLMv2 hash without further interaction. No public exploit code and no CISA KEV listing have been identified at time of analysis, but the underlying coercion technique is well-understood and the attack requires only a single user click.

Uninitialized kernel memory disclosure through the ASUS Armoury Crate Windows driver allows a local low-privileged user to read sensitive data from previously used kernel buffers. The attacker crafts a malicious IOCTL request that bypasses the driver's built-in security verification mechanism, triggering a read of uncleared memory content (CWE-226). No active exploitation has been identified and no public exploit code is known at time of analysis; risk is bounded by the local access prerequisite and the AC:H complexity of defeating the security check.

Kernel virtual address disclosure in the ASUS Armoury Crate Windows driver enables a local low-privileged user to bypass the driver's IOCTL input verification through a crafted request, obtaining kernel virtual addresses and exposing the kernel memory layout. All versions of Armoury Crate are listed as affected per CPE cpe:2.3:a:asus:armoury_crate:*:*:*:*:*:*:*:*. While direct impact is limited to information disclosure, this class of kernel pointer leak is routinely used to defeat KASLR as a prerequisite step in local kernel privilege-escalation chains; no public exploit or CISA KEV listing has been identified at time of analysis.

Unauthorized administrative interface access in SAP Web Dispatcher, Internet Communication Manager (ICM), and SAP Content Server exposes sensitive system state to authenticated low-privileged users. Exploiting this flaw, an attacker with only a basic SAP account can query administrative endpoints normally restricted to higher-privilege roles, retrieving configuration details, system internals, or operational data that could serve as reconnaissance for follow-on attacks. No public exploit code exists and the vulnerability is not listed in CISA KEV, but the low authentication bar (any valid low-privilege account) and direct network accessibility make the exposure surface meaningful in enterprise SAP environments.

Multi-tenant OAuth2 metadata cross-tenant leakage in ash_authentication_oauth2_server (versions 0.1.3 through before 0.3.1) causes shared HTTP caches to serve one tenant's RFC 8414/RFC 9728 discovery metadata - including issuer, authorization_endpoint, token_endpoint, and jwks_uri - to another tenant's clients for up to one hour. The vulnerability arises because the Phoenix ProtocolRouter sent all metadata responses with Cache-Control: public, max-age=3600 and no Vary header; when tenant identity is derived from a request header or Host (not the URL), shared caches key on URL alone, making cross-tenant cache poisoning trivially repeatable. Downstream impact extends beyond disclosure: affected clients may direct authorization codes and client secrets to the wrong tenant's token endpoint and validate tokens against the wrong JWKS keys. No public exploit or active exploitation (CISA KEV) has been identified at time of analysis.

Plaintext credential storage in Dell Secure Connect Gateway 5.0 exposes passwords to local low-privileged attackers, leading to information disclosure. Both the Appliance variant (prior to 5.36.00.16) and Application variant (prior to 5.36.00.00) are affected, as confirmed by Dell advisory DSA-2026-382. No public exploit code or active exploitation has been identified; the CVSS score of 4.7 Medium reflects the local-only, high-complexity attack path.

IntelliJ IDEA before version 2026.2.2 leaks project metadata to JetBrains Marketplace due to a missing project-trust check, exposing potentially sensitive project information without developer consent. The flaw requires local access and user interaction - specifically, a developer must open an untrusted project for the metadata transmission to occur. No public exploit code exists and no active exploitation has been identified; the impact is limited to a low-severity confidentiality breach (CVSS 3.3).

Terminal command input written to idea.log in JetBrains IntelliJ IDEA before 2026.2.2 exposes sensitive command-line strings to any local party that can read the IDE's diagnostic log. Classified as CWE-532 (Insertion of Sensitive Information into Log File), the flaw means that developers who type passwords, API keys, or tokens as command-line arguments in IntelliJ's integrated terminal inadvertently persist those secrets on disk in a plaintext log file. No public exploit has been identified at time of analysis, and the vendor-assigned CVSS score of 2.8 accurately reflects the constrained local-only, user-interaction-dependent attack surface.

Credential exfiltration in JetBrains YouTrack before 2026.2.18769 allows a project administrator to redirect stored mailbox credentials to an attacker-controlled server by modifying the mailbox host setting without triggering re-authentication. The missing re-authentication gate means any project admin who has been compromised, is malicious, or has temporarily elevated access can silently capture email account credentials (username and password) already stored in YouTrack. No public exploit has been identified at time of analysis, and CISA has not added this to the Known Exploited Vulnerabilities catalog.

IP spoofing via forged HTTP headers in JetBrains YouTrack before 2026.2.18634 allows unauthenticated remote attackers to bypass Bitbucket webhook source validation, causing YouTrack to process attacker-crafted webhook payloads as if they originated from a legitimate Bitbucket server. The root cause is CWE-291 - reliance on IP address for authentication - specifically trusting client-controlled headers such as X-Forwarded-For to gate webhook acceptance. No public exploit has been identified at time of analysis, and JetBrains has released a patched build.

Hard-coded cryptographic key exposure in Dell Secure Connect Gateway (SCG) 5.0 allows a local low-privileged attacker to decrypt protected data, leading to high-severity information disclosure. Both the Appliance form factor (prior to 5.36.00.16) and the Application form factor (prior to 5.36.00.00) are affected. No public exploit code or active exploitation has been identified at time of analysis, and the local access requirement significantly constrains the attack surface.

Improper locking in Dell Secure Connect Gateway (SCG) 5.0 Appliance and Application allows a low-privileged remote attacker to exploit a synchronization race condition, resulting in unauthorized filesystem access on the affected system. The vendor CVSS vector rates the primary impact as A:H (Availability), yet the description specifically references attacker filesystem access - a tension that suggests possible confidentiality or integrity impact beyond what the official score reflects. Dell has released fixed versions and published advisory DSA-2026-382; no public exploit or active CISA KEV listing exists at time of analysis.

Cleartext storage of sensitive information in Dell Secure Connect Gateway 5.0 exposes credentials or configuration secrets to any low-privileged local user on the host. Both the hardware Appliance (versions prior to 5.36.00.16) and the virtual Application (versions prior to 5.36.00.00) are affected, as confirmed by Dell Security Advisory DSA-2026-382. No public exploit identified at time of analysis, but the CVSS C:H rating indicates that successful exploitation yields full confidentiality compromise of the stored sensitive material.

Sensitive information exposure in Dell Secure Connect Gateway (SCG) 5.0 allows a low-privileged local attacker to read sensitive data written to application log files without sanitization. Both the Appliance variant (prior to 5.36.00.16) and the Application variant (prior to 5.36.00.00) are affected across all platforms. No public exploit code or active exploitation has been identified; Dell has released fixes via advisory DSA-2026-382.

Hardcoded cryptographic key exposure in Dell Secure Connect Gateway (SCG) 5.0 - both Appliance and Application variants - allows a low-privileged local attacker to access protected data encrypted with the embedded key, leading to information disclosure. Affected versions include SCG 5.0 Appliance prior to 5.36.00.16 and SCG 5.0 Application prior to 5.36.00.00. Dell has released patched versions via DSA-2026-382; no public exploit or KEV listing has been identified at time of analysis.

Hard-coded cryptographic key exposure in Dell Secure Connect Gateway (SCG) 5.0 allows a local low-privileged attacker to decrypt data that was intended to be cryptographically protected, resulting in high-severity information disclosure. Both the Appliance form factor (versions prior to 5.36.00.16) and the Application form factor (versions prior to 5.36.00.00) are affected. No public exploit code or active exploitation has been identified at time of analysis; Dell has released patches via advisory DSA-2026-382.

Information disclosure in light0011 CMS exposes database debug output to unauthenticated remote attackers by manipulating the DB_DEBUG argument processed by the Debug Mode component in App/Common/Conf/config.php. The flaw allows network-accessible attackers to retrieve database diagnostic data - potentially including SQL query traces, schema details, or connection metadata - with no authentication and no user interaction required. A public proof-of-concept exploit exists via GitHub issue #17, and the vendor has not yet responded to the coordinated disclosure report, leaving all deployed instances unpatched.

Organisation metadata enumeration in MISP ≤2.5.45 is possible for authenticated users when the `Security.hide_organisation_index_from_users` configuration option is enabled, because the dashboard organisation picker queries the full organisation table without applying the same ACL conditions enforced by the standard organisation index and per-organisation view endpoints. The picker returns organisation ID, UUID, and name for all organisations, bypassing the visibility restriction. Patch commit 8ca4486af from CIRCL adds the missing `Organisation::createConditions()` call to scope picker results to organisations the requesting user is already authorised to see. No public exploit code has been identified and this CVE is not listed in CISA KEV.

Authenticated information disclosure in MISP ≤2.5.45 allows any logged-in user to bypass email-address redaction by switching from the HTML interface to the REST/JSON representation of DashboardsController::listTemplates(). The query always fetched User.email columns, but the redaction logic only executed inside the non-REST rendering branch - meaning the same session that saw blank email fields in the browser received raw email addresses when requesting JSON. The fix, contributed by CIRCL (MISP's primary maintainer) and released in commit fd554c3bd, centralizes the privilege decision in a new User::canSeeEmails() static helper, conditioning email retrieval on site-admin role or the Security.disclose_user_emails instance setting.

Out-of-bounds read in the 92181 markdown C library's lds() function allows remote unauthenticated attackers to read memory beyond the intended buffer by supplying crafted markdown input. The flaw exists in md.c prior to commit c000d2f9cf390c315378d3717cf20911cf3e80a6, where the lds() function iterated over space characters without enforcing an end-of-buffer boundary. The CVSS 4.0 vector (6.9) reflects low confidentiality, integrity, and availability impact; no public exploit or CISA KEV listing exists at time of analysis.

Hospital Information System 1.0 by code-projects exposes its raw SQL database backup file at the web-accessible path `/HIS/his.sql`, allowing unauthenticated remote attackers to download the full database dump over HTTP with no prerequisites. The vulnerability (CWE-200) stems from placing the database export file inside the application's web root without access controls. A public proof-of-concept exploit document is available on GitHub, confirming practical exploitability; no KEV listing has been issued at time of analysis.

Out-of-bounds read in ModelCloud GPTQModel ≤7.2.0 allows an attacker who controls a GPTQ checkpoint file to trigger unauthorized GPU device memory reads during model inference. The Triton dequantization kernel in `tritonv2.py` indexes `scales`/`qzeros` buffers using the checkpoint-supplied `g_idx` tensor without any upper-bound guard, so a crafted entry ≥ `num_groups` reads past the allocated buffer on the device. A public proof-of-concept exists (GitHub issue #2949), and vendor-released fix v7.3.0 is available.

SQL identifier injection in jaychouchannel's Tourism-Management-System allows remote unauthenticated attackers to enumerate arbitrary database tables and columns by manipulating the `tableName` and `columnName` URL path parameters accepted by multiple endpoints in `CommonController.java`. All commits up to 8122bf020d91199eddfff3ee02d1632a70a9a132 are affected, and exploit code has been publicly disclosed via VulDB. A fix commit (d44ec3aa) is available, introducing a dedicated `SqlIdentifierValidator` to whitelist valid SQL identifiers across the affected controller.

Cleartext storage of sensitive database credentials and user data in SourceCodester Syllabus-Aligned Learning Management & Examination System 1.0 exposes plaintext secrets via the `cict_portal.sql` file. The SQL dump file, commonly placed within the web-accessible directory in SourceCodester PHP projects, can be retrieved directly over the network without authentication, leaking whatever credentials or personal data it contains. A public proof-of-concept exploit is available on GitHub, confirmed by VulDB and the referenced researcher report, raising the practical exploitation risk above what the moderate CVSS 4.0 score of 6.9 might suggest at first glance.

Session fixation in SourceCodester Syllabus-Aligned Learning Management & Examination System 1.0 allows unauthenticated remote attackers to pre-plant a session identifier via the auth_process.php login endpoint, then hijack the authenticated session after a victim logs in. The auth_process.php component fails to regenerate the session ID upon successful authentication, enabling full account takeover of any user who can be socially engineered into authenticating through a crafted link. A public exploit PoC exists on GitHub; no vendor patch has been released.

Local information disclosure in MediaTek's GeniZone trusted execution environment component allows a System-privileged attacker to read out-of-bounds memory due to a missing bounds check (CWE-125), potentially leaking confidential data from the TEE. The flaw affects seventeen MediaTek chipsets documented in the September 2026 security bulletin, and patches are available under IDs ALPS10867524 and ALPS10876355. No public exploit code or active exploitation has been identified at time of analysis, and SSVC assessment rates exploitation status as none.

Use-after-free in the MediaTek GPU kernel driver on chipsets MT6991 and MT8799 allows a local attacker with standard user privileges to read freed kernel or GPU memory, potentially exposing sensitive data such as pointers, credentials, or cryptographic material. The same condition may cause a full system crash, consistent with the Denial of Service tag and the 'system crash' language in the description. No public exploit has been identified and SSVC rates exploitation status as none, placing this in a lower real-world priority bracket despite the C:H rating.

Local information disclosure in MediaTek's Audio Hardware Abstraction Layer affects 63 distinct chipsets, from MT6761 to MT8910, allowing a process already operating at Android System privilege to bypass an absent permission check and extract audio HAL data without authorization. Patch ID ALPS11087632 (Issue MSV-8244) addresses the missing authorization gate, and MediaTek published remediation through the September 2026 security bulletin. SSVC assessment confirms no known exploitation and non-automatable attack path; no public exploit code identified at time of analysis.

Local information disclosure in MediaTek's Audio Hardware Abstraction Layer (HAL) exposes sensitive data to an attacker who has already escalated to System privilege on an affected Android device. Improper input validation (CWE-35 path-traversal class) in the audio subsystem allows a System-level process to read confidentiality-critical data it should not have access to, with no user interaction required. No public exploit code and no CISA KEV listing exist at time of analysis; SSVC assigns exploitation status 'none' and technical impact 'partial', positioning this as a post-compromise data-harvesting primitive rather than a primary attack vector.

CVE-2026-71223 is reported via Ubuntu's security channels, but no description, CVSS score, CWE classification, or affected product detail is available in the current dataset. The vulnerability cannot be characterized beyond its Ubuntu vendor attribution. Security teams should consult Ubuntu Security Notices (USN) or the Ubuntu CVE tracker directly for authoritative details before assessing exposure or priority.

CVE-2026-85218 is attributed to Ubuntu per the vendor intelligence source, but no public description, CVSS score, CWE classification, or technical detail has been released at the time of this analysis. The vulnerability type, affected component, attack vector, and impact are all unknown. No meaningful synthesis of exploitation conditions or attacker capability is possible from available data alone.

Stack buffer underflow in polkit's read_cookie() function, introduced as a regression by the fix for CVE-2026-4897, exposes Linux systems to potential memory corruption and privilege escalation via polkit's D-Bus authentication path. Systems that applied the CVE-2026-4897 patch are specifically affected, meaning the remediation for a prior vulnerability created new exposure. No public exploit code has been identified at time of analysis, but the target (polkit, a setuid/privileged authorization daemon) makes this class of memory corruption high-consequence.

Memory exhaustion via PKCS#7 certificate processing affects an Ubuntu-packaged cryptographic component, allowing crafted certificate containers to gradually leak heap memory. The vulnerable component is reported by Ubuntu but the specific library (e.g., OpenSSL, GnuTLS, or another ASN.1/PKCS#7 parser) is not identified in available data. An attacker capable of delivering malicious PKCS#7 containers to a vulnerable service - such as a TLS endpoint, S/MIME mail processor, or package verification daemon - could trigger sustained memory growth leading to service degradation or crash.

Undefined memory access in PKCS#7 container parsing affects an Ubuntu-packaged cryptographic library, potentially enabling denial of service or information disclosure when processing malformed PKCS#7 input. The specific library (OpenSSL, GnuTLS, NSS, or Linux kernel PKCS#7 module) is not identified in available data. No patch version, CVSS score, or CWE classification was provided, leaving severity and exploitability largely unquantified at time of analysis.

Insufficient data exists to characterize this vulnerability beyond its title. The only available intelligence is the description 'Memory Leak During Message Stringification' and a single Ubuntu vendor attribution. No affected product, version, CVSS score, CWE, CPE, references, or patch details have been provided. Memory leak vulnerabilities during message serialization or stringification operations typically result in heap exhaustion and denial of service, but the specific product, component, and exploitation context remain entirely unknown from available data.

Memory leak vulnerabilities in attribute certificate parsing expose affected cryptographic library users to potential denial-of-service via memory exhaustion. Attribute certificates (X.509v2 AC, RFC 5755) are distinct from public-key certificates and carry authorization attributes; parsing them from untrusted network input - for example during TLS handshakes or certificate validation workflows - would allow an unauthenticated remote attacker to trigger repeated leaks and exhaust process heap memory over time. Reported by Ubuntu, no active exploitation has been identified at time of analysis, and no CVSS score is yet assigned.

Improper access control in JeecgBoot's AI-RAG module (versions up to 3.9.3) permits a low-privileged authenticated user to invoke the exportXls endpoint in AiragModelController.java and extract LLM model credentials by manipulating the credential parameter beyond their authorization level. The attack is network-accessible and requires only a valid low-privileged session with no administrative rights. A public proof-of-concept is available via GitHub issue #9600, and a vendor patch has been released in version 3.9.5.

Unauthenticated remote download of a raw SQL database backup in code-projects Hotel and Tourism Reservation in PHP 1.0 exposes the full application database to any internet-connected attacker. The file /ht/hotel_db%20(1).sql is placed inside the web root without access restrictions, making it directly retrievable over HTTP with no credentials. A publicly available proof-of-concept exploit exists; the database dump likely contains guest PII, booking records, and potentially hashed or plaintext admin credentials.

Shortcode injection in the Redirection for Contact Form 7 WordPress plugin (versions 2.2.7 through 3.2.10) enables unauthenticated remote attackers to execute arbitrary registered WordPress shortcodes server-side and capture their output. The plugin substitutes raw form submission values into its action settings and then evaluates those settings through WordPress's do_shortcode() pipeline without sanitizing or stripping user-supplied shortcode syntax first. A public proof-of-concept is available via WPScan; vendor-released patch version 3.2.11 addresses the issue.

Unauthenticated remote access to an exposed SQL database backup file in code-projects Daily Expense Manager 1.0 allows any network attacker to retrieve sensitive application data. The file `/Daily-Expense-Manager/exp_ak.sql` - a raw database dump - is served directly from the web root without access control, disclosing potentially credentials, user records, and expense data. No public exploitation via CISA KEV, but a public exploit writeup is available on GitHub confirming the exposure path.

SSH authentication bypass in MikroTik RouterOS allows any unauthenticated network attacker to skip the entire SSH user-authentication phase by triggering a client-requested rekey, causing the server to advance directly into the connection protocol and accept session channel and exec requests. The result is unauthenticated file creation, overwrite, and exfiltration within the RouterOS managed file namespace - including support bundles containing configuration and diagnostic data. Publicly available exploit code exists, CERT-PL has published dedicated research, and a companion CERT-PL post titled 'vulnerabilities-in-mikrotik-routeros-actively-exploited' suggests observed exploitation in the wild, though CISA KEV listing is not confirmed in the available data.

Unauthenticated remote access to restricted internal APIs is possible in N-able N-central due to an incomplete access control filter, classified under CWE-791. All N-central deployments prior to versions 2026.3 HF3 and 2026.4 are affected, as confirmed by the vendor advisory. Impact is limited to partial information disclosure (CVSS 4.0 VC:L) with no integrity or availability effects reported; no public exploit code or active exploitation has been identified at time of analysis.

Remote memory disclosure in libpcap's rpcap client allows a malicious or compromised rpcap server to cause a connected client to read up to 20 bytes beyond the end of its receive buffer and treat that data as captured packet content. All libpcap versions with rpcap support are affected per CPE cpe:2.3:a:the_tcpdump_group:libpcap:*:*:*:*:*:*:*:*. The root cause is an incorrect boundary check in pcap_read_nocb_remote(): the RPCAP_MSG_PACKET caplen field was validated against the full payload length rather than against the payload length minus the fixed-size RPCAP_MSG_PACKET header, creating a window of up to sizeof(struct rpcap_pkthdr) bytes that could be read beyond the buffer. No public exploit or CISA KEV listing is identified at time of analysis.

Out-of-bounds memory reads in libpcap's userland BPF interpreter allow a local attacker who can supply a crafted filter program to drive the interpreter's program counter past the end of the filter buffer, reading up to 32 GiB of surrounding process memory on 64-bit systems or the entire address space on 32-bit systems. All libpcap versions tracked under CPE cpe:2.3:a:the_tcpdump_group:libpcap are affected; The Tcpdump Group has published a fix via commit d3f358d3. No active exploitation has been confirmed and no public exploit exists; the vulnerability is restricted to uncommon application patterns that pass raw BPF bytecode directly to the interpreter without prior validation.

SiYuan's `getAttributeViewKeysByID` endpoint, present in all versions before v3.8.2, allows authenticated publish readers to retrieve full key schemas-including sensitive field names and relation definitions-from private or hidden databases they have no visibility into. The flaw is an authorization bypass (CWE-639/IDOR) where the endpoint validates that a caller holds a publish-reader session but never verifies the caller's access rights against the parent database owning the requested attribute view. No public exploit code and no CISA KEV listing have been identified at time of analysis, keeping real-world risk moderate despite the network-accessible attack vector.

Information disclosure in the EmbedPress WordPress plugin (versions 4.6.0 through 4.6.3) allows any authenticated contributor-level user or above to retrieve the site administrator's email address via an improperly restricted Google Reviews REST API endpoint. WordPress core deliberately withholds administrator email from the contributor role as a privacy control; this plugin bypass defeats that restriction without requiring administrative privileges. A publicly available proof-of-concept has been published by WPScan, though EPSS at 0.14% and SSVC exploitation status of 'none' indicate no observed active exploitation at time of analysis.

The Events Calendar WordPress plugin before 6.17.3.1 exposes unpublished site content - drafts, pending posts, and private records from all users - through its public REST API archive endpoints to any contributor-level authenticated user. The plugin fails to enforce WordPress's standard post-status visibility controls on its custom REST routes, allowing a low-privilege account holder to enumerate and read the full body of every non-public record site-wide, bypassing intended access controls. A public proof-of-concept is documented via WPScan, and a vendor patch (6.17.3.1) is available.

Unauthenticated information disclosure in the My Private Site WordPress plugin (all versions before 4.2.3) exposes post content, post URLs, and comments to anonymous visitors, directly defeating the plugin's stated purpose of enforcing mandatory login across a WordPress site. The plugin fails to apply its privacy gate to certain front-end read surfaces, meaning requests to those endpoints bypass the authentication requirement entirely. A publicly available proof-of-concept exists; the vendor has released a corrective patch in version 4.2.3.

Unauthenticated information disclosure in the Smart Post WordPress plugin (versions prior to 4.0.8) exposes both the content of password-protected posts and the passwords themselves via an unprotected AJAX endpoint. Any unauthenticated remote user can query the endpoint to bypass WordPress's native post-password protection mechanism entirely, retrieving guarded content without knowing the password - and also harvesting the password itself for reuse. A public exploit is documented by WPScan; a vendor patch (4.0.8) has been released.

Flatpak's `org.freedesktop.Flatpak.SystemHelper` D-Bus service contains a TOCTOU race condition in the `Deploy()` function where a privileged `chmod` executes before OSTree repository validation completes, allowing a local low-privileged attacker to redirect symlinks to arbitrary system files within that timing window. A successful exploit can yield high-confidentiality impact (reading privileged files) and limited integrity and availability impact (CVSS C:H/I:L/A:L), as the unguarded chmod can be inherited by attacker-controlled symlink targets. No public exploit code or CISA KEV listing has been identified at time of analysis, and the High attack complexity (AC:H) reflects the precision timing required to win the race.

Race condition in jofpin trape 2.0 allows remote unauthenticated attackers to manipulate telemetry data via the vId argument in core/user.py's Telemetry Endpoint, yielding low-impact confidentiality, integrity, and availability compromise. Exploitation is rated high complexity (AC:H) due to the timing requirements inherent in race condition attacks, and the CVSS 4.0 base score is 2.9. A public proof-of-concept exists as a GitHub issue report (#408); the project maintainer has not responded to the disclosure.

SolidInvoice's REST API authenticator, in all versions prior to 3.0.1, silently accepts long-lived bearer tokens via a `?token=` URL query parameter as a fallback to the intended `X-API-TOKEN` request header, causing credentials to be permanently recorded in server access logs, reverse-proxy logs, CDN access logs, browser history, and HTTP Referer headers forwarded to third-party origins. Any actor with read access to those artifacts - sysadmins, log-aggregation pipelines, analytics vendors receiving Referer data, or post-compromise intruders pivoting through log stores - can extract a valid API token and authenticate to the invoicing platform without exploiting any application logic. Version 3.0.1 fixes the issue by removing the query-parameter fallback and enforcing header-only delivery; no public exploit has been identified at time of analysis.

In the Linux kernel, the following vulnerability has been resolved: selinux: require every boolean value to be defined p_bools.nprim comes from the policy image independently of how many booleans follow it, and cond_index_bool() fills bool_val_to_struct[] at value - 1, so a count larger than the values present leaves NULL entries. Every user of that array then walks it by index and dereferences each entry: cond_evaluate_expr() on the access-vector path, security_get_bools() and security_get_bool_value() behind selinuxfs, and security_set_bools(). A sparse class value is absorbed by policydb_class_isvalid() and its siblings; booleans have no such predicate, and no consumer that could use one. Reject a boolean value that no boolean defines, once, where the array is built. Conforming policies define every boolean they declare and are unaffected.

In the Linux kernel, the following vulnerability has been resolved: selinux: reject an unclaimed class value in security_get_classes() security_get_classes() sizes an array by p_classes.nprim and fills it at value - 1, so a class value the policy never defines leaves a NULL. sel_make_classes() passes every entry to sel_make_dir(), reaching the same d_alloc_name() dereference as the permission array. The class symbol table is allowed to be sparse (policydb_class_isvalid() exists to absorb that), but this getter builds its own array straight from the hash table and has no such predicate. Fail the lookup when a value went unclaimed instead of handing out the NULL. Conforming policies define every class they declare and are unaffected.

In the Linux kernel, the following vulnerability has been resolved: ASoC: SOF: sof-audio: Fix error path in sof_widget_setup_unlocked() If either tplg_ops->dai_config or widget_kcontrol_setup fail during widget setup we would double decrement the use_count of the widget because the sof_widget_free_unlocked() would be called twice, similarly the core_put would be invoked twice as well. Since the use_count and core_put() is handled within the widget_free function we need to return without falling through the pipe_widget_free label. The fixes tag is picked to the last change around this part of the code which is adequately old enough for backporting purposes.

In the Linux kernel, the following vulnerability has been resolved: ASoC: codecs: lpass-wsa-macro: Fix enum kcontrol accesses EAR SPKR PA Gain" and the four "WSA RX* Mux" controls are enumerated, but their get and put callbacks access the value through ucontrol->value.integer.value[0] (a long) instead of ucontrol->value.enumerated.item[0] (an unsigned int). This same pattern was fixed in the sibling drivers by commit bcfe5f76cc40 ("ASoC: codecs: rx-macro: fix accessing array out of bounds for enum type") and commit 0ea5eff7c606 ("ASoC: codecs: va-macro: fix accessing array out of bounds for enum type"), but wsa-macro was missed. On 64-bit kernels with CONFIG_SND_CTL_DEBUG this trips the elem value sanity check and every read of these controls fails with -EINVAL.

In the Linux kernel, the following vulnerability has been resolved: drm/amdgpu: Fix UVD dpb min size calculation for H264 This should use actual number of references from the decode message, instead of maximum derived from level. (cherry picked from commit 64b525edb7e7bdfcdc77883c5e413804e2396856)

In the Linux kernel, the following vulnerability has been resolved: net: packet: fix wrong transport_header when sending VLAN-tagged frame In packet_parse_headers(), when processing a VLAN-tagged frame, skb_set_network_header() is called to advance network_header past the VLAN tag to the inner protocol header. skb_probe_transport_header() is then called with skb->protocol still set to the outer VLAN EtherType (e.g. ETH_P_8021Q), while nhoff (derived from skb_network_offset()) already points past the VLAN tag to the inner protocol header. In __skb_flow_dissect(), proto is initialized to ETH_P_8021Q and nhoff points past the VLAN tag. When the dissector hits case ETH_P_8021Q, it reads a struct vlan_hdr at nhoff via __skb_header_pointer(), but that offset contains the inner protocol header (e.g. an IP header). The bytes are misinterpreted as a VLAN header, yielding a garbage encapsulated EtherType that matches no known protocol. The dissector returns false, so skb_probe_transport_header() never calls skb_set_transport_header(), leaving transport_header at its uninitialized sentinel value (~0U). Move skb_probe_transport_header() to before skb_set_network_header(). At the time skb_probe_transport_header() is called, network_header still points to the VLAN header, so nhoff correctly points to the VLAN header. The flow dissector can then parse the VLAN header, extract the inner EtherType, and advance nhoff to the inner protocol header, allowing transport_header to be set correctly.

In the Linux kernel, the following vulnerability has been resolved: net: tap: fix wrong transport_header when sending VLAN-tagged frame In tap_get_user_xdp(), when processing a VLAN-tagged frame (e.g. ETH_P_8021Q), skb_set_network_header() is called first to advance network_header past the VLAN tag to the inner protocol header. skb_probe_transport_header() is then called with skb->protocol still set to ETH_P_8021Q, while nhoff (derived from skb_network_offset()) already points past the VLAN tag to the inner protocol header. In __skb_flow_dissect(), proto is initialized to ETH_P_8021Q and nhoff points past the VLAN tag. When the dissector hits case ETH_P_8021Q, it reads a struct vlan_hdr at the current nhoff via __skb_header_pointer(), but that offset contains the inner protocol header (e.g. an IP header). The bytes are misinterpreted as a VLAN header, yielding a garbage encapsulated EtherType that matches no known protocol. The dissector returns false, so skb_probe_transport_header() never calls skb_set_transport_header(), leaving transport_header at its uninitialized sentinel value (~0U). Move skb_set_network_header() to after skb_probe_transport_header(). At the time skb_probe_transport_header() is called, network_header still points to the VLAN header (offset ETH_HLEN), so nhoff is correct and the flow dissector can parse the VLAN header, extract the inner EtherType, and advance nhoff to the inner protocol header, allowing transport_header to be set correctly.

In the Linux kernel, the following vulnerability has been resolved: net/tls: Fail tls_sw_splice_read() after a failed async decrypt When an async decrypt fails, tls_decrypt_done() records the error in ctx->async_wait.err and calls tls_err_abort(), which stores it in sk_err. tls_sw_recvmsg() and tls_sw_read_sock() each read async_wait.err once they hold the reader lock and fail the call: a record that did not authenticate breaks the connection. tls_sw_splice_read() has no such check, and sk_err does not stand in for one. tls_rx_rec_wait() tests sk_err only inside the loop it skips whenever a record is already parsed, and the first reader to reach sock_error() clears it, while async_wait.err persists. A splice therefore keeps delivering records on a connection that recvmsg() and read_sock() refuse to read. Read async_wait.err in tls_sw_splice_read() as the other two readers do.

In the Linux kernel, the following vulnerability has been resolved: drm/xe/oa: Fix sync entry leak on OA config emit failure xe_oa_emit_oa_config() releases the sync entries and the syncs array only on its success path. When it fails before the point of no return (fence allocation, config buffer allocation or batch submission), it returns without touching stream->syncs. The stream open path handles such failures in the caller, but xe_oa_config_locked() propagates the error without any cleanup, so the syncs array and the fence references held by the parsed entries are leaked. The next config ioctl overwrites stream->syncs, making the memory unreachable for good. Clean up the parsed syncs when xe_oa_emit_oa_config() fails, matching the cleanup done by the stream open error path. (cherry picked from commit 8af97b3da2cfce04e6b457c6eb17ed3c1daf912b)

In the Linux kernel, the following vulnerability has been resolved: dmaengine: sun6i-dma: Fix reclaim descriptors while terminating DMA When terminating DMA transfers, active descriptors are not properly reclaimed. Only cyclic descriptors were handled, leaving non-cyclic descriptors and their LLI chains to be permanently leaked. Fix by using vchan_terminate_vdesc() which handles both cyclic and non-cyclic descriptors by adding them to desc_terminated queue for proper cleanup. Add pchan->desc != pchan->done check to prevent double-adding completed descriptors, which would corrupt the list.

In the Linux kernel, the following vulnerability has been resolved: ipvs: fix the checksum validations ip_vs_in_icmp_v6() is missing checksum validation for ICMPv6 packets from clients. In fact, as for TCP/UDP we should validate the checksum for ICMP packets only when we mangle the packets on MASQ or on reply for tunnel. Also, Sashiko points out that handle_response_icmp() being common for IPv4 and IPv6 is missing the pseudo-header calculation while validating ICMPv6 messages from real servers which is a problem if checksum is not validated by the hardware. Fix the problems by creating ip_vs_checksum_common_check() helper and use it for TCP/UDP/ICMP both for IPv4 and IPv6. Rely on the nf_checksum() for validating the ICMP messages but use it also for TCP and UDP. Use correct IP offset for IP_VS_DBG_RL_PKT for TCP/UDP/SCTP. IPVS packets (TCP/UDP/SCTP/ICMP) do not need checksum validation on LOCAL_OUT (local clients or local real servers) and on FORWARD (traffic from servers on LAN). Do it only on LOCAL_IN, in case nf_checksum() is not called on PRE_ROUTING. Also, ip_vs_checksum_complete() can be marked static.

In the Linux kernel, the following vulnerability has been resolved: ASoC: SDCA: Make UMP message size check more robust If message offset was larger than the buffer length the size check will pass incorrectly. Refactor the check such that it is more robust to invalid sizes.