Federated learning lets cars train a shared model without uploading their camera data. They upload only model updates, and a known attack called gradient inversion can turn those updates back into images. One cheap defense splits each update into pieces and sends each piece to a different aggregating node, so that no single node sees the whole update. Vehicular networks favor this kind of splitting because heavier cryptography does not fit their millisecond deadlines. But in these networks the aggregators are roadside units, and the assignment of pieces to units is redrawn constantly as cars drive past. This note argues that the redrawing is itself a leak. A roadside unit, or a small group of colluding units, that a car meets repeatedly receives different pieces in different rounds. Because one car's updates change slowly from round to round, those pieces can be stitched into something close to a full update and then inverted.
The proposal has two parts. The first measures how much private data an observer can recover as a function of how much of a car's update it has seen over time, a quantity we call coverage. The second builds a scheduler that assigns update pieces to roadside units. It minimizes delivery latency subject to an explicit cap on any coalition's coverage, and it reports the price of that cap in missed deadlines. Neither the low-latency consensus literature nor the gradient-privacy literature has looked at this interaction. The consensus work treats the transaction payload as opaque. The privacy work assumes a fixed set of aggregators.
Core Claim
Information-theoretic sharding defenses bound what one aggregator learns in one round. In mobile networks with latency-driven reassignment, the relevant quantity is instead the cumulative, cross-round coverage held by any plausible coalition, and reconstruction quality tracks that coverage. The privacy guarantee of sharding therefore depends on the reassignment policy, not only on the number of shards. A coverage-capped assignment can restore the guarantee at a measurable latency cost. If a much simpler policy restores it for free, we expect to find that out and report it.
Where This Sits
The sharding defense we build on is ERIS. It compresses updates and splits them into $A$ disjoint pieces held by $A$ client-aggregators. It proves that mutual-information leakage falls as $A$ grows and reports that even two aggregators reduce reconstructions to "unrecognizable noise." ERIS assumes a fixed, non-colluding set of aggregators within a round. It does not model assignments that change over time, which is our central variable.
The latency side comes from two systems. DRDST uses a genetic algorithm to shard roadside units and spreads transactions through minimum-latency broadcast trees over a DAG ledger, where blocks need not form one chain, so transactions are confirmed concurrently. Its simulation covers 100–200 roadside units, 10,000 vehicles at up to 80 km/h, and roughly 98% consensus success at a 15% Byzantine rate. SpeedyChain reaches sub-2 ms transactions by separating payloads from block headers. The DAG review in When Distributed Consensus Meets Wireless Connected Autonomous Systems explains why multi-round voting breaks ultra-low-latency budgets. These systems supply the reassignment dynamics and the latency targets. They evaluate throughput and fault tolerance but never ask what a relaying node can learn from the payload.
On the attack side, Gradient Inversion with Generative Image Prior supplies the threat model. Its method, GIAS, searches the latent space of a pretrained image generator for an image whose gradient matches the observed one. It recovers images at batch size 32 and still succeeds when 99% of gradient values are removed. Its companion method, GIML, learns the image prior from a stream of successive federated gradients, which is exactly the kind of multi-round observation a stitching adversary has.
The GIAS pruning result appears to contradict ERIS, so we address it directly. GIAS removes small-magnitude coordinates and keeps the most informative ones, while ERIS removes whole coordinate blocks regardless of magnitude. Whether a single block-partitioned piece leaks under a generative prior is therefore an open empirical question. The answer constrains everything downstream. If one piece already leaks, coverage caps are moot at practical $A$, and the project becomes a negative result about sharding defenses.
Concealing Sensitive Samples motivates the stitching hypothesis. It shows that reconstruction exploits the low entanglement of individual samples' updates, that is, updates lying in nearly separate directions. Updates computed on the same local data across nearby rounds are the opposite case: highly aligned, which is what makes stitching plausible.
The closest existing system is Federated TrustChain. It combines ledger-based federated learning with LoRA-based unlearning on Hyperledger Fabric, but it needs 28–30 seconds per epoch and never measures inversion attacks. LSHFed verifies hashed gradients but uses static topologies and does not test optimization-based inversion. The Blockchained FL survey flags that edge miners and validators can see gradients but offers no model of the problem.
Research Program
Coverage. For client $k$, a coalition $S$ of observers, and a window of $T$ rounds, define coverage as
$$C_k(S,T) = \frac{1}{d}\left|\bigcup_{t \le T} \bigcup_{o \in S} I_{k,o}^{(t)}\right|.$$
Here $d$ is the update dimension and $I_{k,o}^{(t)}$ is the set of coordinates of client $k$'s round-$t$ update that observer $o$ receives. Reception can come from aggregation or from relaying in the gossip tree, and counting gossip relays covers the DAG broadcast exposure. Coverage ignores how much the model drifts between rounds. We will therefore also record the time gap between stitched pieces and test whether a drift-weighted coverage predicts leakage better than raw coverage.
Stitching attack. The attacker stitches by treating each received piece as a constraint on one shared unknown update. It then runs GIAS against the stitched vector, using masked gradient matching so that only the observed coordinates are compared. A GIML variant meta-learns its prior from the stream of pieces.
Scheduler. The defense is an assignment rule that plugs into DRDST's sharding loop. Each round it chooses which roadside unit receives which piece. It minimizes expected delivery latency subject to $C_k(S,T) \le \kappa$ for every coalition $S$ of size up to $c$. Here $\kappa$ is a target coverage read off the leakage curve, and $c$ is set from DRDST's 15% Byzantine tolerance. Enforcing the cap exactly over all coalitions is combinatorial. We will use an approximation: a per-client ledger of which units have held which coordinate blocks, which is cheap because pieces are contiguous blocks, plus a greedy assignment with a budget-violation penalty. The output is a latency–leakage frontier indexed by $\kappa$ and $c$.
Scope. We study honest-but-curious and colluding roadside units. Active attacks that tamper with the global model, such as the batch-normalization "fishing" models in Breaking Secure Aggregation and OASIS's neuron-isolation setting, are explicitly out of scope and named as a limitation.
Baselines
Naive reference point. Vehicles send unsharded updates to the nearest roadside unit using DRDST's latency-optimal routing. This sets the leakage ceiling. The strongest reported number for the attacker in this regime is GIAS at about 15.58 dB PSNR on CIFAR-10, versus 13.78 dB for pixel-space attacks (Gradient Inversion with Generative Image Prior). We will check that our reimplementation of GIAS reproduces this before trusting any comparison.
Strongest existing defense. ERIS-style sharding with $A$ pieces, re-mapped each round by DRDST's latency-driven assignment. This is the configuration practitioners would actually deploy, and it is the one this note claims leaks. No numeric reconstruction result for ERIS is reported on Lacuna; the file gives only the qualitative "unrecognizable noise" at two aggregators, so we will first reproduce ERIS's single-round result in our setup. Our scheduler beats this baseline if, at matched $A$, matched data, and the same mobility traces, it holds stitched-attack PSNR at the single-round level, or at least 3 dB below this baseline, while keeping deadline-miss rate within a stated margin.
Two sharding ablations. Both isolate the key ingredient, the coverage cap. The first fixes each roadside unit's coordinate block by hashing the unit's identity, so a single unit sees the same block forever. Pieces then have to travel to units holding the right key, which may add multi-hop latency. The second re-randomizes the block assignment every round, which we expect to be the worst policy for leakage.
Mild noise baseline. Local Gaussian noise added on top of DRDST sharding, swept across noise levels. Model accuracy for this baseline is compared against the reported 78–85% MNIST accuracy for differential-privacy baselines in Mixed Quantization.
Tuning and compute. All methods share the same tuning budget for their single knob ($\kappa$, $A$, or noise scale), the same simulator, and the same attacker compute.
Why not just…?
Why not just add differential-privacy noise? The file's evidence is that noise strong enough to stop generative-prior attacks costs too much accuracy. DP baselines fall to roughly 78–85% on MNIST where quantization keeps 96.67% (Mixed Quantization), and GIAS's authors report that the noise needed to stop their attack is impractical. Combined with sharding, though, only mild noise may be needed, so this is a real competitor. The noise-plus-sharding baseline will show whether noise alone closes the stitching gap at acceptable accuracy.
Why not just use cryptographic secure aggregation? Against curious but passive roadside units, secure aggregation would hide individual updates entirely. Its weakness is the extra rounds of key setup and secret sharing, which the consensus literature says break ultra-low-latency budgets. We have no measured number for this in the file, so we will measure its round latency in the DRDST simulator. If it fits the deadline at realistic vehicle density, it dominates our scheduler for the passive threat model, and we will say so.
Why not just key each shard to a fixed roadside unit? This is the most dangerous alternative, because it bounds any single unit's coverage at $1/A$ with no optimization at all. Its costs are possible multi-hop latency and no protection when units collude across keys. If, in simulation, it meets deadlines and coalitions of size $c$ cannot stitch, the scheduler is unnecessary. The contribution would then reduce to the coverage–leakage measurement plus a recommendation to key shards to fixed units, and we would report that outcome.
Proposed Experiments
Experiment 1: does one piece leak? We reproduce GIAS on CIFAR-10, 32×32 FFHQ faces, and 64×64 ImageNet. We then measure PSNR and SSIM as a function of coverage, comparing block-partitioned coverage against GIAS-style magnitude pruning at equal coverage. This directly tests the ERIS–GIAS tension. As reference points, DCS² reports SSIM 0.15 under its defense, and mixed quantization reports DLG PSNR falling to 8.1 on MNIST.
Experiment 2: does stitching work in the driving domain? We repeat Experiment 1 with stitched pieces from rounds spaced $\Delta$ apart, on nuScenes camera crops (nuScenes) used for a federated perception classifier. We vary the number of local steps and the learning rate, since both control drift between rounds. The hypothesis fails if stitched reconstructions are no better than reconstructions from a single piece at matched coverage.
Experiment 3: system-level frontier. We run the DRDST mobility configuration: 100–200 roadside units, up to 10,000 vehicles, speeds up to 80 km/h, and 15% Byzantine units acting as a colluding coalition. Every baseline above is evaluated under this setup. We report three quantities: accumulated coalition coverage over time, stitched-attack PSNR on the nuScenes model, and deadline-miss rate against a sub-second confirmation target. For this last metric, DRDST's 98% consensus success rate is the reference floor; no reported result on Lacuna was found for deadline-miss rates of privacy-augmented federated pipelines.
Decisive check. One comparison settles the project: the coverage-capped scheduler against the fixed-key ablation on the same traces. The proposal earns its place only if fixed keys either miss deadlines or fail against coalitions while the scheduler does neither.
References
- ERIS: Enhancing Privacy and Communication Efficiency in Serverless Federated Learning
- DRDST: Low-Latency DAG Consensus Through Robust Dynamic Sharding and Tree-Broadcasting for IoV
- SpeedyChain: A framework for decoupling data from blockchain for smart cities
- When Distributed Consensus Meets Wireless Connected Autonomous Systems: A Review and a DAG-Based Approach
- Gradient Inversion with Generative Image Prior
- Concealing Sensitive Samples against Gradient Leakage in Federated Learning
- Blockchain-Based Gradient Inversion and Poisoning Defense for Federated Learning
- LSHFed: Robust and Communication-Efficient Federated Learning with Locally-Sensitive Hashing Gradient Mapping
- Blockchained Federated Learning for Internet of Things: A Comprehensive Survey
- Breaking Secure Aggregation: Label Leakage from Aggregated Gradients in Federated Learning
- OASIS: Offsetting Active Reconstruction Attacks in Federated Learning
- Mixed Quantization Enabled Federated Learning to Tackle Gradient Inversion Attacks
- nuScenes: A multimodal dataset for autonomous driving