Point Clouds Leak Through the Power Rail

When a cloud provider packs several customers onto one accelerator chip, the usual guarantee is that nobody can read anyone else's memory. But every circuit on a die drinks from the same power distribution network (PDN), and the current one tenant draws modulates the supply voltage seen by its neighbors — a coupling that logical isolation cannot touch, as Regazzoni et al. survey at length. Prior cross-tenant exploits exploit this coupling in two ways: passive snooping, where an attacker's on-chip delay-line sensor reads a neighbor's voltage trace to reconstruct which instructions ran or which neural network layers executed (Glamocanin et al.; Mercury, Yan et al.), and active attacks, where power-hammering circuits deliberately depress the voltage to corrupt a neighbor's weights in transit (Deep-Dup, Rakin et al.; DeepStrike, Luo et al.).

This proposal argues that sparse volumetric convolution — the standard way to run 3D perception, where computation happens only at occupied voxels of a mostly-empty 3D grid — changes the threat model in a way nobody has measured. Because the work done, and therefore the current drawn, scales directly with the number of occupied voxels $M$, the power trace of a victim processing a private 3D scan encodes coarse properties of the physical scene itself: its volume, its clutter, its room type. An attacker needs no weights, no opcodes, and no malicious circuits — just a voltage sensor and simple statistics. The same data-dependent bursts also cut both ways: a benign sparse workload can swing the shared rail hard enough to fault its neighbors. We propose to characterize this new leakage channel end-to-end, demonstrate it on real FPGA hardware, and build a current-shaping scheduler that buys back most of the privacy and reliability at a small fraction of the cost of the obvious defenses.

Core Claim

The claim has two halves. First, attack: macroscopic features of a remote voltage trace — total duration, phase energies, burst periodicity — are sufficient to regress the occupied-voxel count and classify the scene type of a victim running a submanifold sparse convolutional network, because per-layer runtime scales approximately as

$$T_{\text{layer}} \approx t_{\text{fixed}} + c \cdot M_{\text{active}},$$

where $M_{\text{active}}$ is the number of active voxels and $c$ is a per-architecture constant. Unlike prior topology-extraction attacks, this leaks the user's environment, not the user's model. Second, defense: a scheduler that paces the issue of coordinate batches into the compute array — borrowing the micro-tensor-operator idea from Neu10, Xue et al. — bounds the current slew rate $di/dt$ and, at coarse granularity, flattens the very features the attacker uses, while keeping compute linear in $M$.

The physics is captured by the droop equation the whole field rests on:

$$\Delta V = I R + L \frac{di}{dt},$$

where $R$ and $L$ are the parasitic resistance and inductance of the shared rail. Sparse workloads are unusual in that both terms fluctuate with input geometry: $I$ tracks voxel density, and $di/dt$ spikes when pruning or generative expansion abruptly activates or deactivates thousands of compute sites in a few cycles.

Research Program

The program has three parts, in escalating order of risk.

Measurement. We will deploy a SparsePixels-style submanifold sparse convolution engine (Tsoi et al.) on an AMD/Xilinx Alveo FPGA, occupying roughly the 20% of logic LUTs that design reports, and place a time-to-digital converter (TDC) — a tapped delay line whose reading varies with local supply voltage — in an adjacent partition, exactly as Mercury and Deep-Dup did. We will build a paired dataset of (voltage trace, scene metadata) over ScanNet v2 scans (Dai et al., 1,513 scans of 707 distinct spaces) and KITTI LiDAR frames, varying backbones (submanifold SR-UNet blocks as in PointContrast, a generative decoder as in GSDN, and magnitude-pruned convolutions as in SPS-Conv) so we can attribute leakage to specific sparse mechanisms. Alongside the real hardware, a PDN-aware cycle simulator lets us sweep victim/neighbor placements and rail parameters that we cannot physically rewire; the file's literature reports no PDN or droop measurements for sparse accelerators (no reported result found on Lacuna for voltage-noise metrics of SparsePixels), so this measurement layer is itself a contribution.

Attack. Two attackers run on identical traces. The strong attacker is Mercury's sequence-to-sequence pipeline (RNN with Connectionist Temporal Classification, and a Transformer) retrained on our sparse traces; the file's own analysis predicts its layer-boundary alignment should degrade because layer durations are no longer stationary when $M$ varies and SPS-Conv's top-$k$ pruning reshapes work mid-network. The simple attacker uses only duration, integrated energy, and burst-count statistics with a small classifier. If the simple attacker matches or beats the seq2seq attacker on scene classification and $M$ regression, that is the central result: dynamic sparsity breaks the timing-determinism assumption that prior extraction attacks were built on, while making an easier attack possible.

Defense. We will build a paced sparse scheduler that chunks the active coordinate list into fixed-size batches (micro-tensor operators, in Neu10's spirit) and releases them at a rate chosen so the worst-case $di/dt$ stays inside the co-tenants' timing margin, inserting cheap filler activity in the gaps rather than padding the tensor itself. We will evaluate it on three axes: induced droop against a dense co-tenant victim, leakage reduction against our own best attacker, and throughput loss relative to the unpaced engine. We are explicit that we do not expect full leakage closure: any scheme that keeps compute proportional to $M$ must leave some scene information in the trace. The honest deliverable is a measured leakage–efficiency frontier, with padding as its expensive endpoint.

Baselines

The naive reference point is the unprotected sparse engine with unshaped coordinate streaming, attacked by our best classifier; this is the status quo a cloud provider would ship today, and every reported number in the attack experiments is defined relative to it. The strongest existing competitor for what an adversary can extract from this channel is Mercury's seq2seq architecture-reconstruction pipeline (Yan et al.), which reported an operation error rate as low as 0.01 (1%) on MNIST-scale models and 4% on CIFAR-10 models from a single inference run at 40 dB signal-to-noise ratio; we will retrain it on our sparse traces with the same TDC hardware, the same trace budget, and the same hyperparameter search effort as our simple-statistics attacker, and we consider our attack successful only if simple features match its extraction quality on the geometry task — and, separately, we expect its layer-sequence error rate on sparse backbones to rise well above its reported 1–4%, which would confirm that dynamic sparsity defeats the assumptions that attack was built on. For the defense side, the do-nothing baseline is the unpaced engine, and the upper-bound baseline is full padding to a fixed worst-case voxel capacity, which closes leakage by construction but forfeits the efficiency that motivates sparsity — SparsePixels reports a 73× speedup and 0.665 µs latency over dense execution, and padding returns the pipeline to essentially that dense cost. For the fault-injection axis, the reference points are a dense co-tenant with no sparse neighbor (zero faults) and the known malicious worst case, where Deep-Dup reports collapsing ResNet-20 CIFAR-10 accuracy from 90.77% to 10.92% in 28 search iterations using ring oscillators on only 13.38% of fabric resources; our benign-sparse measurements sit between these anchors. Finally, one ablation isolates the key ingredient: the same batching scheduler without pacing (batches issued as fast as the array accepts them). If unpaced batching alone reduces leakage or droop as much as paced issue does, the proposal's core mechanism is not what is working, and we will say so.

Why not just…?

Why not just pad the sparse tensor to a fixed capacity so execution time is constant? This is the cleanest defense and we will run it as the upper-bound baseline, but the file's evidence says it destroys the point of the method: SparsePixels gets its 73× speedup precisely by touching under 1% of pixels, GSDN processes a 13,984 m³ building in 5 GB only because empty space costs nothing, and SPS-Conv saves 52.4% of GFLOPs on KITTI by pruning background voxels that padding would have to re-execute. The interesting scientific question is how much leakage can be removed before reaching the padded endpoint, which is exactly the frontier our experiments measure.

Why not just enforce physical separation or guard rings between tenants? Guard rings block signal routing between regions, not the power grid, which is a low-impedance metal mesh spanning the whole die (Regazzoni et al.); Mercury reports its TDC attack is location-agnostic, and Deep-Dup induced chip-wide corruption from circuits occupying 13.38% of the fabric. Separation spends billable silicon without touching the channel we study.

Why not just screen bitstreams with a malicious-circuit classifier? Tools like MaliGNNoma detect deliberately hostile netlists such as ring-oscillator arrays. Our leakage comes from an entirely benign victim whose own legitimate workload broadcasts its scene geometry; there is no malicious circuit to flag, and flagging high-activity sparse models would reject valid customers. Static screening is also bypassed entirely in virtualized settings like Neu10, where users submit models rather than bitstreams, and can be evaded via partial reconfiguration (Hacking the Fabric).

Why not just give each tenant a whole chip? This works, but it is economically untenable for sparse workloads specifically: the sparse engine we would deploy uses about 20% of an Alveo's logic (SparsePixels), stranding 80%, and Neu10 shows fine-grained sharing lifts throughput by up to 1.4× and cuts tail latency by up to 4.6×. Our proposal takes the provider's side of that trade seriously: it is a defense that lets multi-tenancy survive.

Why not just read the victim's API response time instead of building a TDC? This is a real threat to the attack's novelty, and we will test it head-on by running an API-timing-only attacker on the same scenes. Our hypothesis is that latency gives one noisy scalar per query, heavily quantized by scheduler batching, whereas the TDC trace exposes intra-run phase structure — the pruning bursts and expansion phases of SPS-Conv and GSDN style networks — which distinguishes scenes of equal voxel count. If the API-timing attacker performs as well, the hardware side channel is unnecessary and the finding becomes a cheaper, broader privacy result; either outcome is publishable, and the experiment settles it.

Proposed Experiments and Decisive Checks

All hardware experiments use the Alveo platform with a TDC in the attacker partition; all scene data come from ScanNet v2 (indoor, with room-type labels and measurable room volumes) and KITTI (outdoor LiDAR, with per-frame voxel counts), with SR-UNet, GSDN-style, and SPS-Conv-style backbones. The decisive checks are four. First, $M$ regression: does trace duration alone predict occupied-voxel count within 10% across held-out scenes, and does adding energy and burst statistics materially improve it? Second, the Mercury comparison: retrained Mercury should show sharply worse layer-sequence reconstruction on sparse backbones than its reported 1–4% operation error rate on dense ones, while our simple features still classify scene type well above chance — that contrast is the paper's central table. Third, benign droop: with a dense co-tenant running at a fixed clock, what droop does the unpaced sparse workload induce, and does pacing bring the co-tenant's fault rate to zero at under 10% throughput cost relative to the unpaced engine? Fourth, the frontier: plot attacker scene-classification accuracy against throughput for unpaced, paced, and fully padded execution; the proposal succeeds if pacing removes most of the accuracy gap between unpaced and padded at a small fraction of the padding cost, and it fails — honestly — if the leakage curve is flat until efficiency is nearly gone.