/

CVE-2026-36501

Severity:

HIGH RISK

(7.5)

Input Validation Flaw (CWE-20) in Controller Externalizable

CVE-2026-36501

Deferred

Vulnerability type

Category:

Improper Input Validation

CWE:

CWE-20

Impact:

Denial of Service (DoS)

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 flawed input validation mechanism in the Externalizable.readExternal() component of Controller v12.0.5 allows crafted data to disrupt normal processing.

By supplying specially formed serialized input, an attacker can trigger a Denial of Service (DoS), causing the affected Controller instance to become unresponsive or crash.

Affected context

The vulnerability arises when Controller v12.0.5 processes externally supplied serialized data using the Externalizable.readExternal() mechanism.

It is relevant in deployments where Controller instances accept or process serialized objects from clients, other services, or untrusted integration points.

The issue manifests when readExternal() does not robustly validate or constrain incoming data before using it to allocate resources, drive logic, or traverse complex data structures.

Exploit preconditions

  • Attack surface: Interfaces that accept serialized objects or binary payloads processed by Externalizable.readExternal().
  • Required access: Ability to submit or influence serialized input reaching the vulnerable Controller instance (e.g., via network endpoints, message queues, or inter-service calls).
  • Trigger point: Invocation of readExternal() on crafted serialized data during object deserialization.
  • Why exploitation is possible: The method assumes the incoming data is well-formed and trusted, performing insufficient bounds, type, or value checks, which allows malformed or extreme inputs to exhaust resources or force error conditions.

Why this happens

The core issue is improper input validation (CWE-20) in the deserialization logic implemented by Externalizable.readExternal().

Instead of treating the serialized stream as untrusted data and enforcing strict constraints on size, structure, and values, the code path relies on assumptions about correctness.

This can lead to excessive memory allocation, deep recursion, unbounded loops, or other costly operations when presented with adversarial input, ultimately enabling an attacker to induce a Denial of Service.

Potential impact

  • The Controller process may become unresponsive due to CPU or memory exhaustion.
  • Service availability can be degraded, impacting dependent applications and users.
  • Automatic restarts or crash loops may occur, leading to operational instability.
  • In clustered setups, repeated attacks could reduce overall capacity and affect system reliability.

General mitigation guidance

Mitigation patterns focus on treating all serialized input as untrusted and enforcing strict validation before it influences control flow or resource usage.

Common defensive practices include:

  • Implementing robust bounds checking on lengths, counts, and sizes read from the serialized stream.
  • Validating all fields for expected type, range, and format before using them in allocations or loops.
  • Applying defensive coding patterns in readExternal(), such as limiting recursion depth and iteration counts.
  • Introducing deserialization filters or whitelists to restrict the classes and structures that may be deserialized.
  • Enforcing rate limits and resource quotas at the service boundary to reduce DoS impact even when malformed input is received.

How teams detect issues like this

Detection typically involves a combination of code-centric and runtime approaches:

  • Static analysis rules that flag deserialization methods (e.g., readExternal()) lacking explicit length, range, or structural validation.
  • Code review checklists that require reviewers to inspect custom deserialization logic for bounds checks and resource constraints.
  • Application-level logging and monitoring to identify repeated failures or abnormal resource spikes during deserialization operations.
  • Security testing and fuzzing focused on serialized inputs to discover inputs that cause hangs, crashes, or excessive resource usage.

Automated code review and SAST tools can help highlight suspicious deserialization patterns for manual investigation.

Sources

SourceLink
docs.opendaylight.orgdocs.opendaylight.org/en/stable-titanium/release-notes/projects/controller.html
github.comgithub.com/majdlatah/ODL-Raft-Bug/blob/main/README.md

Frequently asked

questions

It can be, if the Controller exposes a network or messaging interface that accepts serialized data processed by Externalizable.readExternal(). In such cases, an attacker may trigger the issue remotely by sending crafted payloads.

The attacker must be able to supply or influence serialized input that the Controller deserializes. This might require network access to a specific endpoint, access to an internal messaging channel, or control over an upstream service.

The safest pattern is to harden all readExternal() implementations by adding strict validation of all incoming data, including bounds checks and type/value verification, and by ensuring that deserialization cannot cause unbounded resource consumption or deep processing.

Treat all serialized data as untrusted, adopt secure deserialization frameworks or filters, incorporate input-validation guidelines into coding standards, and use static analysis plus fuzz testing to exercise deserialization paths before release.

Find out what's already
exploitable in your codebase.