Come rimuovere il "codice nascosto" da ChatGPT e altri LLM

Poiché i modelli linguistici di grandi dimensioni (LLM) generano sempre più codice funzionante e vengono integrati in pipeline di sviluppo e stack di agenti, c'è un rischio crescente che nascosto or maligno le istruzioni, siano esse incorporate negli output del modello, iniettate tramite pagine web o plugin di terze parti o introdotte durante l'addestramento del modello, possono causare comportamenti non sicuri quando viene eseguito il codice.

Secondo le segnalazioni degli utenti che circolano nelle comunità degli sviluppatori, uno sviluppatore di software ha subito una catastrofica perdita di dati, pari a circa Sono stati eliminati 800 GB di file, Compresa la l'intera applicazione CursorAI stessa — dopo aver eseguito il codice generato con l'assistenza di Gemini 3 mentre lavoravo all'interno del CursorAI IDEPoiché gli sviluppatori fanno sempre più affidamento sugli LLM per la generazione del codice, le conseguenze degli script non revisionati o non sicuri diventano più gravi.

Pertanto, è molto importante sapere come rilevare e rimuovere i codici pericolosi generati da LLM.

Che cosa si intende per "codice nascosto" nel contesto di ChatGPT e LLM?

Cosa si intende per "codice nascosto"?

"Codice nascosto" è un termine generico utilizzato dagli sviluppatori per descrivere qualsiasi istruzione incorporata o contenuto eseguibile all'interno del testo (o dei file) che un LLM acquisisce o emette, tra cui:

• Istruzioni in stile rapido incorporato nel contenuto dell'utente (ad esempio, "Ignora le istruzioni precedenti..." nascosto in un PDF).
• Personaggi invisibili o spazi di larghezza zero utilizzati per nascondere i token o violare i presupposti di tokenizzazione.
• Carichi utili codificati (base64, codifica URL, incorporamenti steganografici all'interno di immagini o documenti).
• HTML/JS nascosto o blocchi di script inclusi nel contenuto formattato che potrebbero essere interpretati dai renderer downstream.
• Metadati o annotazioni (commenti sui file, livelli nascosti nei PDF) che forniscono istruzioni ai sistemi di recupero o al modello.
• Comportamenti impliciti derivanti dal codice generato che utilizza API pericolose (ad esempio, eval, exec, subprocesso chiamate di rete/sistema), anche quando l'intento non è esplicitamente malevolo.
• Istruzioni rapide inserite che fanno sì che il modello generi codice che include comandi nascosti o logica di tipo backdoor perché un aggressore ha progettato il prompt o il contesto.

Questi vettori di attacco sono spesso chiamati iniezione tempestiva or iniezione indiretta immediata Quando l'obiettivo è modificare il comportamento del modello. La comunità della sicurezza ora considera l'iniezione rapida come una vulnerabilità LLM fondamentale e OWASP l'ha formalizzata come categoria di rischio LLM.

In che cosa si differenzia dal malware tradizionale o XSS?

La differenza è l ' semantico Livello: l'iniezione di prompt prende di mira il comportamento di "instruction-following" del modello, anziché il sistema operativo host o il motore di rendering del browser. Detto questo, l'HTML o lo script nascosto che finisce per essere eseguito in un web renderer è comunque un attacco eseguibile (simile a XSS); è necessario difendere sia il livello semantico che quello di esecuzione. Leader del settore e ricercatori hanno definito l'iniezione di prompt una "sfida di sicurezza di frontiera" e continuano a pubblicare strategie di mitigazione.

Perché LLM può produrre codice nascosto o pericoloso?

Comportamento del modello, dati di formazione e contesto delle istruzioni

Gli LLM sono addestrati a produrre continuazioni plausibili in base al contesto e alle istruzioni. Se il contesto contiene segnali contraddittori, o se un utente richiede al modello un codice che esegua azioni complesse, il modello può generare codice che include comportamenti subdoli o attivi.

Gli LLM producono codice plausibile ma non sicuro

Gli LLM sono ottimizzati per la fluidità e l'utilità, non per la sicurezza in presenza di effetti collaterali distruttivi. Saranno felici di generare un testo sintetico rm -rf /path/to/dir or shutil.rmtree() chiamano quando viene chiesto loro di "pulire" e, poiché le loro risposte sono spesso formulate con sicurezza, gli utenti potrebbero copiare ed eseguire senza sufficiente controllo. Questo problema di "allucinazione della sicurezza" è il motivo per cui richieste apparentemente innocue diventano pericolose.

Automazione dei flussi di lavoro di offuscamento

Gli autori delle minacce stanno ora automatizzando l'offuscamento del codice concatenando le chiamate LLM: un modello genera un payload, un altro lo rielabora per evitare il rilevamento delle firme e così via. I report sulle minacce del settore e le analisi dei fornitori del 2025 documentano questa "offuscamento assistito dall'intelligenza artificiale" come una tecnica emergente.

Come è possibile rilevare il codice nascosto all'interno degli output del modello?

Lista di controllo per il triage rapido

1. Scansiona per Unicode invisibile/insolito (giunzioni a larghezza zero, spazi a larghezza zero, marcatori dell'ordine dei byte, omoglifi non ASCII).
2. Esegui analisi statica / analisi AST per identificare l'uso di API potenti (eval, exec, subprocess, os.system, chiamate riflessive).
3. Cerca payload codificati (base64, blob esadecimali, stringhe lunghe ripetute o contenuto compresso).
4. Controllare i modelli di offuscamento (concatenazione di stringhe che costruisce nomi API, aritmetica dei caratteri, chr() catene).
5. Utilizzare l'analisi semantica per confermare se il codice esegue effettivamente operazioni di I/O, networking o mutazione del file system.

Rilevamento di pattern statico (veloce, prima riga)

• Analisi e linting basati sul linguaggio. Analizzare immediatamente l'output generato in blocchi di codice anziché in prosa. Eseguire formattatori e linter (Black/Prettier, pylint, eslint). Le regole di linterizzazione dovrebbero contrassegnare l'uso di eval, exec, rm -rf, chiamate di sottoprocessi non elaborati o pipe shell che costruiscono comandi in modo dinamico.
• Scanner di token e stringhe. Cerca token e modelli ad alto rischio: sudo, percorsi assoluti come /home/, C:\, rm -rf, shutil.rmtree, subprocess.Popen, blob base64 inline, stringhe lunghe non interpretabili e shebang che cambiano il contesto dell'interprete.
• Scansioni segrete e controlli della provenienza. Rileva credenziali hardcoded, URL che puntano a registri non attendibili o codice che estrae dinamicamente pacchetti da fonti arbitrarie.

L'analisi statica individua rapidamente molti problemi evidenti ed è economica da eseguire come parte di un gate CI.

Rilevamento semantico e contestuale (più approfondito)

• Analisi dell'intento. Utilizzare un modello secondario o un motore di regole per classificare l'intento del codice generato: è "lettura", "scrittura", "eliminazione", "rete", "installazione"? Qualsiasi operazione classificata come eliminazione/scrittura dovrebbe innescare l'escalation.
• Analisi del flusso di dati. Analizzare il codice per rilevare se percorsi non convalidati o forniti dall'utente possano raggiungere API distruttive. Ad esempio, se una variabile derivata da un output LLM o da un file remoto viene successivamente concatenata in un comando shell, contrassegnarla.
• Correlazione di provenienza. Conserva un registro completo della conversazione, dei prompt di sistema e delle pagine di contesto. Se output sospetti sono correlati a un particolare documento esterno o a una chiamata a un plugin, ciò può indicare un'iniezione di prompt o un contesto contaminato.

Rilevamento dinamico e comportamentale (il più affidabile)

• Esecuzione sandbox con monitoraggio. Esegui il codice generato in un ambiente effimero con restrizioni rigorose, senza rete, senza mount host e senza filtraggio delle chiamate di sistema (seccomp). Monitora l'attività del file system, i tentativi di chiamata di rete, la generazione di processi e gli I/O insoliti.
• Test canarino. Prima di eseguire su dati reali, eseguire il codice su directory sintetiche che contengono file sentinella; monitorare eventuali eliminazioni o sovrascritture.
• Euristiche comportamentali. Cercare cicli che attraversano directory padre, operazioni ricorsive senza controlli di profondità o modelli di ridenominazione che potrebbero danneggiare molti file (ad esempio, scrivendo ripetutamente lo stesso nome file).
  L'analisi dinamica è l'unico modo per rilevare i payload offuscati, ritardati o attivati ​​solo in fase di esecuzione.

Come si dovrebbe rimuovere o neutralizzare il codice nascosto prima di eseguire gli output LLM?

Rimozione difensiva vs. alterazione della semantica

Ci sono due obiettivi quando si “rimuove il codice nascosto”:

1. sanificazione — rimuovere i contenuti chiaramente non codificati o sospetti (Unicode invisibili, caratteri di larghezza zero, payload Base64 aggiunti). Ciò non dovrebbe alterare la logica benigna prevista.
2. Neutralizzazione — per qualsiasi cosa esegua o chiami servizi esterni, disabilitare tali chiamate o renderle inattive finché non vengono verificate.

Preferisci sempre neutralizzazione + revisione rispetto all'eliminazione cieca: rimuovere parti di codice in modo arbitrario può produrre comportamenti inaspettati o non corretti. Invece, sostituisci i costrutti sospetti con stub espliciti e registrati che falliscono in modo sicuro (sollevano eccezioni o restituiscono valori predefiniti sicuri).

Passaggio 1: trattare il codice generato come dati non attendibili

Non eseguire mai codice direttamente da ChatGPT (o da qualsiasi LLM) senza prima averlo sottoposto a una pipeline di rimozione e rafforzamento. Tale pipeline dovrebbe essere applicata tramite policy e automatizzata in CI/CD.

Fase 2: estrarre e canonizzare il codice

• Normalizza il testo e rimuovi i caratteri di larghezza zero: Elimina caratteri come U+200B, U+200C, U+200D, U+FEFF e altri punti di codice a larghezza zero/formattazione. Registra ciò che è stato rimosso per l'audit. Questo passaggio elimina molte codifiche "nascoste" utilizzate per la furtività visiva.
• Elimina tutto il contesto non di codice: rimuovi la narrazione, i commenti nascosti e qualsiasi wrapper HTML/Markdown. Converti il ​​codice in formato canonico utilizzando formattatori di linguaggio (Black, Prettier) in modo che gli spazi vuoti offuscati o i caratteri di controllo vengano normalizzati.
• Rifiuta o metti in quarantena il codice con queste strutture: dinamico eval, chiamate di sottoprocesso non elaborate (os.system, subprocess.Popen), blob base64 inline decodificati in esecuzione o incorporati #! direttive che tentano di modificare il contesto dell'interprete. Normalizza il testo e rimuovi i caratteri di larghezza zero
  Eliminare caratteri come U+200B, U+200C, U+200D, U+FEFF e altri punti di codice a larghezza zero/formattazione. Registrare ciò che è stato rimosso per l'audit. Questo passaggio elimina molte codifiche "nascoste" utilizzate per la furtività visiva.

Fase 3: analizzare in AST e sostituire i nodi rischiosi

Con il codice analizzato in un AST, trova i nodi che chiamano l'esecuzione dinamica (ad esempio, exec), o che generano a livello di codice i nomi delle funzioni. Sostituiscili con stub sicuri che generano un'eccezione controllata che indica "comportamento dinamico non sicuro bloccato". Genera una copia sanificata del codice sorgente supportato da AST per la revisione. Esegui controlli dei pattern di sicurezza (regole semgrep personalizzate per il tuo ambiente). Se vengono trovate corrispondenze, contrassegnale e neutralizzale.

Fase 4 — Indurimento statico e riscrittura

• Riscrittura automatizzata: passa il codice attraverso un disinfettante automatico che sostituisce le chiamate pericolose con wrapper sicuri, ad esempio, sostituisci os.system() / subprocess con un esecutore sandbox approvato che impone timeout e blocchi di rete.
• Controllo delle capacità: modifica o rimuovi chiavi API, token o chiamate a endpoint privilegiati; sostituiscili con adattatori fittizi per i test locali. Impedisci l'inclusione accidentale di segreti o URL.
• Riscritture delle dipendenze: blocco dinamico pip / npm installazioni create dal codice. Richiedi che le dipendenze siano dichiarate e approvate tramite il tuo registro.

Fase 5: correre all'interno di una sandbox aggressiva

• Contenitori effimeri / microVM: eseguire il codice in un contenitore/VM privo di rete, senza accesso alle credenziali host e con accesso limitato al file system. Tecnologie come gVisor, Firecracker o servizi di esecuzione temporanea dedicati sono appropriate. Se il codice deve accedere all'I/O, utilizzare un proxy che applichi le policy.
• Filtri di chiamata di sistema e seccomp: limita le chiamate di sistema consentite. Le scritture di file al di fuori di una directory temporanea dovrebbero essere bloccate.
• Limiti di risorse/tempo: imposta limiti di CPU/memoria/tempo in modo che anche le bombe logiche non possano funzionare indefinitamente.

L'esecuzione sandbox e il monitoraggio spesso scoprono payload che i controlli statici non rilevano. Le linee guida del settore e i recenti white paper raccomandano il sandboxing come mitigazione fondamentale.

Quali strumenti e regole automatizzati dovrebbero essere presenti nella tua pipeline?

Componenti consigliati per la toolchain

• Modulo di sanificazione Unicode (librerie personalizzate o esistenti). È necessario registrare i caratteri normalizzati.
• Parser + analizzatore AST per ogni linguaggio di destinazione (Python ast, typed-ast, parser JavaScript, parser Java).
• Analizzatori statici / SAST: Bandit (Python), Semgrep (multi-lingua, personalizzabile), ESLint con plugin di sicurezza.
• Entropia ed euristiche del decodificatore: rileva base64/hex/gzip e indirizza all'ispezione.
• Tempo di esecuzione sandbox: contenitore minimo con profilo seccomp/AppArmor rigoroso o interprete a livello di linguaggio con chiamate di sistema disabilitate.
• Responsabile dell'applicazione delle politiche: un componente che decide i moduli consentiti, gli endpoint consentiti e i wrapper API sicuri.
• Pista di controllo: registri immutabili che registrano l'output originale, l'output ripulito, le differenze e le decisioni.

Esempi di modelli semgrep (concettuali)

Utilizzare regole brevi e conservative che segnalino l'uso di funzioni pericolose. Ad esempio:

• Bandiera eval, exec, Function costruttore (JS), importazioni dinamiche o nomi API creati tramite stringhe.
• Segnala le chiamate di rete al di fuori della lista consentita (ad esempio, requests.get a host sconosciuti).
• Flag scrive su percorsi sensibili (/etc, cartelle di sistema) o generazione di processi.

(Mantenere questi elementi come elementi di configurazione per organizzazione e perfezionarli nel tempo.)

Quali sono gli esempi pratici di sanificazione (esempi sicuri)?

Di seguito sono riportati alcuni esempi difensivi non pericolosi che puoi adattare. Sono sanificazione e rilevamento frammenti, non istruzioni di exploit.

Esempio: eliminare i caratteri di larghezza zero (Python, difensivo)

import re
ZERO_WIDTH_RE = re.compile(r'')
def strip_zero_width(s: str) -> str:
    cleaned = ZERO_WIDTH_RE.sub('', s)
    return cleaned

In questo modo vengono rimossi i caratteri che gli aggressori spesso usano per nascondere il codice in testo altrimenti visibile. Registrate sempre ciò che è stato rimosso e considerate la rimozione come parte del percorso di controllo.

Esempio: analizzare e ispezionare AST (Python, concettuale)

import ast

def has_dynamic_exec(source: str) -> bool:
    tree = ast.parse(source)
    for node in ast.walk(tree):
        if isinstance(node, ast.Call):
            if getattr(node.func, 'id', '') in ('eval', 'exec',):
                return True
        if isinstance(node, ast.Attribute):
            if getattr(node, 'attr', '') in ('popen', 'system'):
                return True
    return False

If has_dynamic_exec restituisce True, non eseguire il codice; sostituire invece il nodo dinamico con uno stub sicuro e richiedere la revisione.

Nota: questi esempi sono di natura difensiva. Non rimuovere la registrazione, l'audit o la revisione umana dalla tua pipeline.

Considerazioni finali: tratta l'output LLM come codice non attendibile, sempre

I LM sono potenti strumenti di produttività: possono produrre codice elegante, accelerare la stesura di bozze e automatizzare il lavoro di routine. Ma quando si incontrano con l'esecuzione, le regole di sicurezza cambiano: gli output del modello devono essere trattati come artefatti non attendibiliLa combinazione di iniezioni tempestive, ricerche backdoor e rivelazioni di vulnerabilità nel mondo reale negli ultimi 18-30 mesi dimostra chiaramente che la superficie di rischio è cresciuta e continuerà a evolversi.

Difese pratiche che combinano analisi sintattica, statica, test dinamici in modalità sandbox, governance e red-teaming continuo fermeranno la maggior parte degli attacchi. Ma i team devono anche investire in controlli organizzativi: privilegi minimi, provenienza e una cultura che presuppone che gli output LLM necessitino di verifica. Il settore sta sviluppando strumenti e framework per semplificare questi modelli; nel frattempo, l'adozione della checklist di cui sopra riduce la possibilità che un payload nascosto sfugga.

Gli sviluppatori possono accedere alle ultime API LLM come Claude Sonetto 4.5 API e al Anteprima di Gemini 3 Pro ecc. tramite CometAPI, l'ultima versione del modello è sempre aggiornato con il sito ufficiale. Per iniziare, esplora le capacità del modello nel Parco giochi e consultare il Guida API per istruzioni dettagliate. Prima di accedere, assicurati di aver effettuato l'accesso a CometAPI e di aver ottenuto la chiave API. CometaAPI offrire un prezzo molto più basso rispetto al prezzo ufficiale per aiutarti a integrarti.

Pronti a partire? → Iscriviti oggi a CometAPI !

Se vuoi conoscere altri suggerimenti, guide e novità sull'IA seguici su VK, X e al Discordia!