CODLAB / Blog · IA e integrazione

Cancello comandi, grant fail-closed e diagnosi IA BYOK con consenso in CardinalHost

15 nov 2026 CODLAB Team 11 min

Aggiornato a novembre 2026: CardinalHost (attualmente in fase di pre-lancio e descritto su cardinalhost.org) separa nettamente la diagnosi assistita dall’IA rispetto all’esecuzione dei comandi. Codice deterministico classifica in anticipo il rischio dei comandi e governa le chiamate agli strumenti IA, impone anteprima dati e consenso esplicito sulle chiamate di lettura file e comando (con tetto di 16 KiB alla sorgente in leggi_file) e collauda envelope firmati e grant di input tramite test di mutazione.

Perché un modello linguistico non può mai fungere da confine di sicurezza

Quando un assistente diagnostico analizza log di sistema, elenchi di processi o file di configurazione provenienti da una macchina remota, ingerisce inevitabilmente dati non fidati. Una riga costruita ad arte nel registro di un server web, il nome manipolato di un container o una variabile d’ambiente anomala possono innescare una prompt injection indiretta. Se il modello potesse invocare direttamente comandi shell o leggere file arbitrari in silenzio, si aprirebbero subito due rischi strutturali: esfiltrazione invisibile di segreti e modifiche distruttive o persistenti sul nodo remoto.

Le barriere puramente probabilistiche — chiedere al modello nel prompt di sistema di «agire con prudenza» — non costituiscono un confine di sicurezza. Nell’ingegneria dei sistemi un confine esiste solo dove codice deterministico e verificabile, esterno al modello, stabilisce ciò che è eseguibile e ciò che viene respinto. È il criterio guida con cui sviluppiamo CardinalHost nella sezione di ricerca dei nostri progetti, in continuità con l’architettura nativa Linux Wayland e di trasporto video ibrido approfondita nel primo articolo.

Il cancello dei comandi: classificatore del rischio, gate degli strumenti IA e verificatore dell’envelope a 18 motivi di rifiuto

Nel client Swift, CardinalHost distingue tre meccanismi separati: la classificazione conservativa del rischio di una stringa di comando (ClassificatoreRischioComando), il gate degli strumenti IA che vi si appoggia (StrumentiAIAgente e GateAIAgente) e la verifica crittografica degli envelope di autorizzazione firmati (VerificatoreEnvelope).

In primo luogo, ClassificatoreRischioComando valuta ogni comando in modo deterministico e conservativo (best-effort, vince la regola di rischio massimo) su tre livelli: lettura è concesso esclusivamente a comandi di sola lettura in whitelist posti come primo token e privi di metacaratteri shell, redirezioni o caratteri di controllo; i comandi che mutano lo stato così come qualunque comando sconosciuto ricadono conservativamente in modifica (mai in lettura); i pattern irreversibili — come rm -rf, dd of=, mkfs, shutdown/reboot, scritture su prefissi di sistema quali /etc, /dev, /boot, /usr o /root, invocazioni dirette di shell/eval e flag di codice inline (-c, -e, -r) — vengono classificati come distruttivo. Quando è presente la chiave API dell’utente (senza chiave il gate resta spento), StrumentiAIAgente traduce le richieste IA in tre decisioni operative:

  • Esecuzione automatica (automatico): Riservata unicamente a tre strumenti delimitati di metadati (leggi_salute, elenca_cartella, indice_cartella). Persino i comandi shell classificati come lettura tramite esegui_comando non ottengono mai automatico, così da impedire che il contenuto di un file venga stampato e inviato al cloud tramite cat o grep.
  • Consenso umano esplicito (chiediConsenso): Letture del contenuto di file (leggi_file) e chiamate esegui_comando di livello lettura o modifica — inclusi espressamente i comandi shell sconosciuti, che ricadono in modifica e restano in attesa della conferma attiva dell’operatore.
  • Rifiuto netto (rifiuta): Qualunque strumento IA sconosciuto assente dal registro degli strumenti e qualunque comando classificato come distruttivo. Nel gate IA il rifiuto è definitivo; un catalogo chiuso di eseguibili che respinga ogni comando non elencato appartiene invece al distinto mattone iniziale PonteAI sul nodo remoto.

