💻 computer science

A Constant-Time Implementation Methodology for Activation Functions on Microcontrollers

Ce papier propose et valide une méthodologie d'implémentation en temps constant pour les fonctions d'activation sur les microcontrôleurs ARM Cortex-M4 qui élimine les vulnérabilités de canal auxiliaire temporel par une sélection sans branchements, des approximations de Padé à coût fixe et un alignement cyclique, tout en maintenant une haute précision numérique sur plusieurs types de fonctions.

Auteurs originaux : Andrii Tyvodar, Andreas Rechberger, Dirmanto Jap, Shivam Bhasin, Bernhard Jungk, Jakub Breier, Xiaolu Hou

Publié 2026-05-22

📖 5 min de lecture🧠 Analyse approfondie

CC BY 4.0

Auteurs originaux : Andrii Tyvodar, Andreas Rechberger, Dirmanto Jap, Shivam Bhasin, Bernhard Jungk, Jakub Breier, Xiaolu Hou

Article original sous licence CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Ceci est une explication générée par l'IA de l'article ci-dessous. Elle n'a pas été rédigée ni approuvée par les auteurs. Pour une précision technique, consultez l'article original. Lire la clause de non-responsabilité complète

Imaginez que vous possédiez un appareil intelligent, comme un tracker d'activité physique ou un capteur médical, qui utilise un « cerveau » (un réseau de neurones) pour prendre des décisions. Ce cerveau dispose de commutateurs spéciaux appelés fonctions d'activation qui déterminent comment traiter l'information.

Le problème est que ces commutateurs fuient des secrets. Tout comme une personne pourrait taper du pied plus vite lorsqu'elle est excitée ou plus lentement lorsqu'elle s'ennuie, ces commutateurs logiciels prennent des durées légèrement différentes pour fonctionner selon les données qu'ils traitent. Un hacker malin se tenant à proximité pourrait écouter ces « battements de temps » et découvrir ce que l'appareil pense, voire reconstruire à l'envers le cerveau de l'appareil.

L'Ancienne Méthode : Cacher le Bruit

Auparavant, les chercheurs tentaient de résoudre ce problème en ajoutant du bruit aléatoire. Imaginez essayer de cacher un code secret en le criant, mais en ajoutant ensuite un bruit statique aléatoire à votre voix afin que personne ne puisse entendre le motif. L'article qualifie cela de « désynchronisation ».

Les auteurs l'ont testé et ont constaté que cela ne fonctionnait pas bien. Même avec le bruit statique, si un hacker écoutait assez longtemps et utilisait une astuce statistique ingénieuse (comme une correspondance de modèle), il pouvait toujours découvrir le motif. C'est comme essayer de cacher une empreinte digitale en la recouvrant de boue ; un détective compétent peut toujours essuyer la boue et retrouver l'empreinte.

La Nouvelle Solution : L'Usine « Temps Constant »

Les auteurs proposent une approche complètement différente : une Implémentation à Temps Constant.

Au lieu d'essayer de cacher le temps nécessaire pour accomplir une tâche, ils ont redessiné la tâche de sorte qu'elle prenne toujours exactement la même durée, quelle que soit l'entrée.

Pensez-y comme à une chaîne de montage d'usine :

L'Ancienne Méthode : Si un ouvrier reçoit une petite boîte, il termine en 2 secondes. S'il reçoit une grande boîte, il prend 5 secondes. Un observateur peut deviner la taille de la boîte simplement en regardant l'horloge.
La Nouvelle Méthode : L'usine est redessinée de sorte que chaque ouvrier, quelle que soit la taille de la boîte, prenne exactement 5 secondes.
- Si la boîte est petite, l'ouvrier fait le travail en 2 secondes, puis reste assis sans rien faire en attendant 3 secondes (effectuant un travail « factice ») pour remplir le temps.
- Si la boîte est grande, il travaille pendant les 5 secondes complètes.
- Résultat : Pour un observateur extérieur, chaque tâche prend exactement 5 secondes. Le secret temporel a disparu.

Comment Ils Ont Fait (La Boîte à Outils)

Pour construire cette usine « parfaitement synchronisée » sur de minuscules puces informatiques (microcontrôleurs), les auteurs ont utilisé quatre outils principaux :

Pas de Branches « Si/Alors » : Les ordinateurs ralentissent ou accélèrent souvent en fonction des décisions (comme « Si le nombre est négatif, faire X ; sinon, faire Y »). Les auteurs ont supprimé ces décisions. Au lieu de cela, ils calculent les deux possibilités et utilisent un « masque » mathématique pour choisir la bonne instantanément, sans s'arrêter pour décider.
Le Raccourci « Padé » : Calculer des courbes complexes (comme Sigmoid ou Tanh) est lent et varie dans le temps. Les auteurs ont remplacé ces calculs lourds par un raccourci mathématique astucieux à étapes fixes (une approximation rationnelle) qui prend toujours le même nombre d'étapes.
Arithmétique Factice : Pour le commutateur le plus simple (ReLU), qui prend généralement presque aucun temps, ils ont ajouté des étapes mathématiques « factices ». C'est comme l'ouvrier qui reste assis sans rien faire ; cela garantit que le commutateur simple prend le même temps long que les commutateurs complexes.
Alignement des Cycles : Ils ont soigneusement compté chaque « tic » de l'horloge de l'ordinateur pour s'assurer que chaque fonction se termine exactement au même moment.

Les Résultats

L'équipe a testé cela sur cinq fonctions d'activation courantes (ReLU, Sigmoid, Tanh, GELU et Swish) sur une puce ARM Cortex-M4 (courante dans les appareils embarqués).

Temps : Dans l'ancienne version non protégée, le temps variait considérablement. Dans la nouvelle version, chaque entrée unique prenait exactement 108 cycles d'horloge (environ 1,3 microseconde). Le temps était parfaitement plat.
Précision : Ils craignaient que l'ajout d'étapes factices et de raccourcis ne rende les mathématiques incorrectes. Cependant, ils ont constaté que les erreurs étaient minuscules — si petites que, pour des besoins pratiques, le cerveau de l'appareil pense toujours correctement.
Vitesse : De manière surprenante, pour les fonctions complexes, la nouvelle méthode était en réalité plus rapide que les anciennes méthodes standard car les raccourcis étaient plus efficaces, même s'ils ajoutaient des étapes factices pour correspondre au temps.

La Conclusion

L'article prouve que l'on peut construire une fonction d'activation « à l'épreuve du temps » pour les petits appareils. En forçant chaque calcul à prendre exactement la même durée, vous empêchez les hackers d'écouter le « battement de cœur » de l'appareil pour voler des secrets. C'est une manière pratique et efficace de rendre l'IA embarquée plus sûre sans briser les performances de l'appareil.

Résumé technique : Méthodologie d'implémentation en temps constant pour les fonctions d'activation sur microcontrôleurs

Énoncé du problème
L'inférence de réseaux de neurones embarquée sur des microcontrôleurs aux ressources limitées est de plus en plus vulnérable aux attaques par canal auxiliaire temporel. Des études récentes ont démontré que les fonctions d'activation au sein de ces réseaux fuient des informations par le biais de variations d'exécution dépendantes des valeurs d'entrée et des types de fonctions. Cette fuite permet aux attaquants de distinguer différentes fonctions d'activation (par exemple, ReLU par rapport à sigmoid) et potentiellement de rétro-ingénierier les architectures de modèles ou d'inférer des données d'entrée sensibles. Bien que les contre-mesures existantes, telles que la désynchronisation (introduction de délais aléatoires), tentent d'obscurcir ces motifs temporels, elles n'éliminent pas le comportement sous-jacent dépendant de l'entrée. Par conséquent, les attaques par modèle basées sur le profilage peuvent toujours distinguer statistiquement les fonctions d'activation malgré le bruit ajouté.

Méthodologie
Les auteurs proposent une méthodologie d'implémentation en temps constant conçue pour éliminer les variations temporelles dépendantes de l'entrée à la source, plutôt que de simplement les masquer. L'approche est mise en œuvre sur une plateforme ARM Cortex-M4 (STM32F411) et cible cinq fonctions d'activation largement utilisées : ReLU, sigmoid, tanh, Unité Linéaire à Erreur Gaussienne (GELU) et Swish.

La méthodologie repose sur quatre composants principaux :

Sélection sans branchement basée sur le masquage : Pour prévenir la divergence du flux de contrôle, l'implémentation évite les branches dépendantes des données. Au lieu de cela, elle utilise un masquage logique et des opérations bit à bit (ET/OU) pour sélectionner entre des valeurs candidates (par exemple, des sorties saturées par rapport à des résultats d'approximation) en fonction de la représentation binaire de l'entrée. Cela garantit que la séquence d'instructions reste identique quelle que soit la valeur d'entrée.
Approximation basée sur Padé à coût fixe : Pour les fonctions non linéaires (sigmoid, tanh, GELU, Swish), les auteurs remplacent les évaluations standard de fonctions transcendantes par une approximation rationnelle partagée et à coût fixe basée sur l'approximant de Padé pour $\tanh(x)$ $tanh (x)$ , noté $R_{tanh}(x)$ $R_{t anh} (x)$ . Cette approximation implique une séquence fixe d'additions, de multiplications et d'une seule division, évitant les boucles ou la sélection d'intervalles dépendante de l'entrée.
- Sigmoid et Swish sont construits en utilisant l'identité $S(x) = \frac{1}{2}(1 + \tanh(x/2))$ .
- GELU est approximé en utilisant une formulation basée sur $\tanh$ .
Saturation basée sur le masquage : Pour gérer les entrées en dehors de la région d'approximation, la méthodologie emploie une logique de saturation (brutage à 0, 1 ou $x$ ) mise en œuvre via la même stratégie de masquage sans branchement. Cela garantit que même lorsque l'approximation rationnelle est contournée pour les entrées saturées, le chemin d'exécution et le nombre de cycles restent constants.
Alignement des cycles et arithmétique factice : Pour obtenir des temps d'exécution identiques pour les cinq fonctions, les auteurs introduisent des opérations arithmétiques factices. Plus précisément, la fonction simple ReLU, qui s'exécute naturellement beaucoup plus vite que les approximations non linéaires, est augmentée de la même séquence arithmétique basée sur $R_{tanh}$ (sans affecter le résultat final) pour aligner son nombre de cycles avec celui des fonctions plus complexes. Un remplissage minimal par NOP est utilisé uniquement pour un alignement fin.

