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
foxguard — Uno scanner di sicurezza del codice universale e veloce, scritto in Rust. Batterie incluse: supporta 14 linguaggi, TUI per triage, segreti, audit post-quantistici, scansioni differenziali e altro ancora 𓃥 | Kitploit
Strumenti/GitHubGitHub/0sec-labs/foxguard
Analisi StaticaScanner di VulnerabilitàStrumenti di Crittografia/DecrittografiaAnalisi del CodiceAudit di ConfigurazioneCrittografiaDevSecOpsRilevamento SegretiSicurezza della Supply ChainMachine LearningConfigurazione Errata
28015934 giorni faRevisionato da Kitploit
GitHub0sec-labs/foxguard

foxguard

Uno scanner di sicurezza del codice universale e veloce, scritto in Rust. Batterie incluse: supporta 14 linguaggi, TUI per triage, segreti, audit post-quantistici, scansioni differenziali e altro ancora 𓃥

Vedi RepositorySito web
Condividi
<p align="center">
  <a href="https://0.security">
    <picture>
      <source media="(prefers-color-scheme: dark)" srcset="www/public/foxguard-lockup-dark.png" />
      <img src="https://assets.kitploit.com/production/public/readmes/13909/3f66c74029caa7a2efde8f7a9482abef5e1c55facd78b73398dc5278f0434a39/4950de8de858d12778f4b297af5760c2b1a48ed4fc04db20e24367b174a1c21b-display-v1.webp" width="460" alt="foxguard by 0security" />
    </picture>
  </a>
</p>

<h1 align="center">foxguard</h1>

<p align="center">
  <strong>Scansione di sicurezza locale e veloce per codice, segreti, dipendenze e rischio crittografico.</strong>
  <br />
  <sub>Integrato in <a href="https://github.com/0sec-labs/0sec">0sec</a>, l'harness open per la cybersecurity.</sub>
</p>

<p align="center">
  <a href="https://github.com/0sec-labs/foxguard/actions/workflows/ci.yml"><img src="https://github.com/0sec-labs/foxguard/actions/workflows/ci.yml/badge.svg" alt="CI" /></a>
  <a href="https://github.com/0sec-labs/foxguard"><img src="https://img.shields.io/badge/foxguard-clean-3fb950" alt="foxguard: clean" /></a>
  <a href="https://crates.io/crates/foxguard"><img src="https://img.shields.io/crates/v/foxguard?color=d97706&amp;label=crates.io" alt="crates.io" /></a>
  <a href="https://www.npmjs.com/package/foxguard"><img src="https://img.shields.io/npm/v/foxguard?color=d97706&amp;label=npm" alt="npm" /></a>
  <a href="https://pypi.org/project/foxguard/"><img src="https://img.shields.io/pypi/v/foxguard?color=d97706&amp;label=PyPI" alt="PyPI" /></a>
  <a href="https://github.com/apps/foxguard-app/installations/new"><img src="https://img.shields.io/badge/GitHub_App-Install-2ea44f?logo=github" alt="Install GitHub App" /></a>
</p>

```sh
npx foxguard .
```

<p align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/13909/2ce579a58299a47cd3e965f13b97bf1c5dcaf020496d4a4eb2141d414ff7bd0c.gif" alt="foxguard scan demo" width="640" />
</p>

## Perché

- <img height="14" src="https://assets.kitploit.com/production/public/readmes/13909/2f74ecece5385bc98563839387fc2cc007c6ec3fe2818ba49df610dfcb0d6873/1b55ff58c9c0484fa5c54437e97d01092e3c2e94391642b49d9b8d714d76d891-display-v1.webp" alt="">&nbsp; Oltre 200 regole integrate per 12 linguaggi sorgente, più controlli su configurazioni e manifest
- <img height="14" src="https://assets.kitploit.com/production/public/readmes/13909/3a4cd9b7803d825b45adaa38e01636f9a7d36d3b0803a6465fc08cc21c17614f/a1fc0ee6309d094c6019c10ecbc279df5071df641cd5e7f00d75c7bf83b89ceb-display-v1.webp" alt="">&nbsp; Taint tracking per 14 linguaggi, con analisi cross-file per Python, JavaScript, Go, Java, Ruby, PHP, C# e Kotlin
- <img height="14" src="https://assets.kitploit.com/production/public/readmes/13909/d25483b85f41bce1890cee6119a3efae621f86cfb979425ff6af3f12065bd801/f5b34ed29e4a7fe413e269293e0518488d27decb4110c8ebc34b12d0bb0d2783-display-v1.webp" alt="">&nbsp; Scansioni locali e CI veloci, con modalità diff per “cosa ha aggiunto questo branch?”
- <img height="14" src="https://assets.kitploit.com/production/public/readmes/13909/e6dfbb684eb09e9e54aa16991becf71604a394b8b2283abf831d2f5d69f445b9/c23135d81f4b5a044749a2b59c5c221cd03441e9bfc29f30a6f299f0711384d3-display-v1.webp" alt="">&nbsp; Scansione dei segreti, scansione delle dipendenze basata su OSV e audit crittografico post-quantum
- <img height="14" src="https://assets.kitploit.com/production/public/readmes/13909/7acd6ee45c06a20346672e4176a9e781d5c8a26f538e2b215b8742bf49daf75b/10d05ad06116cc455d9a363e5552332d006cb703f0b1bcc24bcc51f2310c046d-display-v1.webp" alt="">&nbsp; Bridge YAML compatibile con Semgrep/OpenGrep che carica circa il 98% del registry pubblico ([report di copertura](https://github.com/0sec-labs/foxguard/blob/main/docs/parity/registry-coverage.md))
- <img height="14" src="https://assets.kitploit.com/production/public/readmes/13909/d83dd1d52375e4c855d852c7156a668807d90eeafb4867400d4c78bee7884044/8e75dffc14273864f84471e6a8e8af393ad64c64bffcc6f70df0e45c1e4dce54-display-v1.webp" alt="">&nbsp; Output per terminale, JSON, SARIF, CycloneDX 1.6 CBOM e JSON compatibile con Semgrep

## Installazione

```sh
npx foxguard .                                      # zero install
pipx install foxguard                               # prebuilt CLI from PyPI
curl -fsSL https://foxguard.dev/install.sh | sh     # prebuilt binary (macOS/Linux)
cargo install foxguard                              # from source
```

Gli installer binari standalone verificano i binari delle release GitHub rispetto a `checksums.txt`. I binari delle release pubblicano anche le attestazioni degli artefatti GitHub; usa `gh attestation verify` per la verifica manuale, oppure consulta [release provenance](https://github.com/0sec-labs/foxguard/blob/main/docs/release-provenance.md).

I wheel PyPI supportano Python 3.9+ su Linux glibc 2.28+ (x86_64/ARM64), macOS
(Intel/Apple Silicon) e Windows x86_64. In un ambiente virtuale Python esistente,
usa invece `python -m pip install foxguard`. Questi installano la CLI nativa
senza un compilatore Rust o un download del binario a runtime; non è
fornita alcuna API Python. Gli utenti Alpine/musl dovrebbero usare i binari standalone delle release Linux.

**GitHub Action:**

```yaml
- uses: 0sec-labs/foxguard/[email protected]
  with:
    path: .
    severity: medium
    fail-on-findings: "true"
    upload-sarif: "true"
```

**pre-commit:**

```yaml
repos:
  - repo: https://github.com/0sec-labs/foxguard
    rev: v0.14.2
    hooks:
      - id: foxguard
```

Integrazioni: [GitHub App](https://github.com/apps/foxguard-app/installations/new), [VS Code](https://marketplace.visualstudio.com/items?itemName=peaktwilight.foxguard), [plugin Claude Code](https://github.com/0sec-labs/foxguard/blob/main/docs/claude-code-integration.md) e [server MCP](https://github.com/0sec-labs/foxguard/blob/main/docs/mcp-server.md).

### Operazioni dell'app GitHub ospitata

`foxguard-github-app` scrive log JSON delimitati da newline. Le scansioni completate e fallite utilizzano `event=foxguard.scan.completed` e `event=foxguard.scan.failed`, con campi delivery, installation, repository, PR, commit, duration e `usage_scope` per la correlazione. Mantieni gli identificatori come campi di log, non come etichette di metrica.

Imposta `FOXGUARD_INTERNAL_ACCOUNTS` su un elenco separato da virgole dei tuoi account e organizzazioni GitHub. La corrispondenza non distingue maiuscole e minuscole. Gli altri proprietari sono classificati come `external`; un elenco non impostato o un proprietario mancante produce `unknown`. L'attività esterna non è prova di un cliente pagante, e le scansioni non sono persone.

Il registro delle installazioni viene riconciliato rispetto a tutte le pagine dell'API delle installazioni dell'App di GitHub all'avvio e ogni ora. I refresh falliti mantengono lo stato esistente; i webhook concorrenti hanno la precedenza. I metadati sparsi dei webhook preservano i dettagli noti dell'account e i nomi dei repository osservati. Quei nomi non costituiscono un inventario completo dei repository accessibili di un'installazione.

Persisti `FOXGUARD_INSTALLATIONS_PATH` e `FOXGUARD_PULL_REQUEST_JOBS_PATH` su storage durevole. Monitora `foxguard.installations.reconcile_failed` insieme ai fallimenti delle scansioni; `foxguard.installations.reconciled` riporta il totale e i conteggi delle installazioni interne/esterne/sconosciute dopo un refresh riuscito. Dimensiona `FOXGUARD_PR_WORKERS` in base alla memoria di picco misurata dello scanner e al limite di memoria del container: le terminazioni OOM dei processi figli possono verificarsi senza riavviare l'applicazione ospitata.

## Avvio rapido

```sh
foxguard .                              # scan everything
foxguard diff main .                    # only new findings vs main
foxguard tui .                          # interactive terminal review
foxguard secrets .                      # leaked credentials and keys
foxguard sca .                          # dependency vulnerabilities from OSV
foxguard pqc .                          # post-quantum crypto audit
foxguard --format sarif . > results.sarif
foxguard --format semgrep-json .        # Semgrep CLI-compatible JSON
```

Usa `foxguard --fix src/` o `foxguard --fix src/app.py` per applicare sul posto le correzioni di taint supportate. Le destinazioni vengono verificate rispetto alla directory di scansione canonica o al file selezionato; i risultati al di fuori di tale ambito vengono saltati. Le correzioni di command-injection Python aggiungono `import subprocess` quando necessario, preservando le docstring del modulo e gli import futuri. Rivedi le modifiche generate prima di eseguire il commit.

I fallimenti di lettura file, metadati e directory-traversal nello scanner di codice nativo terminano con `2` invece di produrre un report riuscito o sovrascrivere una baseline. Le esclusioni intenzionali e i file non supportati, binari o di dimensioni eccessive rimangono salti; ispeziona gli avvisi sui file saltati quando verifichi la copertura della scansione.

## Revisione nel Terminale

Esegui `foxguard tui .` e scegli **Scan**, **Diff**, **Secrets** o **PQC** con le frecce o Tab. In modalità Diff, digita il branch di destinazione prima di premere Enter. I terminali larghi mostrano i risultati accanto ai loro dettagli; i terminali più piccoli usano un elenco con una vista dettagliata espandibile. Il contesto del sorgente, il dataflow e le correzioni rimangono scorrevoli ogni volta che il risultato li fornisce.

L'intestazione separa le statistiche di scansione dalle categorie della baseline. Gli intervalli di sorgente selezionati sono evidenziati inline, senza righe di annotazione aggiuntive. I controlli di apertura restano sotto il pannello dei dettagli live mentre il suo contenuto scorre, e le posizioni dei file abbreviate mantengono i loro suffissi di riga e colonna. La ricerca e le finestre di dialogo possiedono le proprie scorciatoie mentre sono attive.

Se il contesto del sorgente non può essere caricato, lo snippet del risultato salvato rimane disponibile. I segreti usano snippet redatti invece di caricare il sorgente grezzo nel pannello dei dettagli.

La scheda di caricamento mostra attività indeterminata e il tempo effettivo trascorso, non una stima percentuale. Ctrl+C esce durante la scansione.

| Tasto | Azione |
|-----|--------|
| `j` / `k`, frecce, Home / End | Sposta tra i risultati |
| `v` | Espandi i dettagli o torna alla vista elenco/divisa |
| PageUp / PageDown | Scorri l'elenco a pagine, o scorri i dettagli visibili |
| `/`, Enter | Modifica e applica una ricerca |
| Ctrl+U | Cancella la ricerca in fase di modifica |
| Esc | Chiudi un modale, annulla le modifiche alla ricerca, esci dai dettagli espansi o cancella i filtri applicati |
| `0`–`4`, `c`, Shift+C | Severità minima, soglia di confidenza e ordinamento |
| `f` | Cicla All → Unreviewed → Todo → Reviewed → Ignore |
| `i` | Anteprima e applica le azioni di triage |
| Space, `a`, `x` | Seleziona un risultato, attiva/disattiva le selezioni visibili e visualizza l'anteprima di un'azione batch |
| Shift+F | Salva, carica, sostituisci o elimina filtri con nome; recupera l'archivio di revisione |
| `b` | Cicla le categorie della baseline quando è disponibile un confronto |
| Tab, Enter / `o` | Scegli finding/source/sink e aprilo nel tuo editor |
| `w`, `[` / `]` | Mostra gli avvisi e scorri la loro cronologia; gli avvisi più recenti appaiono per primi |
| `e` | Esporta CBOM, JSON o SARIF |
| `?`, `q` / Ctrl+C | Aiuto ed esci; Ctrl+C funziona anche all'interno di ogni modale |

Enter e `o` usano un `$VISUAL` non vuoto, poi `$EDITOR`. Senza nessuna delle due impostazioni, foxguard cerca `nvim`, `vim`, `nano` o `vi` nel `PATH` prima di considerare un opener desktop disponibile. I terminali headless non richiedono `xdg-open`.
Ad esempio, esegui `VISUAL="nvim" foxguard tui .` o imposta
`EDITOR='code --wait'`. Un'impostazione esplicita dell'editor non funzionante viene segnalata invece di essere sostituita silenziosamente; se nessun editor è disponibile, la TUI rimane aperta con le indicazioni di configurazione. Gli editor supportati saltano alla riga del finding/source/sink selezionato.

I contrassegni di revisione persistono automaticamente nell'archivio per utente, con ambito sulla radice canonica del progetto e sulla modalità di scansione (inclusa la destinazione in modalità Diff). I filtri con nome ripristinano ricerca, severità, confidenza, stato di revisione, ordinamento e categoria della baseline quando caricati con Shift+F. Non modificano la configurazione di scansione del repository.
L'elenco mostra i risultati visibili/totali e l'avanzamento della revisione; cambiare filtri o ordinamento mantiene selezionato lo stesso risultato quando rimane visibile. Annullare le modifiche alla ricerca ripristina la query precedentemente applicata.

I risultati selezionati sopravvivono ai cambiamenti dei filtri. `x` apre le azioni in batch; Invio mostra i
target esatti, il conteggio della selezione nascosta, la destinazione e l'ambito di effetto. Solo `y`
applica l'anteprima; Invio di nuovo non la conferma, ed Esc annulla senza
scrivere. Le azioni di baseline aggiungono fingerprint esatti. Le azioni di configurazione a livello di regola/file e di progetto possono anche influire su risultati non selezionati, come avverte l'anteprima.
Se un target di configurazione fallisce, le scritture riuscite rimangono e gli esiti vengono
riportati; il batch non è una transazione.

L'archiviazione utilizza `$XDG_STATE_HOME/foxguard/tui` (o
`~/.local/state/foxguard/tui`) su Linux, Application Support su macOS, e
`%LOCALAPPDATA%` su Windows. Le scritture atomiche e i controlli di revisione impediscono a un terminale
di sovrascrivere silenziosamente un altro. Gli errori di archiviazione lasciano le modifiche locali visibilmente
**UNSAVED**. In Shift+F, `w` ritenta il salvataggio, `r` ricarica esplicitamente dal disco, e
Shift+R conferma un backup-and-reset del progetto/modalità corrente. Il ricaricamento/reset può
scartare modifiche non salvate; il reset preserva i byte precedenti su disco, non i
marcatori non salvati. L'archiviazione di revisione contiene fingerprint e impostazioni dei filtri, non il codice sorgente.

Le esportazioni includono i risultati della scansione corrente, non solo le righe filtrate visibili,
e vengono scritte nella directory di lavoro corrente. I file regolari esistenti richiedono
una conferma esplicita con `y`; Esc annulla. Le scritture sono atomiche e i symlink di destinazione, inclusi i link pendenti, vengono rifiutati.

Usa `foxguard tui --baseline .foxguard/baseline.json .` per rivedere un confronto
con baseline salvata. A differenza della soppressione CLI, la revisione da terminale conserva i risultati correnti
e separa le voci **introdotte**, **ricorrenti** e **risolte**.
Risolte significa assenti dall'output della scansione corrente, non remediation verificata:
confronta ambito, regole e soglie equivalenti. L'identità della baseline include il
file e la posizione sorgente, quindi spostare un risultato può apparire come introdotto più
risolto. Le righe risolte sono metadati storici di sola lettura; si applica solo la ricerca,
e `v` espande i loro dettagli scorrevoli. Torna a una categoria di risultati correnti
per fare triage o esportare la scansione corrente.
Git Diff rimane un confronto separato rispetto a un branch.

## Copertura linguistica

| Linguaggio | Regole integrate | Taint tracking | Regole framework-aware |
|----------|:-:|:-:|---|
| JavaScript / TypeScript | Sì | Sì | Express, Next.js |
| Python | Sì | Sì | Django, Flask, FastAPI |
| Go | Sì | Sì | Gin |
| Kotlin | Sì | Sì | Spring |
| Java | Sì | Sì | Spring |
| Ruby | Sì | Sì | Rails |
| PHP | Sì | Sì | Laravel |
| Rust | Sì | -- | -- |
| C# | Sì | Sì | .NET |
| Swift | Sì | Sì | iOS |
| Haskell | Sì | -- | Regole seed Cardano |

Il taint tracking copre anche C, Bash e Solidity. Le scansioni di configurazione, manifest e regole esterne coprono Dockerfile, Nginx, Apache, HAProxy, HCL/Terraform, YAML/JSON/XML/HTML, C tramite Semgrep YAML/Coccinelle e altro ancora.

## Modalità di sicurezza

```sh
foxguard sca .
foxguard pqc .
foxguard --rules ./semgrep-rules .
```

SCA supporta `Cargo.lock`, `package-lock.json`, `pnpm-lock.yaml`, `requirements.txt`, `poetry.lock` e `Pipfile.lock`. L'audit PQC è un scorecard a due facce: segnala le primitive vulnerabili ai quantum (RSA, ECDSA/DSA, ECDH/DH) con le scadenze di migrazione CNSA 2.0, e rileva anche gli algoritmi post-quantum già in uso (ML-KEM, ML-DSA, SLH-DSA, FN-DSA, HQC e ibridi come X25519MLKEM768) come inventario informativo, resistente ai quantum — riportando una percentuale di prontezza alla migrazione. Entrambe le parti esportano in un CBOM CycloneDX 1.6, dove gli algoritmi post-quantum appaiono come asset resistenti ai quantum anziché come vulnerabilità.

## Configurazione

foxguard individua automaticamente `.foxguard.yml` dal percorso di scansione verso l'alto.

```yaml
scan:
  baseline: .foxguard/baseline.json
  disable_rules: [py/no-eval]

secrets:
  exclude_paths: [fixtures, testdata]
```

Sopprimi un risultato accettato inline con `// foxguard: ignore[rule-id]`.

## Documentazione

Inizia con l'[indice della documentazione](https://github.com/0sec-labs/foxguard/blob/main/docs/README.md). Riferimenti chiave: [architettura](https://github.com/0sec-labs/foxguard/blob/main/docs/architecture.md), [compatibilità Semgrep/OpenGrep](https://github.com/0sec-labs/foxguard/blob/main/docs/compatibility.md) e il [runbook di rilascio](https://github.com/0sec-labs/foxguard/blob/main/docs/releasing.md).

## Benchmark

| Repo | LoC | foxguard | Semgrep | Speedup |
|------|-----|----------|---------|---------|
| express | 15K JS | 0.28s | 6.09s | **22x** |
| flask | 14K Py | 0.33s | 6.51s | **20x** |
| gin | 18K Go | 0.50s | 4.95s | **10x** |
| sentry | 1.3M Py | 35s | 194s | **5x** |

Riproduci con `./benchmarks/run.sh`; i risultati variano da macchina a macchina. Vedi [`benchmarks/README.md`](https://github.com/0sec-labs/foxguard/blob/main/benchmarks/README.md).

## Contribuire

Vedi [`CONTRIBUTING.md`](https://github.com/0sec-labs/foxguard/blob/main/CONTRIBUTING.md) per la scrittura delle regole, i test e la configurazione dell'ambiente di sviluppo.

## Licenza

MIT OR Apache-2.0 -- [0sec Labs](https://0.security)
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.

    837
  • 2

    ghostlock-app

    yukonga/ghostlock-app

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

    536
  • 3

    ARTEX

    baarai/artex

    Piattaforma di penetration testing autonoma multi-agente basata su LLM con agenti planner/worker, grafi di asset e di esplorazione, registrazione del traffico MITM e retesting delle vulnerabilità.

    424
  • 4

    redforge

    cybersecurity91/redforge

    Toolkit red team lato browser con 102 strumenti offline per ricognizione, generazione di payload, attacchi alle credenziali, crittografia, codifica e reportistica dell'engagement.

    355
  • 5

    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.

    294
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    Il sistema d'azione per la cybersecurity nativa AI—dove l'intento diventa esecuzione governata, le evidenze diventano memoria operativa, e ogni operazione migliora la successiva.

    276

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →