Does Removing the Synchronous Barrier Expose Peers to Gradient Inversion?

Decentralized learning lets devices train a shared model by trading model copies with a few neighbors instead of sending everything to a server. Most deployed and analyzed protocols are synchronous: every node waits for all its neighbors each round, averages what it receives, and only then moves on. That waiting is the main cost of decentralized training, because the slowest device sets the pace. A large literature therefore removes the barrier and lets nodes exchange messages one pair at a time, whenever each is ready. This note argues that the barrier also does a second job nobody has measured. When a node averages many neighbors in one step, each outgoing message blends many private contributions. When the barrier is removed, messages leave after only one or two events. An eavesdropping neighbor may then see the victim's own training signal nearly in isolation.

We propose to test this directly. We build a delay-aware gradient inversion attack, which reconstructs a peer's training images from the stream of asynchronous messages it sends. We measure how reconstruction quality changes as synchrony is relaxed. We then study one cheap control: a node holds outgoing messages until it has absorbed at least $k$ events since its last send. This "send-side partial barrier" gives a curve of reconstruction fidelity against wall-clock idle time. If the hypothesis holds, the curve tells practitioners how much of the straggler savings from asynchrony they are paying for in privacy. If it fails, and staleness itself scrambles the signal, that is equally useful: asynchrony would be a free defense.

Core Claim

The claim is that the number of unknown mixing events between two consecutive messages from a victim controls how hard inversion is.

In synchronous gossip, the difference between two messages from node $v$ contains one local gradient step plus the summed models of all of $v$'s neighbors. Pasquini et al. needed a dedicated attack, "functional marginalization," to cancel those neighbor contributions. That work, On the (In)security of Peer-to-Peer Decentralized Machine Learning, showed sparse peer-to-peer graphs leak more than centralized federated learning, but it studied synchronous rounds only. In asynchronous pairwise gossip, the same difference often contains only the attacker's own contribution, which the attacker knows, plus a few stale local steps. Writing $x_v^{(i)}$ for the $i$-th model $v$ sends to attacker $u$, the change between sends is

$$x_v^{(i+1)} - x_v^{(i)} = \sum_{j \in M_i} w_j\,(x_j - x_v) \;-\; \eta \sum_{s=1}^{S_i} g_v(\tilde{x}_s),$$

where $M_i$ is the set of mixing partners $v$ met in between, with weights $w_j$. Here $S_i$ is the number of local steps, $\eta$ is the learning rate, and $g_v(\tilde{x}_s)$ is $v$'s gradient on its private batch, evaluated at a possibly stale model $\tilde{x}_s$.

When $M_i$ contains only $u$, the first term is known. Inversion then reduces to multi-step update matching with latent $S_i$ and staleness. Gradient Inversion Attacks Beyond SGD shows update matching of this kind still works up to batch size 16 and remains partially effective across several local steps. The open question is empirical. Asynchrony produces many such "clean" message pairs, which favors the attacker. But staleness and random step counts distort the inversion objective, which favors the victim. SoK: On Gradient Leakage in Federated Learning reports exactly this kind of distortion: multi-step updates push LPIPS (a perceptual image-distance score) above 0.1. Which effect dominates is unknown.

Research Program

We first build a common testbed on decentralizepy. It runs identical models, data partitions and graphs under three protocols. The first is synchronous gossip SGD. The second is randomized pairwise asynchronous gossip, with heterogeneous compute speeds and link delays drawn from a straggler distribution. The third is asynchronous gossip with the send-side partial barrier at $k \in \{1, 2, 4, \text{deg}(v)\}$, where $\text{deg}(v)$ is the victim's neighbor count. At $k = \text{deg}(v)$ the third protocol approximately recovers synchronous mixing at the sender only. Ring, torus and random regular graphs follow the topologies used by Pasquini et al.

The attack has three parts. The attacker is an honest-but-curious neighbor, and the main setting is passive. It records the timestamps and contents of all messages it exchanges with the victim. First, it scores each consecutive message pair by how much unexplained mixing it likely contains. The score uses the norm of the residual after subtracting its own known contribution. Second, it keeps the cleanest pairs. Third, it runs update matching from Wan et al., using their analytic label recovery, over the residual. Local step count and staleness are treated as latent variables, searched over a small grid and refined jointly with the dummy images. To test whether priors change the conclusion, we add a generative-prior variant following Gradient Inversion with Generative Image Prior and Auditing Privacy Defenses in Federated Learning via Generative Gradient Leakage.

As a secondary arm, we add a momentum-and-error-feedback compressed optimizer in the style of MoTEF from Towards Faster Decentralized Stochastic Optimization with Communication Compression. The residual buffers it keeps across rounds are hidden from the attacker. This arm asks whether asynchrony plus hidden optimizer state changes the picture. We keep it secondary so the main question stays clean.

