HIGH 7.5

CVE-2026-40006: Apache IoTDB Unauthenticated Memory Exhaustion Denial of Service

Apache IoTDB has a critical flaw in its optional AirGap pipe receiver feature that allows anyone on the network to crash the system without logging in. When this feature is enabled, the system listens on port 9780 and accepts any connection, then trusts whatever size value an attacker sends, attempting to allocate enormous amounts of memory. A single attacker can exhaust the server's RAM and take down the entire DataNode process. The vulnerability affects IoTDB versions 1.0.0 through 2.0.9, with a fix available in version 2.0.10.

Source data · NVD / CISA · public domain

CVSS
3.1 · 7.5 HIGH · CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
Weaknesses (CWE)
CWE-306, CWE-770, CWE-789
Affected products
0 configuration(s)
Published / Modified
2026-07-10 / 2026-07-10

NVD description (verbatim)

Memory Allocation with Excessive Size Value, Allocation of Resources Without Limits or Throttling, Missing Authentication for Critical Function vulnerability in Apache IoTDB. When pipe_air_gap_receiver_enabled=true, the IoTDB AirGap pipe receiver accepts raw TCP connections on port 9780 with no authentication. The readLength method reads an attacker-controlled 32-bit integer from the socket and readData passes it directly to new byte[length] with no upper-bound check. An unauthenticated attacker can cause the JVM to attempt an allocation of up to 2,147,483,647 bytes per connection, exhausting heap memory and crashing or severely degrading the DataNode process. This issue affects Apache IoTDB: from 1.0.0 before 2.0.10. Users are recommended to upgrade to version 2.0.10, which fixes the issue.

2 reference(s) · View on NVD →

SEC.co analysis · AI-assisted, reviewed against source

Technical summary

This vulnerability chains three weaknesses: missing authentication on a network service, unchecked resource allocation, and unbounded memory requests. When pipe_air_gap_receiver_enabled is set to true, the AirGap receiver binds to TCP port 9780 without requiring credentials. The readLength() method reads a 32-bit signed integer directly from an unauthenticated socket connection, and readData() immediately uses this value as the size parameter in a new byte[length] allocation. Because there is no upper-bound validation, an attacker can specify a length up to 2,147,483,647 bytes (the maximum positive value for a 32-bit signed integer). The JVM will attempt to allocate this massive contiguous heap memory block per connection, and multiple connections amplify the effect. This rapidly exhausts heap space, triggering OutOfMemoryError conditions that crash or severely degrade the DataNode process.

Business impact

For organizations deploying Apache IoTDB with the AirGap pipe receiver enabled, this vulnerability creates a trivial, unauthenticated denial-of-service condition. An attacker with network access to port 9780 can disable time-series data collection and processing capabilities by crashing DataNode instances. In production environments using IoTDB for metrics, telemetry, or sensor data aggregation, this downtime disrupts data pipelines, alerting systems, and dependent applications. There is no data breach risk, but availability impact is severe and can be triggered by any external network actor without specialized tools or credentials.

Affected systems

Apache IoTDB versions 1.0.0 through 2.0.9 are vulnerable when the AirGap pipe receiver feature is explicitly enabled via configuration (pipe_air_gap_receiver_enabled=true). The feature is not enabled by default, so deployments running standard configurations are not at risk. Environments that have specifically activated AirGap receiver for inter-node replication or disaster recovery scenarios are directly exposed. Any DataNode instance with this setting enabled and network access to port 9780 can be attacked.

Exploitability

This vulnerability has very low barriers to exploitation. No authentication is required, the attack vector is network-based, and no user interaction is needed. An attacker needs only the ability to establish a TCP connection to port 9780 and send a crafted packet containing a large 32-bit integer. Exploitation requires no specialized tools, knowledge of IoTDB internals, or valid credentials. The attack is reliable and consistently causes memory exhaustion. The main limiting factor is that the feature must be explicitly enabled; defenders using default configurations are protected by that configuration choice alone.

Remediation

Immediate remediation requires upgrading to Apache IoTDB version 2.0.10 or later, which implements proper bounds checking on memory allocation requests. Organizations unable to patch immediately should disable the AirGap pipe receiver feature by setting pipe_air_gap_receiver_enabled=false in their configuration. If the feature is operationally necessary, network segmentation is critical: restrict access to port 9780 to only trusted internal hosts using firewall rules or network ACLs. Monitor for multiple rapid connection attempts or failed allocation patterns on that port. Verify patch application in your change management process before re-enabling the feature.

Patch guidance

Apply Apache IoTDB version 2.0.10 or any subsequent release after validating compatibility with your deployment. Review the Apache IoTDB release notes for version 2.0.10 to confirm the fix and identify any related changes that affect your configuration or operational procedures. Test the patched version in a non-production environment first, particularly if you rely on the AirGap receiver for active replication scenarios. After patching, re-enable pipe_air_gap_receiver_enabled if it was previously disabled, and verify the feature functions correctly before resuming normal operations. Confirm that memory allocation requests on port 9780 are now properly bounded.

Detection guidance

Monitor for connections to port 9780 from unexpected sources, particularly external or untrusted networks. Log and alert on any connection attempts when pipe_air_gap_receiver_enabled is true. Watch for rapid spikes in memory consumption or repeated OutOfMemoryError exceptions in DataNode logs shortly after unexpected network connections to that port. Implement network-based detection for packets attempting to write abnormally large integer values on that port. Check your JVM heap usage metrics and correlate sudden drops (crashes) with port 9780 connection logs. If you have not explicitly enabled AirGap receiver, verify your configuration file to confirm the setting is false or absent, then scan for any unauthorized configuration changes.

Why prioritize this

Although this vulnerability requires explicit configuration to be enabled and affects availability rather than confidentiality or integrity, it scores HIGH (7.5) because it allows unauthenticated network attackers to reliably crash critical infrastructure with no preconditions. For organizations that have intentionally enabled AirGap receiver—particularly in production environments—this should be treated as urgent. Even organizations running default configurations should verify they haven't accidentally enabled this feature and prioritize patching if they discover it is active.

Risk score, explained

The CVSS 3.1 score of 7.5 (HIGH) reflects an unauthenticated network attack (AV:N, PR:N) with low complexity (AC:L) that requires no user interaction (UI:N) and impacts only availability (C:N, I:N, A:H). The severity is driven by the complete lack of authentication, the ease of exploitation, and the direct ability to crash a critical service. The score does not reach CRITICAL (9.0+) because there is no confidentiality or integrity impact, and the feature is not enabled by default, reducing the scope of affected systems.

Frequently asked questions

If pipe_air_gap_receiver_enabled is not set in my config file, am I vulnerable?

No. The AirGap receiver feature is opt-in and disabled by default. If you have not explicitly set pipe_air_gap_receiver_enabled=true in your IoTDB configuration, your system is not vulnerable to this issue. You should verify your configuration file to be certain.

Can network segmentation protect us until we patch?

Yes. Restricting network access to port 9780 using firewall rules or VPC security groups so that only trusted internal hosts can connect will prevent exploitation. However, this is a temporary measure and should not replace patching. Patching is the permanent fix.

Does this vulnerability allow an attacker to read or modify data?

No. This vulnerability only impacts availability through denial of service. An attacker cannot extract or corrupt data. The memory exhaustion simply crashes the process, requiring a restart. Once restarted, data remains intact.

What versions of Apache IoTDB are affected?

All versions from 1.0.0 through 2.0.9 are affected when the AirGap receiver is enabled. Version 2.0.10 and later include the fix. If you are unsure which version you are running, check the IoTDB version in your deployment or query the service directly.

This analysis is provided for informational purposes and reflects the vulnerability details as published. Organizations should verify all version numbers, patch applicability, and configuration settings against official Apache IoTDB documentation and advisories. The vulnerability requires explicit configuration to be enabled; default deployments are not affected. Patch deployment should be tested in non-production environments first. SEC.co does not provide legal, compliance, or operational liability advice. Always consult official vendor guidance and your internal security policies before taking remediation actions. Source: NVD (public-domain), retrieved 2026-08-17. Analysis generated by SEC.co (claude-haiku-4-5).