Elastic

Log injection in @logtape/syslog allows network-accessible attackers to forge arbitrary syslog records in downstream collectors such as rsyslog, Splunk, and Elastic Stack. The escapeStructuredDataValue() function omits C0 control character escaping, so a literal newline embedded in a log property value terminates the current RFC 6587 TCP syslog frame and begins a new one; if the attacker-supplied bytes constitute a valid RFC 5424 header, the downstream collector accepts them as a separate, authentic-looking record. A second injection path exists through unvalidated SD-NAME keys, which can prematurely close structured-data elements. Both paths require the non-default SyslogSinkOptions.includeStructuredData: true setting. Publicly available proof-of-concept code exists; no CISA KEV listing at time of analysis.

Insecure direct object reference in Kibana's AI Assistant feature allows an authenticated low-privileged user to access or modify another user's AI conversation by supplying that conversation's identifier in API requests. Affected versions are addressed in the Elastic security update ESA-2026-51, covering Kibana 8.16.3 and 8.17.2. No public exploit code or active exploitation has been identified at time of analysis; the AC:H rating reflects the hard-to-guess nature of the conversation identifier as a meaningful practical barrier.

Hardened-mode SSRF protections in the mcp-searxng Node.js MCP server (npm/mcp-searxng < 1.2.1) can be bypassed via three distinct techniques, allowing `web_url_read` to fetch loopback and internal network resources despite `MCP_HTTP_HARDEN=true` being set. The bypasses exploit: unvalidated HTTP redirect chains to internal addresses, the unblocked `0.0.0.0` special address, and IPv4-mapped IPv6 literals that survive Node's WHATWG URL canonicalization intact but defeat regex-based private-address filters. Publicly available proof-of-concept code demonstrates all three bypass paths returning content from a loopback sentinel service; no KEV listing exists at time of analysis.

Broken access control in phpMyFAQ before 4.1.7 exposes sensitive infrastructure configuration to any authenticated user, regardless of permission level. Admin API read endpoints for LDAP, Elasticsearch, OpenSearch, and dashboard configuration fail to enforce the CONFIGURATION_EDIT permission check, meaning a low-privileged account holder can retrieve LDAP server topology, bind account names, search bases, index statistics, and site analytics. No public exploit or CISA KEV listing exists at time of analysis, but the low attack complexity and broad exposure to all authenticated users make this a meaningful reconnaissance risk in environments with LDAP or Elastic integrations.

Denial of service in Kibana's Cases module allows any authenticated user with case comment privileges to permanently render a specific case inaccessible to all users by posting a comment containing malformed link syntax. The comment rendering pipeline fails to sanitize or reject the invalid input, triggering an uncaught exception (CWE-248) that prevents the case from loading for every subsequent viewer until the offending comment is manually deleted. No public exploit has been identified at time of analysis, and no CISA KEV listing is present; the CVSS score of 4.3 (Medium) reflects the limited blast radius - individual cases rather than the Kibana instance as a whole are affected.

Denial of service in Elasticsearch's wildcard matching component allows any authenticated user with search access to terminate an affected node by submitting a single crafted query. The recursive wildcard evaluator has no bounds on recursion depth or total match operations; a pattern containing many wildcard groups evaluated against a sufficiently long field name exhausts the JVM thread stack, triggering a StackOverflowError that Elasticsearch treats as unrecoverable, causing immediate node shutdown rather than graceful request failure. No public exploit has been identified at time of analysis, but exploitation requires only low-privilege search access (CVSS PR:L), meaning any application service account or authenticated API user represents a viable threat origin.

Elasticsearch API key leakage in Kibana Fleet exposes enrolled agent credentials to any low-privileged authenticated user through a filter-based side channel. Fleet's agent listing endpoint accepts caller-supplied filter expressions evaluated under Kibana's own elevated internal Elasticsearch privileges rather than the caller's, and the match count in each response functions as a boolean oracle, enabling character-by-character reconstruction of the full API key value across all Kibana versions prior to 8.19.20, 9.4.5, and 9.5.1. No public exploit code has been identified and the vulnerability is not listed in the CISA KEV catalog at time of analysis, but the CVSS 7.1 (C:H) rating reflects the severity of full credential exfiltration via an authenticated, network-reachable, low-complexity attack.

Privilege escalation in Kibana Fleet allows authenticated low-privileged users to expand the write scope of Elasticsearch API keys issued to Elastic Agents beyond intended boundaries. By declaring extra data streams in an integration policy, an attacker causes Fleet to over-provision the API key given to enrolled agents, granting write-insert and index-mapping-extension privileges on indices outside the legitimate scope of that integration. No public exploit has been identified at time of analysis, and the flaw has not been listed in the CISA KEV catalog, but the network-accessible attack vector and low privilege requirement make this a meaningful integrity risk in multi-tenant or shared Elastic Stack deployments.

Privilege escalation in Kibana Fleet allows an authenticated low-privileged user to bypass integration-scoped authorization controls by exploiting a logic flaw in how policy update requests are validated (CWE-863). An operator holding only the Elastic Defend endpoint policy management role can craft a Fleet API update request that substitutes a different integration type into an existing endpoint policy they control, because Fleet evaluates the authorization check against the stored policy's original integration rather than the replacement integration supplied in the request. No public exploit code has been identified at time of analysis, but the vendor (Elastic) has issued advisory ESA-2026-127 with patched releases.

Cross-space authorization bypass in Kibana allows authenticated users to access trained machine learning model inference outputs, and stop or modify active model deployments, in Kibana Spaces they are not authorized to access. The vulnerability arises because API endpoints for ML model inference and deployment management accept user-controlled resource identifiers without enforcing space-level ACL boundaries, enabling privilege escalation across the Space isolation boundary. No public exploit code has been identified and Elastic has released fixed versions 8.19.20, 9.4.5, and 9.5.1 per advisory ESA-2026-126.

