OpenSearch SQL CVE-2026-63393
HIGHAttack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessObtain basic read/search credentials
-
DeliveryCraft malicious serialized cursor payload
-
ExploitPOST to plugins/sql endpoint
-
ExecutionUnsafe deserialization instantiates gadget chain
-
ImpactExecute arbitrary code on server
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A08:2025 - Software or Data Integrity Failures
ASVS 5.0
V1 - Encoding and Sanitization Safe deserialization, type allowlists
MITRE ATT&CK
2 techniques across 2 tactics: Execution, Initial Access The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Requires a valid OpenSearch account with basic read/search permissions and network reachability to the plugins/sql endpoint of the OpenSearch SQL plugin (which ships enabled by default in OpenSearch distributions); the attacker then supplies a crafted cursor parameter that reaches the unsafe Java deserialization path (pre-patch PlanSerializer / expression serializers lacking an ObjectInputFilter allowlist). Limiting factors: authentication is required (PR:L - not reachable by fully anonymous attackers), and the deployment must run an affected SQL plugin version (2.8.0.0 through <2.19.6.0, or 3.0.0 through <3.7.0.0). Successful code execution additionally depends on a usable gadget chain being present on the server classpath. No non-default configuration is otherwise needed. |
| Impact | This is a genuine high priority, not an inflated-CVSS issue. CWE-502 unsafe deserialization reaching arbitrary code execution is one of the most reliably weaponizable bug classes, and the vendor CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:L/UI:N) with VC:H/VI:H/VA:H confirms network-reachable, low-complexity exploitation requiring only low privileges and no user interaction - consistent with the description's 'remote authenticated user with basic read/search permissions.' The single meaningful barrier is authentication (PR:L): the attacker needs any account able to read/search, which in many OpenSearch deployments is a low bar (shared read-only credentials, broad org-wide access, or any compromised low-privilege user). No EPSS score and no KEV listing were provided, so there is no evidence of active exploitation; the vuln.today decision label is 'this_week' rather than act_now/emergency, indicating urgent-but-not-in-the-wild. No working exploit reference was supplied - the GitHub links are the advisory, fix PRs, patch commits, and release tags, not proof-of-concept code. Net: a serious, straightforwardly exploitable post-authentication RCE that should be patched promptly, with real-world risk gated primarily by how loosely read/search credentials are distributed in a given environment. |
| Exploit ScenarioDerived | An attacker holding (or having phished/compromised) an OpenSearch account with only basic read/search permissions sends a request to the plugins/sql endpoint containing a maliciously crafted cursor parameter. The server deserializes the untrusted cursor without a safe allowlist, instantiating attacker-chosen classes that lead to arbitrary code execution on the OpenSearch node. No working public exploit was provided in the sources, but given the low attack complexity (AC:L) and no required user interaction, exploitation is practical once valid read credentials are obtained. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 30, 2026
Unsafe Java deserialization in the OpenSearch SQL plugin allows a remote user holding only basic read/search permissions to run arbitrary code on the node by sending a crafted cursor parameter to the plugins/sql endpoint. The flaw affects the 2.x line from 2.8.0.0 up to (but not including) 2.19.6.0 and the 3.x line from 3.0.0 up to 3.7.0.0, and it is fixed in releases 2.19.6.0 and 3.7.0.0; the plugin ships enabled by default in OpenSearch distributions, so no unusual configuration is needed to reach the vulnerable path. No public exploit code was identified at time of analysis, but successful code execution additionally depends on a usable gadget chain being present on the server classpath, and the vendor priority places remediation in this week's workload.
RemediationAI
Vendor-released patch: 2.19.6.0 for the 2.x line and 3.7.0.0 for the 3.x line - upgrade the OpenSearch SQL plugin to one of these releases (advisory: https://github.com/opensearch-project/sql/security/advisories/GHSA-r8cv-xvqm-4qj4; releases: https://github.com/opensearch-project/sql/releases/tag/2.19.6.0 and https://github.com/opensearch-project/sql/releases/tag/3.7.0.0). The fix is implemented in the upstream pull requests https://github.com/opensearch-project/sql/pull/5469 and https://github.com/opensearch-project/sql/pull/5572 with commits 402a284f1dff3545236480b67f860aa93fb667de and 9ab50384d3ad571a14211415fba2f6d26d4c80db, which add an ObjectInputFilter allowlist to the plan and expression deserialization paths; note these are repository-level fixes, so the released patched plugin versions above are the artifact to deploy. The vendor advisory explicitly states there are no workarounds, and it also recommends ensuring any forked or derivative code incorporates the new fixes rather than relying on the upstream binary alone. Because exploitation requires only a valid account with basic read/search permissions and reachability to the plugins/sql endpoint, prioritize upgrading clusters where low-privilege or shared accounts can query that endpoint.
Affects your stack
Find out whether the stacks and servers you run are on an affected version.
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
OpenSearch SQL (part of the opensearch-project/sql repository, CPE cpe:2.3:a:opensearch-project:sql) exposes SQL and Piped Processing Language querying over the plugins/sql REST endpoint. To support cursor-based pagination, the plugin serializes query state - physical execution plans via PlanSerializer and expression/RexNode trees via DefaultExpressionSerializer and RelJsonSerializer - into a Java-serialized blob that is handed back to the client and later deserialized when the cursor is re-submitted. Prior to the fix, those deserialization paths used ObjectInputStream without an ObjectInputFilter, so the cursor contents were trusted input; this is the classic CWE-502 unsafe deserialization pattern, where attacker-controlled stream data drives class loading and readObject invocation, and any gadget chain already present on the server classpath can be chained to arbitrary code execution. The upstream fix introduces DeserializationFilterUtil, which builds an ObjectInputFilter from a base allowlist (OpenSearch SQL expression/data/planner types, selected java.lang, java.util, java.time, java.math and Guava collection classes) plus per-serializer extra patterns and a terminating !* reject-all rule, and it wraps the filter to log rejected classes; the filter is then registered on the ObjectInputStream in PlanSerializer.deserialize, DefaultExpressionSerializer.deserialize and RelJsonSerializer.deserialize. The patch also adds a regression test asserting that deserializing a disallowed type such as java.net.URL fails.
Know when Sql gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
Network endpoint, low complexity, and only basic read/search auth (PR:L) yield unauthenticated-adjacent deserialization RCE with full C/I/A impact on the node; scope unchanged.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
DescriptionCVE.org
OpenSearch SQL supports querying OpenSearch data using SQL and Piped Processing Language. In the 2.x line from 2.8.0.0 until 2.19.6.0, and the 3.x line prior to 3.7.0.0, a remote authenticated user with basic read/search permissions can provide a crafted cursor parameter to the plugins/sql endpoint and trigger unsafe deserialization of untrusted data, resulting in arbitrary code execution on the server. This issue is fixed in repository releases 2.19.6.0 and 3.7.0.0.
Technical POC Analysis
Class: CWE-502, Deserialization of Untrusted Data.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
CVE-2026-63393 is a high-severity Java deserialization flaw in the OpenSearch SQL plugin that enables any user with basic read/search permissions to execute arbitrary code on cluster nodes via a crafted cursor parameter. Because the plugin is enabled by default in OpenSearch distributions, the risk extends to virtually all deployments in the affected version ranges, potentially allowing attackers to compromise data integrity, confidentiality, and service availability. Leadership should prioritize patching as the vendor has flagged remediation for this week.
Apply vendor patch.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Insecure deserialization occurs when an application converts serialized data (a stream of bytes representing an object's state) back into a living object without proper validation.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB