/

CVE-2026-26315

Severity:

HIGH RISK

(7.5)

Side-Channel / Information Exposure through Observable

CVE-2026-26315

Analyzed

Vulnerability type

Category:

Side-Channel / Information Exposure through Observable Behavior

CWE:

CWE-203

Impact:

Partial Node Key Disclosure and P2P Identity Weakening

Severity:

HIGH RISK

(7.5)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

A flaw in the ECIES cryptography implementation in go-ethereum (Geth) can leak partial information about a node's long‑term P2P key material.

Under certain conditions, an attacker interacting with the P2P interface may be able to infer bits of the node key, weakening its secrecy and potentially aiding in deanonymization or targeted attacks.

Affected context

The vulnerability affects Geth nodes that use the built‑in ECIES implementation for peer‑to‑peer (P2P) communication and maintain a long‑term node key stored in the data directory.

It becomes relevant in environments where remote parties can initiate or participate in ECIES-based P2P handshakes and observe protocol responses, timing, or error differences.

The issue does not by itself grant direct control over the node, but it can erode the confidentiality of the node's cryptographic identity over repeated interactions.

Exploit preconditions

  • Attack surface: Geth P2P networking interface using ECIES for encrypted peer sessions.
  • Required access: Ability to communicate with the node over the Ethereum P2P protocol (e.g., as a network peer or reachable endpoint).
  • Trigger point: Repeated or crafted ECIES handshakes or message exchanges that cause the node to perform cryptographic operations and emit distinguishable responses.
  • Why exploitation is possible: The ECIES implementation exhibits behavior that leaks information about the secret node key (such as via error patterns, timing, or observable protocol outcomes), which can be statistically exploited to infer bits of the key over time.

Why this happens

This vulnerability stems from information disclosure via side effects in the ECIES cryptography implementation rather than a direct key dump.

In CWE-203 terms, the implementation exposes "discrepancies" in behavior—such as differing outputs, errors, or other observable signals—that correlate with internal secret state tied to the node key.

Instead of treating all invalid or edge-case cryptographic operations identically and in a constant-time, constant-behavior fashion, the ECIES code path allows subtle distinctions that an attacker can measure and use to gradually recover partial key material.

Abstractly, this reflects an insecure pattern where cryptographic operations reveal more about internal secrets than strictly necessary to implement the protocol.

Potential impact

  • An attacker may be able to recover bits of the long‑term P2P node key over multiple interactions.
  • The confidentiality of the node's identity key can be weakened, potentially enabling targeted network attacks.
  • Recovered key information could assist in traffic correlation, deanonymization, or improved effectiveness of other attacks against the node.
  • In combination with other vulnerabilities or misconfigurations, partial key exposure could accelerate full key compromise.

General mitigation guidance

Effective mitigation focuses on hardening cryptographic implementations and reducing key exposure over time:

  • Ensure cryptographic operations, especially ECIES handshakes, use constant-behavior patterns that do not vary based on secret values (e.g., uniform error handling and timing-safe operations).
  • Avoid exposing detailed protocol errors or response variations that could be correlated with specific internal states or key material.
  • Regularly rotate long‑term node keys so that any information an attacker might glean has minimal long-term value.
  • Isolate P2P networking in hardened environments, limiting untrusted peers where feasible and applying standard network security controls (firewalls, access lists, peer whitelists).
  • Adopt defense-in-depth cryptographic design practices, including formal reviews and testing for side-channel leakage.

How teams detect issues like this

Organizations can approach detection through both code-centric and behavior-centric methods:

  • Static analysis and code review:
  • Look for cryptographic code paths that branch on secret-dependent conditions and surface different error messages or return codes.
  • Flag non-constant-time comparisons or operations involving secret keys in ECIES and related cryptographic modules.
  • Review P2P protocol handling for granular or distinguishable error responses during handshake failures.
  • Dynamic and behavioral testing:
  • Perform differential testing of P2P endpoints with varying inputs, measuring response timing, status codes, or error patterns to identify correlations with secret-dependent behavior.
  • Use fuzzing frameworks targeting the ECIES handshake and P2P layer, analyzing whether crafted inputs yield information-rich error behavior.
  • Policy and tooling:
  • Incorporate cryptographic linting or secure coding checklists into CI/CD to flag secret-dependent branching or non-uniform failure handling.
  • Leverage automated security scanning tools that specialize in cryptographic misuse or side-channel pattern detection, where available.

Sources

SourceLink
github.comgithub.com/ethereum/go-ethereum/security/advisories/GHSA-m6j8-rg6r-7mv8

Frequently asked

questions

Yes, in principle. An attacker who can communicate with a Geth node over the P2P network and repeatedly trigger ECIES operations may be able to infer partial information about the node key from observable behavior.

The attacker typically needs network-level access to act as or connect to the node as a P2P peer. Direct file or host access is not required for the information leak itself, but the attacker must be able to exercise and observe ECIES-based interactions.

The general fix pattern is to treat all cryptographic operations as sensitive and ensure constant, uniform behavior regardless of input validity or secret values. This includes normalizing error handling, avoiding secret-dependent branching that impacts observable outputs, and thoroughly reviewing ECIES and related crypto for side-channel leakage.

Prevention relies on adopting hardened cryptographic design and review practices: use well-vetted libraries, enforce constant-time and constant-behavior patterns for operations on secrets, minimize externally visible differences in protocol error handling, and include side-channel and crypto-misuse checks in code review, testing, and automated analysis pipelines.

Find out what's already
exploitable in your codebase.