Incorrect authorization in Kibana Agent Builder allows authenticated users to access, modify, or delete private agents they do not own when sharing a username with another principal across different Elasticsearch authentication realms. The flaw stems from a fallback ownership check that compares usernames - which are not unique across realms - rather than stable user identifiers, enabling cross-realm identity confusion. No public exploit or active exploitation (CISA KEV) has been identified at time of analysis, but the low attack complexity and network accessibility make this a credible insider or multi-tenant threat.

Heap corruption and potential remote code execution in Elasticsearch's native ML inference engine can be triggered by any user holding the low-privilege ML model upload and deploy permission. By crafting a model that embeds an operation computing a memory address from an attacker-controlled offset, a low-privileged authenticated user can cause the native inference subprocess to read and write outside its allocated heap, reliably crashing that process or, under controlled heap layout conditions, executing arbitrary code within it. No active exploitation or public proof-of-concept has been identified at time of analysis, but the CVSS 8.8 rating, network-accessible vector, and explicit RCE potential in the vendor description place this in the urgent-remediation tier for any organization running Elasticsearch with ML features delegated to non-admin users.

Cross-namespace secret exfiltration in the Elastic Cloud on Kubernetes (ECK) operator allows any low-privileged Kubernetes tenant to read secrets from arbitrary namespaces cluster-wide. The operator's reconciliation loop blindly trusts namespace references embedded in secret annotations without verifying whether the requesting user is authorized to access the referenced namespace, enabling a classic confused-deputy (CWE-441) privilege escalation that breaks Kubernetes RBAC namespace isolation. No public exploit code has been identified at time of analysis, but the low attack complexity and high confidentiality impact make this a material priority for any multi-tenant Kubernetes deployment running ECK; vendor-released patch version 3.5.0 is available per ESA-2026-121.

Memory exhaustion in Elasticsearch's search highlighting subsystem allows any authenticated read-only user to terminate a node process with a single crafted request. The highlighting API accepts an unbounded user-supplied count, and the internal data structure allocated from that count is not tracked by Elasticsearch's circuit breaker system, bypassing the existing OOM safeguards entirely. The defect is non-volumetric - one small request is sufficient - and degrades cluster routing and health beyond the targeted node. No public exploit has been identified at time of analysis, though the low attack complexity and minimal privilege requirement make this a realistic internal threat.

Uncontrolled recursion in Elasticsearch's custom analysis definition processing allows an authenticated low-privileged user to crash an individual cluster node with a single request. By submitting a malformed index creation request whose custom analyzer, tokenizer, or filter components reference each other without termination, the resolution logic enters unbounded recursion, exhausts the JVM thread stack, and terminates the targeted node. No public exploit has been identified at time of analysis, but the attack requires only index creation privileges - a permission commonly granted to application service accounts - making the practical barrier lower than the authentication prerequisite might suggest.

Uncontrolled recursion in Elasticsearch's search request processing allows an authenticated user with only read-level privileges on a single index to crash any cluster node by submitting a specially crafted query containing pathologically nested structures. The absence of a recursion depth limit causes thread stack exhaustion during deserialization of the nested payload, triggering an unhandled stack overflow that terminates the affected node. No public exploit code has been identified at time of analysis, and CISA KEV does not list this CVE, but the low privilege bar (read-only access) makes the attack surface broad in multi-tenant or exposed deployments.

Elasticsearch exposes an authenticated denial-of-service path where a user holding only read privileges on a single index can crash an entire cluster node with one small, crafted search request. Rooted in CWE-789 (Memory Allocation with Excessive Size Value) and matching CAPEC-130 (Excessive Allocation), the flaw causes the JVM heap to be exhausted, terminating the affected node and disrupting all workloads on it. No CISA KEV listing and no public exploit code have been identified at time of analysis, but the low attack complexity makes this a credible threat in multi-tenant or broadly-credentialed Elasticsearch deployments.

Cleartext token exposure in Elastic Cloud on Kubernetes allows any principal with namespace workload-spec read access to retrieve live Elasticsearch service account credentials. Affected deployments are those running Fleet Server resources configured to authenticate to Elasticsearch via service account tokens - ECK writes the token directly into the generated Pod specification in cleartext rather than referencing the Kubernetes Secret where other credentials are stored, bypassing an intentional RBAC boundary. No public exploit has been identified and the vulnerability is not listed in CISA KEV, but the confidentiality impact is high given that the exposed credential grants direct Elasticsearch data-plane access.

ES|QL query processing in Elasticsearch allows an authenticated low-privileged user to exhaust heap memory on any receiving cluster node by submitting a specially crafted query, rendering that node unavailable. The CVSS 6.5 score (AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H) reflects remote, low-complexity exploitation requiring only a valid account, with high availability impact but no data exposure. Elastic has released fixes in versions 8.18.0 and 9.0.0 per advisory ESA-2026-111; no public exploit or active exploitation has been identified at time of analysis.

Elastic Security's case management API in Kibana fails to enforce the same authorization controls applied in the UI, allowing authenticated low-privileged users to modify case records they are only entitled to view. The vulnerability arises from a mass-assignment flaw (CWE-915/CAPEC-77) where the API accepts object attributes that bypass privilege checks enforced at the UI layer - a classic server-side trust boundary mismatch. No public exploit code has been identified at time of analysis, and the vulnerability is not listed in CISA KEV, but the low exploitation complexity (AV:N/AC:L/PR:L) makes it accessible to any authenticated insider or compromised low-privilege account.

Resource exhaustion in Elastic Kibana allows an authenticated user who holds maintenance window management privileges to crash the Kibana process for all users by submitting a specially crafted malformed payload. The Kibana process consumes unbounded resources and becomes fully unresponsive, requiring manual operator intervention to restore service - there is no automatic recovery. No public exploit code has been identified and this vulnerability is not listed in the CISA KEV catalog; however, the low access complexity and broad multi-tenant availability impact make it a meaningful operational risk for shared Kibana deployments.

Denial of service in Elastic Kibana's alerting feature allows an authenticated user with read-only alerting privileges to crash the Kibana process for all users by submitting a single crafted malformed payload. The resource exhaustion is unbounded - a single HTTP request is sufficient to render Kibana unable to serve any users until the process is manually restarted. No public exploit code has been identified at time of analysis, and this vulnerability is not listed in the CISA KEV catalog; however, the low attack complexity and broad impact make it a meaningful risk in any multi-tenant Kibana deployment where alerting access is granted to partially-trusted users.

Cross-space alerting rule telemetry disclosure in Kibana allows an authenticated user with read access to alerting rules in one Kibana space to retrieve execution telemetry belonging to other spaces they are not authorized to access. The exposed metadata includes rule identifiers, rule names, space identifiers, execution outcomes, timestamps, and execution counters - a meaningful control gap for organizations using Kibana Spaces for multi-tenant or departmental isolation. Fixes are available in Kibana 8.19.20 and 9.4.5 per Elastic advisory ESA-2026-105; no public exploit or CISA KEV listing exists at time of analysis.

Algorithmic complexity exhaustion in Kibana's TSVB (Time Series Visual Builder) expression evaluator allows any authenticated user to render the entire Kibana instance unresponsive with a single crafted request. The synchronous evaluation of a specially crafted deeply nested expression monopolizes the Kibana request-processing thread indefinitely, blocking all subsequent requests until the service is manually restarted. Patched versions 8.19.20 and 9.4.5 are available per Elastic advisory ESA-2026-104; no public exploit or CISA KEV listing has been identified at time of analysis.

Missing authorization in Kibana's internal data retrieval capability for Elastic Defend endpoint response actions exposes sensitive security telemetry to any authenticated low-privileged user. The internal API endpoint used for endpoint response actions bypasses the Security Solution and endpoint privilege checks applied to its user-facing equivalents, executing with elevated internal permissions rather than the requesting user's permissions. No public exploit or CISA KEV listing exists at time of analysis; however, any authenticated Kibana user - regardless of Security Solution role assignments - can exploit this to read endpoint response records and host-returned response content from managed endpoints.

Denial of service in Kibana allows an authenticated low-privileged user to crash the entire Kibana process by submitting specially crafted input data. The crafted payload triggers an uncaught exception (CWE-248) on a critical execution path, causing Kibana to terminate and become unavailable to all users until manually restarted. Because the condition is repeatable, an attacker holding only basic credentials can maintain a persistent denial-of-service state. No public exploit has been identified at time of analysis, and no KEV listing exists.

Denial of service in Elastic Kibana allows any authenticated low-privileged user to crash the entire Kibana service for all users by submitting a specially crafted, malformed payload to a visualization feature. The root cause is CWE-770 (resource allocation without throttling): Kibana fails to validate the malformed input before processing, causing unbounded heap growth until the host OS kills the process. No public exploit has been identified at time of analysis, and exploitation requires authenticated access, but the low privilege bar and total service disruption make this a meaningful insider or compromised-credential threat. Patch versions 8.19.20 and 9.4.5 are referenced in the vendor advisory ESA-2026-100.

Privilege escalation in Kibana arises from insufficient CSRF protection in the Vega visualization engine, affecting all versions prior to 8.19.20 and 9.4.5. Any Kibana user with visualization creation rights can embed a specially crafted Vega specification that, when rendered by a higher-privileged user's browser, silently issues authenticated HTTP requests to Kibana under the victim's session credentials. No public exploit code has been identified and no CISA KEV listing exists at time of analysis, though the low attack complexity and widely deployed nature of the product make this a meaningful remediation priority.

Unbounded resource allocation in Kibana's Observability log analysis validation feature enables any authenticated low-privilege user to exhaust the Kibana process memory and deny service to all users. The flaw (CWE-770, CAPEC-130) requires only minimal credentials - no elevated roles - and a single inexpensive HTTP request triggers concurrent work without throttling. Notably, the request can be repeated trivially, sustaining pressure even on well-provisioned deployments that might otherwise degrade gracefully rather than crash outright. No public exploit code or active exploitation (CISA KEV) has been identified at the time of analysis, though the low exploitation bar makes this a credible insider or credential-abuse threat.

Unauthorized Osquery live query execution in Elastic Kibana allows a low-privileged authenticated user to run endpoint queries against Elastic Agents assigned to Kibana spaces they have no authorization to access, violating the platform's space-based multi-tenancy access control model. By exploiting a user-controlled key authorization bypass (CWE-639 / CAPEC-1), an attacker can exfiltrate host telemetry - running processes, network connections, file system state - from isolated organizational spaces, with results written to the Osquery results data stream accessible to the attacker. No active exploitation is confirmed (not in CISA KEV) and no public proof-of-concept has been identified at the time of analysis; however, the network-accessible vector and high confidentiality impact make this a meaningful risk in multi-tenant deployments.

Missing Authorization in Kibana's Elastic Security module permits authenticated users holding detection rule authoring privileges to execute Osquery live queries and Elastic Defend response actions against enrolled managed endpoints without possessing the specific Osquery or Elastic Defend privileges that normally govern those capabilities. The CVSS 8.1 score reflects a network-accessible, low-complexity attack path with high confidentiality and integrity impact against enrolled host infrastructure. No active exploitation has been confirmed (not in CISA KEV) and no public exploit code has been identified at time of analysis, but patch versions 8.19.20 and 9.4.5 are available per Elastic Security Advisory ESA-2026-96.

Missing authorization in Elastic Kibana's Security solution allows users holding only detection rule authoring privileges to associate and indirectly trigger Elastic Defend endpoint response actions - including host isolation, process termination, and remote execution - against managed hosts, without ever being granted the dedicated Endpoint response action privileges that are supposed to govern those capabilities. The exploitation path is indirect: a restricted user crafts a detection rule with embedded response actions, and when that rule generates alerts against matching endpoints, the privileged actions execute autonomously through the Elastic Defend agent. No public exploit has been identified at time of analysis, and the flaw is not listed in the CISA KEV catalog.

Relative path traversal in Kibana's Fleet component allows an authenticated low-privileged user to delete arbitrary Kibana resources by supplying a crafted Fleet Server host configuration identifier containing traversal sequences. Elastic has confirmed the flaw in ESA-2026-94 and released patched versions 8.19.17, 9.3.6, and 9.4.3. No public exploit has been identified at time of analysis, and the vulnerability is not listed in the CISA KEV catalog.

Code injection in Elastic Fleet Server allows an authenticated Kibana administrator to execute arbitrary server-side scripts by embedding script syntax within an output configuration identifier. Affected are all Fleet Server versions prior to those addressed in Elastic advisory ESA-2026-93, where Kibana's failure to restrict identifier characters permits injected script content to be incorporated into scripts Fleet Server constructs during routine agent policy processing. No active exploitation has been confirmed in CISA KEV and no public proof-of-concept has been identified at time of analysis, but the confidentiality and integrity impact is rated high given full script execution capability within the Fleet Server process.

Kibana's Machine Learning subsystem fails to enforce space-level authorization, allowing any authenticated low-privilege user in one Kibana space to read ML data from all other spaces and make unauthorized modifications across the entire deployment. The root cause is that ML operations execute with elevated internal Elasticsearch permissions while a subset of ML functionality omitted the per-request space isolation filter that enforces tenancy boundaries. No public exploit has been identified, but the attack requires only a standard user account, making it a realistic internal threat in multi-tenant or shared Kibana deployments. Fixed versions 8.19.20 and 9.4.5 are referenced in the Elastic security advisory ESA-2026-92.

Denial of service in Kibana's Playground for RAG feature allows a low-privileged authenticated user to exhaust the memory and processing resources of a Kibana instance via a single crafted request. The vulnerable endpoint accepts a user-supplied list of document fields without enforcing any length bound or deduplication, enabling a request to trigger construction of a response orders of magnitude larger than the underlying data. No active exploitation has been confirmed (not in CISA KEV), and no public exploit code has been identified at time of analysis. Elastic has released fixes in versions 9.3.8 and 9.4.4.

Incorrect authorization in Kibana's Synthetics feature allows an authenticated user holding only Synthetics write privilege in a single space to permanently delete private locations shared across multiple spaces, including those the user has no access to. The root cause is an incomplete access-control check that evaluates only the monitors visible in the requesting user's own space, ignoring dependent monitors in other spaces. No public exploit or active exploitation has been identified; the CVSS 5.4 score reflects a real but bounded integrity and availability impact limited to Elastic Kibana instances using multi-space Synthetics deployments.

Elastic Kibana's Elastic Security endpoint policy editor exposes sensitive Elastic Defend telemetry through a privilege escalation in the field value suggestion feature. Authenticated users holding Kibana Elastic Security feature privileges - but lacking Elasticsearch index-level read access to Elastic Defend event indices - can retrieve field values including process command line arguments, which routinely contain credentials, API tokens, and connection strings harvested from protected endpoints. No public exploit has been identified at time of analysis, but the low attack complexity and scope change across the Kibana-to-Elasticsearch authorization boundary make this straightforward to abuse by any user with a qualifying Kibana role.

Kibana's Machine Learning space management feature performs an incomplete authorization check when removing a saved object from a space, accepting trained models as targets while only verifying privileges for anomaly detection jobs and data frame analytics jobs. Authenticated users whose roles grant ML job creation rights but lack the trained model privilege can therefore remove a trained model from the active space, despite having no legitimate authority over trained models. No public exploit is identified and this vulnerability is not listed in CISA KEV; real-world impact is bounded by the reversibility of the action and the non-deletion of the underlying model.

Missing authorization on Kibana's Observability Onboarding API routes allows any authenticated low-privilege user sharing a Kibana space to enumerate, read, and overwrite the onboarding flow state of other users in that space. Affected installations include all Kibana versions prior to 8.19.19 and 9.4.5 across both self-managed and Elastic Cloud deployments. No public exploit code has been identified at time of analysis and this vulnerability is not listed in the CISA KEV catalog; however, the CVSS high integrity impact (I:H) reflects an attacker's ability to corrupt another user's onboarding progress and trigger persistent server errors in the victim's Observability Onboarding view.

Kibana's Agent Builder feature bypasses cross-feature authorization, allowing any authenticated low-privilege user to create and execute agent tools that invoke Kibana features requiring higher privileges than the user possesses. Affected by CWE-862 (Missing Authorization), this flaw effectively nullifies role-based access controls for features reachable via Agent Builder tooling, enabling unauthorized read access to sensitive data. No public exploit or active exploitation has been identified; Elastic has issued a fix in Kibana 9.4.4 via advisory ESA-2026-83.

Kibana's Agent Builder feature exposes an A2A JSON-RPC API endpoint vulnerable to Insecure Direct Object Reference (CWE-639), allowing an authenticated low-privilege user to overwrite and seize ownership of another user's conversation within the same Kibana space. The root cause is that the server-side ownership check treats a non-existent conversation ID identically to one that exists but belongs to a different user, so supplying a known identifier is sufficient to hijack it. No confidentiality breach occurs - the attacker does not read overwritten content - but the original owner suffers permanent, irrecoverable loss of their conversation history. No public exploit code has been identified and this CVE does not appear in CISA KEV at time of analysis.

Denial of service in Elasticsearch allows any authenticated user holding only read-only index privileges to crash a cluster node by submitting a single crafted search request. The intervals query type does not enforce Elasticsearch's configurable input-length restriction, so a deeply nested pattern drives unbounded recursion that exhausts the JVM thread stack and terminates the node process. No public exploit or CISA KEV listing exists at time of analysis; however, the low complexity and minimal privilege bar make this a credible internal threat, and Elastic has released fixes in versions 8.19.20 and 9.4.5 per ESA-2026-81.

Memory exhaustion in Elasticsearch allows any authenticated user with only read privileges to crash an Elasticsearch node with a single small crafted API request. The root cause is missing validation of a user-controlled size value that is passed directly to an internal memory reservation routine, enabling uncontrolled heap allocation that terminates the node process and degrades cluster health. No public exploit code has been identified at time of analysis, and the vulnerability is not listed in CISA KEV, but the non-volumetric nature - one request is sufficient regardless of heap configuration - significantly lowers the bar for disruption by low-privileged insiders or compromised service accounts.

Denial of service in Elasticsearch allows any low-privileged authenticated user to crash an affected cluster node with a single crafted HTTP request. The root flaw is a validate-after-deserialize ordering error: Elasticsearch decodes and deserializes an opaque identifier before confirming the cluster issued it, and an attacker-controlled size value embedded in the forged identifier drives an uncapped heap allocation (CWE-789) that exhausts available memory and fatally terminates the node process. No public exploit code has been identified at time of analysis, and this CVE is not listed in the CISA KEV catalog.

Stack exhaustion in Elasticsearch allows any low-privileged authenticated user to crash an Elasticsearch node with a single crafted request. Affected are all Elasticsearch versions across the 8.x and 9.x release lines, with Elastic releasing fixed versions 8.19.20, 9.4.5, and 9.5.1 under ESA-2026-78. No public exploit code or CISA KEV listing is confirmed at time of analysis, but the low attack complexity and minimal privilege requirement make this a straightforward denial-of-service vector for any credentialed user.

Elasticsearch's indexing pipeline contains an algorithmic complexity flaw (CWE-407) that allows any low-privileged authenticated user with document indexing rights to submit a single crafted document that occupies a worker thread in the bounded indexing thread pool for a disproportionate duration, degrading indexing availability on the affected node. Affected versions span both the 8.x and 9.x release lines, with fixes available in 8.19.20 and 9.4.5 per ESA-2026-77. No public exploit has been identified at time of analysis, and no active exploitation is confirmed.

Denial of service in Elasticsearch allows an authenticated user with only read privileges to crash a cluster node by submitting a crafted search request. Processing the malicious input triggers unbounded memory allocation in a specific internal component, bypassing existing memory accounting controls and causing a fatal out-of-memory condition that terminates the affected node process. No public exploit code has been identified at time of analysis, but the low privilege requirement (read-only access) significantly broadens the potential attacker pool in multi-tenant or SaaS deployments.

Node process termination in Elasticsearch via the ingest simulate pipeline API allows low-privilege authenticated users to crash individual cluster nodes by submitting a crafted request that induces uncontrolled recursion. The vulnerability affects multiple Elasticsearch version lines, with Elastic releasing fixes in versions 8.19.1, 9.3.8, and 9.4.4 per advisory ESA-2026-75. No public exploit code or CISA KEV active-exploitation listing has been identified at time of analysis, but the low attack complexity and broad enterprise footprint of Elasticsearch make this a meaningful availability risk, particularly in multi-tenant or shared-cluster deployments.

Denial-of-service in Kibana's connector reporting endpoint allows any authenticated user - including those with read-only privileges - to permanently incapacitate the Kibana process with a single crafted request. The flaw stems from accepting arbitrarily large query expressions without size limits, causing the process to consume unbounded CPU evaluating the expression and rendering the instance unable to serve any user until manually restarted. No public exploit has been identified, but the low privilege bar (read-only access) and single-request reproducibility make this an attractive target for internal threat actors or compromised low-privilege accounts seeking to disrupt SOC or observability operations.

ES|QL engine denial of service in Elasticsearch allows any authenticated network user to trigger exponential CPU consumption by submitting a specially crafted query, exhausting query worker thread pool resources and rendering ES|QL unavailable until the node is manually restarted. Affected versions span two major release trains: Elasticsearch 8.0.0-8.19.18 and the full 9.x series through 9.4.3. No public exploit code has been identified at time of analysis and CISA KEV confirmation is absent; however, Elastic's security team has released patches across all three affected branches (ESA-2026-74).

Cross-space information disclosure in Kibana 9.4.0 through 9.4.3 allows authenticated users to access data from Kibana Spaces they are not authorized to view. The flaw (CWE-862, Missing Authorization) arises because user-supplied input can reference cross-space resources without adequate space-level authorization checks, enabling privilege boundary bypass within a multi-tenant Kibana deployment. No public exploit code has been identified at time of analysis, and this vulnerability is not listed in the CISA KEV catalog.

Uncontrolled memory allocation in Kibana's machine learning feature allows low-privileged authenticated users to exhaust server memory, causing a complete denial of service for all users. Three major version lines are affected - 8.x through 8.19.18, 9.0.x through 9.3.7, and 9.4.x through 9.4.3 - with vendor-released patches available across all three. No active exploitation confirmed via CISA KEV and no public exploit code identified at time of analysis, but the low authentication barrier (any valid account) makes this a meaningful internal threat in shared Kibana environments.

Denial of service in Elastic Kibana allows any authenticated low-privilege user to crash the Kibana process by sending a specially crafted oversized HTTP request payload, exhausting Node.js heap memory and making the analytics platform unavailable to all users. Affected branches span Kibana 8.x (through 8.19.18), 9.0.x-9.3.x (through 9.3.7), and 9.4.x (through 9.4.3), with patched releases available per ESA-2026-71. No public exploit code has been identified at time of analysis, and this CVE does not appear in the CISA KEV catalog.

Kibana's multi-tenancy Spaces model can be bypassed through an Insecure Direct Object Reference (IDOR) vulnerability, allowing authenticated users to read scheduled query results belonging to Spaces they are not authorized to access. Affected versions span Kibana 9.4.0 through 9.4.3, with the fix delivered in 9.4.4. The CVSS vector (PR:L, C:L) confirms the impact is limited to low-privilege authenticated access resulting in partial confidentiality loss - no integrity or availability impact is involved. No public exploit code exists and no CISA KEV listing has been identified at time of analysis.

Incorrect Authorization in Kibana's Machine Learning management endpoint allows a low-privileged authenticated user to manipulate ML audit and notification records for arbitrary jobs across any space or user boundary. The endpoint validates only a coarse ML access privilege without enforcing resource-level authorization, and then uses Kibana's internally elevated credentials to write to restricted ML system indices on behalf of the requesting user. No public exploit has been identified at time of analysis, and CVSS scores this at Medium (4.3) given the limited integrity-only impact scope.

