| CVE |
Vendors |
Products |
Updated |
CVSS v3.1 |
| In the Linux kernel, the following vulnerability has been resolved:
ocfs2/dlm: serialize migration MLE cleanup on failure
A migration MLE has a base reference for the mastering answer and an
in-use reference held by dlm_migrate_lockres(). The finishing assertion
consumes the base reference, but migration failure drops it again
without checking whether the assertion already consumed it.
The target queues its migration worker before it acknowledges the
ALL_DONE packet, so its finishing assertion can be handled while the
sender still waits for the status. If the connection fails before the
status arrives, dlm_send_one_lockres() returns an error for a migration
that the target has already completed:
Old-master sender Finishing assertion
----------------- -------------------
publish MLE; take in-use reference
send ALL_DONE; wait for status
take lookup reference
unlink MLE
put lookup and base references
send returns a connection error
put base reference again; free MLE
put in-use reference; access freed MLE
dlm_assert_master_handler() holds dlm->spinlock from the MLE lookup to
the final puts, and it takes dlm->master_lock around the unlink and the
puts. Decide under the same locks: if the MLE is already unhashed, the
assertion consumed the base reference, so drop only the sender's in-use
reference. Otherwise unlink it before consuming the base reference so a
later assertion no longer finds it.
An assertion that got there first has also made the target the owner
and cleared DLM_LOCK_RES_MIGRATING. Treating the attempt as failed at
that point would leave the lockres owned by the target while this node
still holds the other nodes' locks and refmap bits, so it could neither
be purged nor migrated again. Finish our side as a completed migration
does instead: drop those locks under res->spinlock if the target still
owns the lockres, and recalculate its usage.
Use the same cleanup for the pre-send failure, the send failure and the
target-death failure paths. The sender's in-use reference keeps the MLE
alive until its final put outside the nested locks. Successful
migration retains its existing in-use-only put.
A target that has died cannot assert after the sender has seen its
death. The o2net node-down callback runs before the DLM one; it
disconnects the node and flushes the workqueue that runs the message
handlers, so an assertion already received has been handled by the time
the DLM removes the node from the domain map. A node that leaves the
domain cleanly sends its exit message only after its assertions have
been answered.
Two windows of the hand-over itself are left as they are: the handler
switches the owner and the sender drops the other nodes' locks moments
later, and an assertion from a live target that arrives after the
sender has given up still meets the owner check in the handler. Waiting
for the target before giving up would only stretch the first window
into the time in which recovery of the target can observe it.
KASAN report, only the relevant frames are kept:
BUG: KASAN: slab-use-after-free in dlm_put_mle_inuse+0xce/0xe0
Read of size 8 at addr ffff8881190e3c20 by task umount/593
Call Trace:
<TASK>
dlm_put_mle_inuse+0xce/0xe0
dlm_migrate_lockres+0x16af/0x20d0
dlm_empty_lockres+0x60a/0xbd0
dlm_unregister_domain+0x53b/0x11d0
o2cb_cluster_disconnect+0xa5/0x110
ocfs2_cluster_disconnect+0x73/0xc0
ocfs2_dlm_shutdown+0x311/0x440
ocfs2_dismount_volume+0x696/0x940
generic_shutdown_super+0x15f/0x490
kill_block_super+0x40/0xa0
deactivate_locked_super+0xae/0x120
deactivate_super+0xa2/0xc0
cleanup_mnt+0x217/0x450
task_work_run+0x144/0x230
</TASK>
Allocated by task 593:
kmem_cache_alloc_noprof+0x20b/0x5c0
dlm_migrate_lockres+0x20e/0x20d0
dlm_empty_lockres+0x60a/0xbd0
dlm_unregister_domain+0x53b/0x11d0
o2cb_cluster_disconnect+0xa5/
---truncated--- |
| In the Linux kernel, the following vulnerability has been resolved:
ocfs2: find the xattr entry again after defragmenting a bucket
ocfs2_xattr_set_entry_bucket() hands loc.xl_entry to ocfs2_xa_set() twice:
once for the bucket as it stands, and, if that reports -ENOSPC, once more
after ocfs2_defrag_xattr_bucket() has packed the name/value pairs down.
Defragmenting ends by sorting the entry array on xe_name_hash. Buckets
are kept sorted, so the sort only permutes entries that share a hash, but
lib/sort.c is an unstable heapsort and it does permute them. loc.xl_entry
is an address inside xh_entries[], so afterwards it denotes whichever
entry landed in that slot rather than the one the search found.
The second ocfs2_xa_set() then works on the wrong entry. Nothing on that
path compares the entry's name with xi->xi_name, so what happens depends
on how the two entries compare in size: ocfs2_xa_reuse_entry() trips its
BUG_ON() when the padded name sizes differ, and otherwise the new value is
written into the neighbouring attribute's value slot while the attribute
being set is left untouched. setxattr() reports success either way.
Remember the entry's hash before defragmenting and look the entry up
again afterwards, the way ocfs2_xattr_bucket_find() does. An entry that
cannot be found again means the bucket no longer holds what the search
found, so fail with -EFSCORRUPTED rather than writing through the stale
pointer. |
| In the Linux kernel, the following vulnerability has been resolved:
mm/cma: accept memory of CMA areas reserved at a fixed address
CMA areas allocated from memblock have their memory accepted by
memblock_alloc_range_nid(), but areas reserved at a fixed address with
memblock_reserve() are not.
If a fixed CMA area is requested by the cma=<size>@<base> command line
parameter, it may be in regular RAM and on TDX and SEV-SNP guests it
must be accepted.
Accept the memory of fixed CMA areas as well, so that all CMA areas are
accepted regardless of how they were reserved. |
| In the Linux kernel, the following vulnerability has been resolved:
mm/cma: accept memory of multi-range CMA areas
Patch series "mm/cma: accept memory of CMA areas reserved with
memblock_reserve()", v1.
Pages of allocated CMA areas are released to the buddy allocator with
__free_pages(), which does not check for unaccepted memory.
This usually works because memblock accepts the memory it allocates.
However, multi-range CMA areas, used by hugetlb_cma, and fixed CMA areas
requested with cma=<size>@<base> are reserved with memblock_reserve() and
their memory is never accepted.
On TDX and SEV-SNP guests the first access to such a page is fatal.
To ease the backporting, each case is addressed by a separate patch:
- patch 1 accepts the memory of multi-range CMA areas
- patch 2 does the same for the fixed CMA areas
The second patch won't apply cleanly to 6.6 and 6.12, but I believe the
stable team LLMs will take care of that :)
This patch (of 2):
On systems with unaccepted memory, memblock allocations accept the
allocated range, but when cma_declare_contiguous_multi() uses open coded
allocation of multiple ranges, it reserves them with memblock_reserve()
and they are never accepted.
These pages are released to the buddy allocator by cma_activate_area()
with __free_pages() that does not check for unaccepted memory, so the
first access to such a page in a TDX or SEV-SNP guest is fatal.
Accept the memory of each range when it is reserved. |
| Missing Authorization vulnerability in Omnisend Newsletters, Email Marketing, SMS and Popups by Omnisend omnisend allows Exploiting Incorrectly Configured Access Control Security Levels.This issue affects Newsletters, Email Marketing, SMS and Popups by Omnisend: from n/a through 1.9.1. |
| The Simple Membership WP user Import plugin for WordPress is vulnerable to Cross-Site Request Forgery in all versions up to, and including, 1.9.2 This is due to missing or incorrect nonce validation on the add function. This makes it possible for unauthenticated attackers to import arbitrary WordPress users into Simple Membership and modify their WordPress role via the plugin's membership-level-to-role mapping via a forged request granted they can trick a site administrator into performing an action such as clicking on a link. Successful exploitation additionally requires an action by an administrator — the attacker cannot trigger the vulnerability on their own. |
| The Seraphinite Accelerator plugin for WordPress is vulnerable to Stored Cross-Site Scripting via the 'HTTP_USER_AGENT' parameter in all versions up to, and including, 2.31 due to insufficient input sanitization and output escaping. This makes it possible for unauthenticated attackers to inject arbitrary web scripts in pages that will execute whenever a user accesses an injected page. Exploitation requires that an administrator has previously enabled the 'Enable logging' and 'HTTP trace' diagnostic options in the plugin's Advanced → Debug settings, both of which are disabled by default. |
| In Splunk Enterprise versions below 10.4.5, 10.2.9, 10.0.12, and 9.4.17, a user who holds the "power" Splunk role could craft a shared Classic Dashboard that runs arbitrary Search Processing Language (SPL) commands for another authenticated user. Exploitation requires the dashboard viewer to open the shared dashboard. The injected commands could access data available to the dashboard viewer, modify data available to the dashboard viewer, and partially disrupt Splunk Enterprise.
For more information see Add sparklines to search results (https://help.splunk.com/en/splunk-enterprise/search/search-manual/10.6/calculate-statistics/add-sparklines-to-search-results), Configure dashboard permissions (https://help.splunk.com/en/splunk-enterprise/create-dashboards-and-reports/simple-xml-dashboards/10.6/manage-and-share-dashboards/configure-dashboard-permissions), and SPL safeguards for risky commands (https://help.splunk.com/en/splunk-enterprise/administer/manage-users-and-security/10.6/best-practices-for-splunk-platform-security/spl-safeguards-for-risky-commands) in the Splunk documentation. |
| In Splunk Enterprise versions below 10.4.5, 10.2.9, 10.0.12, and 9.4.17, a user who holds the "power" Splunk role could add attacker-controlled Search Processing Language (SPL) to a shared dashboard. When another user opens the dashboard in Splunk Web, Splunk Enterprise could run the attacker-controlled SPL using the permissions of that dashboard viewer. The attacker-controlled SPL could expose stored credentials, modify indexed data, and reduce availability.
The vulnerability is possible because Splunk Enterprise does not neutralize special elements in search filter values before it builds optimized search jobs.
The vulnerability requires the attacker to phish the affected user by tricking them into initiating a request within their browser. The attacker should not be able to exploit the vulnerability at will. |
| In Splunk Enterprise versions below 10.4.5, 10.2.9, 10.0.12, and 9.4.17, a user who holds the "power" Splunk role could create and share a dashboard that contains attacker-controlled Search Processing Language (SPL). The SPL could run using the permissions of the user who opens the dashboard. With this access, the user who created the dashboard could expose stored credentials and write data to an index.
The vulnerability is possible because Splunk Enterprise does not correctly escape field names in searches that use the rename command.
For more information see rename (https://help.splunk.com/en/splunk-enterprise/spl-search-reference/10.4/search-commands/rename) and SPL safeguards for risky commands (https://help.splunk.com/en/splunk-enterprise/administer/manage-users-and-security/10.4/best-practices-for-splunk-platform-security/spl-safeguards-for-risky-commands) in the Splunk documentation. |
| In Splunk Enterprise versions below 10.4.5, 10.2.9, 10.0.12, and 9.4.16, a user who does not hold the "admin" or "power" Splunk roles could use Data Model Acceleration to run malicious Search Processing Language (SPL) commands and perform actions through the Representational State Transfer (REST) API that the user cannot perform directly.
The vulnerability is possible because Splunk Enterprise does not neutralize user-provided data before it adds that data to a generated search.
For more information, see Accelerate data models (https://help.splunk.com/en/splunk-enterprise/manage-knowledge-objects/knowledge-management-manual/10.2/use-data-summaries-to-accelerate-searches/accelerate-data-models), Define roles on the Splunk platform with capabilities (https://help.splunk.com/en/splunk-enterprise/administer/manage-users-and-security/10.2/manage-splunk-platform-users-and-roles/define-roles-on-the-splunk-platform-with-capabilities), and About the search language (https://help.splunk.com/en/splunk-enterprise/search/search-manual/10.6/search-overview/about-the-search-language). |
| In Splunk Enterprise versions below 10.4.5, 10.2.9, 10.0.12, and 9.4.17, a user who holds the "power" Splunk role could store malicious Search Processing Language (SPL) in a shared dashboard. The malicious SPL could run using the permissions of the user who opened the dashboard and could access or modify data available to that user and disrupt Splunk Enterprise availability.
The vulnerability is possible because Splunk Enterprise does not preserve quoted search argument boundaries when it processes a dashboard search.
The vulnerability requires the attacker to phish the affected user by tricking them into initiating a request within their browser. The attacker, a user who holds the "power" Splunk role, should not be able to exploit the vulnerability at will. |
| In Splunk Enterprise versions below 10.4.5, 10.2.9, 10.0.12, and 9.4.17, a low-privileged user who holds the "power" Splunk role could inject arbitrary Search Processing Language (SPL) commands into a Classic Dashboard search. When another user opens the affected dashboard in Splunk Web, those injected commands execute with the viewing user's permissions, potentially allowing the low-privileged user to access stored credentials and write data to indexes.
The vulnerability is possible because Splunk Enterprise does not correctly escape user-supplied content when it rewrites a search, which lets the rewritten search include additional SPL commands.
The vulnerability requires another user to open the dashboard in Splunk Web. Consequently, a user who holds the "power" Splunk role should not be able to exploit the vulnerability at will.
For more information see SPL safeguards for risky commands (https://help.splunk.com/en/splunk-enterprise/administer/manage-users-and-security/10.6/best-practices-for-splunk-platform-security/spl-safeguards-for-risky-commands) and Define roles on the Splunk platform with capabilities (https://help.splunk.com/en/splunk-enterprise/administer/manage-users-and-security/10.6/manage-splunk-platform-users-and-roles/define-roles-on-the-splunk-platform-with-capabilities) in the Splunk documentation. |
| In Splunk Enterprise versions below 10.6.1, 10.4.5, 10.2.9, 10.0.12, and 9.4.17, a low-privileged user who does not hold the "admin" or "power" Splunk roles could inject a malicious script into the name of a private saved search. If another user subsequently enables, disables, or edits the corresponding platform alert in the Monitoring Console, the injected script executes within that user's browser session, potentially allowing the low-privileged user to view sensitive information or modify data in Splunk Enterprise.
The vulnerability is possible because the Monitoring Console does not safely handle saved-search names in the platform alert workflow.
For more information see Enable and configure platform alerts (https://help.splunk.com/en/splunk-enterprise/administer/monitor/10.4/configure-the-monitoring-console/enable-and-configure-platform-alerts) and About configuring role-based user access (https://help.splunk.com/en/splunk-enterprise/administer/manage-users-and-security/10.4/manage-splunk-platform-users-and-roles/about-configuring-role-based-user-access) in the Splunk documentation. |
| In Splunk Enterprise versions below 10.4.5, 10.2.9, 10.0.12, and 9.4.17, a user who does not hold the "admin" or "power" Splunk roles could use the apps backup and restore Representational State Transfer (REST) API to prevent subsequent apps backup or restore operations until Splunk Enterprise restarts. This could result in a Denial of Service (DoS).
The vulnerability is possible because the apps backup and restore REST API handlers do not correctly enforce authorization. |
| In Splunk Enterprise versions below 10.4.5, 10.2.9, 10.0.12, and 9.4.17, a user that holds a role with the list_deployment_server capability could access sensitive information from inputs.conf files outside the intended deployment app directory through the Representational State Transfer (REST) API.
The vulnerability is possible because the REST API does not restrict a deployment app name to an existing deployment app before reading input configurations.
For more information see authorize.conf (https://help.splunk.com/en/splunk-enterprise/administer/admin-manual/10.4/configuration-file-reference/10.4.4-configuration-file-reference/authorize.conf), Deployment server architecture (https://help.splunk.com/en/splunk-enterprise/administer/update-your-deployment/9.0/deployment-server-and-forwarder-management/deployment-server-architecture), and inputs.conf (https://help.splunk.com/en/splunk-enterprise/administer/admin-manual/9.4/configuration-file-reference/9.4.16-configuration-file-reference/inputs.conf) in the Splunk documentation. |
| In Splunk Enterprise versions below 10.6.1, 10.4.5, and 10.2.9, a low-privileged user who does not hold the "admin" or "power" Splunk roles could access file path and metadata listings from search head knowledge bundles via the Representational State Transfer (REST) API. This unauthorized access could expose sensitive metadata, including Splunk platform usernames, private knowledge-object configuration file names, installed application directories, and the file path names of security-sensitive configuration and key files.
The vulnerability is possible because the REST API actions that list bundle contents and denied files use a capability available to the "user" role instead of requiring distributed-search administration capabilities.
For more information see Knowledge bundle replication overview (https://help.splunk.com/en/splunk-enterprise/administer/distributed-search/10.6/knowledge-bundle-replication/knowledge-bundle-replication-overview) in the Splunk documentation. For more information see Define roles on the Splunk platform with capabilities (https://help.splunk.com/en/splunk-enterprise/administer/manage-users-and-security/10.6/manage-splunk-platform-users-and-roles/define-roles-on-the-splunk-platform-with-capabilities) in the Splunk documentation. |
| In Splunk Enterprise versions below 10.4.4, 10.2.8, 10.0.11, and 9.4.16, an unauthenticated user could craft a malicious link that, if opened by an authenticated user, executes arbitrary Search Processing Language (SPL) searches with the victim's permissions.
Successful exploitation could allow the unauthenticated user to access or modify data, alter Splunk platform configurations, and disrupt operations available to the affected user.
The vulnerability is possible because the Portable Document Format (PDF) generation component processes request data before it rejects deprecated GET requests and does not apply SPL safeguards for risky commands to subsearches.
For more information see Generate PDFs of your reports and dashboards (https://help.splunk.com/en/splunk-enterprise/create-dashboards-and-reports/reporting-manual/10.4/report-management/generate-pdfs-of-your-reports-and-dashboards) and SPL safeguards for risky commands (https://help.splunk.com/en/splunk-enterprise/administer/manage-users-and-security/10.4/best-practices-for-splunk-platform-security/spl-safeguards-for-risky-commands) in the Splunk documentation. |
| In Splunk Enterprise versions below 10.4.5, 10.2.9, 10.0.12, and 9.4.17, an unauthenticated user could inject arbitrary fields into Splunk Enterprise audit records via the Representational State Transfer (REST) API.
Successful exploitation could allow the unauthenticated user to forge audit evidence, compromising the integrity of audit reviews and security detections that rely on legacy audit-field parsing.
The vulnerability exists because Splunk Enterprise does not neutralize field delimiters in user-supplied data before writing the data to a legacy audit record. The affected workflow also does not create a corresponding structured audit record.
For more information see Auditing activities in a Splunk platform instance (https://help.splunk.com/en/splunk-enterprise/administer/manage-users-and-security/10.0/audit-activity-in-splunk-enterprise/auditing-activities-in-a-splunk-platform-instance) and About structured audit trail logs (https://help.splunk.com/en/splunk-enterprise/administer/manage-users-and-security/10.2/audit-activity-in-splunk-enterprise/about-structured-audit-trail-logs) in the Splunk documentation. |
| In Splunk Enterprise versions below 10.4.5, 10.2.9, 10.0.12, and 9.4.17, an unauthenticated user could access RapidDiag process metadata and log file inventory information through the Representational State Transfer (REST) API.
The vulnerability is possible because certain RapidDiag REST API endpoints accept a factory-default shared key for node authentication, which lets requests bypass Splunk user authentication.
For more information see Using RapidDiag (https://help.splunk.com/en/splunk-enterprise/administer/troubleshoot/9.0/contact-splunk-support/using-rapiddiag) and Secure Splunk Enterprise services with pass4SymmKey (https://help.splunk.com/en/splunk-enterprise/administer/manage-users-and-security/10.0/secure-distributed-and-clustered-splunk-environments/secure-splunk-enterprise-services-with-pass4symmkey) in the Splunk documentation. |