The Kirki - Freeform Page Builder, Website Builder & Customizer plugin for WordPress is vulnerable to Unauthorized Data Access in versions up to, and including, 6.4.1 via the `kirki_post_apis` AJAX action's `get-dynamic-content-batch` and `get-collection-batch` endpoints. This is due to the plugin opening these resolvers behind a site-wide, resource-unbound preview token (`EditorPreview::has_valid_token()`) that is NOT bound to the specific page the administrator intended to share, combined with the absence of any `list_users` or `can_user_read_post()` capability check inside `HelperFunctions::get_user_dynamic_content()` and `Collection::get_collection_batch()` — the equivalent checks ARE present on the plugin's own REST route (`FrontendRESTController::get_item_permissions_check()`). This makes it possible for unauthenticated attackers holding any valid read-only share link to extract from the entire user table every user's `user_email`, `first_name`, `last_name`, `nickname`, `registered_date`, arbitrary string-valued `user_meta` (including custom keys such as `billing_phone`), and the e-mail address of every approved commenter — information that WordPress itself withholds from anonymous readers (served only in the `edit` context behind `list_users`).
Apache Kafka contains a vulnerability in its code-generated protocol readers where an attacker can cause the broker to allocate excessive heap memory by declaring an array length much larger than the actual request buffer size. This leads to an OutOfMemoryError and broker crash. The issue affects all Kafka API types with array fields and occurs before authorization checks, allowing unauthenticated attackers on unauthenticated listeners to exploit it. The vulnerability is fixed in Apache Kafka versions 4.2.2, 4.3.2, and 4.4.0.
CVE-2026-64123 is a vulnerability related to the handling of node table freeing in the net: hsr component, specifically involving deferring node table free operations until after RCU readers have completed. The vulnerability is identified with CWE-416, indicating a use-after-free issue. The affected version is exactly version 4.0 of the Microsoft product. No CVSS score or detailed impact information is provided, and there are no known exploits in the wild. No patch or remediation details are available in the provided data.
LibreOffice can import EMF, EMF+ and WMF images, which may be embedded in documents. Several out-of-bounds reads existed in the readers for these formats, because sizes, counts and offsets taken from a crafted image were not checked against the data the image actually holds. In fixed versions these values are checked against the size of each record and the data that remains, and a record that fails the checks is not used.
In the vulnerability-lookup web application, the authentication decorators for feed-key requests (auth_feedkey_func in website/decorators.py) and API-key requests (auth_func in website/web/api/v1/common.py) called Flask-Login's login_user() function. This caused the HTTP response to a request authenticated solely by a feed key (supplied as the X-FEED-KEY URL parameter) or an API key (supplied as the X-API-KEY header) to set a session cookie that grants full authenticated access to every page in the application, without requiring a password or two-factor authentication.
The practical impact is that any party possessing a leaked feed URL (a common occurrence, as feed URLs are shared with RSS readers) or an API key could obtain a valid web session for the associated account. This session provides access to the user's account page, which exposes the API key and other profile data, and for accounts with the administrator role, access to the /admin interface, enabling full administrative control of the application.
The vulnerability affects all users whose feed key or API key is exposed. No prior authentication, user interaction, or special network conditions are required; a single HTTP request with the token is sufficient to establish the session. The session persists until it expires, and because it is not bound to the original credential (a related CWE-613 issue noted by the developers), revoking the feed key or API key does not invalidate the already-created session.
The fix replaces the login_user() call with assignment to g._login_user, which Flask-Login's current_user property reads for the current request only, without writing any session cookie. The affected views remain unchanged and continue to see the authenticated user for the single request.
NLTK's YCOECorpusReader allows directory symlinks named 'psd' or 'pos' inside a YCOE corpus to escape the intended corpus root containment. This occurs because the path joining and validation logic does not resolve symlinks properly, enabling nested sub-readers to access files outside the corpus root but within the global NLTK data sandbox. An attacker controlling the corpus contents can exploit this to read files outside the corpus root, but only within the allowed sandbox. The vulnerability affects NLTK versions 3.10.0 through 3.10.3 and is fixed in version 3.10.4.
WriteFreely versions before 0.17.3 contain a stored cross-site scripting (XSS) vulnerability. Authenticated authors can exploit this by injecting malicious HTML through the post slug in the CreatePost API. This injected script executes in RSS/Atom feed readers, newsletter recipients, and ActivityPub viewers. The vulnerability is fixed in version 0.17.3.
A vulnerability in the Linux kernel's xen-netback component related to XenBus connection failure cleanup has been fixed. The issue involved improper handling of vif->num_queues under rcu_read_lock, which could lead to readers accessing invalid queues. The fix ensures that vif->num_queues is unpublished before synchronize_net is called, preventing access to invalid queues. This vulnerability is tracked as XSA-531 and affects multiple Linux kernel versions.
The bsv-rs library versions before 0.8.5 and certain beta versions allow transaction readers to accept trailing bytes after a parsed transaction. This causes the transaction's cached serialization and ID to include extra bytes, potentially resulting in a transaction being identified by a different ID than expected. The issue is fixed in versions 0.8.5 and 0.9.0-beta.7.0.
Vikunja versions prior to 2.7.1 have an information exposure vulnerability where the request logger records the raw URI of the /shares/:share/auth route. This logging behavior exposes link-share hashes in logs accessible to attackers with access to Vikunja or reverse proxy logs. These hashes are non-expiring and not password-protected, allowing attackers to reuse them to obtain project JWTs with read, write, or admin permissions.
Rustls versions before 0.23.46 and 0.24.0-dev.2 contain an information disclosure vulnerability. The issue arises from derived Debug formatting of client session values, which can expose secret key material. Specifically, custom ClientSessionStore implementations that log Tls12ClientSessionValue or Tls13ClientSessionValue may leak TLS 1.2 master secrets or TLS 1.3 resumption PSKs to log readers.
CVE-2026-99280 is a vulnerability in the Linux kernel's ksmbd component where improper handling of session procfs readers during session cleanup can cause use-after-free conditions. The flaw arises when session table references are dropped while procfs entries remain accessible. The issue is fixed by removing procfs entries before dropping table references and properly draining procfs readers during connection cleanup.
eBook-speaker versions 6.1.0 through 6.2.0 have a stack buffer overflow vulnerability in the get_attributes() function due to an unbounded strcpy operation on an element's name attribute. This flaw allows an attacker to craft a specially designed EPUB or DAISY book with a name attribute of 511 or more characters, which can corrupt the stack and cause the reader application to crash when opening the file.
CVE-2026-99237 is a high-severity vulnerability in the Linux kernel tracing subsystem. It involves improper locking when resetting last boot data from readers, which can lead to double freeing of memory and concurrent modification issues. The flaw arises because update_last_data_if_empty() is called without holding the required trace_types_lock in certain code paths, allowing race conditions between readers and module notifiers.