A modern many-core cluster is a chip where hundreds or a thousand processors share one memory pool through a hierarchy of switches. The wiring network that routes memory requests — the interconnect — is the performance bottleneck of such chips, and also a nearly invisible attack surface. A malicious edit that changes only timing leaves every functional test passing: RTL-Breaker showed that a poisoned HDL code generator can swap a fast adder for a slow, functionally identical one while keeping 95%–97% of the clean model's pass@1 on VerilogEval, and $\tt{PoisonedGNN}$ showed that functionally neutral inserted circuits can reach 100% toggle and statement coverage. The obvious detectors look at the wrong thing: graph neural networks trained on the netlist's wiring structure, which cannot see a "legitimate-looking" module that merely misbehaves under rare conditions.
The hiding place for such a trojan is, paradoxically, already huge. Latency in these clusters is wildly state-dependent: DAS showed that merely remapping where data physically resides yields 1.94× speedups on Vision Transformer layers and 3.68× on matrix–vector products on a 1024-core RISC-V cluster at 920 MHz, which means legitimate latency varies by multiples depending on workload state. A trojan that stalls one memory bank only when a specific request pattern appears hides inside exactly this variation. This proposal takes the central trick from pose-dependent appearance modeling — do not model a surface as a function of position alone, but as a canonical template plus a deformation conditioned on a low-dimensional body pose — and applies it to hardware: model interconnect latency as a canonical field plus a workload-conditioned deformation, learn the benign deformation from measurements, and flag deformations the learned field cannot explain. Detection then proceeds through an oracle-guided loop that ports the SAT attack's "distinguishing input" idea from Boolean outputs to timing traces. In one sentence: teach a model how latency normally bends with workload, then hunt for bends that do not fit.
Core Claim
The claim is that state-conditioned deformation models, imported from avatar graphics, turn stealthy interconnect trojans from invisible (to functional verification and structural netlist analysis) into detectable with few measurements, and that the same machinery formalizes why Boolean SAT reverse engineering cannot touch this threat class. Three facts from the literature motivate each half. First, the attack exists and evades current tools: timing-degradation backdoors pass functional suites (RTL-Breaker), and TrojanSAINT, the strongest netlist-level detector, explicitly evaluates only structural trigger implants — no reported result found on Lacuna for TrojanSAINT or any other detector on timing-degradation or interconnect-resident trojans. Second, the signal carrier exists: hierarchical shared-L1 clusters such as MemPool (256 cores, 22 nm, 600 MHz, L1 access in fewer than 6 cycles) and TeraPool exhibit structured, non-uniform memory access latency that is a deterministic function of routing state and workload. Third, the methodological template exists: avatar work solved the analogous "one point, many appearances" ambiguity by conditioning on pose (GaussianAvatar), and SAT attackers solved an analogous hypothesis-pruning problem with distinguishing inputs (Protect Your Chip Design Intellectual Property: An Overview; High-Level Approaches to Hardware Security: A Tutorial).
The Model
Let $r$ denote a route through the interconnect (a source tile, the switch stages it traverses, a destination memory bank) and let $\theta$ denote a low-dimensional "workload pose": per-tile request rates, the entropy of the bank-access distribution, barrier phase, and the active remapping configuration. We model measured latency as
$$L(r, \theta) \;=\; L_0(r) \;+\; \Delta(r, \theta;\, \phi),$$
where $L_0$ is the canonical non-uniform-memory-access profile (local banks fast, remote banks slow, per MemPool) and $\Delta$ is a deformation field with parameters $\phi$, trained on traces from a known-clean instance. Each design choice has a direct ancestor in the graphics literature, and each ancestor's lesson transfers. GaussianAvatar found that mapping pose forward into geometry avoids the ambiguity of inferring pose from geometry; likewise we predict latency forward from $\theta$ rather than trying to infer the workload from observed latency. Choi et al. (Pose-Conditioned Appearance and Surface Deformation) found that wrinkles depend on motion history, not just instantaneous pose; some trojans (e.g., a counter that fires after seeing a request sequence) are history-triggered, so $\theta$ must include a short temporal window — this is a concrete, testable modeling requirement, not decoration. And the discrete "texture vocabulary" idea from the graphics side guards against over-smoothing: latency spikes are high-frequency, so the deformation field should retrieve from a codebook of observed (state, deformation) pairs rather than regress a smooth average, which would smear away exactly the sharp stall signatures we hunt.
A trojan is then defined operationally: a residual $\lVert L_{\text{measured}} - L_0 - \Delta(\cdot,\theta;\phi)\rVert$ that is large, localized to a specific switch or bank, and — crucially — concentrated on a narrow set of states, inconsistent with how benign deformation distributes over $\theta$.
Research Program
Three components. First, a benchmark. No existing trojan benchmark contains interconnect-resident, functionally neutral, timing-degradation trojans: TrustHub (used by TrojanSAINT) covers structural implants on small cores, so we construct one from the open MemPool/TeraPool-style cluster RTL. The trojan catalog follows the substitution pattern proven by RTL-Breaker, applied to interconnect components: a round-robin arbiter replaced by a priority arbiter whose priority flips only under a specific request-pattern signature; a burst-packing mechanism (TCDM Burst Access) silently disabled under a trigger, which is functionally identical but bandwidth-starving; and corrupted entries in a DAS-style remapping table (DAS) that push hot data to the farthest banks under load. Each variant is swept across trigger rarity, from frequent (fires in 1 of 100 states) to rare (1 of 10,000), because rarity is the axis on which we expect unconditioned detectors to collapse.
Second, the deformation model and detection loop. The loop is a direct port of the oracle-guided SAT attack's distinguishing-input iteration into the timing domain. Given two hypotheses $H_1$ (benign) and $H_2$ (a specific trojan template), we query the physical or emulated chip with the state that maximizes predicted divergence,
$$\theta_d \;=\; \arg\max_{\theta}\; \bigl\lVert \Delta_{H_1}(\cdot,\theta) - \Delta_{H_2}(\cdot,\theta) \bigr\rVert,$$
observe the real latency, and prune the hypothesis family that predicted wrong. The lesson of Fun-SAT — that a cheap predictive statistic beats blind iterative search, cutting a 19% one-day timeout rate to 0.7% and achieving a 90× average speedup, with s38584 falling from 2.64 hours to 507 seconds — is what justifies using the learned deformation field to select $\theta_d$ rather than sweeping workload states blindly. This is also where the SAT connection becomes substantive rather than decorative: a standard Boolean SAT attack (Protect Your Chip Design Intellectual Property) cannot even express this hypothesis space, because the observable is a latency distribution, not a Boolean output — the same limitation TimingCamouflage+ exploited defensively when wave-pipelined delays made SAT attacks fail on every circuit tested. We claim the timing-domain distinguishing-input loop is the natural generalization, and we test that claim by measuring query counts against blind and random querying.
Third, the dual-use evaluation, which closes the loop with reverse engineering. The identical machinery, pointed at a defensive use of interconnect state (a remapping configuration treated as a secret key), should recover that configuration from latency traces in few queries — an attacker's tool for stealing the remap tables that give DAS its speedups. Demonstrating both directions on the same model establishes that state-conditioned deformation is a general instrument for inverting hidden state-dependent hardware behavior, not a one-off detector.
Baselines
The "do nothing" reference point is the standard pre-silicon verification flow: functional testbenches, design rule checks, and toggle/code coverage, the practice documented as insufficient for adversarial insertions by Tuan La et al. and Huili Chen et al. and quantified as evadable at 100% toggle and statement coverage by $\tt{PoisonedGNN}$. We will run the full coverage flow on every trojan variant; beating it means detecting anything at all where it detects nothing, and we expect exactly zero catches since every variant is functionally identical to the clean design.
The strongest existing competitor is TrojanSAINT, which converts gate-level netlists into graphs and uses GraphSAINT sub-graph sampling with probability-threshold tuning to find dormant Trojan gates amid class imbalance up to 719:1; it reports 78% true-positive rate and 85% true-negative rate in practical cross-circuit validation across 17 TrustHub benchmarks (98%/96% best-case leave-one-out). It is the strongest because it is the only published netlist-level detector that generalizes across unseen circuits. For fairness we synthesize our interconnect trojans and clean variants to gate level, hand TrojanSAINT the same netlists, sweep its threshold parameter over its published 0-to-0.5 range with the same compute and tuning budget we give our own method, and also include a structural-trigger control set (classic TrustHub-style implants in the same cluster) so the comparison cannot be accused of cherry-picking a regime. Beating it means substantially higher true-positive rate at true-negative rate of at least 85% on the timing-degradation set, while performing no worse than it does on the structural control set.
The key ablation is an unconditioned differential-latency detector: a regression (linear and gradient-boosted) from aggregate performance counters to latency, compared against a golden model's prediction, with an alarm threshold on the residual — identical data, traces, and threshold-sweep budget, but no state conditioning and no canonical/deformation decomposition. This isolates the proposal's central ingredient. A second ablation isolates the query-selection ingredient: the same detection logic driven by random and grid-swept workload states instead of the learned $\theta_d$, mirroring how Fun-SAT compared its guided approach against blind iterative unrolling.
Why not just…?
Why not just run a GNN netlist detector like TrojanSAINT? Because the trojans in question leave no structural signature: an arbiter swapped for a different arbiter, or a burst mechanism conditionally disabled, consists of legitimate gates doing legitimate local logic — precisely the class of functionally neutral modification that $\tt{PoisonedGNN}$ used to achieve 100% attack success rate against GNN hardware-security models while leaving zero post-synthesis layout footprints. GNNUnlock's success at 100% design recovery across 564 locked benchmarks shows graph learning is powerful when the defense creates structural anomalies (as SAT-hard locking schemes do); timing trojans create none. Still, we treat this as an empirical question, not a rhetorical one: TrojanSAINT runs on every benchmark, and if it detects our variants, the proposal's motivation collapses and we will report that.
Why not just compare measured latency against a golden chip? This is the most serious alternative, and we design the experiment to settle it rather than argue around it. A plain golden-reference residual detector fails only if benign state-dependence is large relative to trojan-induced shifts — and the literature says it is large: DAS reports latency swings of 1.94×–3.68× from remapping alone, and MemPool documents systematic local-versus-remote bank asymmetry. Our prediction is a crossover: at frequent triggers the unconditioned detector will match ours, but as trigger rarity increases its false alarms (benign state-dependent variation misread as anomalous) will crowd out true positives while the conditioned model stays clean. If no crossover appears and the unconditioned detector matches at all rarity levels, the state-conditioning ingredient is worthless and the proposal's core claim is falsified — we would report that and fall back to the query-efficiency contribution alone.
Why not just use power side-channel analysis? NiLoPher broke a SAT-hardened locking scheme via power analysis on small circuits, so the precedent is real and this is a genuine threat to novelty. But on a kilo-core cluster, aggregate power is dominated by workload variation far larger than a single arbiter's misbehavior, and the method presumes a golden reference die. Latency, by contrast, is already measured per-route by existing performance counters at zero hardware cost, and our conditioning machinery absorbs exactly the variation that drowns a side-channel signal. If latency-only detection plateaus below our targets, the honest response is to add power as a second conditioned channel within the same framework rather than concede the approach.
Why not just secure the supply chain with split manufacturing or watermarking? Physical defenses like split manufacturing and AutoMarks-style layout watermarking address a different threat: they deter an untrusted foundry from cloning or tampering with layout. Our trojans can enter earlier, as third-party RTL or LLM-generated code — the exact vector RTL-Breaker demonstrated — before any layout exists, and ARIANNA-class redaction carries substantial area and power penalties. The defenses are complementary, not substitutes.
Proposed Experiments and Decisive Checks
All experiments run on cycle-accurate RTL simulation of a MemPool/TeraPool-class cluster (256- and 1024-core configurations), with an FPGA emulation pass to confirm the timing traces survive real clocking; the hardware monitor budget is reported as chip-area percentage against the DAS reference point of under 0.1% area and 0% frequency degradation. Metrics are true- and false-positive rates at module level, queries-to-localization for the timing-domain distinguishing-input loop, and area/power overhead of any instrumentation. The decisive checks are four. First, the coverage flow catches zero of the trojan variants while our detector localizes them — the headline table. Second, TrojanSAINT's cross-circuit numbers on our timing-degradation set come out near chance even after threshold tuning, while it retains its published 78%/85% behavior on the structural control set, cleanly partitioning what structure-based and behavior-based detection each cover. Third, the receiver-operating curves of the conditioned versus unconditioned detectors as trigger rarity sweeps four orders of magnitude: the crossover prediction is the make-or-break result for the core claim. Fourth, the dual-use run: recovering a held-out DAS remapping configuration from latency traces, with query count compared against blind state sweeps — success in tens of queries where blind sweeps need thousands would confirm that the Fun-SAT lesson (guided search beats blind iteration, 90× speedup, 19%→0.7% failure) transfers to the timing domain. A negative on any of the four is reportable and informative; the third is the one that could kill the idea, and it is designed so that it can.
References
- RTL-Breaker: Assessing the Security of LLMs Against Backdoor Attacks on HDL Code Generation
- $\tt{PoisonedGNN}$: Backdoor Attack on Graph Neural Networks-Based Hardware Security Systems
- A Dynamic Allocation Scheme for Adaptive Shared-Memory Mapping on Kilo-Core RV Clusters for Attention-Based Model Deployment
- TrojanSAINT: Gate-Level Netlist Sampling-Based Inductive Learning for Hardware Trojan Detection
- MemPool: A Scalable Manycore Architecture With a Low-Latency Shared L1 Memory
- GaussianAvatar: Towards Realistic Human Avatar Modeling from a Single Video via Animatable 3D Gaussians
- Protect Your Chip Design Intellectual Property: An Overview
- High-Level Approaches to Hardware Security: A Tutorial
- Relightable and Dynamic Gaussian Avatar Reconstruction from Monocular Video
- TCDM Burst Access: Breaking the Bandwidth Barrier in Shared-L1 RVV Clusters Beyond 1000 FPUs
- Fun-SAT: Functional Corruptibility-Guided SAT-Based Attack on Sequential Logic Encryption
- TimingCamouflage+: Netlist Security Enhancement With Unconventional Timing
- Denial-of-Service on FPGA-based Cloud Infrastructures - Attack and Defense
- AdaTest: Reinforcement Learning and Adaptive Sampling for On-chip Hardware Trojan Detection
- GNNUnlock: Graph Neural Networks-based Oracle-less Unlocking Scheme for Provably Secure Logic Locking
- NiLoPher: Breaking a Modern SAT-Hardened Logic-Locking Scheme via Power Analysis Attack
- AutoMarks: A GNN-based Automated Physical Design Watermarking Framework
- ARIANNA: An Automatic Design Flow for Fabric Customization and eFPGA Redaction