<p align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/7654/dfb768a9b8e8fa64082992f11d0b284d5ec6a199fc1eac85e0352fb20452186f.gif" alt="Escaneo de KeyHog que muestra severidad, evidencia, archivo y línea, remediación, resultados y estado de cobertura" width="900" />
</p>

## Un escáner de secretos construido alrededor de la GPU

KeyHog no entrega unas pocas expresiones regulares a un shader de cómputo genérico.
Su ruta de GPU está construida sobre [Vyre](https://github.com/santhreal/vyre), un sustrato
de cómputo GPU en Rust desarrollado junto con KeyHog. Los disparadores de detectores se compilan en
tablas inmutables residentes en la GPU. Los lotes de origen acotados producen posiciones de coincidencia
completas para el mismo pipeline de confirmación, supresión, evidencia y generación de informes
utilizado por las rutas de CPU y Hyperscan.

- **Tres peers físicos de GPU.** CUDA, Metal nativo y WGPU portátil se
  adquieren, miden y reportan de forma independiente.
- **Paridad exacta de resultados.** La calibración rechaza un candidato cuya
  identidad de hallazgo difiere de la ruta de referencia. Una respuesta incorrecta más rápida nunca entra
  en la tabla de enrutamiento.
- **Evidencia persistente de ruta.** KeyHog registra el binario, el corpus de detectores,
  la configuración, la clase de carga de trabajo, el host, el acelerador, el controlador y la evidencia
  de tiempos medida. Los escaneos normales no realizan benchmarks en la ruta crítica.
- **Ejecución residente.** Los workers del daemon mantienen el estado compilado de detectores y
  aceleradores activo para lotes repetidos de archivos, archivos comprimidos, historial, remotos y en la nube.
- **Sin vía de escape oculta a la CPU.** Un acelerador seleccionado explícitamente que no puede
  inicializarse o despacharse falla de forma visible en lugar de devolver hallazgos de CPU bajo
  una etiqueta de GPU.

La instalación predeterminada de crates.io utiliza la ruta de CPU pura en Rust portátil, por lo que funciona
en un host Rust limpio. Habilita los tres peers de GPU sin adquirir Hyperscan:```sh
cargo install --locked keyhog --no-default-features --features portable,gpu

Ejecuta el diagnóstico del backend de producción y luego inspecciona la ruta medida:```sh
keyhog backend --self-test
keyhog calibrate-autoroute --policy all
keyhog backend --autoroute --json

El primer comando revisa los hallazgos encontrados y sale con `0` sin imprimirlos. Confirma ese archivo y luego usa el segundo comando para reportar solo las identidades de nuevos hallazgos. Una entrada de línea base coincide con el detector y el valor de la credencial, nunca con la ruta del archivo, por lo que mover un secreto registrado no hace fallar la compuerta, pero rotarlo sí. Las credenciales cambiadas y la cobertura incompleta permanecen visibles. La ruta completa, incluidas las particiones de monorepos, está en [Fallar solo con secretos nuevos](https://santhreal.github.io/keyhog/workflows/ci.html#fail-only-on-new-secrets).

Para el siguiente escaneo, usa el [libro de recetas](https://santhreal.github.io/keyhog/recipes.html) o los comandos copiables en [Elegir el flujo de trabajo correcto](#choose-the-right-workflow). Puedes escanear el historial de Git, imágenes de contenedores, buckets en la nube, colecciones de repositorios, URLs y una máquina completa sin cambiar de herramientas.

### Proteger repositorios para escaneos rápidos previos al commit

Registra un repositorio con el daemon perpetuo de KeyHog para la detección rápida de secretos previa al commit (requiere Unix; en Windows usa `keyhog scan` en proceso):```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

La acción escanea el árbol verificado, falla ante hallazgos de nivel `high` o `critical`, sube SARIF a Code Scanning y conserva el informe como artefacto del flujo de trabajo. Los fallos de instalación, cobertura, backend y publicación del informe también hacen fallar el trabajo.

Consulta la [guía de GitHub Action](https://santhreal.github.io/keyhog/workflows/github-action.html) para entradas, salidas, adopción de línea base, particiones de monorepo, verificación y comportamiento ante fallos. Usa la [guía de CI](https://santhreal.github.io/keyhog/workflows/ci.html) para GitLab, CircleCI, Jenkins, Buildkite y trabajos shell genéricos. Usa la [guía de escaneo masivo](https://santhreal.github.io/keyhog/guides/mass-scanning.html) para organizaciones de repositorios, grupos de Git alojados, buckets en la nube e inventarios particionados.

## Superficies de escaneo que otras herramientas tratan como productos separados

KeyHog escanea bytes en el límite donde pueden filtrarse, no solo archivos fuente rastreados. Usa un informe por límite para que la CI conserve la cobertura exacta y el estado de fallo.

| Superficie de exposición | Ejemplo |
|---|---|
| Artefacto de paquete final | Ejecuta `npm pack` y luego escanea el `.tgz` generado con `keyhog scan package.tgz`. La expansión de archivos comprueba archivos generados, source maps, fixtures y metadatos ausentes del árbol fuente esperado. |
| Aplicación de navegador desplegada | `keyhog scan --url https://app.example.com/assets/app.js` sigue la decodificación acotada de JavaScript, source maps, WASM y respuestas sin convertir el escáner en un rastreador sin límites. |
| Issues, pull requests, discussions, wikis y gists de GitHub | `keyhog scan --github-collaboration owner/repo --github-all` escanea cada superficie de colaboración fuera del checkout. |
| Configuración de agentes de IA y MCP | `keyhog scan ~/.config ~/.claude ~/.codex` aplica el mismo pipeline de detector, decodificación, evidencia e informes a la configuración local de herramientas. |
| Capas de imágenes de contenedor | `keyhog scan --docker-image registry.example.com/team/app:v1` escanea el contenido de la imagen que se ejecutará, incluidos los archivos introducidos durante la compilación. |
| Inventarios de objetos en la nube | `keyhog scan --s3-bucket BUCKET`, `--gcs-bucket BUCKET` o `--azure-container-url URL` conserva la paginación del proveedor, los objetos y los límites de bytes en el informe de terminal. |
| Host de desarrollo completo | `sudo keyhog scan-system --space 50G` descubre sistemas de archivos montados e historial de Git alcanzable bajo un presupuesto de almacenamiento estricto. |

Estas rutas comparten un único contrato de detección e informes. Un fallo específico de una fuente no puede convertirse silenciosamente en un escaneo local más limitado.

## Elige el flujo de trabajo adecuado

Elige primero el límite de la fuente. Un preset cambia el trabajo de detección, mientras que un backend cambia la ejecución. Ninguno de los dos expande un escaneo del árbol de trabajo al historial de Git, un inventario de proveedor, almacenamiento en la nube o una auditoría del host.

No existe un atajo honesto de `scan everything`. Una revisión completa del patrimonio ejecuta los límites relevantes a continuación como trabajos separados y conserva cada informe `json-envelope` con su código de salida sin procesar.

| Necesidad | Comienza con | Rendimiento y reutilización | Límite de cobertura |
|---|---|---|---|
| Retroalimentación local rápida | `keyhog scan . --fast --incremental` | Reutiliza hashes de archivos sin cambios. El preset rápido omite trabajo de decodificación, entropía y ML. | Ejecuta la política predeterminada antes del merge porque el modo rápido es intencionalmente más limitado. |
| Escaneo completo del repositorio | `keyhog scan .` | `auto` calibrado y el valor predeterminado de workers por núcleo de CPU. Añade `--incremental` para escaneos repetidos del mismo árbol de confianza. | Solo archivos actuales. No añade historial de Git. |
| Puerta de commit en stage | `keyhog scan --git-staged` o `keyhog hook install` | Lee blobs exactos del índice, por lo que las ediciones sin stage no pueden cambiar el resultado. | Solo contenido en stage. Ejecuta un escaneo del árbol de trabajo por separado cuando los bytes locales sin stage importan. |
| Guardia perpetua del repositorio | `keyhog guard add . --mode repo` y luego `keyhog guard status .` | Registro raíz residente en el daemon con una máquina de 7 estados, caché de atestación limpia y seguimiento de identidad de política. | Requiere un daemon en ejecución. La guardia complementa, no reemplaza, los escaneos en stage y del árbol de trabajo. |
| Puerta de pull request de GitHub | `santhreal/keyhog@v0` | La Action instala, escanea, publica SARIF y un artefacto, y luego conserva el estado de KeyHog. | Una única ruta verificada. Usa el escaneo de inventario de proveedor para una organización. |
| GitLab, Jenkins, Buildkite o CI shell | `keyhog scan . --format json-envelope --output keyhog.json` | Conserva el informe y el código de salida en éxito, hallazgos y errores. Usa `--git-diff <base>` solo para una puerta de líneas modificadas explícitamente más limitada. | Los bytes presentes en el checkout o el diff seleccionado. |
| Adoptar un repositorio con hallazgos conocidos | Crea `.keyhog-baseline.json`, haz commit y luego escanea con `--baseline .keyhog-baseline.json`. | Las identidades existentes permanecen visibles en la línea base mientras solo los hallazgos nuevos hacen fallar la puerta. | Una línea base no suprime credenciales modificadas ni cobertura incompleta. |
| Recuperación recursiva de Git | `keyhog scan --deep --git-history . --git-blobs . --daemon=off` | Calibra la política profunda una vez por clase de worker. Ejecuta en proceso. | Un repositorio. `--git-history` cubre solo la ascendencia del checkout actual, por lo que una rama que nunca verificaste se omite sin brecha de cobertura; `--git-blobs` también alcanza blobs colgantes, commits eliminados por amend, stashes, notas, mensajes de tags anotados y refs empaquetados. |
| Inspección de contenedor o archivo | `keyhog scan --docker-image registry/app:v1` o `keyhog scan incoming/` | Conserva un informe envelope para que los miembros omitidos, corruptos, cifrados, inseguros o sobredimensionados sigan siendo visibles. | Solo la imagen o ruta de sistema de archivos seleccionada y los formatos anidados compatibles. |
| Inspección de URL, respuesta o HAR | `keyhog scan --url https://api.example.com/config` o `keyhog scan capture.har` | Usa límites de fuente acotados y conserva el envelope de terminal. | Solo respuestas obtenidas o entradas de captura. Esto no es un rastreador. |
| Inventario de organización o nube | `keyhog scan --daemon=off --github-org acme --format json-envelope --output acme.json` | Particiona por proveedor, propietario o bucket. Ejecuta particiones independientes de forma concurrente con un informe y estado cada una. | Un inventario de proveedor seleccionado por trabajo. Los límites de paginación u objetos siguen siendo límites de cobertura. |
| Confirmar si los hallazgos elegibles están activos | `keyhog scan . --verify` | La concurrencia del proveedor y los controles de tasa están separados de los workers del escáner. | Envía solicitudes derivadas de credenciales a endpoints declarados del proveedor. No todos los detectores admiten verificación. |
| Escaneo de salud de todo el host | `sudo keyhog scan-system --space 50G` | Usa todos los núcleos de CPU por defecto y escanea el historial de Git descubierto después de los datos del sistema de archivos. | Sistemas de archivos locales montados. Los montajes de red son opcionales y el límite de espacio es estricto. |
| Directorio, historial, archivo, remoto o inventario de nube con GPU en Unix | Calibra autoroute, inicia `keyhog daemon start --mass` y luego ejecuta `keyhog scan --daemon=mass <SOURCE>`. | Transmite lotes acotados a través de un único worker compilado de CPU, Hyperscan, CUDA, Metal o WGPU. Añade `--incremental` para árboles de sistema de archivos cálidos sin cambios. El recibo de terminal informa totales exactos y lotes de GPU, chunks, bytes, cuota de GPU y rendimiento. | Las líneas base, verificación, lockdown, presets, overlays y otros cambios de política del escáner se rechazan antes de la adquisición. El estado incremental se aplica solo a raíces de sistema de archivos locales del daemon. |

### Escanea cada límite de fuente compatible

Usa un comando por límite. Conserva un informe `json-envelope` y el estado de salida sin procesar para cada partición de inventario.

| Fuente o caso de uso | Comando |
|---|---|
| Varias raíces locales | `keyhog scan services/api services/web deploy/` |
| Archivos cambiados continuamente | `keyhog watch services/api deploy/` |
| Bytes en stage, líneas modificadas, historial alcanzable o blobs | `keyhog scan --git-staged`, `--git-diff main`, `--git-history .` o `--git-blobs .` |
| Binarios nativos y strings de firmware | `keyhog scan --binary firmware.bin` (un escaneo de directorio simple omite binarios y aun así sale con `0`) |
| Archivos comprimidos y fuentes comprimidas | `keyhog scan incoming/` (los miembros compatibles se expanden automáticamente) |
| Capas de imágenes Docker | `keyhog scan --docker-image registry/app:v1` |
| JavaScript, source maps, WASM o una respuesta de endpoint | `keyhog scan --url https://api.example.com/config` |
| Capturas de solicitudes y respuestas HTTP | `keyhog scan capture.har` |
| Issues, pull requests, discussions, wikis y gists de GitHub | `keyhog scan --github-collaboration owner/repo --github-all` |
| Inventarios de GitHub, GitLab o Bitbucket | `--github-org ORG`, `--gitlab-group GROUP` o `--bitbucket-workspace WORKSPACE` |
| Inventarios de S3, GCS o Azure Blob | `--s3-bucket BUCKET`, `--gcs-bucket BUCKET` o `--azure-container-url URL` |
| Un flujo acotado de otra herramienta | `producer \| keyhog scan --stdin` (usa `set -o pipefail` para que un productor fallido muestre su propio error, no un escaneo de cero bytes) |

Un escaneo de directorio simple no lee binarios nativos. Cada uno se convierte en una brecha de cobertura `binary (extension or content sniff)`, el escaneo aun así sale con `0` y `--no-default-excludes` no lo cambia, así que pasa `--binary` cuando los artefactos compilados están en alcance. Ese flag necesita una compilación con la feature `binary`, que la instalación predeterminada de crates.io tiene y la feature reducida `ci` no.

La extracción de binarios nativos informa credenciales completas que satisfacen el contrato de forma explícita de un detector nombrado. Suprime fragmentos cortos de prefijo y strings genéricas con forma de asignación de secciones de datos compiladas porque esos bytes no conservan el contexto de la fuente.

La obtención de endpoints está acotada y protegida contra SSRF. No es un rastreador. Los endpoints privados en la nube y el reenvío de credenciales requieren sus flags de confianza explícitos. Los tokens de proveedor pertenecen a las variables de entorno documentadas, no a los argumentos de proceso.

Usa el [selector de flujos de trabajo](https://santhreal.github.io/keyhog/capabilities.html) para detalles de fuente y política, la [guía de GitHub Action](https://santhreal.github.io/keyhog/workflows/github-action.html) para la puerta de repositorio mantenida, la [guía de CI directa](https://santhreal.github.io/keyhog/workflows/ci.html) para informes duraderos y manejo de salidas, y la [guía de escaneo masivo](https://santhreal.github.io/keyhog/guides/mass-scanning.html) para particionado y agregación. El [recetario](https://santhreal.github.io/keyhog/recipes.html) cubre contenedores, archivos, URLs, contenido de colaboración de GitHub y fuentes en la nube.

### Velocidad y concurrencia sin conjeturas

Comienza con los valores predeterminados. Cargo no puede ejecutar KeyHog después de `cargo install`, así que ejecuta los comandos a continuación una vez tras instalar una compilación de Cargo multi-backend y de nuevo después de que cambien el host, el binario, el corpus de detectores, el driver o las clases de carga de trabajo:```sh
keyhog calibrate-autoroute --policy all
keyhog backend --autoroute --json

Para un runner compartido donde el trabajo tiene asignados cuatro workers de escaneo y un
worker de lectura:```sh
keyhog scan . --threads 4 --reader-threads 1 \
  --format json-envelope --output keyhog.json

Compila el checkout del repositorio cuando necesites un cambio no publicado:```sh
cargo install --path crates/cli --locked

Usa la [guía de instalación](https://santhreal.github.io/keyhog/install.html) para
los requisitos de la cadena de herramientas de Rust, los perfiles de funciones y las dependencias
de ejecución específicas de la plataforma.


## Qué detecta

934 detectores integrados con validación offline propia de cada detector y acompañantes:

- **Proveedores de nube:** AWS (clave de acceso + secreta + verificación STS),
  Azure (clave de suscripción, clave de cuenta de almacenamiento, SAS), GCP (cuenta de servicio,
  clave de API), Cloudflare, Heroku, Vercel, Supabase.
- **Procesadores de pago:** Stripe, Braintree, Razorpay, Paddle, Plaid,
  Square y PayPal, con comprobaciones propias del detector y acompañantes opcionales u obligatorios.
  Una clave secreta de Razorpay requiere su ID de clave cercano.
- **Plataformas de código fuente:** PAT de GitHub (con suma de comprobación CRC32), tokens de GitLab,
  contraseñas de aplicación de Bitbucket, tokens de npm (con suma de comprobación), Gitea / Forgejo
  / Codeberg.
- **Autenticación / SSO:** Okta, Auth0, Clerk, JumpCloud, Kinde.
- **Comunicaciones:** Slack, Discord, Twilio, SendGrid, Postmark, Mailgun,
  Resend, Loops.
- **IA / ML:** OpenAI (sk-/sk-proj-), Anthropic, Google AI Studio,
  Cohere, Mistral, HuggingFace, Replicate. Las credenciales de organización de HuggingFace
  incluyen tanto la forma actual `hf_` como los tokens heredados `api_org_`.
- **Gestores de contraseñas:** claves secretas de cuenta de 1Password (`A3-` seguidas de
  cinco o seis componentes alfanuméricos en mayúsculas segmentados).
- **Bases de datos:** cadenas de conexión de Postgres, MongoDB Atlas, Supabase
  service-role, PlanetScale, Neon, Turso, MySQL, URLs de Redis.
- **Descubrimiento genérico + de entropía:** `API_KEY=<blob-de-alta-entropía>` detecta
  credenciales sin detector nombrado, limitado por umbrales de entropía por contexto
  + puntuación ML.
- **Material criptográfico:** claves privadas RSA / EC / SSH, bloques privados PGP,
  secretos de firma JWT.

Cada detector se distribuye como un [archivo TOML](https://github.com/santhreal/keyhog/blob/main/detectors) (datos, no código):
metadatos del servicio, patrones de regex, palabras clave, validadores offline, política de entropía y ML,
campos de acompañante y manejador de verificación. Añadir un nuevo detector es un
único cambio de TOML revisable;
la [guía para colaboradores](https://github.com/santhreal/keyhog/blob/main/CONTRIBUTING.md) lo explica paso a paso.

`keyhog explain <id>` vuelca la especificación completa de cualquier detector: patrones, palabras clave,
punto final de verificación, además de una guía de rotación y remediación paso a paso
clave por servicio, de modo que un hallazgo nunca sea una caja negra:

<p align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/7654/0fc64959950abfa39c0ba81a1f5fbde3fe17a57169d2edca38cb0f248c834470.gif" alt="keyhog explain github-classic-pat: volcado de especificación del detector (patrón ghp_[A-Za-z0-9]{36}, palabra clave, URL de verificación) seguido de la guía de rotación de github y la remediación paso a paso" width="860" />
</p>

Explora la creación e inspección de detectores en la
[referencia de detectores](https://github.com/santhreal/keyhog/blob/main/docs/src/detectors.md), o consulta el corpus instalado con
`keyhog detectors --search <término> --verbose`.

## Por qué mayor recall, menos falsos positivos

- **Escaneo con decodificación.** Manifiestos `Secret` de Kubernetes, cuadernos
  Jupyter, cargas útiles JWT, entornos envueltos en base64, valores de Helm y blobs
  `auth:` de docker-config. El preprocesador estructurado trata las acciones de Helm equilibradas como
  valores inertes de tiempo de renderizado y cierra los delimitadores Jupyter faltantes al final del archivo,
  de modo que los bytes literales y las celdas de código completas permanecen cubiertos. Decodifica los valores
  estructurados en su lugar y alimenta a cada detector posterior con el texto plano. Los detectores
  no necesitan reimplementar la decodificación cada uno. Los escaneos con decodificación habilitada también recuperan
  expresiones XOR de matriz de bytes JavaScript sin efectos secundarios y AES-256-CBC cuando
  todo el material de recuperación está incrustado, incluidos los envoltorios estrictos de frase de contraseña con sal de CryptoJS/OpenSSL. KeyHog nunca ejecuta la fuente.
- **Reensamblaje multilínea.** Continuación `"sk-proj-" + \` en JavaScript,
  cadenas multilínea de YAML, continuación con barra invertida en Makefile, salidas
  con plantillas Helm / Jinja, todo reensamblado antes de la coincidencia de regex.
- **Validación de acompañantes.** Los acompañantes obligatorios limitan los detectores de alto ruido. Una
  clave de API de Twilio sin su secreto de API se omite. Los acompañantes opcionales enriquecen
  la puntuación de evidencia o la verificación. La detección de clave de acceso de AWS no requiere
  su secreto, pero el secreto es necesario para la verificación en vivo.
- **Resolución entre detectores.** El TOML del detector puede requerir, rechazar o subsumir
  hallazgos acotados de otro detector. La resolución permanece determinista independientemente del
  orden de entrada, y los objetivos inválidos, las contradicciones o los ciclos de dependencia hacen fallar
  la compilación del corpus.
- **Veredictos de evidencia.** Cada hallazgo lleva un nivel exacto `review`, `likely` o
  `confirmed` más un código de razón canónico. La suma de comprobación intrínseca o la prueba de gramática,
  los acompañantes obligatorios y la verificación en vivo producen evidencia confirmada;
  la forma fuerte específica del proveedor en un rol que porta credenciales produce evidencia
  probable; los anclajes débiles, las asignaciones genéricas, los candidatos solo por entropía y los
  contextos de prueba, documentación, regla o identificador permanecen como evidencia de revisión.
  Un `evidence_score` opcional complementa el veredicto cuando se mide.
  El umbral predeterminado `0.40` controla el piso de confianza interno del escáner
  y sigue siendo configurable con `--min-confidence`.
- **Calibración bayesiana por detector.** `keyhog calibrate --fp generic-api-key`
  escribe un posterior Beta(α,β). Los escaneos lo usan solo cuando `--calibration-cache`
  o `[system].calibration_cache` apunta a ese archivo, de modo que el ajuste de confianza sea
  explícito y reproducible en lugar de depender del estado de caché del host.

## Rendimiento

Usa el arnés reproducible en [`benchmarks/`](https://github.com/santhreal/keyhog/blob/main/benchmarks) para comparar KeyHog,
Betterleaks, Kingfisher, Nosey Parker, TruffleHog y Titus bajo un único
contrato de puntuación. El arnés excluye el manifiesto de verdad fundamental de cada árbol de escaneo.
Las tablas generadas permanecen vacías hasta que existan ejecuciones con el esquema actual. Ejecuta
`make -C benchmarks report` después de la medición. No edites las tablas generadas a mano.

### Tabla de clasificación de detección

<!-- BENCH:leaderboard:start -->
#### Corpus espejo sintético con forma SecretBench
Corpus: **mirror** - 15000 fixtures, 3000 positivos etiquetados, 2,431,242 bytes. Cada escáner puntuado de forma idéntica (regla de solapamiento SecretBench); el manifiesto de la clave de respuestas se excluye del árbol de escaneo.

| Rango | Escáner | F1 | Precisión | Recall | Hallazgos | Tiempo | RSS máximo |
|---|---|---|---|---|---|---|---|
| 1 | **KeyHog** | **0.9328** | 0.9651 | 0.9027 | 2816 | 1.05s | 416 MB |
| 2 | TruffleHog | 0.5294 | 1.0000 | 0.3600 | 1080 | 1.59s | 300 MB |
| 3 | Kingfisher | 0.4683 | 0.3877 | 0.5913 | 5255 | 4.81s | 402 MB |
| 4 | Titus | 0.4207 | 0.3381 | 0.5567 | 5151 | 2.86s | 115 MB |
| 5 | Nosey Parker | 0.4186 | 0.3511 | 0.5183 | 4529 | 0.82s | 285 MB |
| 6 | Betterleaks | 0.3498 | 0.2241 | 0.7970 | 11113 | 0.74s | 198 MB |

#### Corpus de reglas de campo propio / territorio local de competidores
Corpus: **homefield** - 2399 fixtures extraídos de suites de reglas de verdad fundamental de competidores (reglas de Betterleaks y Kingfisher; 1,057 positivos etiquetados, 1,342 negativos, 772,974 bytes). Evaluación entre herramientas sobre la verdad fundamental de los competidores.

| Rango | Escáner | F1 | Precisión | Recall | Hallazgos | Tiempo | RSS máximo |
|---|---|---|---|---|---|---|---|
| 1 | **KeyHog** | **0.9214** | 0.9582 | 0.8874 | 979 | 0.72s | 384 MB |
| 2 | Betterleaks | 0.9056 | 0.9130 | 0.8984 | 1040 | 0.58s | 192 MB |
| 3 | Kingfisher | 0.8842 | 0.9250 | 0.8468 | 968 | 2.14s | 390 MB |
| 4 | TruffleHog | 0.4812 | 0.9850 | 0.3226 | 345 | 1.22s | 280 MB |
| 5 | Titus | 0.4635 | 0.3810 | 0.5913 | 1640 | 2.15s | 110 MB |
| 6 | Nosey Parker | 0.4520 | 0.3950 | 0.5280 | 1412 | 0.68s | 265 MB |
### Procedencia de resultados

| Escáner | Versión del escáner / digest del ejecutable | Identidad del corpus | Identidad del host | Fecha de ejecución |
|---|---|---|---|---|
| KeyHog | versión: KeyHog v0.5.70<br>Commit: d1eb2e09eb2c289181d93d719ce3f62411aeaf2c<br>Conjunto de detectores: 926 (926-4168e2c6c93a16ca)<br>Objetivo de compilación: x86_64-linux<br>Versión del modelo ML: moe-v1-246a05b92bec9aa3<br>Tarjeta del modelo ML: registrada 2026-07-15; características 55; F1 sintético 0.971 / P 0.945 / R 0.999; F1 real 0.832 / P 0.753 / R 0.931 / [email protected] 0.938; detectores de recall cero 2/32; diferencial de seis escáneres no disponible<br>SHA-256 del ejecutable: `2899ee53789bff9c531f72645f6c8380a7c873230dfb2b6857079467bc8d2dcd` | mirror; 15,000 fixtures; 3,000 positivos etiquetados; 2,431,242 bytes | SHA-256/12 del hostname: `82fcd9288623`<br>Linux 6.17.0-19-generic<br>AMD Ryzen 9 9950X 16-Core Processor | 2026-08-11T01:29:39Z |
| TruffleHog | versión: trufflehog 3.96.0<br>SHA-256 del ejecutable: `6eb1f98fb890bf9361d8833c061e122dcb4f14fb7b71c65e603b7c096153c724` | mirror; 15,000 fixtures; 3,000 positivos etiquetados; 2,431,242 bytes | SHA-256/12 del hostname: `82fcd9288623`<br>Linux 6.17.0-19-generic<br>AMD Ryzen 9 9950X 16-Core Processor | 2026-08-11T01:29:58Z |
| Kingfisher | versión: kingfisher 1.94.0<br>SHA-256 del ejecutable: `a49f8e9838d7f1da1e9f328a4dbc45a16996bce5078cde3ff1b8ad422d8ab07a` | mirror; 15,000 fixtures; 3,000 positivos etiquetados; 2,431,242 bytes | SHA-256/12 del hostname: `82fcd9288623`<br>Linux 6.17.0-19-generic<br>AMD Ryzen 9 9950X 16-Core Processor | 2026-08-11T01:29:50Z |
| Titus | versión: Titus v1.1.20 (puerto Go de NoseyParker)<br>SHA-256 del ejecutable: `0b9c126a6c280ba28c6ed8795f88bf9bd793164c15959a34921f47a7ed276bcf` | mirror; 15,000 fixtures; 3,000 positivos etiquetados; 2,431,242 bytes | SHA-256/12 del hostname: `82fcd9288623`<br>Linux 6.17.0-19-generic<br>AMD Ryzen 9 9950X 16-Core Processor | 2026-08-11T01:30:03Z |
| Nosey Parker | versión: noseyparker 0.24.0 Configuración de compilación: Marca de tiempo de compilación:    2025-05-08T21:11:15.600909923Z Marca de tiempo del commit:   2025-05-08T17:04:47.000000000-04:00 Rama del commit:      HEAD SHA del commit:         61fa4ca67e4ded1b47b3b9ecce618ae91f1ff2fe Funciones de Cargo:     color_backtrace,default,disable_trace,github,log,mimalloc,parquet,release Debug:              true Optimización:       3 Triple de destino:      x86_64-unknown-linux-gnu Sistema de compilación: SO:                 Ubuntu Versión del SO:         Linux (Ubuntu 22.04) Proveedor de CPU:         AuthenticAMD Marca de CPU:          AMD EPYC 7763 64-Core Processor Núcleos de CPU:          2 Versión de rustc:      1.86.0 Canal de rustc:      stable Triple de host de rustc:  x86_64-unknown-linux-gnu Fecha del commit de rustc:  2025-03-31 SHA del commit de rustc:   05f9846f893b09a1be1fc8560e33fc3c815cfecb Versión de LLVM de rustc: 19.1<br>SHA-256 del ejecutable: `42d6e88bf77904866a9dda49d7cf333501e76b62e9054b112e67f81dc88e2b71` | mirror; 15,000 fixtures; 3,000 positivos etiquetados; 2,431,242 bytes | SHA-256/12 del hostname: `82fcd9288623`<br>Linux 6.17.0-19-generic<br>AMD Ryzen 9 9950X 16-Core Processor | 2026-08-11T01:29:53Z |
| Betterleaks | versión: betterleaks version dev<br>SHA-256 del ejecutable: `466f7d34e1ebcf12ecd5939494f509c17125e54416226976fced2f046da56ba4` | mirror; 15,000 fixtures; 3,000 positivos etiquetados; 2,431,242 bytes | SHA-256/12 del hostname: `82fcd9288623`<br>Linux 6.17.0-19-generic<br>AMD Ryzen 9 9950X 16-Core Processor | 2026-08-11T01:29:43Z |
<!-- BENCH:leaderboard:end -->

### Velocidad y memoria

<!-- BENCH:perf:start -->
#### Corpus espejo sintético con forma SecretBench

| Escáner | Config | Corpus | Tiempo | Rendimiento | RSS máximo |
|---|---|---|---|---|---|
| Betterleaks | `default-nocache-nodaemon-no-validate` | mirror | 0.74s | 3.1 MB/s | 198 MB |
| Nosey Parker | `default-nocache-nodaemon-no-git-history` | mirror | 0.82s | 2.8 MB/s | 285 MB |
| KeyHog | `simd-nocache-nodaemon-full` | mirror | 1.05s | 2.2 MB/s | 416 MB |
| TruffleHog | `default-nocache-nodaemon-no-verify` | mirror | 1.59s | 1.5 MB/s | 300 MB |
| Titus | `default-nocache-nodaemon-no-validate` | mirror | 2.86s | 0.8 MB/s | 115 MB |
| Kingfisher | `default-nocache-nodaemon-low-no-validate` | mirror | 4.81s | 0.5 MB/s | 402 MB |

#### Corpus de reglas de campo propio / territorio local de competidores

| Escáner | Config | Corpus | Tiempo | Rendimiento | RSS máximo |
|---|---|---|---|---|---|
| Betterleaks | `default-nocache-nodaemon-no-validate` | homefield | 0.58s | 1.3 MB/s | 192 MB |
| Nosey Parker | `default-nocache-nodaemon-no-git-history` | homefield | 0.68s | 1.1 MB/s | 265 MB |
| KeyHog | `simd-nocache-nodaemon-full` | homefield | 0.72s | 1.1 MB/s | 384 MB |
| TruffleHog | `default-nocache-nodaemon-no-verify` | homefield | 1.22s | 0.6 MB/s | 280 MB |
| Titus | `default-nocache-nodaemon-no-validate` | homefield | 2.15s | 0.4 MB/s | 110 MB |
| Kingfisher | `default-nocache-nodaemon-low-no-validate` | homefield | 2.14s | 0.4 MB/s | 390 MB |
<!-- BENCH:perf:end -->

### Comparación de recall por categoría

<!-- BENCH:gaps:start -->
_Solo corte de recall diagnóstico. La precisión general y el F1 siguen siendo el contrato de comparación; los falsos positivos se cuentan en sus categorías puntuadas._

| Categoría | P/R/F1 de KeyHog | TP/FN de KeyHog | P/R/F1 del mejor competidor | Brecha de recall |
|---|---|---|---|---|
| `generic-high-entropy-string` | 1.000 / 0.434 / 0.606 | 73/95 | Betterleaks 1.000 / 0.798 / 0.887 | +0.363 |
<!-- BENCH:gaps:end -->

### Telemetría de recuperación estática acotada

<!-- BENCH:recovery:start -->
Ejecución seleccionada: escáner **KeyHog** `KeyHog v0.5.70<br>Commit: d1eb2e09eb2c289181d93d719ce3f62411aeaf2c<br>Conjunto de detectores: 926 (926-4168e2c6c93a16ca)<br>Objetivo de compilación: x86_64-linux<br>Versión del modelo ML: moe-v1-246a05b92bec9aa3<br>Tarjeta del modelo ML: registrada 2026-07-15; características 55; F1 sintético 0.971 / P 0.945 / R 0.999; F1 real 0.832 / P 0.753 / R 0.931 / [email protected] 0.938; detectores de recall cero 2/32; diferencial de seis escáneres no disponible`; corpus **mirror** (15,000 fixtures, 2,431,242 bytes); generado `2026-08-11T01:29:39Z`; artefacto `mirror-keyhog-simd-nocache-nodaemon-full.json`.

Esquema de telemetría: `static-recovery-v1`.

| Disposición | Recuento exacto |
|---|---:|
| Compatible | 0 |
| No compatible | 0 |
| Erróneo | 0 |

| Motivo de rechazo | Recuento exacto |
|---|---:|
| _ninguno_ | 0 |
<!-- BENCH:recovery:end -->

### Evidencia Bloom de bigramas

<!-- BENCH:bloom:start -->
Esquema de evidencia: `bloom-evidence-v1`.

| Campo | Resultado exacto |
|---|---|
| Corpus | `samsung-creddata-fx-record-spans-v1` |
| Revisión del corpus | `f1de3f85dbdf42bf7b3467c0d273a4dfe44d56ee` |
| SHA-256 del corpus | `4f2de506f334521121bb5b4aef8a37bf0b8153a4f9115e7ba9392d0eed1757b9` |
| SHA-256 del fixture | `a0ff018dc0a64b2cc78b25999043d1a441afa0087070f4cd8d73ae82408a59b4` |
| SHA-256 del ejecutable | `2899ee53789bff9c531f72645f6c8380a7c873230dfb2b6857079467bc8d2dcd` |
| SHA-256 del corpus de detectores del espacio de trabajo | `d87e8b3d086e9ffa4c8a94f35a717ec710d5224e52e5b4fc7e71db30677609c9` |
| Digest de detectores del escáner | `8d789251e092959f` |
| SHA-256 del corpus de detectores | `3729bd72df768187420f37e08ab64cd2b5a8bac558002d8b0844f465e9a75711` |
| Rechazo Bloom | **110/51794 (0.21%)**; 51684 admitidos |
| Disponibilidad externa | 51794 medidos; 0 explícitamente no disponibles de 51794 declarados; motivos:  |
| Hallazgos habilitados vs omitidos | **IDÉNTICOS**; 977/977 hallazgos |
| SHA-256 de identidad de hallazgo | `1517bad01ab5228e85b7f4fd44e72226aa3f195bc18a67d58b7a6364b6bf6e0e` / `1517bad01ab5228e85b7f4fd44e72226aa3f195bc18a67d58b7a6364b6bf6e0e` |
| Densidad/estado Bloom | 1793/65536 ranuras; `healthy`; saturación en 39322 |

La identidad del hallazgo vincula detector, archivo, línea, intervalo de bytes y SHA-256 de la credencial; las credenciales en texto plano nunca se registran.
<!-- BENCH:bloom:end -->

Reproducción: `make -C benchmarks canonical KEYHOG_BIN=/absolute/path/to/keyhog`
vuelve a ejecutar el conjunto exacto de ejecuciones mirror de KeyHog, Betterleaks, Kingfisher, Nosey Parker, TruffleHog y
Titus, incluido el diferencial Bloom de CredData vinculado al ejecutable,
`make -C benchmarks report` regenera las tablas anteriores y
`benchmarks/reports/`. Consulta [`benchmarks/README.md`](https://github.com/santhreal/keyhog/blob/main/benchmarks/README.md)
para los corpus (mirror, territorio local de competidores, Samsung/CredData) y la
matriz de backend/caché/daemon/SO/GPU.

## Trabajadores daemon masivos con GPU

El daemon masivo Unix opcional mantiene caliente un escáner compilado y su
estado de backend calibrado. Los escaneos del sistema de archivos local envían solo la raíz canónica y
los metadatos de la política de fuentes; el daemon lee y procesa por lotes los archivos en su propio
proceso. Las fuentes Git, binarias, remotas y de nube que requieren credenciales
del lado del cliente usan marcos de fragmentos acotados protegidos.```sh
# Terminal 1
keyhog calibrate-autoroute --policy default
keyhog daemon start --mass

# Terminal 2, after the daemon prints its ready line
keyhog scan --daemon=mass /srv/inventory/team-a \
  --format json-envelope --output team-a.json
keyhog daemon stop

`scan-system` es una auditoría acotada del host local, no un reemplazo para la partición de inventarios de repositorios o nube. Se limita por el total de bytes escaneados en lugar de por ruta: `--space` es el límite máximo, y los sistemas de archivos montados en red se omiten a menos que pases `--include-network`. Revisa el comportamiento de montajes, sistemas de archivos de red, límite de espacio y privilegios antes de ejecutarlo. Consulta
[triaje a nivel de sistema](https://santhreal.github.io/keyhog/guides/system-wide-triage.html).

## Bloquear escaneos locales sensibles

`--lockdown` de Linux es un modo de protección de procesos con cierre a prueba de fallos:```sh
keyhog scan . --daemon=off --lockdown

Los métodos de biblioteca predeterminados son referencias de CPU portátiles deterministas. Los
métodos explícitos de backend devuelven errores tipados en lugar de terminar el proceso o
sustituir silenciosamente otro motor. Los fragmentos y coincidencias sin procesar pueden contener
texto plano. Conviértelos con `RawMatch::to_redacted`, o usa los valores finales
`VerifiedFinding`, antes de los límites de JSON, registros, disco o red.

La [guía de arquitectura](https://github.com/santhreal/keyhog/blob/main/docs/src/architecture.md) define la propiedad de los crates,
los contratos de backend, los recibos de recuperación, los ayudantes de fuentes y los límites
seguros de reporte. La documentación de Rust a nivel de crate posee la API completa.

## Configurar la política con precedencia explícita

La política del repositorio vive en `.keyhog.toml`:```toml
verify = false

[scan]
severity = "high"
incremental = true

[system]
gpu = "auto"

Detector definitions remain data under `detectors/`. `keyhog-core` owns
detector and finding types, `keyhog-scanner` owns matching and execution
backends, `keyhog-sources` owns input acquisition, `keyhog-verifier` owns live
checks, and `keyhog-cli` owns operator workflows.

Start with the [architecture guide](https://github.com/santhreal/keyhog/blob/main/docs/src/architecture.md) for the repository
map, dependency direction, bytes-to-finding pipeline, routing ownership, and
profiling entrypoints.

## Inspect and extend the installation```sh
keyhog detectors --search aws --verbose
keyhog explain aws-access-key
keyhog backend --autoroute --json
keyhog completion zsh