Skip to content
KitploitKITPLOIT
OutilsExploitsBlog
Log in
Soumettre
OutilsExploitsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

FluxContactConfidentialité© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
foxguard — Un scanner de sécurité de code universel et rapide, écrit en Rust. Fonctionnalités incluses : prend en charge 14 langages, TUI pour le triage, secrets, audits post-quantiques, analyses différentielles et plus encore 𓃥 | Kitploit
Outils/GitHubGitHub/0sec-labs/foxguard
Analyse StatiqueScanners de VulnérabilitésOutils de Chiffrement/DéchiffrementAnalyse de CodeAudit de ConfigurationCryptographieDevSecOpsDétection de SecretsSécurité de la Chaîne LogistiqueApprentissage AutomatiqueMauvaise Configuration
2801545il y a 3 joursVérifié par Kitploit
GitHub0sec-labs/foxguard

foxguard

Un scanner de sécurité de code universel et rapide, écrit en Rust. Fonctionnalités incluses : prend en charge 14 langages, TUI pour le triage, secrets, audits post-quantiques, analyses différentielles et plus encore 𓃥

Voir le dépôtSite web

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →
Partager
<p align="center">
  <img src="https://raw.githubusercontent.com/0sec-labs/foxguard/main/www/public/foxguard-logo.png" width="128" alt="foxguard" />
</p>

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

<p align="center">
  <strong>Analyse de sécurité locale rapide pour le code, les secrets, les dépendances et les risques cryptographiques.</strong>
  <br />
  <sub>Intégré à <a href="https://github.com/0sec-labs/0sec">0sec</a>, le harnais open source de cybersécurité.</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>

## Pourquoi

- <img height="14" src="https://raw.githubusercontent.com/0sec-labs/.github/main/profile/assets/icons/checklist.png" alt="">&nbsp; Plus de 200 règles intégrées couvrant 12 langages sources, ainsi que des vérifications de configuration et de manifestes
- <img height="14" src="https://raw.githubusercontent.com/0sec-labs/.github/main/profile/assets/icons/git-branch.png" alt="">&nbsp; Suivi de teinte (taint tracking) pour 14 langages, avec analyse inter-fichiers pour Python, JavaScript, Go, Java, Ruby, PHP, C# et Kotlin
- <img height="14" src="https://raw.githubusercontent.com/0sec-labs/.github/main/profile/assets/icons/zap.png" alt="">&nbsp; Analyses locales et CI rapides, avec un mode diff pour « qu'a ajouté cette branche ? »
- <img height="14" src="https://raw.githubusercontent.com/0sec-labs/.github/main/profile/assets/icons/key.png" alt="">&nbsp; Détection de secrets, analyse des dépendances via OSV et audit cryptographique post-quantique
- <img height="14" src="https://raw.githubusercontent.com/0sec-labs/.github/main/profile/assets/icons/plug.png" alt="">&nbsp; Passerelle YAML compatible Semgrep/OpenGrep qui charge ~98 % du registre public ([rapport de couverture](https://github.com/0sec-labs/foxguard/blob/main/docs/parity/registry-coverage.md))
- <img height="14" src="https://raw.githubusercontent.com/0sec-labs/.github/main/profile/assets/icons/file-code.png" alt="">&nbsp; Sorties terminal, JSON, SARIF, CycloneDX 1.6 CBOM et JSON compatible Semgrep

## Installation

```sh
npx foxguard .                                      # sans installation
pipx install foxguard                               # CLI précompilée depuis PyPI
curl -fsSL https://foxguard.dev/install.sh | sh     # binaire précompilé (macOS/Linux)
cargo install foxguard                              # depuis les sources
```

Les installateurs de binaires autonomes vérifient les binaires des releases GitHub par rapport à `checksums.txt`. Les binaires de release publient également des attestations d'artefacts GitHub ; utilisez `gh attestation verify` pour une vérification manuelle, ou consultez [la provenance des releases](https://github.com/0sec-labs/foxguard/blob/main/docs/release-provenance.md).

Les wheels PyPI prennent en charge Python 3.9+ sur Linux glibc 2.28+ (x86_64/ARM64), macOS (Intel/Apple Silicon) et Windows x86_64. Dans un environnement virtuel Python existant, utilisez plutôt `python -m pip install foxguard`. Ces installations fournissent la CLI native sans compilateur Rust ni téléchargement de binaire à l'exécution ; aucune API Python n'est fournie. Les utilisateurs d'Alpine/musl doivent utiliser les binaires de release Linux autonomes.

**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.0
    hooks:
      - id: foxguard
```

Intégrations : [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) et [serveur MCP](https://github.com/0sec-labs/foxguard/blob/main/docs/mcp-server.md).

### Opérations hébergées de la GitHub App

`foxguard-github-app` écrit des journaux JSON délimités par des retours à la ligne. Les analyses terminées et échouées utilisent `event=foxguard.scan.completed` et `event=foxguard.scan.failed`, avec les champs de livraison, d'installation, de dépôt, de PR, de commit, de durée et `usage_scope` pour la corrélation. Conservez les identifiants comme champs de journal, et non comme étiquettes de métriques.

Définissez `FOXGUARD_INTERNAL_ACCOUNTS` sur une liste d' comptes et d'organisations GitHub qui vous appartiennent, séparés par des virgules. La correspondance est insensible à la casse. Les autres propriétaires sont classés comme `external` ; une liste non définie ou un propriétaire manquant produit `unknown`. L'activité externe ne prouve pas qu'il s'agit d'un client payant, et les analyses ne sont pas des personnes.

Le registre des installations est réconcilié avec toutes les pages de l'API d'installation de la GitHub App au démarrage et toutes les heures. Les rafraîchissements échoués conservent l'état existant ; les webhooks concurrents ont la priorité. Les métadonnées de webhook partielles préservent les détails de compte connus et les noms de dépôts observés. Ces noms ne constituent pas un inventaire complet des dépôts accessibles d'une installation.

Persistez `FOXGUARD_INSTALLATIONS_PATH` et `FOXGUARD_PULL_REQUEST_JOBS_PATH` sur un stockage durable. Surveillez `foxguard.installations.reconcile_failed` en parallèle des échecs d'analyse ; `foxguard.installations.reconciled` rapporte le total et les nombres d'installations internes/externes/inconnues après un rafraîchissement réussi. Dimensionnez `FOXGUARD_PR_WORKERS` en fonction de la mémoire de pointe mesurée du scanner et de la limite mémoire du conteneur : des processus enfants tués par OOM peuvent survenir sans redémarrer l'application hébergée.

## Démarrage rapide

```sh
foxguard .                              # tout analyser
foxguard diff main .                    # uniquement les nouveaux résultats par rapport à main
foxguard tui .                          # revue interactive dans le terminal
foxguard secrets .                      # identifiants et clés divulgués
foxguard sca .                          # vulnérabilités des dépendances via OSV
foxguard pqc .                          # audit cryptographique post-quantique
foxguard --format sarif . > results.sarif
foxguard --format semgrep-json .        # JSON compatible avec la CLI Semgrep
```

Utilisez `foxguard --fix src/` ou `foxguard --fix src/app.py` pour appliquer sur place les corrections de teinte prises en charge. Les cibles sont vérifiées par rapport au répertoire d'analyse canonique ou au fichier sélectionné ; les résultats hors de ce périmètre sont ignorés. Les corrections d'injection de commandes Python ajoutent `import subprocess` si nécessaire, en préservant les docstrings de module et les imports futurs. Relisez les modifications générées avant de les committer.

Les échecs de lecture de fichier, de métadonnées et de parcours de répertoire dans le scanner de code natif se terminent par le code `2` au lieu de produire un rapport réussi ou d'écraser une baseline. Les exclusions intentionnelles et les fichiers non pris en charge, binaires ou surdimensionnés restent ignorés ; inspectez les notifications de fichiers ignorés lors de la vérification de la couverture d'analyse.

## Revue dans le terminal

Lancez `foxguard tui .` et choisissez **Scan**, **Diff**, **Secrets** ou **PQC** avec les flèches ou Tab. En mode Diff, saisissez la branche cible avant d'appuyer sur Entrée. Les terminaux larges affichent les résultats à côté de leur détail ; les terminaux plus petits utilisent une liste avec une vue détaillée dépliable. Le contexte source, le flux de données et les corrections restent défilables lorsque le résultat les fournit.

L'en-tête sépare les statistiques d'analyse des catégories de baseline. Les plages source sélectionnées sont mises en évidence en ligne, sans lignes d'annotation supplémentaires. Les contrôles d'ouverture restent sous le volet de détail en direct pendant que son contenu défile, et les emplacements de fichiers raccourcis conservent leurs suffixes de ligne et de colonne. La recherche et les boîtes de dialogue possèdent leurs raccourcis lorsqu'elles sont actives.

Si le contexte source ne peut pas être chargé, l'extrait de résultat enregistré reste disponible. Les secrets utilisent des extraits masqués plutôt que de charger le code source brut dans le volet de détail.

La carte de chargement affiche une activité indéterminée et le temps écoulé réel, et non une estimation en pourcentage. Ctrl+C quitte pendant l'analyse.

| Touche | Action |
|-----|--------|
| `j` / `k`, flèches, Home / End | Se déplacer entre les résultats |
| `v` | Déplier le détail ou revenir à la liste/vue partagée |
| PageUp / PageDown | Paginer la liste, ou faire défiler le détail visible |
| `/`, Entrée | Modifier et appliquer une recherche |
| Ctrl+U | Effacer la recherche en cours d'édition |
| Échap | Fermer une modale, annuler les modifications de recherche, quitter le détail déplié ou effacer les filtres appliqués |
| `0`–`4`, `c`, Shift+C | Sévérité minimale, seuil de confiance et ordre de tri |
| `f` | Parcourir Tout → Non revu → À faire → Revu → Ignorer |
| `i` | Prévisualiser et appliquer les actions de triage |
| Espace, `a`, `x` | Cocher un résultat, basculer les sélections visibles et prévisualiser une action par lot |
| Shift+F | Enregistrer, charger, remplacer ou supprimer des filtres nommés ; récupérer le stockage de revue |
| `b` | Parcourir les catégories de baseline lorsqu'une comparaison est disponible |
| Tab, Entrée / `o` | Choisir finding/source/sink et l'ouvrir dans votre éditeur |
| `w`, `[` / `]` | Afficher les notifications et faire défiler leur historique ; les plus récentes apparaissent en premier |
| `e` | Exporter en CBOM, JSON ou SARIF |
| `?`, `q` / Ctrl+C | Aide et quitter ; Ctrl+C fonctionne aussi dans chaque modale |

Entrée et `o` utilisent un `$VISUAL` non vide, puis `$EDITOR`. Sans l'un ou l'autre, foxguard cherche `nvim`, `vim`, `nano` ou `vi` dans le `PATH` avant d'envisager un ouvreur de bureau disponible. Les terminaux sans affichage ne nécessitent pas `xdg-open`.
Par exemple, lancez `VISUAL="nvim" foxguard tui .` ou définissez `EDITOR='code --wait'`. Un paramètre d'éditeur explicite défectueux est signalé plutôt que silencieusement remplacé ; si aucun éditeur n'est disponible, la TUI reste ouverte avec des conseils de configuration. Les éditeurs pris en charge sautent à la ligne du finding/source/sink sélectionné.

Les marques de revue persistent automatiquement dans un stockage par utilisateur, limité à la racine de projet canonique et au mode d'analyse (y compris la cible en mode Diff). Les filtres nommés restaurent la recherche, la sévérité, la confiance, le statut de revue, le tri et la catégorie de baseline lorsqu'ils sont chargés avec Shift+F. Ils ne modifient pas la configuration d'analyse du dépôt.
La liste affiche les résultats visibles/totaux et la progression de la revue ; changer les filtres ou le tri conserve le même résultat sélectionné tant qu'il reste visible. L'annulation des modifications de recherche restaure la requête précédemment appliquée.

Les résultats cochés survivent aux changements de filtres. `x` ouvre les actions par lot ; Entrée affiche les cibles exactes, le nombre de sélections masquées, la destination et la portée de l'effet. Seul `y` applique l'aperçu ; appuyer à nouveau sur Entrée ne le confirme pas, et Échap annule sans écrire. Les actions de baseline ajoutent des empreintes exactes. Les actions de configuration règle/fichier et à l'échelle du projet peuvent aussi affecter des résultats non sélectionnés, comme l'avertit l'aperçu. Si une cible de configuration échoue, les écritures réussies sont conservées et les résultats sont rapportés ; le lot n'est pas une transaction.

Le stockage utilise `$XDG_STATE_HOME/foxguard/tui` (ou `~/.local/state/foxguard/tui`) sous Linux, Application Support sous macOS, et `%LOCALAPPDATA%` sous Windows. Les écritures atomiques et les vérifications de révision empêchent un terminal d'écraser silencieusement un autre. Les erreurs de stockage laissent les modifications locales visiblement **NON ENREGISTRÉES**. Dans Shift+F, `w` réessaie l'enregistrement, `r` recharge explicitement depuis le disque, et Shift+R confirme une sauvegarde-et-réinitialisation du projet/mode courant. Le rechargement/la réinitialisation peut supprimer des modifications non enregistrées ; la réinitialisation préserve les octets précédents sur disque, pas les marques non enregistrées. Le stockage de revue contient des empreintes et des paramètres de filtre, pas de code source.

Les exports incluent les résultats de l'analyse en cours, pas seulement les lignes filtrées visibles, et sont écrits dans le répertoire de travail courant. Les fichiers réguliers existants nécessitent une confirmation explicite par `y` ; Échap annule. Les écritures sont atomiques et les liens symboliques de destination, y compris les liens cassés, sont rejetés.

Utilisez `foxguard tui --baseline .foxguard/baseline.json .` pour revoir une comparaison de baseline enregistrée. Contrairement à la suppression en CLI, la revue dans le terminal conserve les résultats actuels et sépare les entrées **introduites**, **récurrentes** et **résolues**. Résolu signifie absent de la sortie de l'analyse en cours, et non remédiation vérifiée : comparez une portée, des règles et des seuils équivalents. L'identité de baseline inclut le fichier et l'emplacement source, donc déplacer un résultat peut apparaître comme introduit plus résolu. Les lignes résolues sont des métadonnées historiques en lecture seule ; seule la recherche s'applique, et `v` déplie leurs détails défilables. Revenez à une catégorie de résultats actuels pour trier ou exporter l'analyse en cours.
Git Diff reste une comparaison distincte par rapport à une branche.

## Couverture des langages

| Langage | Règles intégrées | Suivi de teinte | Règles conscientes du framework |
|----------|:-:|:-:|---|
| JavaScript / TypeScript | Oui | Oui | Express, Next.js |
| Python | Oui | Oui | Django, Flask, FastAPI |
| Go | Oui | Oui | Gin |
| Kotlin | Oui | Oui | Spring |
| Java | Oui | Oui | Spring |
| Ruby | Oui | Oui | Rails |
| PHP | Oui | Oui | Laravel |
| Rust | Oui | -- | -- |
| C# | Oui | Oui | .NET |
| Swift | Oui | Oui | iOS |
| Haskell | Oui | -- | Règles de seed Cardano |

Le suivi de teinte couvre également C, Bash et Solidity. Les analyses de configuration, de manifestes et de règles externes couvrent Dockerfile, Nginx, Apache, HAProxy, HCL/Terraform, YAML/JSON/XML/HTML, C via Semgrep YAML/Coccinelle, et plus encore.

## Modes de sécurité

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

SCA prend en charge `Cargo.lock`, `package-lock.json`, `pnpm-lock.yaml`, `requirements.txt`, `poetry.lock` et `Pipfile.lock`. L'audit PQC est une carte de score à deux volets : il signale les primitives vulnérables au quantique (RSA, ECDSA/DSA, ECDH/DH) avec les échéances de migration CNSA 2.0, et il détecte aussi les algorithmes post-quantiques déjà utilisés (ML-KEM, ML-DSA, SLH-DSA, FN-DSA, HQC et hybrides comme X25519MLKEM768) comme inventaire informatif résistant au quantique — rapportant un pourcentage de préparation à la migration. Les deux volets s'exportent en CycloneDX 1.6 CBOM, où les algorithmes post-quantiques apparaissent comme des actifs résistants au quantique plutôt que comme des vulnérabilités.

## Configuration

foxguard découvre automatiquement `.foxguard.yml` depuis le chemin d'analyse vers le haut.

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

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

Supprimez un résultat accepté en ligne avec `// foxguard: ignore[rule-id]`.

## Documentation

Commencez par l'[index de la documentation](https://github.com/0sec-labs/foxguard/blob/main/docs/README.md). Références clés : [architecture](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) et le [runbook de release](https://github.com/0sec-labs/foxguard/blob/main/docs/releasing.md).

## Benchmarks

| Dépôt | LoC | foxguard | Semgrep | Accélération |
|------|-----|----------|---------|---------|
| 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** |

Reproduisez avec `./benchmarks/run.sh` ; les résultats varient selon la machine. Voir [`benchmarks/README.md`](https://github.com/0sec-labs/foxguard/blob/main/benchmarks/README.md).

## Contribution

Voir [`CONTRIBUTING.md`](https://github.com/0sec-labs/foxguard/blob/main/CONTRIBUTING.md) pour l'écriture de règles, les tests et la configuration de développement.

## Licence

MIT OR Apache-2.0 -- [0sec Labs](https://0sec.ai)
Télécharger l’outil