Separatamente dalla classificazione del rischio, VerificatoreEnvelope controlla gli envelope di capacità firmati (EnvelopeFirmato) subito prima dell’effetto sul sink secondo il principio fail-closed, distinguendo esattamente 18 motivi tipizzati di rifiuto (MotivoNegazioneEnvelope): struttura malformata (malformato), emittente sconosciuto (emittenteSconosciuto), firma non valida (firmaNonValida), campo non valido (campoNonValido), epoca revocata (revocato), tenant, host o sessione errati (tenantErrato, hostErrato, sessioneErrata), verbo d’azione o hash canonico degli argomenti diversi da quelli attesi (azioneErrata, argomentiDiversi), soggetto non autorizzato (soggettoNonAutorizzato), policy malformata o insufficiente rispetto al rischio reale (policyMalformata, policyInsufficiente), TTL eccessivo, finestra non ancora valida o scaduta (ttlEccessivo, nonAncoraValido, scaduto) e replay del nonce o registro nonce pieno (replay, registroNoncePieno).

Sottosistema Stato verificato oggi (novembre 2026) Limite dichiarato / prossimo traguardo
Classificatore rischio e gate strumenti IA nel client Livelli di rischio (lettura / modifica / distruttivo; comandi sconosciuti → modifica) e gate IA (automatico solo metadati, chiediConsenso inclusi comandi sconosciuti, rifiuta per strumenti sconosciuti o distruttivo) testati Classificazione best-effort per il gate IA e comandi; nessun catalogo chiuso di binari nel client, e il terminale SSH interattivo resta un percorso distinto per l’amministratore
Verificatore envelope e grant di input VerificatoreEnvelope con 18 motivi tipizzati di rifiuto; grant di input fail-closed con scadenza e revoca istantanea Le ricevute d’effetto firmate crittograficamente e verificabili offline da terzi sull’intera catena di prodotto sono in costruzione
Verifica sul nodo remoto (PonteAI) Primo mattone senza shell verificato a banco con catalogo chiuso (uname -sr, uptime) e test di mutazione Collegamento al dispatcher remoto, alla UI di consenso e a tutti i percorsi esecutivi sul nodo di destinazione in costruzione

Dichiarare con precisione questo perimetro fa parte del metodo ingegneristico: non affermiamo di limitare ciò che un sistemista digita volontariamente in un terminale SSH aperto, e distinguiamo ciò che oggi è operativo nel client da ciò che stiamo completando sul nodo remoto.

Grant fail-closed e perché i soli unit test verdi non bastano

Sia i permessi di input nelle sessioni di assistenza sia le singole azioni approvate sono modellati in CardinalHost come grant espliciti dotati di ambito, scadenza temporale (expiry) e revoca immediata. Se un attributo manca, l’orologio supera la scadenza o interviene la revoca, il sistema applica rigorosamente il principio fail-closed: in ogni caso dubbio l’azione viene bloccata.

Nel codice di sicurezza, tuttavia, una suite di test tradizionali può raggiungere un’alta copertura delle righe lasciando passare errori sottili sui casi limite — ad esempio un operatore < trasformato in <= o un controllo di scadenza saltato su campi opzionali. Per questo sottoponiamo il verificatore e i grant a test di mutazione (sabotaggi controllati): uno strumento introduce deliberatamente mutanti nel codice sorgente e verifica che la suite di collaudo intercetti e faccia fallire ciascuna alterazione. Se un mutante sopravvive, a dover essere rafforzata è la suite di test.

Cosa ha corretto la revisione avversariale interna su diagnosi IA BYOK e scritture agente

Per la diagnosi assistita opzionale, CardinalHost adotta rigorosamente il modello Bring Your Own Key (BYOK): l’utente conserva la propria chiave API nel portachiavi nativo del sistema operativo (Keychain su macOS o GNOME Keyring su Linux), senza alcun ricarico da parte di CodLab (0 € di margine sul traffico IA) e senza passare da proxy centralizzati CodLab. Per la diagnosi dello stato macchina (DiagnosiAI), CardinalHost richiede un opt-in diagnostico esplicito e mostra prima dell’invio un’anteprima obbligatoria dei dati (anteprimaLeggibile) ricavata direttamente dai campi JSON serializzati.

Nell’agosto 2026 abbiamo sottoposto a revisione avversariale interna sia il perimetro IA (GateAIAgente e DiagnosiAI) sia la distinta superficie di scrittura file dell’agente, fissando tre difese con confini espliciti:

  1. Consenso per singola azione, tetto di 16 KiB alla sorgente in leggi_file e troncamento successivo dell’output: Per evitare che una prompt injection nascosta in un log esfiltri file in un ciclo autonomo, sia leggi_file sia i comandi di lettura tramite esegui_comando sono esclusi da automatico e richiedono, in presenza della chiave utente, il consenso umano esplicito per ogni singola chiamata (chiediConsenso). Soltanto leggi_file racchiude il percorso approvato tra apici singoli con terminatore d’opzioni (--) ed esegue head -c 16384, limitando il prelievo a 16 KiB alla sorgente, mentre una chiamata esegui_comando approvata esegue il comando confermato senza tale limite alla sorgente; quando l’output ricevuto dallo strumento (su elenca_cartella, leggi_file o esegui_comando) supera 8.192 caratteri, limita conserva i primi 8.192 caratteri e aggiunge il marcatore da 11 caratteri …[troncato] (8.203 caratteri restituiti in totale su puro testo ASCII; poiché limita conta i caratteri Swift e non i byte, un testo UTF-8 con caratteri multibyte letto da leggi_file può comunque raggiungere tutti i 16 KiB della sorgente). Va dichiarato con chiarezza il confine: leggi_file non applica una lista di blocco sui percorsi in lettura; la difesa poggia sulla verifica umana del percorso o del comando richiesto.
  2. Sanificazione delle righe nell’anteprima diagnostica: Per impedire che valori non fidati provenienti dall’agente (ad esempio un ritorno a capo nel nome di un servizio fallito o della distribuzione) generino righe fantasma nell’anteprima obbligatoria, senzaACapo neutralizza a-capo e caratteri di controllo nei valori visualizzati da anteprimaLeggibile — come presidio di fedeltà dell’anteprima, non come filtro universale del prompt su file arbitrari.
  3. Guardie anti-persistenza separate con realpath sulle scritture dell’agente: Separatamente dalle letture IA, il controllo canonico _percorso_avvio_vietato protegge le operazioni di scrittura e rinomina del file manager dell’agente (file-carica, file-rinomina, file-crea-cartella). Risolve i symlink tramite realpath e blocca in modo deterministico le sole scritture dirette verso vettori di persistenza quali ~/.ssh, file di avvio delle login shell (.bashrc, .zshrc, .profile, .bash_aliases, .pam_environment, .netrc), systemd --user e cartelle di avvio automatico dell’utente.

Applichiamo la medesima separazione tra logica di controllo fidata e fonti documentali non fidate nelle architetture aziendali che progettiamo, come illustrato nella nostra Engineering Note su confini delle fonti e difesa dalla prompt injection nei sistemi RAG e nei nostri servizi di ingegneria dei sistemi e integrazione IA.

Il primo mattone di PonteAI sul nodo: esecuzione senza shell e consumo atomico

Per non affidare la sicurezza unicamente al lato client, nel repository infrastrutturale di Cardinal sviluppiamo PonteAI, il verificatore di esecuzione sul nodo remoto. Il primo mattone completato e collaudato nel settembre 2026 mostra come ridurre al minimo la superficie d’attacco:

  • Limite di 16 KiB e schema JSON rigoroso: Richieste fuori taglia o malformate vengono scartate prima di qualunque risoluzione.
  • Esecuzione diretta tramite vettore argv[] senza shell: I processi vengono avviati passando direttamente il vettore degli argomenti, mai tramite /bin/sh -c, neutralizzando alla radice metacaratteri, concatenazioni e subshell.
  • Catalogo chiuso di comandi: Nel mattone iniziale sono ammesse esclusivamente le ispezioni diagnostiche dichiarate nel catalogo (uname -sr e uptime); ogni altro eseguibile o flag viene rifiutato.
  • Impronta SHA-256, scadenza a 60 secondi e consumo singolo: Ogni autorizzazione lega comando e argomenti in un hash SHA-256, scade dopo 60 secondi e viene consumata atomicamente una sola volta contro eventuali tentativi di replay.
  • Isolamento non-root e registro di audit locale indurito: L’esecuzione richiede un utente non privilegiato (UID != 0), chiude stdin, impone un timeout massimo di 5 secondi e scrive ogni evento in un file JSONL locale con permessi 0600, protezione O_NOFOLLOW contro i symlink e fsync esplicito.

Nelle evidenze storiche registrate a banco il 14 settembre 2026 (ambiente macOS con classificatore e AutoritaPermessi reali, modello e canale mock ed esecuzione locale di uname -sr), questo primo mattone ha superato 41 test comportamentali su 41 e intercettato 6 mutanti di sabotaggio su 6. Dichiariamo con altrettanta precisione i limiti di questa prima fetta: il verbo remoto SSH/CLI --esegui-proposta, il dispatcher del canale, la finestra reale di consenso nella UI, il packaging Linux e l’adattatore verso un provider IA reale non sono ancora collegati, e il registro JSONL locale è indurito sul filesystem ma non ancora firmato crittograficamente.

Quali sei mutanti di sabotaggio esegue davvero prove-sabotaggi.py

Mentre i vincoli su scadenza a 60 secondi, impronta SHA-256, rimozione atomica singola, UID != 0 e permessi 0600 sono coperti dai 41 test comportamentali di ProvePonteAI.swift, lo script prove-sabotaggi.py altera copie temporanee di PonteAI.swift introducendo sei sabotaggi specifici, ciascuno dei quali deve far fallire l’esatta asserzione comportamentale attesa (non limitarsi a rompere la compilazione):

  • automatico-diventa-clic (automatico di sessione accettato come clic): Indebolisce origine == .clic così che un permesso automatico di sessione venga scambiato per un clic esplicito sulla singola azione.
  • consenso-ampio (potere troppo ampio accettato): Sostituisce il confronto esatto poteri == [a.potere] con true, verificando che un consenso generico non valga al posto del potere legato all’azione.
  • classificazione-saltata (classificatore del rischio aggirato): Forza l’esito di ClassificatoreRischioComando.rischio a .lettura per controllare che comandi distruttivi o mascherati vengano comunque bloccati.
  • catalogo-aperto (catalogo chiuso disattivato): Salta la guardia CatalogoPonteAI.eseguibile(proposta.argv) != nil, verificando il rifiuto di comandi sconosciuti, script e invocazioni root anche con classificazione bassa.
  • registro-inizio-saltato (annotazione iniziale di audit omessa): Rimuove la scrittura preliminare annota(.inizio, ...) per accertare che un guasto dell’audit prima dell’avvio chiuda il cancello (fail-closed).
  • consenso-assente-esegue (esecuzione in assenza di consenso valido): Avvia l’esecutore dentro il ramo d’errore .consensoNonValido, dimostrando che persino una lettura non parte mai senza consenso valido.

Ulteriori mutanti — ad esempio sull’inversione della finestra di 60 secondi o sui bit di permesso del registro — rappresentano estensioni future da aggiungere e non vengono attribuiti a questo catalogo di sei controprove. Sui moduli di autorizzazione e PonteAI documentati, l’abbinamento tra test sui casi limite e sabotaggi comportamentali impedisce che la suite diventi compiacente.

«La voce»: avvisi vocali di stato e rischio generati localmente sul dispositivo

Non ogni funzione di assistenza richiede modelli cloud. Quando si seguono più server contemporaneamente o serve un preavviso immediato su una soglia di rischio, CardinalHost offre avvisi vocali sintetici («La voce») nella lingua attiva dell’applicazione. La sintesi avviene interamente sul dispositivo locale: funziona offline, non richiede alcuna chiave IA e non trasmette alcun testo diagnostico a servizi vocali in cloud.

Domande frequenti (FAQ)

L’assistente IA di CardinalHost può eseguire autonomamente comandi shell sui miei server?

No. I modelli linguistici in CardinalHost non dispongono mai di accesso diretto alla shell. Nel gate degli strumenti IA solo tre strumenti di metadati operano in automatico; la lettura di file e i comandi shell di lettura, modifica o sconosciuti (classificati conservativamente come modifica) richiedono consenso umano esplicito, mentre gli strumenti IA sconosciuti e i comandi classificati come distruttivi vengono rifiutati. Separatamente, VerificatoreEnvelope controlla gli envelope firmati con 18 motivi tipizzati di rifiuto.

I dati diagnostici passano dai server di CodLab quando uso la diagnosi IA?

No. CardinalHost adotta il modello Bring Your Own Key (BYOK): la chiave API resta nel portachiavi del sistema operativo dell’utente senza alcun ricarico CodLab, non esiste alcun proxy IA centrale di CodLab e prima di ogni invio al fornitore scelto viene mostrata un’anteprima obbligatoria dei dati.

Come viene impedita la lettura silenziosa di file riservati tramite prompt injection?

Nel gate degli strumenti IA né leggi_file né i comandi shell di lettura tramite esegui_comando partono mai in automatico: entrambi i percorsi esigono per ogni chiamata il consenso umano esplicito (chiediConsenso). Soltanto leggi_file racchiude il percorso tra apici singoli con -- e limita il prelievo alla sorgente a 16 KiB tramite head -c 16384, mentre una chiamata esegui_comando approvata esegue il comando confermato senza tale limite alla sorgente; quando l’output ricevuto dallo strumento (su elenca_cartella, leggi_file o esegui_comando) supera 8.192 caratteri, limita conserva i primi 8.192 caratteri e aggiunge il marcatore da 11 caratteri …[troncato] (8.203 caratteri restituiti in totale su puro testo ASCII; poiché limita conta i caratteri Swift e non i byte, un testo UTF-8 con caratteri multibyte letto da leggi_file può comunque raggiungere tutti i 16 KiB della sorgente). Lo strumento leggi_file non impone una lista di blocco sui percorsi in lettura; le guardie canoniche realpath su ~/.ssh, file di avvio della shell e autostart si applicano separatamente alle operazioni di scrittura, rinomina e creazione cartella dell’agente.

La funzione di avviso vocale («La voce») richiede una chiave IA o una connessione internet?

No. Gli avvisi vocali sullo stato dei sistemi e sui livelli di rischio vengono sintetizzati localmente sul dispositivo nella lingua dell’applicazione, senza bisogno di chiavi IA e senza inviare testi a servizi cloud esterni.

Condividi questo articolo

Commenti

Nessun commento ancora. Sii il primo a commentare!

Lascia un commento

Non sarà pubblicata

Articoli Correlati

Hai un progetto in mente?

Sviluppiamo software personalizzato e soluzioni IA. Iniziamo insieme il tuo prossimo progetto.

Primo colloquio gratuito