When a chip design house sends its layout to an offshore fab, the fab sees everything: the full wiring of the design, and the opportunity to quietly copy it or modify it. Machine-learning defenses against this inspect the gate-level netlist — the circuit's wiring diagram — as a static picture, using graph neural networks to spot suspicious trigger logic. But two attack classes are nearly invisible in that picture. Sequential Trojans misbehave only after rare multi-cycle state sequences, so their structural signature is weak and ambiguous. And "degradation" Trojans do not change logic at all — they swap in functionally equivalent but slower or hungrier circuits, passing every functional check while stealing timing margin under load. What neither attack class can hide is behavior over time: which gates switch, when, and how often, across millions of clock cycles.
This proposal builds a detector that watches a circuit the way one watches video: each gate is a node in the circuit's own graph, and its switching activity over time is a per-node signal, giving a spatio-temporal graph. The catch is that the time axis cannot be trusted. The side-channel literature shows that dynamic frequency scaling, random delays, and voltage-induced jitter scramble time-series observations so badly that CNN-based analyses collapse — on the Chameleon benchmark, dynamic frequency scaling drove a deep-learning attack's success rate to 0.7%. An adversary can weaponize exactly these tricks to camouflage a Trojan's anomalous activity, and a defender's own desynchronization countermeasures blind conventional dynamic detection. So the detector must be invariant to time-axis warping, and it must be affordable: a 300,000-gate netlist times a million cycles of activity is not a tensor anyone can process densely. Temporal redundancy is the enabling tool here — most gates are idle most cycles, and the redundant stretches can be merged or skipped, the way video models skip static frames.
Core Claim
The claim is threefold. First, sequential and timing-degradation Trojans that evade static structural analysis — the hardest cases in the existing GNN detectors — leave a distinctive spatio-temporal fingerprint in per-gate switching activity: dormant trigger logic shows near-zero switching punctuated by rare activations, and degradation implants show localized timing residuals, both visible only when topology and time are modeled jointly. Second, this fingerprint survives deliberate temporal desynchronization if the model's temporal attention operates on an inferred logical time axis (cycle count) rather than the observed, warped physical sample index. Third, learned compression of the redundant idle stretches — adapted from video token-merging methods — makes the whole pipeline tractable without losing the rare events that constitute the evidence.
The closest existing work differs on every axis. TrojanSAINT maps netlists to static graphs and reports 78% true positive rate and 85% true negative rate averaged over 17 TrustHub designs, best case 98% and 96% — but it never models execution over time (TrojanSAINT). GATE-Net classifies fan-in subgraphs with contrastive GCNs and shows exactly where static structure runs out of signal: its F1 improvement over hand-crafted features drops from 46.99% on combinatorial triggers to 21.91% on sequential ones (GATE-Net) — the gap this proposal attacks. On the trace side, Chameleon and EstraNet treat power traces as 1D sequences only, without any circuit topology, and aim at key recovery rather than Trojan or IP-theft detection (Chameleon, EstraNet). MACPruning is the mirror image of this work: it creates temporal desynchronization by skipping redundant operations to protect IP, achieving resistance to over 1,000,000 electromagnetic traces at under 1% overhead, but only on single-core microcontrollers and with no graph model or detector (MACPruning). Nobody has combined the circuit graph with cycle-accurate dynamics, desynchronization invariance, and redundancy compression; the dossier confirms no such work exists in this literature.
Research Program
Three components get built. The first is a data pipeline: take gate-level netlists from TrustHub and GATE-Net's 18 third-party IP cores, run cycle-accurate logic simulation (and FPGA emulation for the timing-sensitive cases) under randomized and structured test vectors, and emit per-gate switching-activity time series aligned to the netlist graph. For the desynchronized setting, the Chameleon dataset supplies 600+ GB of real power traces from a RISC-V system-on-chip under four hardware obfuscations — dynamic frequency scaling, random delay, morphing, chaffing — with cycle-exact ground-truth boundaries from an on-chip pinpointing unit (Chameleon); we map these traces onto the SoC's module-level graph to obtain desynchronized spatially resolved observations, which the original dataset never provided. We additionally synthesize timing-degradation variants of the IP cores by substituting functionally equivalent slower cells, following the degradation-Trojan construction of Mankali et al.; no reported result found on Lacuna for any detector evaluated on that attack class, which is precisely the opening.
The second component is the model, provisionally called GateFlow. It interleaves spatial graph aggregation with a temporal encoder, in the decoupled style of GMAN and T-GCN rather than a monolithic recurrence, because decoupling lets each axis be scaled and ablated independently (GMAN, T-GCN). The key design choice is the time axis. EstraNet's Gaussian positional attention scores event pairs by their offset in the raw sample index and is therefore shift-invariant only to rigid displacement (EstraNet); desynchronization from frequency scaling is a non-linear warp, which is why it defeated CNN pipelines so thoroughly on Chameleon. GateFlow instead infers a logical cycle index $\ell$ for each event — using the redundancy structure of the trace itself, since repeated loop iterations and idle stretches form detectable, self-similar blocks — and computes temporal attention in that space:
$$\alpha_{ij} \propto \exp\!\Big( \frac{q_i^{\top} k_j}{\sqrt{d}} - \lambda\,|\ell_i - \ell_j| \Big)$$
where $q_i, k_j$ are learned query and key vectors of dimension $d$ for events $i$ and $j$, and $\lambda$ controls how quickly influence decays across cycle distance. The spatial half aggregates over netlist neighborhoods, so a node's anomaly score is informed by what its structural neighbors did in adjacent cycles — the property a 1D trace model cannot have. Adaptive memory mechanisms from dynamic-graph work (Adaptive Memory Retention in Dynamic Graphs) handle the non-stationary topology of activity graphs, where active edge sets change as execution moves through the design.
The third component is compression. Switching traces are dominated by idle repetition, exactly the property video models exploit: DyCoke merges 50–60% of redundant tokens across adjacent frames and recycles wrongly-discarded ones from a cache, and STTS shows temporal redundancy exceeds spatial redundancy so aggressive frame-level pruning is safe when selection preserves structure (DyCoke, STTS). GateFlow adapts DyCoke's merge-then-recycle scheme to per-gate activity: consecutive quiescent windows merge into single summary tokens, and any token whose attention weight later rises — the signature of a rare trigger activation — is restored from the recycle cache. This matters because our evidence is the rare event; one-shot pruning would discard it, the way random pixel pruning in MACPruning cost over 15% accuracy while importance-aware selection cost 1.72% (MACPruning). A CoViAR-style decomposition into baseline state snapshots plus switching residuals (CoViAR) is the fallback formulation if merging proves unstable.
Proposed Experiments
Experiment 1 runs node-level Trojan localization on the 17 TrustHub designs used by TrojanSAINT, with cycle-accurate activity generated by our pipeline. Metrics are true positive rate and true negative rate per gate, directly comparable to TrojanSAINT's reported 78% TPR / 85% TNR average and 98% / 96% best case (TrojanSAINT); the decisive comparison is on the sequential-trigger subset, where we target a substantial TPR gain at matched TNR. Experiment 2 uses GATE-Net's 18 IP cores with synthetic combinatorial and sequential triggers, reporting precision and recall against its reported precision of 1.0 and recall of 0.92+, with the sequential-trigger F1 as the headline number (GATE-Net). Experiment 3 evaluates the synthesized degradation Trojans, where static baselines should sit at chance and any non-trivial detection AUC is a new result. Experiment 4 is the desynchronization sweep: we apply the four Chameleon obfuscation modes to the activity traces at increasing magnitude and plot detector performance against desync strength, using the Chameleon traces with cycle-exact ground truth for calibration; the reference points are that unprotected key recovery there needed only 14 traces, chaffing pushed it to 104, and dynamic frequency scaling crushed CNN success to 0.7% (Chameleon). Experiment 5 measures the compression trade-off: detection quality versus compression ratio and wall-clock training cost, with the hypothesis that idle stretches compress far beyond DyCoke's 50–60% video figure while trigger-activation tokens are preserved by the recycle cache.
Baselines
The naive reference point is the all-benign predictor: because Trojan gates can be as scarce as 1 in 719 on TrustHub (TrojanSAINT), a detector that flags nothing scores over 99.8% gate-level accuracy while being useless. Any credible result must therefore be reported as TPR at a fixed TNR and as design-level detection, never raw accuracy, and must beat random gate-flagging at the true Trojan prevalence.
The strongest existing competitors are the two golden-free netlist detectors. GATE-Net is the primary rival because it targets the same setting (untrusted third-party cores, no golden reference) and the same benchmarks; it extracts each node's backward fan-in cone, embeds it with a three-layer GCN, and separates trigger subgraphs with supervised contrastive learning, reporting precision 1.0 and recall above 0.92 with F1 improvements of 46.99% (combinatorial) and 21.91% (sequential) over manual features (GATE-Net). TrojanSAINT is the second rival, using sampled-subgraph GraphSAINT training with threshold tuning for imbalance, reporting 78% TPR / 85% TNR averaged and 98% / 96% best case on TrustHub (TrojanSAINT). Both will be retrained on our benchmarks with a matched parameter count, the same train/validation splits, and the same tuning budget (threshold and hyperparameter search counted in trials), so any gain is attributable to the dynamic signal rather than compute. Beating them means higher sequential-trigger F1 at matched combinatorial performance, plus non-trivial detection on the degradation subset where both should be at chance — if GateFlow only matches them on combinatorial and sequential triggers, the proposal has failed its main claim.
The strongest trace-only competitor is a two-stage 1D pipeline in the Chameleon style — a sliding-window CNN segmenter followed by an anomaly classifier — plus an EstraNet-style shift-invariant temporal encoder with Gaussian positional attention, both fed the same activity and power traces but with the graph removed (traces either aggregated or treated per-node independently). Chameleon's segmenter reached 84–91% intersection over union across obfuscation modes (Chameleon), and EstraNet needed fewer than 100 traces to break jittered implementations where benchmark models failed at 5,000, with up to 90% fewer traces to key recovery and 3–13× faster training (EstraNet); we adapt both from key recovery to Trojan scoring and give them identical data and tuning. Beating them means holding detection performance as desync magnitude increases, where their curves should fall off faster.
The key-ingredient ablation removes spatial message passing while keeping everything else: the same temporal encoder, compression, and logical-time inference run on each gate independently, with scores combined by a small MLP. The difference between this and full GateFlow isolates the claim that topology-plus-time jointly, not time alone, carries the signal. A second ablation swaps learned merge-and-recycle compression for uniform cycle downsampling at the same retained-data budget, and a third replaces the inferred logical-time attention with fixed-grid temporal convolution (a T-GCN-style cell), isolating the desynchronization-invariance claim.
Why not just…?
Why not just make the static GNNs bigger or feed them better features? This is the most serious alternative, and GATE-Net's own numbers bound it: its sequential-trigger improvement is already less than half its combinatorial one (21.91% versus 46.99%), which is the signature of missing signal rather than missing capacity, and degradation Trojans leave the netlist functionally intact by construction (Mankali et al.), so no structural feature can separate them from benign logic that computes the same function. The proposal settles this empirically rather than rhetorically: the matched-budget static baseline is run on every benchmark, and if it matches GateFlow on sequential triggers and degradation Trojans, the dynamic component is cut. The honest risk is that many TrustHub Trojans are statically detectable, so aggregate gains may be modest; that is why the evaluation is stratified by attack class rather than reported as a single average.
Why not just align the desynchronized traces first, then use standard models? Alignment preprocessing is exactly what the desynchronization literature shows failing: on EstraNet's benchmarks, standard models needed elastic alignment and still failed at 5,000 traces under clock jitter, and Chameleon's dynamic frequency scaling produced non-linear warps that drove CNN success to 0.7% (EstraNet, Chameleon). Correlation estimators collapse under even small jitter because a leak that lands at 145 ns in one trace and 155 ns in another decorrelates (Swaminathan et al.). The desynchronization sweep includes a DTW-plus-CNN arm so the comparison is direct; if dynamic time warping recovers performance at high desync magnitudes, the logical-time machinery was unnecessary and we will say so.
Why not just uniformly downsample the switching traces instead of building learned compression? Uniform downsampling is precisely tuned to destroy our evidence: Trojan triggers activate on rare states (Huili Chen et al.), so the informative cycles are as scarce in time as Trojan gates are in space. The analogous failure is documented twice in the dossier — random pixel pruning in MACPruning cost over 15% accuracy versus 1.72% for importance-aware selection, and one-shot token pruning in DyCoke permanently lost tokens that later became critical, which is why its recycle cache exists (MACPruning, DyCoke). Still, the downsampling ablation at matched retained-data budget is the fair test; if it matches merge-and-recycle at the same detection quality, the compression component reduces to a simple engineering choice and the paper should report it that way.
Decisive Checks
Three results decide the proposal. First, on sequential triggers and degradation Trojans specifically, GateFlow must beat the matched-budget static GNN baselines by a margin large enough to justify the simulation and data-pipeline cost; a gain only on combinatorial triggers, which static methods already handle, is a null result. Second, the desynchronization sweep must show a flatter performance-versus-desync curve for the logical-time model than for the alignment-preprocessed and fixed-grid baselines, calibrated against Chameleon's ground truth. Third, compression must preserve detection quality at ratios that make million-cycle traces processable — if uniform downsampling matches it, the learned component is dropped and the contribution narrows honestly to the desynchronization-invariant spatio-temporal detector itself.
References
- TrojanSAINT: Gate-Level Netlist Sampling-Based Inductive Learning for Hardware Trojan Detection
- Contrastive Graph Convolutional Networks for Hardware Trojan Detection in Third Party IP Cores
- Chameleon: A Dataset for Segmenting and Attacking Obfuscated Power Traces in Side-Channel Analysis
- EstraNet: An Efficient Shift-Invariant Transformer Network for Side-Channel Analysis
- MACPruning: Dynamic Operation Pruning to Mitigate Side-Channel DNN Model Extraction
- RTL-Breaker: Assessing the Security of LLMs Against Backdoor Attacks on HDL Code Generation
- GMAN: A Graph Multi-Attention Network for Traffic Prediction
- T-GCN: A Temporal Graph Convolutional Network for Traffic Prediction
- Adaptive Memory Retention in Dynamic Graphs
- DyCoke: Dynamic Compression of Tokens for Fast Video Large Language Models
- Efficient Video Transformers with Spatial-Temporal Token Selection
- Compressed Video Action Recognition
- Deep Learning-Based Side-Channel Analysis Against AES Inner Rounds
- AdaTest: Reinforcement Learning and Adaptive Sampling for On-chip Hardware Trojan Detection