# TrojanForge : exemples de chevaux de Troie matériels adversariaux avec apprentissage par renforcement

*Auteur : [Votre nom]*  
*Date : [Date actuelle]*  

La sécurité matérielle demeure un défi critique dans les chaînes d’approvisionnement complexes d’aujourd’hui. Avec l’externalisation croissante des conceptions de semi-conducteurs vers des fabricants tiers, le risque d’insertion de chevaux de Troie matériels (HT) dans les circuits intégrés (CI) a explosé. Dans cet article, nous examinons en détail TrojanForge — un cadre qui exploite l’apprentissage par renforcement (RL) pour générer des exemples de HT adversariaux capables de tromper les mécanismes de détection. Nous explorons ses objectifs, les techniques sous-jacentes et les résultats expérimentaux qui mettent en lumière ses atouts et ses limites. Du guide débutant sur les HT à la discussion avancée sur l’entraînement adversarial et l’élagage de nets rares, cet article vous accompagne pas à pas dans les innovations techniques de TrojanForge.

---

## Table des matières
1. [Introduction](#introduction)  
2. [Contexte et travaux connexes](#contexte-et-travaux-connexes)  
   2.1 [Outils d’insertion de HT](#outils-dinsertion-de-ht)  
   2.2 [Outils de détection de HT](#outils-de-detection-de-ht)  
3. [Cadre TrojanForge](#cadre-trojanforge)  
   3.1 [Élagage des nets rares](#elagage-des-nets-rares)  
   &emsp;3.1.1 [Élagage fonctionnel](#elagage-fonctionnel)  
   &emsp;3.1.2 [Élagage structurel](#elagage-structurel)  
   3.2 [Entraînement adversarial](#entrainement-adversarial)  
   3.3 [Cas particulier : déclencheurs incompatibles](#cas-particulier-declencheurs-incompatibles)  
4. [Résultats expérimentaux](#resultats-experimentaux)  
   4.1 [Indice de similarité de Jaccard (JSI) et compatibilité des déclencheurs](#jsi-et-compatibilite-des-declencheurs)  
   4.2 [Insertion de HT avec TrojanForge](#insertion-de-ht-avec-trojanforge)  
5. [Conclusion](#conclusion)  
6. [Exemples pratiques et extraits de code](#exemples-pratiques-et-extraits-de-code)  
7. [Références](#references)  

---

## Introduction
<a name="introduction"></a>

Les chevaux de Troie matériels (HT) représentent une menace persistante dans l’industrie des semi-conducteurs. Historiquement, la détection et l’atténuation des HT constituent une course aux armements entre défenseurs et attaquants, chacun cherchant à surpasser l’autre par de nouvelles techniques. TrojanForge introduit une approche inédite d’insertion de HT en s’appuyant sur le RL dans une boucle de type GAN (Generative Adversarial Network). L’agent RL apprend à insérer des HT dans des netlists de manière à échapper aux détecteurs de pointe.

L’essence de TrojanForge réside dans sa capacité à automatiser et à optimiser l’insertion. Le cadre sélectionne des nets déclencheurs potentiels, les élague fonctionnellement et structurellement, puis affine ses insertions en apprenant de ses interactions avec les modèles de détection. Cette adaptation met en évidence les vulnérabilités des méthodes de détection actuelles et améliore notre compréhension de la furtivité des HT.

---

## Contexte et travaux connexes
<a name="contexte-et-travaux-connexes"></a>

### Outils d’insertion de HT
<a name="outils-dinsertion-de-ht"></a>

Les jeux de référence comme [TrustHub](https://www.trust-hub.org/) ont fourni les premières données pour l’étude des HT, mais souffrent de :

- **Échelle et diversité limitées**  
- **Biais humain** lors de l’insertion manuelle  
- **Écarts pré/post-synthèse** rendant certains HT irréalistes  

Pour y remédier, plusieurs outils automatisés ont vu le jour :

- **Cruz et al. (2018)** : génération automatisée de HT paramétrable  
- **Sarihi et al. (2022)** : agent RL naviguant dans le circuit avec récompense liée à l’activation du HT  
- **Gohil et al. (2022a)** : ATTRITION, outil RL récompensant la taille d’ensembles de déclencheurs « compatibles »  

Ces avancées ont inspiré l’emploi du RL pour créer des HT adversariaux : TrojanForge.

### Outils de détection de HT
<a name="outils-de-detection-de-ht"></a>

La recherche en détection a progressé parallèlement :

- **Méthodes basées sur les caractéristiques**  
- **Réseaux de neurones graphiques (GNN)**  
- **Robustesse adversariale** (ex. Nozawa et al., 2021)  

TrojanForge se distingue par une boucle d’entraînement adversarial : l’agent insertion (analogue au générateur) apprend à contourner le détecteur (discriminateur).

---

## Cadre TrojanForge
<a name="cadre-trojanforge"></a>

TrojanForge génère des HT adversariaux difficiles à identifier. Il combine élagage de nets rares, entraînement adversarial et système de récompenses basé sur la compatibilité des déclencheurs.

### Élagage des nets rares
<a name="elagage-des-nets-rares"></a>

Les nets rares sont d’excellents candidats pour les déclencheurs, mais tous ne conviennent pas. Deux approches :

#### Élagage fonctionnel
<a name="elagage-fonctionnel"></a>

Objectif : préserver le comportement du circuit.  
Techniques :

- **Analyse de sensibilité**  
- **Tests d’activation**  

```python
import numpy as np

def simulate_signal_activity(netlist, test_vectors):
    """
    Simule l’activité des signaux d’un netlist à l’aide de vecteurs de test.
    Retourne un dictionnaire {net: nombre_d’activations}.
    """
    activation_counts = {net: 0 for net in netlist['nets']}
    for vector in test_vectors:
        simulation_results = run_simulation(netlist, vector)
        for net, value in simulation_results.items():
            if value == 1:  # net actif (haut)
                activation_counts[net] += 1
    return activation_counts

def filter_rare_nets(activation_counts, threshold=5):
    """Filtre les nets dont le nombre d’activations est inférieur au seuil."""
    return [net for net, count in activation_counts.items() if count < threshold]

# Fonctions factices pour l’exemple
def run_simulation(netlist, vector):
    # Ici on appellerait un simulateur réel
    return {net: np.random.choice([0, 1]) for net in netlist['nets']}

netlist = {'nets': ['net1', 'net2', 'net3', 'net4']}
test_vectors = [np.random.randint(0, 2, size=4) for _ in range(100)]
activation_counts = simulate_signal_activity(netlist, test_vectors)
rare_nets = filter_rare_nets(activation_counts, threshold=10)
print("Nets rares candidats :", rare_nets)

Élagage structurel

Objectif : vérifier que les nets retenus s’intègrent topologiquement sans anomalies visibles.

Analyse de graphe (connectivité, centralité)
Vérification de redondance

Entraînement adversarial

Après élagage, l’agent RL insère les HT et reçoit des récompenses lorsque ceux-ci échappent à la détection.

Signaux de récompense : succès, furtivité, compatibilité
Optimisation de la politique
Mise à jour éventuelle du détecteur

Cas particulier : déclencheurs incompatibles

Certains nets rares ne peuvent pas être activés simultanément.

Analyse de compatibilité (Indice de Jaccard…)
Stratégies de repli vers d’autres nets compatibles

Résultats expérimentaux

Indice de similarité de Jaccard (JSI) et compatibilité des déclencheurs

def jaccard_similarity(set1, set2):
    intersection = len(set1.intersection(set2))
    union = len(set1.union(set2))
    return intersection / union if union else 0

activ1 = {1, 2, 3, 7, 8}
activ2 = {2, 3, 4, 8, 9}
print("Indice Jaccard :", jaccard_similarity(activ1, activ2))

TrojanForge sélectionne ainsi des nets à forte compatibilité, améliorant le taux d’activation des HT.

Insertion de HT avec TrojanForge

Principales observations :

Taux de réussite élevé face aux détecteurs testés
Importance du choix du payload
Apprentissage adaptatif lorsque le détecteur évolue

Conclusion

TrojanForge constitue une avancée majeure :

Insertion automatisée de HT réduisant le biais humain
Élagage fonctionnel & structurel garantissant la qualité des nets candidats
Boucle d’entraînement adversarial inspirée des GAN
Analyse fine de la compatibilité des déclencheurs et de l’impact du payload

Ces travaux soulignent la nécessité de systèmes de détection robustes et adaptatifs pour contrer des méthodes adversariales toujours plus sophistiquées.

Exemples pratiques et extraits de code

Analyse d’un netlist avec Bash

#!/bin/bash
# Recherche de nets rares dans un netlist

NETLIST_FILE="mon_circuit.v"

grep -oP 'wire\s+\K\w+' "$NETLIST_FILE" | sort | uniq -c | sort -nk1 > net_counts.txt

THRESHOLD=5
echo "Nets rares (occurrences < $THRESHOLD) :"
awk -v thresh="$THRESHOLD" '$1 < thresh {print $2 " apparaît " $1 " fois"}' net_counts.txt

Traitement des résultats en Python

import matplotlib.pyplot as plt

def load_net_counts(filename):
    nets = {}
    with open(filename) as f:
        for line in f:
            parts = line.split()
            if len(parts) == 3:
                count, net, _ = parts
                nets[net] = int(count)
    return nets

def plot_net_distribution(nets):
    plt.figure(figsize=(10, 6))
    plt.bar(nets.keys(), nets.values(), color='skyblue')
    plt.xlabel('Noms des nets')
    plt.ylabel('Occurrences')
    plt.title('Distribution des occurrences des nets')
    plt.xticks(rotation=90)
    plt.tight_layout()
    plt.show()

if __name__ == "__main__":
    counts = load_net_counts("net_counts.txt")
    print("Comptage des nets chargé :", counts)
    plot_net_distribution(counts)

Environnement RL simplifié pour l’insertion de HT

import gym
from gym import spaces
import numpy as np

class NetlistTrojanEnv(gym.Env):
    """
    Environnement simplifié simulant la modification d’un netlist pour l’insertion de HT.
    """
    def __init__(self, num_nets=10):
        super().__init__()
        self.num_nets = num_nets
        self.observation_space = spaces.Box(low=0, high=1, shape=(num_nets,), dtype=np.float32)
        self.action_space = spaces.Discrete(num_nets)
        self.state = np.random.rand(num_nets)

    def step(self, action):
        self.state[action] = 1.0  # activation du déclencheur
        reward = 10 if self.state[action] < 0.5 else -5
        done = np.sum(self.state) > self.num_nets * 0.9
        return self.state, reward, done, {}

    def reset(self):
        self.state = np.random.rand(self.num_nets)
        return self.state

    def render(self, mode='human'):
        print("Activation actuelle des nets :", self.state)

if __name__ == "__main__":
    env = NetlistTrojanEnv()
    state = env.reset()
    for _ in range(20):
        action = env.action_space.sample()
        state, reward, done, _ = env.step(action)
        print(f"Action : modifier net {action}, Récompense : {reward}")
        env.render()
        if done:
            print("Épisode terminé !")
            break

Références

TrustHub – Dépôt de benchmarks pour HT
https://www.trust-hub.org/
Bhunia, S., & Tehranipoor, M. (2018). Hardware Security: A Survey of Emerging Threats and Security Techniques.
Xing et al. (2023). The Evolution of the Fabless Semiconductor Business Model.
Krieg, [année]. Analysis of HT Benchmarks from TrustHub.
Cruz et al. (2018). Automated Hardware Trojan Generation Tool.
Sarihi et al. (2022). Reinforcement Learning in HT Insertion.
Nozawa et al. (2021). Adversarial Examples for HT Detection Evasion.
Pandit et al. (2011). Jaccard Similarity Index in Hardware Security Applications.
Gohil et al. (2022a). ATTRITION: RL-Based HT Insertion Tool.
Gohil et al. (2024). AttackGNN: Adversarial Attacks on GNN-based HT Detectors.

Bon codage et conception matérielle sécurisée !

Untitled Post