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
keyhog — Scanner de secrets open source en Rust | Kitploit
Outils/GitHubGitHub/santhreal/keyhog
Analyse StatiqueScanners de VulnérabilitésSécurité des ConteneursAnalyse de CodeAudit de ConfigurationSécurité CloudDevSecOpsDétection de SecretsRenseignement sur les MenacesSécurité de la Chaîne LogistiqueRéponse aux Incidents
881358il y a 6 joursVérifié par Kitploit
GitHubsanthreal/keyhog

keyhog

Scanner de secrets open source en Rust

Voir le dépôtSite web
Partager
<p align="center">
  <img src="https://raw.githubusercontent.com/santhreal/keyhog/HEAD/docs/assets/keyhog-banner.svg" alt="KeyHog GPU-accelerated open-source secret scanner for code, Git history, cloud, containers, browser assets, and CI" width="960" />
</p>

<p align="center">
  <a href="https://crates.io/crates/keyhog"><img src="https://img.shields.io/crates/v/keyhog?style=flat-square&amp;color=ffd60a&amp;label=crates.io&amp;labelColor=0a0a0a" alt="KeyHog on crates.io" /></a>&nbsp;
  <a href="https://santhreal.github.io/keyhog/"><img src="https://img.shields.io/badge/docs-KeyHog-ffd60a?style=flat-square&amp;labelColor=0a0a0a" alt="KeyHog documentation" /></a>&nbsp;
  <a href="https://github.com/santhreal/keyhog/actions"><img src="https://img.shields.io/github/actions/workflow/status/santhreal/keyhog/ci.yml?style=flat-square&amp;label=CI&amp;labelColor=0a0a0a" alt="CI" /></a>&nbsp;
  <a href="https://github.com/santhreal/keyhog/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-MIT%20OR%20Apache--2.0-9aa0b4?style=flat-square&amp;labelColor=0a0a0a" alt="MIT OR Apache-2.0" /></a>&nbsp;
  <a href="https://github.com/santhreal/keyhog/blob/main/metrics/stars.svg"><img src="https://img.shields.io/github/stars/santhreal/keyhog?style=flat-square&amp;color=ffd60a&amp;label=stars&amp;labelColor=0a0a0a" alt="GitHub stars and repository-owned star history" /></a>
</p>

<p align="center">
  <strong><a href="https://santh.dev/keyhog/">Site web</a></strong> ·
  <strong><a href="https://santhreal.github.io/keyhog/">Documentation</a></strong> ·
  <strong><a href="https://santh.dev/blog/keyhog/">Architecture</a></strong> ·
  <strong><a href="https://github.com/santhreal/vyre">Moteur GPU Vyre</a></strong>
</p>

# KeyHog : scanner de secrets accéléré par GPU pour le code, le cloud et les CI

**KeyHog est un scanner de secrets open source en Rust qui détecte et vérifie les
clés API, jetons, mots de passe et identifiants divulgués dans le code source,
l'historique Git, les conteneurs, le stockage cloud, les actifs de navigateur,
le contenu collaboratif et les systèmes en cours d'exécution.**

La plupart des scanners de secrets s'arrêtent aux correspondances regex CPU dans
une copie de dépôt. KeyHog combine **934 détecteurs spécifiques à chaque service**,
le décodage des identifiants dissimulés, les preuves contextuelles et la
suppression, la vérification en direct auprès des fournisseurs, et une exécution
de premier ordre **CUDA, Metal et WGPU via
[Vyre](https://github.com/santhreal/vyre)**. La calibration mesure chaque backend
CPU purement Rust éligible, Hyperscan/SIMD et GPU. Le routage automatique utilise
ensuite la route la plus rapide prouvée par parité pour l'hôte et la classe de
charge de travail exacts.

| Le GPU est un vrai backend | Analysez la surface d'attaque réelle | Séparez le signal du bruit | Agissez sur le résultat |
|---|---|---|---|
| CUDA, Metal natif et WGPU sont des pairs mesurés, pas une chaîne de repli silencieuse. | Analysez l'historique Git, les couches Docker, les archives, les buckets cloud, les source maps, WASM, les captures HAR, les collections Git hébergées et des systèmes entiers. | Décodez base64, hex, URL, protobuf, multiligne et la configuration structurée avant d'appliquer les preuves, la suppression d'exemples et les lignes de base. | Vérifiez les identifiants éligibles avec les API des fournisseurs, émettez des enveloppes SARIF ou structurées, et préservez la couverture exacte et la sémantique de sortie. |```sh
cargo install --locked keyhog
keyhog scan .
```
<p align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/7654/dfb768a9b8e8fa64082992f11d0b284d5ec6a199fc1eac85e0352fb20452186f.gif" alt="Analyse KeyHog montrant la sévérité, les preuves, le fichier et la ligne, la remédiation, les résultats et l'état de couverture" width="900" />
</p>

## Un scanner de secrets conçu autour du GPU

KeyHog ne confie pas quelques expressions régulières à un compute shader générique.
Son chemin GPU repose sur [Vyre](https://github.com/santhreal/vyre), un substrat
de calcul GPU en Rust développé en parallèle de KeyHog. Les déclencheurs de détection
sont compilés en tables immuables résidant sur le GPU. Des lots de sources bornés
produisent des positions de correspondance complètes pour le même pipeline de
confirmation, de suppression, de preuve et de rapport utilisé par les routes CPU et Hyperscan.

- **Troix pairs GPU physiques.** CUDA, Metal natif et WGPU portable sont
  acquis, mesurés et rapportés indépendamment.
- **Parité exacte des résultats.** La calibration rejette un candidat dont
  l'identité de résultat diffère de la route de référence. Une réponse erronée plus rapide
  n'entre jamais dans la table de routage.
- **Preuve de route persistante.** KeyHog enregistre le binaire, le corpus de détecteurs,
  la configuration, la classe de charge de travail, l'hôte, l'accélérateur, le pilote et les
  preuves de timing mesurées. Les analyses normales ne benchmarkent pas dans le chemin critique.
- **Exécution résidente.** Les workers du démon maintiennent les détecteurs compilés et l'état
  de l'accélérateur à chaud pour les lots répétés de fichiers, d'archives, d'historique, distants et cloud.
- **Aucune échappatoire CPU cachée.** Un accélérateur explicitement sélectionné qui ne peut pas
  s'initialiser ou se répartir échoue de manière visible au lieu de renvoyer des résultats CPU sous
  une étiquette GPU.

L'installation par défaut via crates.io utilise la route CPU pure-Rust portable afin de fonctionner
sur un hôte Rust propre. Activez les trois pairs GPU sans acquérir Hyperscan :```sh
cargo install --locked keyhog --no-default-features --features portable,gpu
```
Activez le pair regex SIMD Hyperscan ou Vectorscan :```sh
cargo install --locked keyhog --no-default-features --features portable,simd
```
Exécutez le diagnostic du backend de production, puis inspectez la route mesurée :```sh
keyhog backend --self-test
keyhog calibrate-autoroute --policy all
keyhog backend --autoroute --json
```
Le [guide du backend](https://santhreal.github.io/keyhog/backends.html) documente
les tables résidentes, le modèle de dispatch borné, le contrat de parité et les
preuves de croisement reproductibles.

## Pour commencer

### Installer et lancer votre première analyse

Les deux commandes ci-dessus installent la dernière version de crates.io et analysent
l’arborescence actuelle avec la route portable pure-Rust.

Épinglez un environnement CI à une version exacte avec
`cargo install --locked --version '=0.5.86' keyhog`. KeyHog nécessite Rust 1.89
ou plus récent. Consultez le [guide d’installation](https://santhreal.github.io/keyhog/install.html)
pour les profils GPU, Hyperscan, CI, portable et de compilation depuis les sources.

KeyHog se termine avec le code `1` lorsqu’un résultat bloque la politique de preuve active. La politique
par défaut bloque les résultats `likely` et `confirmed` tout en gardant les résultats `review`
visibles avec le code `0` ; `--evidence-policy paranoid` bloque chaque niveau. Examinez
le niveau de preuve exact, le code de raison, le fichier, la ligne, le détecteur et la
remédiation de chaque résultat. Les autres codes non nuls décrivent des échecs d’entrée, système, de vérification ou
de couverture ; consultez la
[référence des codes de sortie](https://santhreal.github.io/keyhog/reference/exit-codes.html).

Le contrat de processus complet est le suivant :

| Sortie | Signification |
|---|---|
| `0` succès | Aucun résultat ne bloque la politique de preuve active, et aucune défaillance de couverture ne s’est produite. Les résultats de niveau review peuvent rester visibles sous la politique par défaut. |
| `1` résultats bloquants | Au moins un résultat bloque la politique de preuve active, mais aucun n’a été confirmé comme actif. |
| `2` erreur de l’opérateur | Corrigez les arguments, la configuration, le corpus de détecteurs ou l’entrée corrigeable par l’opérateur. |
| `3` erreur système | Réparez ou réessayez l’exécuteur. Cela inclut les E/S de bas niveau, le service démon fatal, le cache incrémental et les échecs SIMD explicitement sélectionnés. |
| `4` échec de santé/auto-test | Un contrôle de santé `doctor` ou `backend --self-test` était non sain. |
| `10` identifiants actifs | Au moins un identifiant a été confirmé comme actif. |
| `11` panique du scanner | Ignorez le résultat de l’analyse car l’état du scanner n’est pas fiable. |
| `12` échec GPU requis | Un chemin GPU explicitement sélectionné ou requis n’a pas pu s’exécuter. |
| `13` couverture incomplète | Une source demandée a échoué ou la couverture d’entrée était incomplète, et aucun résultat ne l’a emporté. |
| `130` interrompu | SIGINT ou Ctrl-C a interrompu le processus. |

**Filtrer, formater, contrôler :**

Créez une ligne de base avant de l’utiliser comme filtre :```sh
keyhog scan . --create-baseline .keyhog-baseline.json
keyhog scan . --baseline .keyhog-baseline.json --format json-envelope --output keyhog.json
```
La première commande enregistre les résultats examinés et se termine avec le code `0` sans les afficher. Validez ce fichier, puis utilisez la seconde commande pour ne signaler que les nouvelles identités de secrets. Une entrée de référence correspond au détecteur et à la valeur de l’identifiant, jamais au chemin du fichier, donc déplacer un secret enregistré ne fait pas échouer la validation, mais le faire pivoter, si. Les identifiants modifiés et la couverture incomplète restent visibles. Le chemin complet, y compris les partitions de monorepo, est [Échouer uniquement sur les nouveaux secrets](https://santhreal.github.io/keyhog/workflows/ci.html#fail-only-on-new-secrets).

Pour la prochaine analyse, utilisez le [livre de recettes](https://santhreal.github.io/keyhog/recipes.html) ou les commandes copiables dans [Choisir le bon workflow](#choose-the-right-workflow). Vous pouvez analyser l’historique Git, les images de conteneurs, les buckets cloud, les collections de dépôts, les URL et une machine entière sans changer d’outil.

### Protéger les dépôts pour des analyses pré-commit rapides

Enregistrez un dépôt avec le démon KeyHog permanent pour une détection rapide de secrets avant chaque commit (nécessite Unix ; sous Windows, utilisez `keyhog scan` en processus) :```sh
# 1. Start the daemon (accelerated by CUDA, Metal, WGPU, or SIMD)
keyhog guard up

# 2. Guard your repository (indexes baseline and installs pre-commit hook in one step)
keyhog guard add /path/to/repo

# 3. Every staged commit checks only changed blobs against in-memory attestations
keyhog scan --git-staged

# 4. View all active guarded repositories and their states
keyhog guard list

# 5. Turn the daemon on and off cleanly without losing registrations or durable index
keyhog guard down
```
Voir le [guide du gardien perpétuel](https://santhreal.github.io/keyhog/workflows/guard.html)
et le [workflow pre-commit](https://santhreal.github.io/keyhog/workflows/precommit.html)
pour la configuration complète, le cycle de vie de la machine à états et l’automatisation des hooks.

### L’ajouter à GitHub Actions

Créez `.github/workflows/keyhog.yml` :```yaml
name: keyhog
on:
  push:
    branches: [main]
  pull_request:
permissions:
  contents: read
  security-events: write
jobs:
  scan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
      - uses: santhreal/keyhog@v0
        with:
          path: .
          severity: high
```
L'action analyse l'arborescence extraite, échoue sur les résultats de gravité `high` ou `critical`, téléverse le SARIF vers Code Scanning et conserve le rapport comme artefact de workflow. Les échecs d'installation, de couverture, de backend et de publication du rapport font également échouer le job.

Consultez le [guide GitHub Action](https://santhreal.github.io/keyhog/workflows/github-action.html) pour les entrées, les sorties, l'adoption de la ligne de base, les partitions de monorepo, la vérification et le comportement en cas d'échec. Consultez le [guide CI](https://santhreal.github.io/keyhog/workflows/ci.html) pour GitLab, CircleCI, Jenkins, Buildkite et les jobs shell génériques. Consultez le [guide de scan de masse](https://santhreal.github.io/keyhog/guides/mass-scanning.html) pour les organisations de dépôts, les groupes Git hébergés, les buckets cloud et les inventaires partitionnés.

## Surfaces de scan que d'autres outils traitent comme des produits distincts

KeyHog analyse les octets à la frontière où ils peuvent fuir, pas seulement les fichiers sources suivis. Utilisez un rapport par frontière afin que la CI conserve la couverture exacte et l'état d'échec.

| Surface d'exposition | Exemple |
|---|---|
| Artefact de package final | Exécutez `npm pack`, puis analysez le `.tgz` produit avec `keyhog scan package.tgz`. L'expansion d'archive vérifie les fichiers générés, les source maps, les fixtures et les métadonnées absents de l'arborescence source attendue. |
| Application de navigateur déployée | `keyhog scan --url https://app.example.com/assets/app.js` suit le décodage JavaScript, source-map, WASM et des réponses de manière bornée sans transformer le scanner en crawler illimité. |
| Issues GitHub, pull requests, discussions, wikis et gists | `keyhog scan --github-collaboration owner/repo --github-all` analyse chaque surface de collaboration en dehors de l'extraction. |
| Configuration d'agent IA et MCP | `keyhog scan ~/.config ~/.claude ~/.codex` applique le même pipeline de détection, décodage, preuve et rapport à la configuration locale des outils. |
| Couches d'images conteneur | `keyhog scan --docker-image registry.example.com/team/app:v1` analyse le contenu de l'image qui sera exécuté, y compris les fichiers introduits pendant la construction. |
| Inventaires d'objets cloud | `keyhog scan --s3-bucket BUCKET`, `--gcs-bucket BUCKET` ou `--azure-container-url URL` préserve la pagination du fournisseur, les objets et la couverture des limites d'octets dans le rapport terminal. |
| Hôte de développement entier | `sudo keyhog scan-system --space 50G` découvre les systèmes de fichiers montés et l'historique Git accessible sous un budget de stockage strict. |

Ces routes partagent un contrat unique de détection et de rapport. Un échec spécifique à une source ne peut pas se transformer silencieusement en un scan local plus restreint.

## Choisir le bon workflow

Choisissez d'abord la frontière de la source. Un préréglage modifie le travail de détection, tandis qu'un backend modifie l'exécution. Ni l'un ni l'autre n'étend un scan d'arborescence de travail à l'historique Git, à un inventaire de fournisseur, au stockage cloud ou à un audit d'hôte.

Il n'existe pas de raccourci honnête `scan everything`. Un examen complet du patrimoine exécute les frontières pertinentes ci-dessous comme des jobs séparés et conserve chaque rapport `json-envelope` avec son code de sortie brut.

| Besoin | Commencer par | Débit et réutilisation | Frontière de couverture |
|---|---|---|---|
| Retour rapide local | `keyhog scan . --fast --incremental` | Réutilise les hachages de fichiers inchangés. Le préréglage rapide ignore le décodage, l'entropie et le travail ML. | Exécutez la politique par défaut avant la fusion car le mode rapide est volontairement plus restreint. |
| Scan complet du dépôt | `keyhog scan .` | `auto` calibré et le défaut de workers par cœur CPU. Ajoutez `--incremental` pour les scans répétés de la même arborescence de confiance. | Fichiers actuels uniquement. Il n'ajoute pas l'historique Git. |
| Porte de commit stagé | `keyhog scan --git-staged` ou `keyhog hook install` | Lit les blobs d'index exacts, donc les modifications non stagées ne peuvent pas changer le résultat. | Contenu stagé uniquement. Exécutez un scan d'arborescence de travail séparément lorsque les octets locaux non stagés comptent. |
| Garde perpétuelle du dépôt | `keyhog guard add . --mode repo` puis `keyhog guard status .` | Registre racine résident en démon avec une machine à 7 états, cache d'attestation propre et suivi d'identité de politique. | Nécessite un démon en cours d'exécution. La garde complète, ne remplace pas, les scans stagés et d'arborescence de travail. |
| Porte de pull request GitHub | `santhreal/keyhog@v0` | L'action installe, analyse, publie le SARIF et un artefact, puis préserve le statut de KeyHog. | Un chemin extrait. Utilisez le scan d'inventaire de fournisseur pour une organisation. |
| GitLab, Jenkins, Buildkite ou shell CI | `keyhog scan . --format json-envelope --output keyhog.json` | Persistez le rapport et le code de sortie en cas de succès, de résultats et d'erreurs. Utilisez `--git-diff <base>` uniquement pour une porte de lignes modifiées explicitement plus restreinte. | Les octets présents dans l'extraction, ou le diff sélectionné. |
| Adopter un dépôt avec des résultats connus | Créez `.keyhog-baseline.json`, committez-le, puis analysez avec `--baseline .keyhog-baseline.json`. | Les identités existantes restent visibles dans la ligne de base tandis que seuls les nouveaux résultats font échouer la porte. | Une ligne de base ne supprime pas les identifiants modifiés ni la couverture incomplète. |
| Récupération Git récursive | `keyhog scan --deep --git-history . --git-blobs . --daemon=off` | Calibrez la politique profonde une fois par classe de worker. Exécutez en processus. | Un dépôt. `--git-history` couvre uniquement l'ascendance de l'extraction actuelle, donc une branche jamais extraite est manquée sans écart de couverture ; `--git-blobs` atteint également les blobs orphelins, les commits amendés, les stashes, les notes, les messages de tags annotés et les refs empaquetées. |
| Inspection de conteneur ou d'archive | `keyhog scan --docker-image registry/app:v1` ou `keyhog scan incoming/` | Conservez un rapport d'enveloppe afin que les membres ignorés, corrompus, chiffrés, non sûrs ou surdimensionnés restent visibles. | Uniquement l'image ou le chemin de système de fichiers sélectionné et les formats imbriqués pris en charge. |
| Inspection d'URL, de réponse ou de HAR | `keyhog scan --url https://api.example.com/config` ou `keyhog scan capture.har` | Utilisez des limites de source bornées et préservez l'enveloppe terminale. | Uniquement les réponses récupérées ou les entrées de capture. Ce n'est pas un crawler. |
| Inventaire d'organisation ou cloud | `keyhog scan --daemon=off --github-org acme --format json-envelope --output acme.json` | Partitionnez par fournisseur, propriétaire ou bucket. Exécutez des partitions indépendantes en parallèle avec un rapport et un statut chacun. | Un inventaire de fournisseur sélectionné par job. Les limites de pagination ou d'objets restent des frontières de couverture. |
| Confirmer si les résultats éligibles sont actifs | `keyhog scan . --verify` | La concurrence et les contrôles de débit du fournisseur sont séparés des workers du scanner. | Envoie des requêtes dérivées des identifiants aux points de terminaison déclarés du fournisseur. Tous les détecteurs ne prennent pas en charge la vérification. |
| Scan de santé de l'hôte entier | `sudo keyhog scan-system --space 50G` | Utilise tous les cœurs CPU par défaut et analyse l'historique Git découvert après les données du système de fichiers. | Systèmes de fichiers locaux montés. Les montages réseau sont facultatifs et le plafond d'espace est strict. |
| Inventaire de répertoire, historique, archive, distant ou cloud accéléré GPU sur Unix | Calibrez l'auto-routage, démarrez `keyhog daemon start --mass`, puis exécutez `keyhog scan --daemon=mass <SOURCE>`. | Diffuse des lots bornés via un worker compilé CPU, Hyperscan, CUDA, Metal ou WGPU. Ajoutez `--incremental` pour les arborescences de fichiers système chaudes inchangées. Le reçu terminal rapporte les totaux exacts et les lots GPU, les chunks, les octets, la part GPU et le débit. | Les lignes de base, la vérification, le verrouillage, les préréglages, les overlays et autres changements de politique du scanner sont rejetés avant l'acquisition. L'état incrémental s'applique uniquement aux racines de système de fichiers locales du démon. |

### Analyser chaque frontière de source prise en charge

Utilisez une commande par frontière. Conservez un rapport `json-envelope` et le statut de sortie brut pour chaque partition d'inventaire.

| Source ou cas d'usage | Commande |
|---|---|
| Plusieurs racines locales | `keyhog scan services/api services/web deploy/` |
| Fichiers modifiés en continu | `keyhog watch services/api deploy/` |
| Octets stagés, lignes modifiées, historique atteignable ou blobs | `keyhog scan --git-staged`, `--git-diff main`, `--git-history .` ou `--git-blobs .` |
| Binaires natifs et chaînes de firmware | `keyhog scan --binary firmware.bin` (un scan de répertoire simple ignore les binaires et sort toujours avec `0`) |
| Archives et sources compressées | `keyhog scan incoming/` (les membres pris en charge se développent automatiquement) |
| Couches d'images Docker | `keyhog scan --docker-image registry/app:v1` |
| JavaScript, source maps, WASM ou réponse de point de terminaison | `keyhog scan --url https://api.example.com/config` |
| Captures de requêtes et réponses HTTP | `keyhog scan capture.har` |
| Issues GitHub, pull requests, discussions, wikis et gists | `keyhog scan --github-collaboration owner/repo --github-all` |
| Inventaires GitHub, GitLab ou Bitbucket | `--github-org ORG`, `--gitlab-group GROUP` ou `--bitbucket-workspace WORKSPACE` |
| Inventaires S3, GCS ou Azure Blob | `--s3-bucket BUCKET`, `--gcs-bucket BUCKET` ou `--azure-container-url URL` |
| Un flux borné depuis un autre outil | `producer \| keyhog scan --stdin` (utilisez `set -o pipefail` pour qu'un producteur en échec fasse remonter sa propre erreur, pas un scan de zéro octet) |

Un scan de répertoire simple ne lit pas les binaires natifs. Chacun devient un écart de couverture `binary (extension or content sniff)`, le scan sort toujours avec `0`, et `--no-default-excludes` ne change pas cela, donc passez `--binary` lorsque les artefacts compilés sont dans le périmètre. Ce drapeau nécessite une compilation avec la fonctionnalité `binary`, que l'installation crates.io par défaut possède et que la fonctionnalité allégée `ci` ne possède pas.

L'extraction de binaires natifs rapporte des identifiants complets qui satisfont le contrat de forme explicite d'un détecteur nommé. Elle supprime les fragments de préfixe courts et les chaînes génériques en forme d'assignation des sections de données compilées car ces octets ne conservent pas le contexte source.

La récupération de points de terminaison est bornée et filtrée contre le SSRF. Ce n'est pas un crawler. Les points de terminaison cloud privés et le transfert d'identifiants nécessitent leurs drapeaux de confiance explicites. Les jetons de fournisseur appartiennent aux variables d'environnement documentées, pas aux arguments de processus.

Consultez le [sélecteur de workflow](https://santhreal.github.io/keyhog/capabilities.html) pour les détails de source et de politique, le [guide GitHub Action](https://santhreal.github.io/keyhog/workflows/github-action.html) pour la porte de dépôt maintenue, le [guide CI direct](https://santhreal.github.io/keyhog/workflows/ci.html) pour les rapports durables et la gestion des sorties, et le [guide de scan de masse](https://santhreal.github.io/keyhog/guides/mass-scanning.html) pour le partitionnement et l'agrégation. Le [livre de recettes](https://santhreal.github.io/keyhog/recipes.html) couvre les conteneurs, les archives, les URL, le contenu de collaboration GitHub et les sources cloud.

### Vitesse et concurrence sans conjectures

Commencez par les valeurs par défaut. Cargo ne peut pas exécuter KeyHog après `cargo install`, donc exécutez les commandes ci-dessous une fois après l'installation d'une compilation Cargo multi-backend et à nouveau après un changement de l'hôte, du binaire, du corpus de détecteurs, du pilote ou des classes de charge de travail :```sh
keyhog calibrate-autoroute --policy all
keyhog backend --autoroute --json
```
| Contrôle | À utiliser pour | Conserver cet invariant |
|---|---|---|
| `--backend auto` calibré | Sélection de routine CPU, Hyperscan ou GPU. | Un backend explicite est une surcharge de diagnostic, pas un défaut plus rapide. |
| `--threads <N>` | Réserver la capacité CPU sur un exécuteur partagé. Les hôtes dédiés devraient normalement le laisser non défini afin que KeyHog utilise les cœurs disponibles. | Chaque valeur doit être positive. Plusieurs processus KeyHog concurrents possèdent chacun un pool de travailleurs, donc divisez le budget de l’hôte entre les partitions. |
| `--reader-threads <N>` | Pipelines de stockage mesurés où le travail du lecteur, et non l’analyse, est le goulot d’étranglement. | La valeur par défaut dérive du pool de travailleurs d’analyse. Laissez-le non défini jusqu’à ce que le profilage montre un goulot d’étranglement du lecteur. |
| `--incremental` et `--incremental-cache <PATH>` | Analyses répétées du même arbre de confiance. | Ne partagez pas un index entre des dépôts sans rapport ou des tâches non fiables. |
| Partitions de fournisseur ou de dépôt | Analyse concurrente du parc et nouvelles tentatives indépendantes. | Préservez une enveloppe terminale et un code de sortie brut par partition. Ne concaténez pas les résultats et ne jetez pas l’état de couverture. |
| `--verify-concurrency`, `--verify-rate` et `--verify-batch` | Limiter les vérifications actives du fournisseur indépendamment de l’analyse des fichiers. | La vérification envoie des requêtes dérivées des identifiants. Les limites de débit du fournisseur, et non le nombre de CPU, possèdent cette concurrence. |
| Démon de masse | Flux de répertoires, d’historique, d’archives, distants ou cloud à l’échelle du To sur un seul travailleur Unix. | Chaque trame est limitée à 8 Mio et 1 024 fragments. Le démon sérialise l’état des fragments et renvoie un reçu d’exécution CPU/GPU exact. |
| `--fast`, défaut, `--deep` ou `--precision` | Sélection d’une politique explicite de coût de détection et de rappel. | Ces préréglages sont mutuellement exclusifs et modifient la couverture. Ils ne sont pas des boutons de vitesse interchangeables. |

Inspectez la politique résolue avec `keyhog config --effective`. Utilisez `--profile`
pour mesurer les étapes fixes du scanner et l’exécution complète de l’opérateur avant de modifier
les contrôles de lecteur, de lot ou de profondeur de canal. Le rapport à faible surcharge enregistre
la source, le backend, le cache, la charge de travail, les threads, l’entrée, les transitions d’état, le temps CPU,
le pic de mémoire, le SHA-256 binaire exact, le SHA-256 des fonctionnalités activées, le triplet cible, le profil
de build, le compilateur, l’allocateur, le SHA-256 du backend lié, le SHA-256 du corpus de détecteurs,
le BLAKE3 des détecteurs activés, le BLAKE3 du plan compilé, la provenance hachée des détecteurs,
le BLAKE3 complet de la configuration résolue, le BLAKE3 de la politique de performance, le préréglage,
l’état de protection appliqué, les adaptateurs de source, le BLAKE3 haché de la cible source,
le BLAKE3 haché de la partition source, les octets bruts de la source, le fanout des unités source,
les octets dérivés du décodage, les octets complétés de la répartition du backend, et les compartiments stables
de taille/fanout. Les domaines d’octets que leur adaptateur de source ne peut pas encore distinguer restent
explicitement indisponibles au lieu de devenir des zéros mesurés. Le rapport n’enregistre
pas le contenu de la source, les valeurs d’identifiants, les chemins bruts, les URL brutes ni les valeurs
brutes de configuration. Utilisez `--perf-trace` uniquement pour les compteurs de diagnostic coûteux par motif et
par backend.
Laissez les contrôles avancés du pipeline non définis sauf si une mesure reproductible sur le
travailleur cible montre une amélioration.

Pour une analyse récurrente complète du dépôt :```sh
keyhog scan . --incremental \
  --format json-envelope --output keyhog.json
```
Pour un runner partagé où le job se voit allouer quatre workers de scan et un
worker de lecture :```sh
keyhog scan . --threads 4 --reader-threads 1 \
  --format json-envelope --output keyhog.json
```
La deuxième commande est un budget de ressources, pas un optimum universel. Mesurez
l'hôte cible avant de choisir des nombres de workers explicites.

Pour la [récupération approfondie](https://santhreal.github.io/keyhog/guides/deep-recovery.html)
et le [tri à l'échelle du système](https://santhreal.github.io/keyhog/guides/system-wide-triage.html),
utilisez leurs guides dédiés car leur couverture et leurs règles de complétion diffèrent
d'un scan de dépôt normal.

## Benchmarks du scanner de secrets

Ces panneaux comparent la politique de détection, les requêtes d'exécution CPU et GPU,
le comportement du cache incrémental et les requêtes de démon à chaud. Chaque valeur est
générée à partir de l'instantané de benchmark vérifié. L'instantané lie la version du
scanner, le digest de l'exécutable, le digest du détecteur, le corpus, l'hôte et
l'horodatage d'exécution. Utilisez les
[preuves complètes du benchmark](#performance) pour la provenance des concurrents et
le rappel par catégorie.

### Précision de détection

<!-- BENCH:accuracy:start -->
KeyHog `KeyHog v0.5.70` a scanné le corpus **mirror** : 15 000 fixtures, 3 000 positifs étiquetés et 2 431 242 octets d'entrée. Le manifeste de la clé de réponse a été exclu de l'arbre de scan. La ligne utilise la politique par défaut sur la route explicite Hyperscan/SIMD sur **AMD Ryzen 9 9950X 16-Core Processor**.

| Précision | Rappel | F1 | Vrais positifs | Faux positifs | Faux négatifs |
|---:|---:|---:|---:|---:|---:|
| 0.9651 | 0.9027 | 0.9328 | 2 708 | 98 | 292 |

L'arbre source suivi était propre.
<!-- BENCH:accuracy:end -->

### Routes d'exécution, préréglages et cache

<!-- BENCH:config:start -->
Mesuré sur **AMD Ryzen 9 9950X 16-Core Processor** avec **NVIDIA GeForce RTX 5090**, 32 cœurs logiques, 15 000 fixtures, 3 000 positifs étiquetés et 2 431 242 octets d'entrée. Scanner : `KeyHog v0.5.70`. L'arbre source suivi était propre.

#### Scan complet par route d'exécution

Toutes les lignes utilisent la politique de détection par défaut avec le cache incrémental et le démon désactivés. La ligne automatique enregistre la politique demandée, mais le résultat du benchmark ne lie pas la route persistée sélectionnée, ce n'est donc pas une preuve de routage. Les lignes GPU incluent l'acquisition et le démarrage complet du scanner sur ce petit corpus ; ce ne sont pas des mesures de croisement de noyaux GPU.

| Route demandée | Mur | Débit | RSS de pointe | F1 |
|---|---:|---:|---:|---:|
| Hyperscan/SIMD | 860 ms | 2,70 Mo/s | 416 Mio | 0.9328 |
| CPU Pure-Rust | 903 ms | 2,57 Mo/s | 509 Mio | 0.9328 |
| CUDA | 2,03 s | 1,14 Mo/s | 963 Mio | 0.9328 |
| WGPU | 1,97 s | 1,18 Mo/s | 1264 Mio | 0.9328 |
| Automatique | 1,46 s | 1,59 Mo/s | 634 Mio | 0.9328 |

#### Politique de détection sur Hyperscan/SIMD

La route, le cache, l'état du démon, le corpus et l'hôte restent fixes. Les préréglages modifient le travail de détection, comparez donc la précision et le rappel ainsi que le temps.

| Politique | Mur | Précision | Rappel | F1 | Résultats |
|---|---:|---:|---:|---:|---:|
| Rapide | 737 ms | 0.9700 | 0.8837 | 0.9248 | 2 738 |
| Par défaut | 860 ms | 0.9651 | 0.9027 | 0.9328 | 2 816 |
| Approfondie | 861 ms | 0.9645 | 0.9067 | 0.9347 | 2 845 |
| Précision | 849 ms | 0.9590 | 0.6397 | 0.7674 | 2 001 |

#### Nouvelle exécution incrémentale à chaud

Le benchmark remplit l'index Merkle BLAKE3, puis chronomètre le deuxième scan identique. Le petit arbre synthétique change peu car le démarrage du scanner domine ; mesurez votre dépôt avant de revendiquer une accélération.

| Politique par défaut Hyperscan/SIMD | Mur | Débit | RSS de pointe |
|---|---:|---:|---:|

---

[Read more](https://github.com/santhreal/keyhog)
Télécharger l’outil

Populaires

Voir tout →

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

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 La boîte à outils OSINT ultime : graphe d'enquête, notation de confiance, familles d'alias, carte, chronologie et rapports. 49 modules, plus de 400 sites, aucune clé API requise.

    772
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Application d'exécution en un clic GhostLock (CVE-2026-43499)

    505
  • 3

    ARTEX

    baarai/artex

    Plateforme autonome de tests d'intrusion multi-agents basée sur des LLM, avec agents planificateur/ouvrier, graphes d'actifs et d'exploration, enregistrement du trafic MITM et retest des vulnérabilités.

    420
  • 4

    redforge

    cybersecurity91/redforge

    Boîte à outils red team côté navigateur avec 102 outils hors ligne pour la reconnaissance, la génération de payloads, les attaques par identifiants, la cryptographie, l'encodage et le reporting d'engagement.

    345
  • 5

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    Le système d'action pour la cybersécurité native IA—où l'intention devient une exécution gouvernée, les preuves deviennent une mémoire opérationnelle, et chaque opération améliore la suivante.

    260
  • 6

    antifox

    antifox-ai/antifox

    Plateforme de test d'intrusion autonome multi-agents par IA qui exécute la reconnaissance, la découverte de la surface d'attaque, la validation de l'exploitation et la livraison de rapports étayés par des preuves.

    251

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →