Summary
A high-severity input validation flaw in iperf3 allows a remote attacker to send crafted control-channel JSON containing oversized numeric parameters. When these values are not constrained, the server may create excessive streams and threads or allocate very large buffers, potentially causing denial of service.
Affected context
The vulnerability occurs in iperf3 server deployments that accept control channel JSON from remote clients and use numeric parameters such as parallel and len without sufficient range, size, or resource validation. Risk depends on network exposure, server configuration, and the resources available to the iperf3 process.
Exploit preconditions
- Attack surface: The iperf3 control channel exposed by a server
- Required access: Network connectivity to the affected iperf3 service; authentication requirements depend on deployment configuration
- Trigger point: Processing crafted JSON parameters during test-session setup or stream and buffer allocation
- Why exploitation is possible: Oversized values can be accepted without effective bounds, causing disproportionate thread, stream, or memory consumption
Why this happens
The underlying bug is insufficient validation of attacker-controlled numeric input before it is used to determine concurrency and allocation behavior. Parameters such as parallel and len influence the number of resources created and the size of buffers, but are not adequately constrained against operational or system limits. This maps to CWE-20, Improper Input Validation, because input is accepted and used without enforcing appropriate type, range, and resource-related requirements.
Potential impact
- The iperf3 server may become unresponsive or unavailable.
- Excessive thread or stream creation could degrade system performance.
- Large buffer allocations could exhaust memory or trigger process termination.
- Other services sharing the host may experience resource contention.
- Repeated requests could cause sustained denial of service.
General mitigation guidance
Mitigation generally focuses on treating control-channel values as
untrusted and enforcing safe resource boundaries before allocation or
concurrency changes.
Common defensive patterns include:
- Applying strict type, range, and maximum-value validation to all numeric parameters.
- Enforcing aggregate limits for streams, threads, buffer sizes, and concurrent sessions.
- Rejecting invalid requests before creating resources or beginning intensive processing.
- Using bounded allocation and admission-control mechanisms where possible.
- Running iperf3 with least privilege and suitable operating-system resource limits.
- Restricting control-channel exposure to trusted networks or authenticated clients where appropriate.
- Preserving safe defaults when optional or malformed parameters are received.
How teams detect issues like this
Organizations can look for this class of issue through:
- Static analysis and code review rules for externally controlled values used in allocation, looping, or thread creation.
- Tests that submit boundary, oversized, negative, missing, and type-confused numeric parameters.
- Fuzzing of control-channel JSON and monitoring for crashes, memory growth, and thread-count spikes.
- Runtime telemetry for abnormal session concurrency, allocation failures, and service unavailability.
- Network policies and rate limits that constrain access to the control channel.
- Automated review tools that flag missing range checks and unchecked resource multipliers.