Baselines

The naive reference point is the synchronous protocol attacked with Pasquini et al.'s functional marginalization followed by the same update-matching inversion. This is the existing method for this threat model and the condition asynchrony is meant to replace. Running our full inversion pipeline on it, with the same attacker knowledge, iteration budget and prior, ensures that any gap is due to the protocol, not the attack implementation. The file reports no reconstruction PSNR for Pasquini et al. (no reported result found on Lacuna for gradient inversion fidelity in their synchronous peer-to-peer setting), so we measure it ourselves.

The strongest existing attack is update matching from Wan et al. applied naively to raw message differences in the asynchronous protocol, with no event filtering and no latent step or staleness modeling. Wan et al. report up to a 6.5 dB PSNR gain over prior attacks against Adam on ImageNet and a 3.0 dB gain on SGD, with attacks effective up to B = 16. As a sanity anchor for the centralized single-step ceiling, Mixed Quantization Enabled Federated Learning to Tackle Gradient Inversion Attacks reports 55.3 dB DLG PSNR on undefended CIFAR-10 LeNet-5 updates. Our attack beats this baseline if event filtering plus latent modeling improves median PSNR and LPIPS on the same victims and message budget, at matched optimizer iterations.

The ablation that isolates our key ingredient removes event filtering but keeps latent modeling, and separately keeps filtering but fixes step count and staleness at their nominal values.

The strongest defense competitor is Top-DP's asynchronous pairwise protocol from Topology-aware Differential Privacy for Decentralized Image Classification. It adds noise that accounts for noise already inherited from neighbors and was designed for exactly this asynchronous regime. It was evaluated only by formal privacy guarantees and accuracy, so the file has no reconstruction number for it (no reported result found on Lacuna). We tune its noise and the partial barrier's $k$ to the same final test accuracy. The partial barrier "wins" if it reaches lower reconstruction fidelity at equal accuracy and no more than equal idle time.

Why not just…?

Why not just reuse Pasquini et al.'s functional marginalization on asynchronous traffic? It assumes a fixed round structure in which every neighbor contributes once per round, so marginalization subtracts a known set of terms. Under asynchrony the set of contributors between two messages is random and timing-dependent. That is exactly what our event filter estimates. We run their attack on asynchronous traffic as a baseline. If it already matches our attack, the delay-aware component adds nothing and we will report that.

Why not just add differential privacy noise and stop worrying about the protocol? Calibrated noise does bound leakage in principle. But the file records large utility costs: DP baselines falling to 78–85% on MNIST in the mixed-quantization study, and failing to converge on CIFAR-10 in the Top-DP study. GGL also reconstructs identifiable images from DP-defended updates. This is a real competitor, not a strawman, which is why Top-DP's asynchronous variant is run at matched accuracy. If it dominates the partial barrier on that curve, the defensive half of this proposal is unnecessary. The measurement half, showing how much asynchrony itself changes leakage, would still stand.

Why not just raise the number of local steps, which already hurts inversion? The SoK finds multi-step updates degrade optimization-based inversion. But Wan et al. report partial success up to 8 local steps. Under non-identical data, many local steps also cause drift that compressed decentralized methods correct with tracking. We include local step counts of 1, 4 and 8 as a factor in every condition. If large step counts alone neutralize the asynchronous attack at acceptable accuracy, the partial barrier is moot, and the experiment will show it.

Why not just conclude staleness is a free defense? That is one of the two outcomes we are testing for, not an objection to them. The decisive experiment below distinguishes it.

Proposed Experiments

The main benchmarks are CIFAR-10 and LFW at 32×32 with small convolutional networks and ResNet-9, with 16 to 64 nodes partitioned non-identically. A 224×224 ImageNet subset with ResNet-18 tests whether conclusions survive higher resolution with generative priors. Reconstruction is scored by PSNR, SSIM and LPIPS per victim image, matched to the true batch by optimal assignment. Training is scored by test accuracy and simulated wall-clock time under a heavy-tailed straggler distribution.

The decisive check is a dose-response plot. On the x-axis is the measured mean number of unknown mixing events between consecutive victim messages, varied by protocol, graph degree and $k$. On the y-axis is median reconstruction LPIPS. The hypothesis predicts a monotone increase in leakage as this count falls toward zero. Fully asynchronous gossip should then sit closer to the centralized single-update ceiling than to synchronous peer-to-peer. Staleness-as-defense predicts the reverse.

A second check holds the event count fixed and varies only the delay spread. This separates "fewer blended contributions" from "older gradients." A third check plots the partial barrier's leakage against wall-clock time recovered relative to full synchrony, alongside Top-DP at matched accuracy. That plot is the practical answer to how much of the straggler speedup costs privacy.