Modern semiconductor manufacturing relies on a highly globalized, fragmented supply chain. Because building and maintaining a state-of-the-art fabrication facility costs billions of dollars, most design houses operate under a "fabless" model, outsourcing chip production to offshore foundries. This creates a critical security dilemma: high-security entities must choose between using cutting-edge but untrusted offshore foundries, or relying on trusted but technologically obsolete onshore facilities (Riad S. Wahby et al.).
When manufacturing is outsourced to an untrusted entity, an adversary at the foundry can steal intellectual property (IP) via reverse engineering or insert a Hardware Trojan (HT)—a malicious modification to the physical silicon logic (Johann Knechtel et al.). Because software-level security guarantees are fundamentally broken if the underlying hardware layer is compromised (Chin‐Ling Chen et al.), researchers have developed a multi-layered defensive paradigm. These techniques range from structural netlist analysis and physical layout obfuscation to mathematical verification.
Why Hardware Trojans Evade Traditional Verification
To understand why hardware security requires specialized defenses, one must understand why traditional testing fails. Standard hardware verification tools and vendor Design Rule Checks (DRCs) are optimized to identify unintentional functional errors or physical layout violations, not adversarial intent (Tuan La et al.).
Hardware Trojans exploit this blind spot by remaining dormant during standard functional testing, activating only under extremely rare logic conditions (Huili Chen et al.). Furthermore, as shown by Syed Kamran Haider et al., Trojans can employ implicit functional masking, where the corrupted output happens to match the intended specification under normal conditions, causing massive false negatives in standard testing suites.
More sophisticated backdoors do not even alter digital logic outputs. Instead, they can be designed to cause stealthy performance degradation by substituting optimized architectures with slower, functionally equivalent versions (Lakshmi Likhitha Mankali et al.). These attacks satisfy all logical requirements and pass standard functional simulations, yet cause the final physical chip to fail timing requirements or experience localized power starvation under specific workloads.
Catching Malicious Logic via Netlist Analysis
To detect these hidden structures without relying on dynamic execution, defenders analyze the circuit's structural topology. This analysis is performed directly on the gate-level netlist generated by synthesis tools, bridging the gap between high-level algorithmic descriptions and physical logic gates (Hannes Groß et al.).
When high-level structural information is flattened into a netlist, finding a Trojan is akin to finding a needle in a massive graph of interconnected logic gates. To solve this, Hazem Lashen et al. developed TrojanSAINT, a framework that models gate-level netlists as graphs and applies Graph Neural Networks (GNNs) to sample and analyze them.
The intuition behind this approach is that malicious triggers possess distinct topological signatures. Because a Trojan trigger must remain dormant during normal operations, it is typically connected to nodes with exceptionally low controllability (signals that rarely change value). By training GNNs to recognize these localized structural anomalies, defenders can flag malicious insertions without executing the code.
Crucially, graph-based analysis can identify these malicious implants in commercial off-the-shelf components without requiring a trusted reference model for comparison—an essential capability when a verified "golden" design is unavailable in a globalized supply chain (see the overview by Guru Venkataramani in the special issue).
Blinding the Foundry via Split Manufacturing and Camouflaging
If a foundry cannot be trusted, an alternative strategy is to prevent them from seeing the full design. Split Manufacturing achieves this by dividing the physical fabrication process into two distinct stages:
- Front-End-of-Line (FEOL): The untrusted, high-performance offshore foundry fabricates the lowest layers of the chip, which contain the raw transistors and local gates.
- Back-End-of-Line (BEOL): A trusted, lower-performance onshore facility deposits the upper metal layers that define the global interconnects and routing logic.
By withholding the BEOL routing, the untrusted foundry is presented with a "sea of gates" without knowing how they connect to form a functional circuit. As Satwik Patnaik demonstrates, randomizing the netlist before layout creates a misleading physical design that thwarts proximity attacks, leaving the untrusted foundry with a $0\%$ success rate in reconstructing the true functional logic.
+-------------------------------------------------------+
| Trusted BEOL Facility (Routing) |
| [Global Interconnects / Final Functional Logic] |
+-------------------------------------------------------+
|| (Vias / Connections)
+-------------------------------------------------------+
| Untrusted FEOL Foundry (Transistors) |
| [Generic Sea of Gates / Obfuscated Components] |
+-------------------------------------------------------+
To protect the chip from reverse engineering after it leaves the trusted facility and enters the market, designers pair split manufacturing with Layout Camouflaging. Nikhil Rangarajan et al. proposed a paradigm shift known as Dynamic Camouflaging using polymorphic devices. Instead of using static CMOS gates—which can be visually decoded under an electron microscope—the circuit leverages emerging technologies like Magneto-Electric Spin-Orbit (MESO) devices to enable post-fabrication activation.
Under this model, the chip is manufactured in a generic, unconfigured state. Its true logic gates (e.g., whether a component acts as an AND gate or an OR gate) are only defined and unlocked via cryptographic keys in a trusted environment after delivery. Physical inspection of the manufacturing masks at the foundry reveals nothing about the circuit's actual runtime behavior.
Verifiable ASICs through Cryptographic Proofs
What if an organization must outsource the entire fabrication process—both FEOL and BEOL—to an untrusted foundry? Riad S. Wahby et al. introduced a solution called Verifiable ASICs, implemented in a system named Zebra.
Instead of attempting to physically inspect the hardware or hide its layout, this approach treats the untrusted ASIC as a prover in a cryptographic Verifiable Computation (VC) framework.
+------------------------+ +------------------------+
| Trusted Verifier | --- Input ---> | Untrusted ASIC |
| (Slow, Legacy Tech) | <--- Proof --- | (Fast, Cutting-Edge) |
+------------------------+ +------------------------+
| |
Validates mathematical Executes computation
proof of correctness and generates proof
The high-performance, untrusted ASIC executes a computation and simultaneously generates an interactive, probabilistic proof of correctness. A slower, trusted hardware component (the verifier, manufactured in a trusted legacy facility) checks this proof.
Because verifying the mathematical proof is exponentially faster than executing the underlying computation, the trusted component can validate the output of the untrusted ASIC in real time. If a Hardware Trojan alters even a single bit of the computation, the mathematical proof fails. This framework allows systems to leverage the raw speed of cutting-edge, untrusted offshore silicon while maintaining the absolute security guarantees of trusted onshore hardware.