Uncontrolled recursion in Elasticsearch's query evaluation component allows a low-privileged authenticated user with read-level index access to crash an affected node by submitting a specially crafted search request. All three active release lines are affected: 8.19.x through 8.19.18, 9.3.x through 9.3.7, and 9.4.x through 9.4.3. The impact ranges from complete service outage in single-node deployments to sustained availability degradation and repeated node restarts in multi-node clusters. No public exploit code or active exploitation has been identified at time of analysis; Elastic has released patched versions 8.19.19, 9.3.8, and 9.4.4.

Unauthorized access to workflow execution outputs in Kibana 9.3.0-9.3.7 and 9.4.0-9.4.3 allows an authenticated low-privileged user to read sensitive data returned by workflow steps - including results from connected data sources they are not authorized to query - by directly calling the workflow output endpoint without the authorization the documented API requires. The flaw is classified as Missing Authorization (CWE-862) via Privilege Abuse (CAPEC-122), with impact limited to confidentiality within the user's accessible Kibana space. No public exploit code has been identified and the vulnerability is not listed in the CISA KEV catalog; Elastic has released patched versions 9.3.8 and 9.4.4.

Outbound request restriction bypass in Kibana's Reporting feature enables authenticated low-privileged attackers to cause the reporting service to issue HTTP requests to network destinations explicitly denied by administrator-configured security policy. Affected versions span Kibana 8.x through 8.19.18, 9.0.x through 9.3.7, and 9.4.x through 9.4.3. The scope-changed CVSS vector (S:C) confirms the impact extends beyond Kibana itself to internal network resources, making this a server-side request forgery (SSRF)-class issue. No public exploit code or CISA KEV listing identified at time of analysis.

Local privilege escalation to full product takeover in Oracle Communications BRM - Elastic Charging Engine (versions 15.0.0.0.0, 15.0.1.0.0, 15.1.0.0.0, 15.2.0.0.0) lets a low-privileged attacker with logon access to the host running the ECE infrastructure compromise the Diameter Gateway and SDK component. Per Oracle's CVSS 3.1 vector (AV:L/AC:L/PR:L/UI:N), exploitation is authenticated and local but easily performed, yielding high confidentiality, integrity, and availability impact (base 7.8). No public exploit identified at time of analysis, and the CVE is not listed in CISA KEV.

Missing authorization controls in Kibana's Cloud Connect endpoints allow any authenticated low-privilege user to read and modify Cloud Connect configuration and service settings that should be restricted to users with specific feature privileges. Exploitation occurs via direct HTTP requests to insufficiently protected internal API endpoints, bypassing Kibana's privilege enforcement layer entirely. No public exploit code exists and this vulnerability is not listed in CISA KEV; however, the low barrier - requiring only a valid Kibana account - elevates practical risk in multi-tenant or externally accessible deployments.

Node process termination in Elasticsearch allows a low-privileged authenticated user to crash any reachable cluster node with a single malformed search request. The vulnerability stems from a reachable assertion in the query parsing layer triggered by a null value in a specific query clause; because Elasticsearch treats assertion failures as fatal, the node process exits immediately. Single-node deployments lose service entirely; in clustered environments, each targeted node reduces available search capacity. No public exploit has been identified at time of analysis, and Elastic has released patched versions 8.19.19, 9.3.8, and 9.4.4 per advisory ESA-2026-64.

Kibana's Canvas functionality allows any authenticated low-privileged user to crash the Kibana server process via a specially crafted request, causing a complete denial of service for all users of the affected instance. The root cause is uncontrolled resource consumption (CWE-400 / CAPEC-130), where Canvas fails to bound server-side resource allocation when processing attacker-controlled input. No active exploitation has been confirmed (not in CISA KEV) and no public exploit code has been identified at time of analysis, though the low attack complexity once authenticated makes independent rediscovery plausible.

Heap exhaustion in Elasticsearch allows authenticated users holding search privileges to crash individual data nodes by submitting specially crafted search requests, degrading or taking down the cluster and requiring manual administrator intervention to restore service. Affected versions span the 8.x and 9.x release lines per vendor advisory ESA-2026-60, with fixes available in 8.19.15, 9.2.9, and 9.3.4 as inferred from the advisory URL. No public exploit code has been identified and this vulnerability is not listed in the CISA KEV catalog, but the low authentication barrier makes it a meaningful risk for multi-tenant or shared Elasticsearch deployments.

Unauthorized information disclosure and case-attachment tampering in Elastic Kibana lets a low-privileged authenticated user with limited file-management permissions read, alter, or delete case attachments belonging to feature areas they should not reach, including sensitive Security Solution cases. The flaw stems from Kibana's file-access authorization check and its resource retrieval using two different resolution mechanisms, allowing the authorization gate to be bypassed. No public exploit identified at time of analysis; not listed in CISA KEV, and EPSS was not provided.

Incorrect Authorization (CWE-863) in Kibana's Entity Analytics Watchlist feature allows low-privileged authenticated users with read-only Security Solution access to perform unauthorized write operations against watchlist configuration endpoints that should require elevated privileges. The CVSS 5.4 vector (AV:N/AC:L/PR:L/UI:N) confirms network-exploitable but credential-gated exploitation with limited confidentiality and integrity impact; under specific deployment conditions, affected users may additionally access data outside their authorized scope. No public exploit code has been identified and this vulnerability is not listed in the CISA KEV catalog at time of analysis.

Denial of service in Elasticsearch allows a low-privileged authenticated user to crash an Elasticsearch node by submitting a specially crafted EQL sequence query against an index they control, triggering uncontrolled memory consumption (CWE-400, CAPEC-130). Affected across all tracked versions per CPE wildcard, with Elastic releasing fixes in versions 8.19.18, 9.3.7, and 9.4.4 per advisory ESA-2026-57. No public exploit code or CISA KEV listing has been identified at time of analysis, but the low attack complexity and broad Elasticsearch deployment footprint make this a credible internal threat in multi-tenant or shared cluster environments.

Incorrect Authorization (CWE-863) in Elasticsearch's ingest simulation feature allows authenticated users with limited index privileges to bypass per-index access controls and trigger ingest pipeline execution on indices they are not authorized to access directly. Pipeline output - potentially containing enriched or processed sensitive data - is returned to the requestor, and index mapping metadata for restricted indices can also be retrieved through the same mechanism. No public exploit code has been identified at time of analysis; vendor-released fixes are available in versions 8.19.18, 9.3.7, and 9.4.4.

Denial of service in Kibana's Entity Analytics feature allows authenticated users to render the application unavailable by submitting oversized input values to affected API endpoints. The root cause is CWE-770 - absent resource allocation limits on specific Entity Analytics endpoints - enabling a single crafted request to trigger excessive memory or CPU consumption disproportionate to normal operation. No public exploit code has been identified at time of analysis, and the PR:L authentication requirement constrains opportunistic exploitation to credentialed actors.

Kibana's authorization layer fails to enforce ACLs correctly in certain code paths, allowing a lower-privileged authenticated user to cause data from restricted Elasticsearch sources to be processed under another user's elevated privileges - effectively a confused deputy attack resulting in unauthorized information disclosure. The CVSS 4.3 (Medium) rating reflects low confidentiality impact and the requirement for a valid Kibana account, but the real-world risk is material in multi-tenant or role-segregated deployments where data isolation is a compliance requirement. No active exploitation confirmed (not in CISA KEV) and no public exploit code has been identified at time of analysis.

Server-side request forgery in the strands-agents-tools elasticsearch_memory tool enables prompt-injection attacks that exfiltrate the operator's Elasticsearch API key to attacker-controlled infrastructure. Applications using strands-agents-tools prior to 0.7.0 that rely on the ELASTICSEARCH_API_KEY environment-variable fallback - rather than explicitly passing api_key - are exposed to credential theft when an attacker can influence LLM input. No public exploit code or CISA KEV listing has been identified at time of analysis, but the prompt-injection-to-SSRF primitive is well understood in the AI agent security community and the credential-theft impact warrants prompt remediation.

Elasticsearch Painless script injection via OpenCTI's GraphQL API allows any authenticated user holding the KNOWLEDGE capability to submit computationally expensive, unvalidated scripts that saturate Elasticsearch cluster CPU, degrading or denying service for the entire platform. All OpenCTI deployments prior to version 7.260401.0 are affected, with the vulnerability residing in the exposed 'script' FilterOperator of the GraphQL API. No public exploit code or CISA KEV listing is confirmed at time of analysis; a vendor-released patch is available in version 7.260401.0.

Authorization bypass in Apache Camel's camel-elasticsearch-rest-client component allows unauthenticated remote attackers to override Elasticsearch query operations by injecting HTTP headers. Because the component uses unprefixed header constants ('SEARCH_QUERY', 'OPERATION', 'INDEX_NAME', 'INDEX_SETTINGS', 'ID') that are not blocked by Camel's inbound HttpHeaderFilterStrategy - which filters only 'Camel'-prefixed names - any HTTP client reaching a Camel route that fronts an elasticsearch-rest-client producer can substitute their own query body, operation type, or target index. Practical outcomes include full index enumeration via match_all, targeted document deletion, and field-level data exfiltration. No public exploit has been identified at time of analysis and this CVE is not listed in CISA KEV, but the attack requires no credentials and is trivially reproducible from the description alone.

Authorization bypass and information disclosure in GeoNetwork 4.x (4.0.0-alpha.1 through 4.4.10) lets an unauthenticated remote user retrieve restricted metadata records through the Elasticsearch-backed search API. Under certain request conditions the proxy layer skips the step that injects GeoNetwork's access-control filters, so requests reach the index without group-visibility, ownership, draft-exclusion, or portal filtering applied. There is no public exploit identified at time of analysis, but the flaw is unauthenticated and network-reachable on any public-facing instance, making disclosure of non-public catalog records trivial once the triggering condition is known.

Log injection in Elastic Kibana (fixed in 7.17.15 and 8.11.1) allows an attacker with low-privilege access to embed unneutralized control characters in input that Kibana writes verbatim to its log files; when an operator later views those logs in a terminal that interprets ANSI/control sequences, the injected payload can forge, hide, or rewrite displayed log content. The issue is tracked as CWE-117 (Improper Output Neutralization for Logs) and carries a vendor CVSS of 8.0. There is no public exploit identified at time of analysis and it is not listed in CISA KEV.

Incorrect Authorization (CWE-863) in Elastic Defend exposes response action data to low-privileged authenticated users who should not have access to it. The flaw, classified under CAPEC-1, arises because access controls on specific functionality are not properly enforced, allowing a user with minimal privileges to read security response action data belonging to other users or roles. No public exploit code has been identified and the vulnerability is not listed in the CISA KEV catalog, but the High confidentiality impact (CVSS C:H) means sensitive endpoint response data - such as isolation actions, process kills, or file retrieval outputs - could be disclosed.

Fleet policy management in Kibana is vulnerable to denial of service through insufficient validation of user-supplied policy inputs. An authenticated Kibana user with Fleet write access can submit a specially crafted Fleet policy input that bypasses server-side validation, rendering Fleet agent management, server operations, and policy configuration unavailable. No public exploit has been identified at time of analysis, and this vulnerability is not listed in CISA KEV; however, the low authentication bar (any valid low-privilege account) and network accessibility make it a meaningful operational risk for organizations relying on Elastic Agent deployments.

Elasticsearch's machine learning API contains an unbounded resource allocation flaw that allows an authenticated user with elevated privileges to crash an affected node by submitting a specially crafted ML request over the network. The absence of throttling or quota enforcement on ML request memory consumption (CWE-770) means the node's JVM heap can be exhausted, rendering it unavailable without any confidentiality or integrity exposure. No public exploit code has been identified at the time of analysis, and this vulnerability does not appear in the CISA KEV catalog.

Denial of service in Elasticsearch allows any authenticated user to crash an affected cluster node by submitting a specially crafted query that triggers uncontrolled recursion during query processing. Excessive resource consumption during request handling can render the targeted node unavailable, disrupting search and indexing operations for all dependent applications. No public exploit code has been identified at time of analysis, and the vulnerability is not listed in the CISA KEV catalog; however, the low privilege requirement makes it accessible to any user with query access.

Sensitive HTTP request header values are written into Kibana application logs when the optional APM (Application Performance Monitoring) instrumentation feature is enabled, exposing credentials or tokens to anyone with operator-level log access. This affects multiple Kibana release branches (8.18.x, 8.19.x, 9.0.x, and 9.1.x) and is classified as information disclosure under CWE-532. No public exploit or active exploitation has been identified at time of analysis; the exposure is passive and gated behind both a non-default configuration and existing operator privileges.

Denial of service in Kibana allows any authenticated user with low-privilege access to exhaust server resources via a specially crafted bulk deletion request, potentially rendering the Kibana interface completely unavailable. Affected are Kibana deployments prior to versions 8.19.15 and 9.3.4 across both the 8.x and 9.x release branches. The vulnerability requires no special configuration to be present and no user interaction beyond submitting the malicious request, making it reliably triggerable by any valid Kibana account holder. No public exploit or CISA KEV listing identified at time of analysis.

Sustained CPU exhaustion in Elasticsearch allows an authenticated low-privilege user to render an affected node unresponsive by submitting a specially crafted bulk request to the _bulk API endpoint. The root cause is CWE-400 (Uncontrolled Resource Consumption), whereby the bulk request processing path fails to bound CPU allocation per request, aligning with CAPEC-130 (Excessive Allocation). No public exploit identified at time of analysis, and no KEV listing exists; however, the low attack complexity and standard network accessibility of the bulk API make this a credible insider or compromised-credential threat in production environments.

Authentication bypass in Daytona prior to 0.184.0 allows attackers to join organizations via pending invitations using unverified email addresses. The invitation accept and decline paths failed to enforce email verification (unlike organization creation), so on OIDC identity providers permitting self-service signup with pre-verification sessions, an attacker registering an email matching a pending invite can claim it and inherit the assigned role - up to Owner. No public exploit identified at time of analysis, but the path to full Owner-level organization takeover makes this a high-priority fix.

Git credential exposure in Daytona's daemon (all versions prior to 0.185.0) allows a network-positioned attacker to silently harvest HTTP Basic Authorization headers by exploiting a complete absence of TLS certificate validation on both the go-git and native git CLI clone code paths. An attacker with man-in-the-middle capability on clone traffic can present any fraudulent TLS certificate, capture the Git credentials supplied for the clone, and simultaneously inject tampered repository content into the execution sandbox - threatening both credential confidentiality and supply-chain integrity of AI-generated code workflows. No public exploit or active exploitation has been identified at time of analysis; a vendor-released fix is available in version 0.185.0.

Unauthenticated NoSQL operator injection in Budibase server <= 3.39.0 allows anonymous attackers to read or modify all documents in any MongoDB, CouchDB, Elasticsearch, DynamoDB-PartiQL, or REST-with-JSON-body datasource when a builder has published a query with a PUBLIC role. By injecting JSON metacharacters through query parameters, an attacker can override the intended filter, bypass authentication, and exfiltrate sensitive data or mass-update records in a single HTTP request. Exploit code is publicly available, though no active exploitation is confirmed, and the vulnerability has been patched in version 3.39.12.

Server-side request forgery in Open WebUI versions 0.9.5 and earlier allows authenticated OAuth users to read arbitrary internal HTTP responses by abusing the `_process_picture_url` function in `backend/open_webui/utils/oauth.py`, which validates only the initial URL and then permits aiohttp's default 10-redirect follow chain to reach internal addresses. The decoded response body is stored in the attacker's `profile_image_url` and retrievable via `GET /api/v1/auths/`, yielding cloud metadata credentials and access to localhost-bound services. Publicly available exploit code exists (detailed sentinel-verified PoC supplied by the reporter); no public exploit identified at time of analysis in the form of weaponized tooling, and the CVE is not on the CISA KEV list.

NoSQL/query injection in Spring AI Vector Stores (1.0.0-1.0.8 and 1.1.0-1.1.7) allows remote unauthenticated attackers to inject special characters into vector-store inputs and force execution of arbitrary queries against Elasticsearch, OpenSearch, and GemFire VectorDB backends. The flaw resides in the spring-ai-elasticsearch-store, spring-ai-opensearch-store, and spring-ai-gemfire-store components, enabling information disclosure and limited integrity/availability impact against any application embedding Spring AI's vector-store abstraction. No public exploit identified at time of analysis, but the CVSS 8.6 (scope unchanged here, network vector, no privileges) makes this a high-priority patch for any Spring AI deployment ingesting untrusted text.

Server-Side Request Forgery in Elastic Kibana 9.3.0 through 9.3.2 lets an authenticated user holding connector management privileges override the operator-configured connector allowlist and force the Kibana server to make outbound requests to destinations that egress controls were meant to block. Because the request originates from the trusted server, an attacker can reach internal or otherwise restricted network services and exfiltrate their responses. EPSS is very low (0.03%, 9th percentile) and there is no public exploit identified at time of analysis, but the scope-changing CVSS 7.7 rating reflects meaningful confidentiality impact against internal assets.

Denial of service in Kibana's analytics collections management endpoint allows any authenticated user with viewer-level access to render the service completely unavailable. By submitting a request containing an oversized input value, the attacker causes Kibana to consume excessive CPU and memory, crashing the service for all users and requiring manual intervention to restore. No public exploit has been identified at time of analysis, and the vulnerability is not listed in CISA KEV, but the low privilege bar - viewer access only - significantly elevates real-world risk in multi-tenant or SaaS Elastic deployments.

Privilege escalation in Elastic Kibana's Fleet agent policy management feature allows authenticated Fleet administrators to inject unvalidated values into a configuration override mechanism, causing Elastic Agents to be provisioned with API keys carrying elevated Elasticsearch privileges. Successful exploitation yields unauthorized read/write access to sensitive Elasticsearch security indices beyond the Fleet role's intended scope. No public exploit identified at time of analysis, and CISA KEV does not list this issue.