Contributions clés

Méthodologie en temps constant : L'article introduit un principe de construction réutilisable pour les fonctions d'activation garantissant un temps d'exécution indépendant de l'entrée sur les microcontrôleurs embarqués.
Mise en œuvre sur cinq fonctions : La méthodologie est appliquée avec succès à ReLU, sigmoid, tanh, GELU et Swish, en utilisant une approximation rationnelle partagée pour les composants non linéaires.
Vulnérabilité de la désynchronisation : Les auteurs démontrent que les contre-mesures basées sur la désynchronisation, bien qu'elles obscurcissent visuellement les traces temporelles, restent vulnérables aux attaques par modèle basées sur le profilage temporel. L'analyse statistique des temps d'exécution permet à un attaquant de distinguer les fonctions d'activation avec une grande confiance après un nombre suffisant de mesures.
Validation expérimentale : Le travail fournit des preuves empiriques que les implémentations protégées proposées atteignent des nombres de cycles identiques pour toutes les entrées testées, supprimant efficacement les fuites temporelles.

Résultats expérimentaux
La méthodologie a été évaluée sur un ARM Cortex-M4 fonctionnant à 84 MHz.

Régularité temporelle :
- Dans un cadre à trois fonctions (ReLU, sigmoid, tanh) sur l'intervalle $[-8, 8]$ , toutes les implémentations protégées se sont exécutées en exactement 88 cycles d'horloge (1,048 µs), quelle que soit la valeur d'entrée.
- Dans un cadre étendu à cinq fonctions (incluant GELU et Swish) sur l'intervalle $[-500, 500]$ , toutes les implémentations se sont exécutées en exactement 108 cycles d'horloge (1,286 µs).
- En revanche, les implémentations non protégées ont montré des variations temporelles significatives (par exemple, ReLU non protégé a pris ~12 cycles, tandis que tanh non protégé a pris ~403 cycles) et des fluctuations dépendantes de l'entrée.
Précision numérique :
- Les approximations ont conservé une haute précision. Pour l'intervalle $[-8, 8]$ , l'erreur quadratique moyenne (MSE) pour sigmoid était de $2,93 \times 10^{-12}$ et pour tanh de $6,14 \times 10^{-10}$ .
- Sur l'intervalle étendu $[-500, 500]$ , les erreurs sont restées négligeables pour sigmoid et tanh (car ils saturent rapidement), tandis que GELU et Swish ont montré une faible erreur localisée près des seuils de saturation (Erreur absolue maximale pour Swish de $1,11 \times 10^{-3}$ ).
Compromis de performance :
- L'implémentation protégée de ReLU a entraîné une augmentation de la latence (de ~12 à 88/108 cycles) due à l'insertion d'arithmétique factice pour l'alignement.
- À l'inverse, les fonctions non linéaires protégées étaient significativement plus rapides que leurs équivalents non protégés (par exemple, sigmoid/tanh protégés étaient ~33-38 % plus rapides que les versions non protégées) car l'approximation rationnelle est plus efficace que les fonctions transcendantes des bibliothèques standard sur le matériel cible.

Signification et affirmations
L'article affirme que la méthodologie proposée fournit une base pratique pour construire des fonctions d'activation résistantes aux canaux auxiliaires dans l'inférence embarquée. En passant du "masquage" (randomisation) à la conception "en temps constant", l'approche élimine la cause racine des fuites temporelles : les chemins d'exécution dépendants de l'entrée. Les auteurs affirment que cette méthodologie permet de construire des fonctions d'activation où la séquence d'instructions exécutée est indépendante de la valeur d'entrée, empêchant ainsi les attaques par modèle basées sur le temps.

Le travail se positionne comme un bloc de construction pour l'apprentissage automatique embarqué sécurisé, en particulier pour les appareils périphériques sensibles à la vie privée (par exemple, capteurs médicaux, wearables) où les informations temporelles peuvent être accessibles aux attaquants. Les auteurs notent modestement que bien que cela traite des fuites temporelles dans les fonctions d'activation, cela ne constitue pas une contre-mesure complète pour l'ensemble du pipeline d'inférence, et d'autres canaux auxiliaires (puissance, EM) ou détails d'implémentation peuvent encore nécessiter une protection. L'étude se concentre spécifiquement sur le domaine temporel et ne prétend pas traiter tous les vecteurs potentiels de canaux auxiliaires.