Nell'era moderna della creazione di software, una rivoluzione silenziosa è in corso. I grandi modelli linguistici, i potenti sistemi di intelligenza artificiale capaci di scrivere codice informatico, sono diventati strumenti standard per gli sviluppatori, promettendo di accelerare la costruzione di applicazioni digitali. Tuttavia, questa comodità porta con sé una sfida significativa: quando una macchina scrive un programma, diventa quasi impossibile stabilire chi lo abbia effettivamente creato. I confini tra l'impegno umano e la generazione della macchina si sfumano, lasciando le aziende del software e i ricercatori vulnerabili al furto, al plagio e alla diffusione di codice non verificato. Per risolvere questo problema, gli esperti hanno cercato a lungo di nascondere firme digitali, o filigrane, all'interno del testo del codice stesso. Ma questi metodi tradizionali sono fragili; sono come scrivere un messaggio segreto negli spazi tra le parole, che viene distrutto nel momento in cui qualcuno riscrive il documento o cambia il carattere. Il codice rimane lo stesso, ma il messaggio nascosto svanisce.

Un nuovo approccio, dettagliato in una ricerca recente, sposta la strategia dalla superficie del testo alla logica sottostante del programma. Invece di nascondere un messaggio nelle parole, questo metodo lo nasconde nella struttura dell'architettura del codice. I ricercatori hanno sviluppato un sistema che tratta un programma per computer non come una riga di testo, ma come una mappa gerarchica della propria logica, nota come albero di sintassi astratta (abstract syntax tree). Questa mappa mostra come le diverse parti del codice si connettono e interagiscono, indipendentemente da come il codice sia formattato o denominato. Effettuando piccole modifiche matematicamente garantite a questa struttura — come scambiare l'ordine di due numeri in un calcolo che non è rilevante, o trasformare un tipo specifico di ciclo in un altro tipo di ciclo equivalente — il sistema incorpora una firma crittografica direttamente nel DNA del programma. Queste modifiche sono invisibili al computer che esegue il codice e non alterano ciò che il software fa, ma lasciano un segno permanente e rilevabile che sopravvive anche se il codice viene pesantemente modificato o riscritto.

Il nucleo di questo framework si basa su uno strumento chiamato tree-sitter, che funge da parser ad alta fedeltà capace di leggere il codice e ricostruire lo scheletro logico senza perdere alcun dettaglio. A differenza degli strumenti standard che potrebbero scartare la formattazione o i commenti, questo sistema preserva l'esatto layout byte per byte del file sorgente pur costruendo una struttura ad albero che rappresenta la logica del codice. I ricercatori hanno utilizzato questo strumento per identificare punti specifici nel codice dove potevano apportare modifiche in sicurezza senza interrompere il programma. Si sono concentrati su tre tipi principali di trasformazioni. Primo, hanno cercato operazioni commutative, dove l'ordine di due elementi non cambia il risultato, come l'aggiunta di due numeri. Scambiare l'ordine di questi numeri è un modo sicuro per codificare un singolo bit di dati. Secondo, hanno identificato istruzioni indipendenti, ovvero righe di codice che non dipendono l'una dall'altra, e ne hanno riordinato l'ordine. Terzo, hanno trasformato determinate strutture di controllo, come trasformare un ciclo standard che conta in aumento fino a un numero in un tipo diverso di ciclo che ottiene esattamente lo stesso risultato.

Per incorporare una filigrana, il sistema utilizza una chiave segreta per generare una specifica sequenza di queste modifiche strutturali. Successivamente scansiona il codice, trova i punti idonei e applica le modifiche dettate dalla chiave segreta. Ad esempio, se la chiave dice di scambiare l'ordine di un'addizione specifica, il sistema lo fa. Se la chiave dice di mantenere l'ordine, non interviene. Poiché queste modifiche si basano sulla logica del linguaggio piuttosto che sulle parole specifiche utilizzate, esse sopravvivono agli strumenti di formattazione standard che semplicemente puliscono la spaziatura o rinominano le variabili. Anche se uno sviluppatore passa il codice attraverso un formatter che riorganizza l'intero file, la struttura logica rimane intatta e la firma nascosta persiste. Il sistema è progettato per essere robusto contro i tentativi di cancellare la filigrana, inclusi gli attacchi in cui una seconda intelligenza artificiale viene interrogata per riscrivere il codice al fine di rimuovere la firma.

Per verificare se un pezzo di codice contiene una filigrana, i ricercatori hanno costruito un motore di rilevamento che lavora al contrario. Prende un pezzo di codice, ricostruisce il suo albero logico e cerca negli stessi punti in cui avrebbero potuto essere apportate modifiche. Verifica quindi lo stato di quei punti rispetto al pattern previsto dalla chiave segreta. Se il codice è stato marchiato, il pattern delle modifiche corrisponderà alla chiave segreta molto più spesso di quanto ci si aspetterebbe dal caso. I ricercatori hanno utilizzato un test statistico per misurare questa probabilità, confrontando i match osservati con una linea di base di variazione casuale. Se il numero di match è sufficientemente alto, il sistema conclude con alta confidenza che il codice è stato generato dal modello di IA specifico che ha applicato la filigrana. Questo processo è rigoroso e matematico, garantendo che il rilevamento non sia una supposizione, ma un reperto statisticamente significativo.

I ricercatori hanno testato il loro framework contro una vasta gamma di attacchi per vedere quanto fosse resistente. Hanno simulato scenari in cui il codice con filigrana veniva passato attraverso strumenti di formattazione, subiva la rinomina delle variabili o veniva riscritto da un altro modello di intelligenza artificiale per "pulirlo". In questi test, i metodi tradizionali di watermarking basati sul testo sono falliti quasi completamente. Quando il codice veniva formattato, le firme basate sul testo venivano distrutte e il tasso di rilevamento scendeva a una mera frazione di quello presente sul codice pulito. Al contrario, il nuovo approccio strutturale manteneva un tasso di rilevamento vicino al novantanove per cento anche dopo la formattazione. Quando il codice era sottoposto alla rinomina delle variabili, il metodo strutturale rilevava la filigrana in quasi tutti i casi, mentre i vecchi metodi strutturali faticavano. Anche quando veniva utilizzata una seconda intelligenza artificiale per parafrasare e riscrivere il codice, una tecnica molto difficile da contrastare, il nuovo framework manteneva un tasso di rilevamento superiore all'ottantaquattro per cento. Questa resilienza è dovuta al fatto che il sistema incorpora molte copie della firma attraverso il codice; anche se il processo di riscrittura distrugge alcuni dei segni, ne rimangono abbastanza da provare l'origine.

Lo studio ha affrontato anche il timore che queste modifiche potessero rompere il codice o rallentarlo. I ricercatori hanno verificato che ogni trasformazione applicata preservava l'esatto output del programma e non cambiava la sua velocità o l'uso della memoria. Il codice compilava ed eseguiva perfettamente, con zero degradazione funzionale. Questa è una distinzione critica rispetto ad altri metodi che cercano di influenzare il bias dell'IA durante il processo di scrittura, il che può talvolta portare a errori o codice non valido. Lavorando sul codice finito e apportando solo scambi matematicamente sicuri, il framework assicura che il software rimanga pienamente funzionale. Anche il processo di rilevamento è efficiente, basandosi su un test statistico che può essere eseguito rapidamente per verificare la provenienza di grandi quantità di codice.

Le implicazioni di questo lavoro vanno oltre la semplice protezione del copyright. Man mano che l'intelligenza artificiale diventa sempre più integrata nella catena di approvvigionamento del software, la capacità di verificare l'origine del codice diventa una questione di sicurezza. Se un pezzo di codice contiene una vulnerabilità nascosta introdotta da un'IA, conoscere la sua origine è essenziale per risolvere il problema. Questo framework fornisce un modo per tracciare tale origine, garantendo che il software critico possa essere vagliato e considerato affidabile. I ricercatori hanno dimostrato che il loro metodo funziona su un dataset di migliaia di script generati, mostrando che è scalabile e pronto per l'uso nel mondo reale. Sebbene lo studio sia stato condotto su codice Python, i principi dell'invarianza strutturale si applicano a molti linguaggi di programmazione, suggerendo una vasta strada da seguire per proteggere gli strumenti digitali del futuro.

Le scoperte suggeriscono un cambiamento fondamentale nel modo in cui proteggiamo la proprietà intellettuale nell'era dell'intelligenza artificiale. Spostando la filigrana dalla fragile superficie del testo allo scheletro robusto della logica, i ricercatori hanno creato un sistema che è difficile da cancellare e facile da verificare. I risultati indicano che questo approccio non è solo una possibilità teorica, ma una soluzione pratica in grado di resistere all'editing aggressivo e alla riscrittura che caratterizzano lo sviluppo moderno del software. Mentre la linea tra codice umano e macchina continua a sfumare, questo watermarking strutturale offre un modo affidabile per mantenere la trasparenza e la responsabilità nel software che costruiamo. La ricerca conferma che è possibile incorporare una firma permanente e indistruttibile nella logica stessa di un programma, garantendo che l'origine reale del codice rimanga visibile, indipendentemente da quanto la superficie venga modificata.