Skip to main content

OpenSearch SQL CVE-2026-63393

HIGH
Deserialization of Untrusted Data (CWE-502)
2026-10-30 GitHub_M
8.7
CVSS 4.0 · Vendor: GitHub_M
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Obtain basic read/search credentials
  2. Delivery
    Craft malicious serialized cursor payload
  3. Exploit
    POST to plugins/sql endpoint
  4. Execution
    Unsafe deserialization instantiates gadget chain
  5. Impact
    Execute 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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
No patch listed yet 0.5% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

Vendor (GitHub_M) PRIMARY 8.7 HIGH
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
vuln.today AI 8.8 HIGH

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.

3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
4.0 AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
Low
User Interaction
None
Vulnerable system: Confidentiality
High
Vulnerable system: Integrity
High
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

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

Why It Matters

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.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.5%
Top 57% exploitable
Prevalence
High
OpenSearch is widely deployed enterprise search; SQL plugin ships by default in distributions
Social Media
1
Sightings
Data Quality
5 sources
Confidence: Medium

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.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.5%
Patch available No
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
No
Human Impact
High
Technical Impact
Total

Priority Score

44
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +44
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

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.

Affected Products (CPE)CVE.org

cpe:2.3:a:opensearch-project:sql:*:*:*:*:*:*:*:*

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy