When we think about adversarial attacks on computer vision models, we usually imagine a scenario where an attacker manipulates an image to cause a misclassification—making a stop sign look like a speed limit sign, or making a pedestrian invisible. These attacks target the accuracy of the model.
However, a different class of security vulnerabilities targets a system's availability by exploiting latency. Deep neural networks typically have a fixed execution time during their feedforward pass; given an input size, a GPU takes roughly the same amount of time to compute the layer activations regardless of what is in the image. But as Chenyi Wang 0005 et al. point out in From Threat to Trust: Exploiting Attention Mechanisms for Attacks and Defenses in Cooperative Perception, the complete perception pipeline relies on classical, algorithmic post-processing steps that scale dynamically based on the network's output.
By forcing a model to generate specific types of redundant or chaotic outputs, an attacker can trigger worst-case computational complexity in these post-processing algorithms. This turns a real-time system into an unresponsive one, creating a hardware-level Denial-of-Service (DoS) or "sponge" attack that can paralyze safety-critical applications like autonomous driving.
The Quadratic Cost of Non-Maximum Suppression
The primary target for these latency attacks is Non-Maximum Suppression (NMS). Object detection models typically propose thousands of candidate bounding boxes across an image, many of which overlap around the same object. To clean this up, NMS sorts the candidate boxes by their confidence scores, selects the highest-scoring box, and removes all other overlapping boxes that have an Intersection over Union (IoU) above a certain threshold. This process repeats until no boxes remain.
In the best-case scenario, many boxes overlap significantly and are pruned early in the loop. However, NMS exhibits a worst-case quadratic time complexity ($\mathcal{O}(N^2)$) relative to the number of candidate boxes $N$. If an adversary can artificially inflate $N$ while ensuring the boxes do not trigger early pruning, the computational cost explodes.
Standard Input:
[Box A: 0.95] <--> (High Overlap / High IoU) <--> [Box B: 0.80]
Result: Box B is quickly pruned. Few loop iterations.
Adversarial Input (Sponge Attack):
[Box A: 0.93] [Box B: 0.92] [Box C: 0.91] [Box D: 0.90]
(Dispersed across the background, zero or minimal IoU overlap)
Result: No boxes prune each other. NMS evaluates every pair. Quadratic slowdown.
As first demonstrated by Alon Zolfi et al. in Phantom Sponges: Exploiting Non-Maximum Suppression to Attack Deep Object Detectors, an attacker can generate a Universal Adversarial Perturbation (UAP) that tricks the network into predicting thousands of "phantom" objects in the background. Crucially, to maximize the NMS bottleneck, the attack must satisfy two conditions:
- High Confidence: The phantom boxes must survive the initial confidence thresholding stage.
- Low Overlap: The boxes must be non-overlapping. If they overlap, NMS will simply suppress them in the first few iterations, defeating the purpose of the attack.
To optimize this, Coen Schoof et al. in Beyond PhantomSponges: Enhancing Sponge Attack on Object Detection Models introduced loss functions that explicitly minimize the IoU between predicted bounding boxes. By forcing the model to scatter thousands of tiny, high-confidence false positives across the background, the NMS algorithm is forced to evaluate almost every single pair of proposals, causing inference delays to spike by over 500%.
Diverse Vectors for Latency Exploitation
This algorithmic bottleneck can be exploited through several distinct threat vectors, ranging from digital image manipulation to hardware faults and multi-agent network injections.
- Physical and Backdoor Injections: Rather than computing an adversarial perturbation for every frame, Hangtao Zhang et al. in Detector Collapse: Backdooring Object Detection to Catastrophic Overload or Blindness in the Physical World demonstrated that object detectors can be backdoored during training. When a specific physical trigger is present in the scene, the backdoored model collapses into a "sponge" state, flooding the post-processing pipeline with thousands of small, non-overlapping false positives.
- Hardware Bit-Flips: Latency attacks do not even require modifying the input image. Manojna Sistla et al. in Bit-Flip Induced Latency Attacks in Object Detection showed that executing a small number of hardware-level bit-flips in the model's memory can corrupt the weight representations. This corruption causes the model to consistently hallucinate dense fields of phantom objects in the background, slowing down edge devices by over 20x.
- Multi-Object Tracking (MOT) Exploitation: The vulnerability extends past single-frame detection into temporal tracking. Multi-object tracking algorithms maintain state threads over time to handle temporary occlusions (e.g., a car driving behind a tree). In SlowTrack: Increasing the Latency of Camera-Based Perception in Autonomous Driving Using Adversarial Examples, Chen Ma et al. showed that an attacker can exploit this occlusion logic. By strategically re-triggering brief, sporadic detections for non-existent objects, the adversary forces the tracking system to open and maintain a massive pool of active tracking threads, exponentially increasing the downstream data association overhead.
- Cooperative Perception: In connected vehicle environments, vehicles share perception data to see around corners. Chenyi Wang et al. developed CP-FREEZER: Latency Attacks Against Vehicular Cooperative Perception, demonstrating that injecting adversarial proposals into Vehicle-to-Vehicle (V2V) messages can overwhelm a receiver's fusion and NMS stages, increasing perception latency by over 90× and effectively freezing the vehicle's decision-making loop.
Defenses and the Reality of Edge Deployment
Mitigating these attacks is challenging because standard defensive heuristics often introduce trade-offs. For instance, imposing a hard time limit or a strict cap on the number of allowed bounding boxes can stop the latency spike, but as noted by Alon Zolfi et al., it risks dropping legitimate object detections, causing the vehicle to become "blind" to actual obstacles.
To counter this, Tianyi Wang et al. proposed a defense called Underload in Can't Slow Me Down: Learning Robust and Hardware-Adaptive Object Detectors against Latency Attacks for Edge Devices. Underload utilizes hardware-adaptive, background-attentive adversarial training. By training the model to explicitly suppress high-confidence variations in background regions where phantom objects are typically generated, the defense successfully stabilizes edge hardware frame rates (e.g., restoring performance from 13 FPS back to a safe 43 FPS).
Is the Threat Real or Theoretical?
While the algorithmic vulnerability of NMS is mathematically clear, its real-world exploitability remains a subject of active debate. Erh-Chung Chen et al. in Overload: Latency Attacks on Object Detection for Edge Devices confirmed that resource-constrained edge devices are highly susceptible to these attacks due to limited parallel processing power.
Conversely, Jean-Philippe Monteuuis et al. challenged the severity of this threat in Latency NMS Attacks: Is It Real Life or Is It Just Fantasy?. Introducing the EVADE framework, the authors demonstrated that when object detection pipelines are deployed in production environments—utilizing heavily parallelized GPU operations, model quantization (such as INT8 precision), and basic input preprocessing—the theoretical quadratic slowdowns largely vanish. Quantization often disrupts the precise adversarial perturbations required to generate thousands of stable phantom boxes, suggesting that while post-processing bottlenecks exist on paper, modern hardware acceleration and optimization pipelines offer inherent resilience.
Key Foundational Work
Detector Collapse: Backdooring Object Detection to Catastrophic Overload or Blindness in the Physical World (2024) — contributed 4 concept elements to this direction.
Phantom Sponges: Exploiting Non-Maximum Suppression to Attack Deep Object Detectors (2023) — contributed 3 concept elements to this direction.
Overload: Latency Attacks on Object Detection for Edge Devices (2024) — contributed 2 concept elements to this direction.