Dans l'ère moderne de la création de logiciels, une révolution silencieuse est en cours. Les grands modèles de langage, ces puissants systèmes d'intelligence artificielle capables d'écrire du code informatique, sont devenus des outils standards pour les développeurs, promettant d'accélérer la construction d'applications numériques. Cependant, cette commodité apporte un défi de taille : lorsqu'une machine écrit un programme, il devient presque impossible de déterminer qui l'a réellement créé. Les lignes entre l'effort humain et la génération par machine se brouillent, laissant les entreprises de logiciels et les chercheurs vulnérables au vol, au plagiat et à la propagation de code non vérifié. Pour résoudre ce problème, les experts tentent depuis longtemps de cacher des signatures numériques, ou tatouages numériques (watermarks), à l'intérieur même du texte du code. Mais ces méthodes traditionnelles sont fragiles ; elles sont comparables à l'écriture d'un message secret dans l'espacement entre les mots, lequel est détruit dès que quelqu'un retype le document ou change la police de caractères. Le code reste le même, mais le message caché disparaît.

Une nouvelle approche, détaillée dans des recherches récentes, déplace la stratégie de la surface du texte vers la logique sous-jacente du programme. Au lieu de cacher un message dans les mots, cette méthode le cache dans la structure de l'architecture du code. Les chercheurs ont développé un système qui traite un programme informatique non pas comme une ligne de texte, mais comme une carte hiérarchique de sa propre logique, appelée arbre de syntaxe abstraite (abstract syntax tree). Cette carte montre comment les différentes parties du code se connectent et interagissent, indépendamment de la manière dont le code est formaté ou nommé. En effectuant de minuscules changements mathématiquement garantis sur cette structure — comme inverser l'ordre de deux nombres dans un calcul qui n'en change pas le résultat, ou transformer un type spécifique de boucle en un autre type mais équivalent — le système intègre une signature cryptographique directement dans l'ADN du programme. Ces changements sont invisibles pour l'ordinateur qui exécute le code et ne modifient pas ce que le logiciel fait, mais ils laissent une marque permanente et détectable qui survit même si le code est lourdement édité ou réécrit.

Le cœur de ce cadre repose sur un outil appelé tree-sitter, qui agit comme un analyseur (parser) de haute fidélité capable de lire le code et de reconstruire son squelette logique sans perdre aucun détail. Contrairement aux outils standards qui pourraient supprimer le formatage ou les commentaires, ce système préserve l'agencement exact octet par octet du fichier source tout en construisant une structure d'arbre qui représente la logique du code. Les chercheurs ont utilisé cela pour identifier des points spécifiques dans le code où ils pouvaient effectuer des changements en toute sécurité sans casser le programme. Ils se sont concentrés sur trois types principaux de transformations. Premièrement, ils ont recherché des opérations commutatives, où l'ordre de deux éléments ne change pas le résultat, comme l'addition de deux nombres. Inverser l'ordre de ces nombres est un moyen sûr d'encoder un seul bit de donnée. Deuxièmement, ils ont identifié des instructions indépendantes, ou lignes de code qui ne dépendent pas les unes des autres, et en ont réorganisé l'ordre. Troisièmement, ils ont transformé certaines structures de contrôle, comme transformer une boucle standard qui compte jusqu'à un nombre en un autre type de boucle qui parvient exactement au même résultat.

Pour intégrer un tatouage numérique, le système utilise une clé secrète pour générer une séquence spécifique de ces changements structurels. Il scanne ensuite le code, trouve les emplacements éligibles et applique les changements dictés par la clé secète. Par exemple, si la clé ordonne d'inverser l'ordre d'une addition spécifique, le système le fait. Si la clé ordonne de conserver l'ordre, elle ne fait rien. Parce que ces changements sont basés sur la logique du langage plutôt que sur les mots spécifiques utilisés, ils survivent aux outils de formatage standards qui se contentent de nettoyer l'espacement ou de renommer les variables. Même si un développeur passe le code par un formateur qui réorganise l'intégralité du fichier, la structure logique reste intacte et la signature cachée persiste. Le système est conçu pour être robuste face aux tentatives de suppression du tatouage, y compris les attaques où une seconde intelligence artificielle est sollicitée pour réécrire le code afin de supprimer la signature.

Pour vérifier si un morceau de code contient un tatouage numérique, les chercheurs ont construit un moteur de détection qui fonctionne en sens inverse. Il prend un morceau de code, reconstruit son arbre logique et examine les mêmes endroits où des changements auraient pu être effectués. Il vérifie ensuite l'état de ces points par rapport au modèle attendu généré par la clé secrète. Si le code est tatoué, le schéma de changements correspondra au modèle de la clé secrète bien plus souvent que ne le ferait le hasard. Les chercheurs ont utilisé un test statistique pour mesurer cette probabilité, comparant les correspondances observées par rapport à une variation aléatoire de base. Si le nombre de correspondances est suffisamment élevé, le système conclut avec une grande confiance que le code a été généré par le modèle d'IA spécifique qui a appliqué le tatouage. Ce processus est rigoureux et mathématique, garantissant que la détection n'est pas une supposition, mais une conclusion statistiquement significative.

Les chercheurs ont testé leur cadre contre un large éventail d'attaques pour voir comment il tenait le coup. Ils ont simulé des scénarios où le code tatoué passait par des outils de formatage, voyait ses variables renommées, ou était réécrit par un autre modèle d'intelligence artificielle pour le "nettoyer". Lors de ces tests, les méthodes traditionnelles de tatouage textuel ont presque totalement échoué. Lorsque le code était formaté, les signatures textuelles étaient détruites, et le taux de détection tombait à une infime fraction de ce qu'il était sur le code propre. En revanche, la nouvelle approche structurelle maintenait un taux de détection de près de quatre-vingt-dix-neuf pour cent, même après formatage. Lorsque le code était soumis au renommage de variables, la méthode structurelle détectait le tatouage dans presque tous les cas, alors que les anciennes méthodes structurelles peinaient. Même lorsqu'une seconde intelligence artificielle était utilisée pour paraphraser et réécrire le code, une technique très difficile à contrer, le nouveau cadre conservait un taux de détection supérieur à quatre-vingt-quatre pour cent. Cette résilience est due au fait que le système intègre de nombreuses copies de la signature à travers le code ; même si le processus de réécriture détruit certaines marques, suffisamment d'entre elles subsistent pour prouver l'origine.

L'étude a également abordé la préoccupation selon laquelle ces changements pourraient casser le code ou ralentir son exécution. Les chercheurs ont vérifié que chaque transformation appliquée préservait exactement la sortie du programme et ne modifiait ni la vitesse ni l'utilisation de la mémoire. Le code compilait et s'exécutait parfaitement, avec une dégradation fonctionnelle nulle. C'est une distinction cruciale par rapport aux autres méthodes qui tentent de biaiser l'IA pendant le processus d'écriture, ce qui peut parfois entraîner des erreurs ou du code invalide. En travaillant sur le code fini et en n'effectuant que des échanges mathématiquement sûrs, le cadre garantit que les logiciels restent pleinement fonctionnels. Le processus de détection lui-même est également efficace, reposant sur un test statistique qui peut être exécuté rapidement pour vérifier la provenance de grandes quantités de code.

Les implications de ce travail dépassent la simple protection du droit d'auteur. À mesure que l'intelligence artificielle s'intègre dans la chaîne d'approvisionnement logicielle, la capacité de vérifier l'origine du code devient une question de sécurité. Si un morceau de code contient une vulnérabilité cachée introduite par une IA, connaître sa source est essentiel pour résoudre le problème. Ce cadre offre un moyen de tracer cette origine, garantissant que les logiciels critiques peuvent être inspectés et approuvés. Les chercheurs ont démontré que leur méthode fonctionne sur un ensemble de milliers de scripts générés, montrant qu'elle est évolutive et prête pour une utilisation réelle. Bien que l'étude ait été menée sur du code Python, les principes d'invariance structurelle s'appliquent à de nombreux langages de programmation, suggérant une voie large pour sécuriser les outils numériques du futur.

Les conclusions suggèrent un changement fondamental dans la manière dont nous protégeons la propriété intellectuelle à l'ère de l'intelligence artificielle. En déplaçant le tatouage de la surface fragile du texte vers le squelette robuste de la logique, les chercheurs ont créé un système difficile à effacer et facile à vérifier. Les résultats indiquent que cette approche n'est pas seulement une possibilité théorique, mais une solution pratique capable de résister à l'édition et à la réécriture agressives qui caractérisent le développement logiciel moderne. Alors que la frontière entre le code humain et la machine continue de s'estomper, ce tatouage structurel offre un moyen fiable de maintenir la transparence et la responsabilité dans les logiciels que nous construisons. La recherche confirme qu'il est possible d'intégrer une signature permanente et incassable dans la logique même d'un programme, garantissant que l'origine réelle du code reste visible, peu importe à quel point la surface est modifiée.