<p align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/7654/dfb768a9b8e8fa64082992f11d0b284d5ec6a199fc1eac85e0352fb20452186f.gif" alt="Escaneo de KeyHog que muestra severidad, confianza, 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 a KeyHog. Los disparadores de los 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, confianza e informes
utilizado por las rutas de CPU e Hyperscan.

- **Tres peers físicos de GPU.** CUDA, Metal nativo y WGPU portátil son
  adquiridos, medidos e informados 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 de ruta persistente.** 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 hacen benchmarking en la ruta crítica.
- **Ejecución residente.** Los workers del daemon mantienen caliente el estado compilado de detectores y aceleradores
  para lotes repetidos de archivos, archivos comprimidos, historial, remotos y en la nube.
- **Sin escotilla de escape oculta a 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 portátil de CPU pura en Rust, 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

La [guía de backend](https://santhreal.github.io/keyhog/backends.html) documenta
las tablas residentes, el modelo de despacho acotado, el contrato de paridad y la
evidencia reproducible de cruce.

## Comenzar

### Instala y ejecuta tu primer escaneo

Los dos comandos anteriores instalan la última versión de crates.io y escanean el
árbol actual con la ruta portátil de Rust puro.

Fija un entorno de CI a una versión exacta con
`cargo install --locked --version '=0.5.75' keyhog`. KeyHog requiere Rust 1.89
o superior. Consulta la [guía de instalación](https://santhreal.github.io/keyhog/install.html)
para los perfiles GPU, Hyperscan, CI, portátil y de compilación desde el código fuente.

KeyHog sale con `0` cuando el escaneo está limpio y con `1` cuando informa hallazgos por encima de tu
umbral de gravedad. La salida `1` significa que el escáner funcionó. Revisa el archivo, la línea, el detector y la corrección de cada hallazgo antes de decidir si eliminar,
rotar o suprimir la credencial. Otros códigos distintos de cero describen fallos de entrada,
sistema, verificación o cobertura; consulta la
[referencia de códigos de salida](https://santhreal.github.io/keyhog/reference/exit-codes.html).

El contrato completo del proceso es:

| Salida | Significado |
|---|---|
| `0` limpio | El escaneo se completó sin hallazgos reportables ni fallos de cobertura. |
| `1` hallazgos | Hay hallazgos, pero ninguno se confirmó como activo. |
| `2` error del operador | Corrige los argumentos, la configuración, el corpus de detectores o la entrada corregible por el operador. |
| `3` error del sistema | Repara o reintenta el ejecutor. Esto incluye E/S de bajo nivel, fallos fatales del servicio daemon, caché incremental y fallos SIMD seleccionados explícitamente. |
| `4` `backend --self-test` o fallo de mantenimiento | La instalación, reparación, backend o verificación de salud de autoroute solicitada no era saludable. |
| `10` credenciales activas | Al menos una credencial se confirmó como activa. `update --check` también usa este código cuando existe una versión más reciente. |
| `11` pánico del escáner | Descarta el resultado del escaneo porque el estado del escáner no es confiable. |
| `12` fallo de GPU requerido | Una ruta de GPU seleccionada o requerida explícitamente no pudo ejecutarse. |
| `13` cobertura incompleta | Una fuente solicitada falló o la cobertura de entrada fue incompleta, y ningún resultado de hallazgo tuvo prioridad. |
| `130` interrumpido | SIGINT o Ctrl-C interrumpió el proceso. |

**Filtro, formato y compuerta:**

Crea una línea base antes de usarlo como filtro:```sh
keyhog scan . --create-baseline .keyhog-baseline.json
keyhog scan . --baseline .keyhog-baseline.json --format json-envelope --output keyhog.json

La Action escanea el árbol verificado, falla en hallazgos de gravedad `high` o `critical`, sube SARIF a Code Scanning y conserva el informe como artefacto del workflow. Los fallos de instalación, cobertura, backend y publicación del informe también hacen fallar el job.

Usa la [guía de GitHub Action](https://santhreal.github.io/keyhog/workflows/github-action.html) para entradas, salidas, adopción de líneas 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 trabajos de GitLab, CircleCI, Jenkins, Buildkite y shell genéricos. Usa la [guía de escaneo masivo](https://santhreal.github.io/keyhog/guides/mass-scanning.html) para organizaciones de repositorios, grupos 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 los archivos fuente rastreados. Usa un informe por límite para que el CI conserve la cobertura exacta y el estado de fallo.

| Superficie de exposición | Ejemplo |
|---|---|
| Artefacto final del paquete | Ejecuta `npm pack` y luego escanea el `.tgz` generado con `keyhog scan package.tgz`. La expansión del archivo comprueba archivos generados, source maps, fixtures y metadatos que no están en el árbol fuente esperado. |
| Aplicación de navegador desplegada | `keyhog scan --url https://app.example.com/assets/app.js` sigue JavaScript acotado, source maps, WASM y decodificación de respuestas sin convertir el escáner en un rastreador sin límites. |
| Issues, pull requests, discusiones, wikis y gists de GitHub | `keyhog scan --github-collaboration owner/repo --github-all` escanea todas las superficies 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, confianza 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 en el informe de terminal la cobertura de paginación, objetos y límite de bytes del proveedor. |
| Host de desarrollo completo | `sudo keyhog scan-system --space 50G` descubre sistemas de archivos montados e historial de Git accesible bajo un presupuesto de almacenamiento estricto. |

Estas rutas comparten un mismo 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 a historial de Git, inventario de proveedor, almacenamiento en la nube ni auditoría de host.

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

| Necesidad | Empieza con | Rendimiento y reutilización | Límite de cobertura |
|---|---|---|---|
| Retroalimentación local rápida | `keyhog scan . --fast --incremental` | Reutiliza los hashes de archivos sin cambios. El preset rápido omite el trabajo de decodificación, entropía y ML. | Ejecuta la política predeterminada antes del merge porque rápido es intencionadamente 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 los archivos actuales. No añade historial de Git. |
| Puerta de commit en staged | `keyhog scan --git-staged` o `keyhog hook install` | Lee los blobs exactos del índice, por lo que los cambios sin stage no pueden alterar el resultado. | Solo contenido en staged. Ejecuta un escaneo del árbol de trabajo por separado cuando los bytes locales sin stage importan. |
| Guardián perpetuo de 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íticas. | Requiere un daemon en ejecución. El guardián complementa, no reemplaza, los escaneos en staged 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 sola ruta con checkout. Usa el escaneo de inventarios de proveedor para una organización. |
| CI de GitLab, Jenkins, Buildkite o shell | `keyhog scan . --format json-envelope --output keyhog.json` | Persiste el informe y el código de salida en éxito, hallazgos y errores. Usa `--git-diff <base>` solo para una puerta de líneas cambiadas 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 el commit y luego escanea con `--baseline .keyhog-baseline.json`. | Las identidades existentes permanecen visibles en la línea base mientras que solo los hallazgos nuevos hacen fallar la puerta. | Una línea base no suprime credenciales cambiadas ni cobertura incompleta. |
| Recuperación recursiva de Git | `keyhog scan --deep --git-history . --git-blobs . --daemon=off` | Calibra la política deep una vez por clase de worker. Ejecútalo en el proceso. | Un repositorio. `--git-history` cubre solo la ascendencia del checkout actual, por lo que una rama que nunca has revisado se omite sin generar una brecha de cobertura; `--git-blobs` alcanza también blobs colgantes, commits eliminados por amend, stashes, notas, mensajes de tags anotados y refs empaquetadas. |
| Inspección de contenedores o archivos | `keyhog scan --docker-image registry/app:v1` o `keyhog scan incoming/` | Conserva un informe envelope para que los miembros omitidos, corruptos, cifrados, inseguros o de tamaño excesivo sigan siendo visibles. | Solo la imagen o ruta del sistema de archivos seleccionada y los formatos anidados admitidos. |
| 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 job. La paginación o los límites de objetos siguen siendo límites de cobertura. |
| Confirmar si los hallazgos elegibles están activos | `keyhog scan . --verify` | La concurrencia y los límites de tasa del proveedor están separados de los workers del escáner. | Envía solicitudes derivadas de credenciales a los endpoints del proveedor declarados. 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 requieren habilitación explícita y el límite de espacio es estricto. |
| Inventario de directorio, historial, archivo, remoto o nube con respaldo de 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 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 el total exacto y los lotes de GPU, chunks, bytes, proporción 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 al daemon. |

### Escanea cada límite de fuente admitido

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 que cambian continuamente | `keyhog watch services/api deploy/` |
| Bytes en staged, líneas cambiadas, historial accesible o blobs | `keyhog scan --git-staged`, `--git-diff main`, `--git-history .` o `--git-blobs .` |
| Binarios nativos y cadenas de firmware | `keyhog scan --binary firmware.bin` (un escaneo de directorio simple omite los binarios y aun así sale con `0`) |
| Archivos y fuentes comprimidas | `keyhog scan incoming/` (los miembros admitidos se expanden automáticamente) |
| Capas de imágenes de Docker | `keyhog scan --docker-image registry/app:v1` |
| JavaScript, source maps, WASM o respuesta de un endpoint | `keyhog scan --url https://api.example.com/config` |
| Capturas de solicitudes y respuestas HTTP | `keyhog scan capture.har` |
| Issues, pull requests, discusiones, 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 S3, GCS o Azure Blob | `--s3-bucket BUCKET`, `--gcs-bucket BUCKET` o `--azure-container-url URL` |
| Un flujo acotado desde otra herramienta | `producer \| keyhog scan --stdin` (usa `set -o pipefail` para que un productor que falla 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 dentro del alcance. Ese flag necesita una compilación con la característica `binary`, que la instalación predeterminada de crates.io incluye y la característica ligera `ci` no incluye.

La extracción de binarios nativos reporta credenciales completas que cumplen el contrato de forma explícito de un detector nombrado. Suprime fragmentos cortos de prefijo y cadenas 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 es acotada y está protegida contra SSRF. No es un rastreador. Los endpoints de nube privados y el reenvío de credenciales requieren sus flags de confianza explícitos. Los tokens de proveedor van en las variables de entorno documentadas, no en 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

Empieza con los valores predeterminados. El instalador histórico verificado de activos binarios ejecuta la calibración por sí mismo. Cargo no puede ejecutar KeyHog después de `cargo install`, así que ejecuta los comandos siguientes una vez después de instalar una compilación 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 al trabajo se le asignan cuatro workers de escaneo y un
worker de lectura:```sh
keyhog scan . --threads 4 --reader-threads 1 \
  --format json-envelope --output keyhog.json

Compila la copia del repositorio cuando necesites un cambio sin publicar:```sh
cargo install --path crates/cli --locked

Utiliza la [guía de instalación](https://santhreal.github.io/keyhog/install.html) para conocer los requisitos del toolchain de Rust, los perfiles de funcionalidades y las dependencias de ejecución específicas de cada plataforma.


## Qué detecta

926 detectores integrados con validación offline propia y compañeros:

- **Proveedores de nube:** AWS (access key + secret + verificación STS),
  Azure (subscription key, storage account key, SAS), GCP (service account,
  API key), Cloudflare, Heroku, Vercel, Supabase.
- **Procesadores de pago:** Stripe, Braintree, Razorpay, Paddle, Plaid,
  Square y PayPal, con comprobaciones propias de cada detector y compañeros
  opcionales u obligatorios. Una Razorpay key secret requiere su key ID cercano.
- **Forjas de código:** PATs de GitHub (con checksum CRC32), tokens de GitLab,
  contraseñas de aplicación de Bitbucket, tokens de npm (con checksum),
  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, rol de
  servicio de Supabase, PlanetScale, Neon, Turso, MySQL, URLs de Redis.
- **Genéricos + descubrimiento por entropía:** `API_KEY=<blob-de-alta-entropía>` detecta
  credenciales sin detector específico, controlado 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/HEAD/detectors/) (datos, no código):
metadatos del servicio, patrones regex, palabras clave, validadores offline, política de
entropía y ML, campos de compañeros y manejador de verificación. Añadir un nuevo detector es un
único cambio TOML revisable;
la [guía del colaborador](https://github.com/santhreal/keyhog/blob/HEAD/CONTRIBUTING.md) lo explica paso a paso.

`keyhog explain <id>` muestra la especificación completa de cualquier detector: patrones, palabras clave,
endpoint de verificación, además de una guía de rotación y remediación
paso a paso específica del servicio, para 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/HEAD/docs/src/detectors.md), o consulta el corpus instalado con
`keyhog detectors --search <term> --verbose`.

## Por qué más recall y menos falsos positivos

- **Escaneo con decodificación.** Manifiestos `Secret` de Kubernetes, notebooks
  de Jupyter, payloads JWT, entornos envueltos en base64, valores de Helm y blobs
  `auth:` de docker-config. El preprocesador estructurado trata las acciones Helm balanceadas 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 valores
  estructurados en su lugar y alimenta a todos los detectores posteriores con el texto plano. Los detectores
  no necesitan reimplementar la decodificación cada uno. Los escaneos con decodificación también recuperan
  expresiones XOR de byte-array en JavaScript y AES-256-CBC sin efectos secundarios cuando
  todo el material de recuperación está incrustado, incluyendo envoltorios estrictos de passphrase salada CryptoJS/OpenSSL. KeyHog nunca ejecuta el código fuente.
- **Reensamblado multilínea.** Continuación con `"sk-proj-" + \` en JavaScript,
  cadenas multilínea de YAML, continuación con barra invertida en Makefile,
  salidas de plantillas Helm / Jinja, todo reensamblado antes del emparejamiento regex.
- **Validación por compañeros.** Los compañeros obligatorios filtran los detectores de alto ruido. Una
  API key de Twilio sin su API secret se omite. Los compañeros opcionales enriquecen la
  confianza o la verificación. La detección de access-key de AWS no requiere su
  secret, pero el secret es necesario para la verificación en vivo.
- **Resolución entre detectores.** El TOML de un detector puede exigir, 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.
- **Puntuación de confianza.** Cada hallazgo lleva una puntuación `[0.0, 1.0]`
  derivada de la entropía de Shannon, el contexto circundante, la coincidencia de compañeros,
  la prueba offline propia del detector (CRC32 de GitHub/npm y decodificación de payload PyPI),
  la evidencia estructural y un pequeño clasificador ML
  (~30k parámetros). El umbral predeterminado `0.40` (el mínimo canónico
  de `ScanConfig::default()`; igual que el predeterminado de `--min-confidence`
  y el `[scan].min_confidence` del ejemplo siguiente) filtra las coincidencias
  de baja calidad sin ocultar secretos reales.
- **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 harness reproducible en [`benchmarks/`](https://github.com/santhreal/keyhog/blob/HEAD/benchmarks/) para comparar KeyHog,
Betterleaks, Kingfisher, Nosey Parker, TruffleHog y Titus bajo un mismo contrato
de puntuación. El harness excluye el manifiesto de ground-truth 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 medir. No edites las tablas generadas a mano.

### Clasificación de detección

<!-- BENCH:leaderboard:start -->
Corpus: **mirror** - 15000 fixtures, 3000 positivos etiquetados. Todos los escáneres puntuados 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 |

### Procedencia de resultados

| Escáner | Versión del escáner / digest del ejecutable | Identidad del corpus | Identidad del host | Fecha de ejecución |
|---|---|---|---|---|
| KeyHog | version: KeyHog v0.5.70<br>Commit: d1eb2e09eb2c289181d93d719ce3f62411aeaf2c<br>Detector Set: 926 (926-4168e2c6c93a16ca)<br>Build Target: x86_64-linux<br>ML Model Version: moe-v1-246a05b92bec9aa3<br>ML Model Card: recorded 2026-07-15; features 55; synthetic F1 0.971 / P 0.945 / R 0.999; real F1 0.832 / P 0.753 / R 0.931 / [email protected] 0.938; zero-recall detectors 2/32; six-scanner differential unavailable<br>executable SHA-256: `2899ee53789bff9c531f72645f6c8380a7c873230dfb2b6857079467bc8d2dcd` | mirror; 15,000 fixtures; 3,000 positivos etiquetados; 2,431,242 bytes | hostname SHA-256/12: `82fcd9288623`<br>Linux 6.17.0-19-generic<br>AMD Ryzen 9 9950X 16-Core Processor | 2026-08-11T01:29:39Z |
| TruffleHog | version: trufflehog 3.96.0<br>executable SHA-256: `6eb1f98fb890bf9361d8833c061e122dcb4f14fb7b71c65e603b7c096153c724` | mirror; 15,000 fixtures; 3,000 positivos etiquetados; 2,431,242 bytes | hostname SHA-256/12: `82fcd9288623`<br>Linux 6.17.0-19-generic<br>AMD Ryzen 9 9950X 16-Core Processor | 2026-08-11T01:29:58Z |
| Kingfisher | version: kingfisher 1.94.0<br>executable SHA-256: `a49f8e9838d7f1da1e9f328a4dbc45a16996bce5078cde3ff1b8ad422d8ab07a` | mirror; 15,000 fixtures; 3,000 positivos etiquetados; 2,431,242 bytes | hostname SHA-256/12: `82fcd9288623`<br>Linux 6.17.0-19-generic<br>AMD Ryzen 9 9950X 16-Core Processor | 2026-08-11T01:29:50Z |
| Titus | version: Titus v1.1.20 (Go port of NoseyParker)<br>executable SHA-256: `0b9c126a6c280ba28c6ed8795f88bf9bd793164c15959a34921f47a7ed276bcf` | mirror; 15,000 fixtures; 3,000 positivos etiquetados; 2,431,242 bytes | hostname SHA-256/12: `82fcd9288623`<br>Linux 6.17.0-19-generic<br>AMD Ryzen 9 9950X 16-Core Processor | 2026-08-11T01:30:03Z |
| Nosey Parker | version: noseyparker 0.24.0 Build Configuration: Build Timestamp:    2025-05-08T21:11:15.600909923Z Commit Timestamp:   2025-05-08T17:04:47.000000000-04:00 Commit Branch:      HEAD Commit SHA:         61fa4ca67e4ded1b47b3b9ecce618ae91f1ff2fe Cargo Features:     color_backtrace,default,disable_trace,github,log,mimalloc,parquet,release Debug:              true Optimization:       3 Target Triple:      x86_64-unknown-linux-gnu Build System: OS:                 Ubuntu OS Version:         Linux (Ubuntu 22.04) CPU Vendor:         AuthenticAMD CPU Brand:          AMD EPYC 7763 64-Core Processor CPU Cores:          2 rustc Version:      1.86.0 rustc Channel:      stable rustc Host Triple:  x86_64-unknown-linux-gnu rustc Commit Date:  2025-03-31 rustc Commit SHA:   05f9846f893b09a1be1fc8560e33fc3c815cfecb rustc LLVM Version: 19.1<br>executable SHA-256: `42d6e88bf77904866a9dda49d7cf333501e76b62e9054b112e67f81dc88e2b71` | mirror; 15,000 fixtures; 3,000 positivos etiquetados; 2,431,242 bytes | hostname SHA-256/12: `82fcd9288623`<br>Linux 6.17.0-19-generic<br>AMD Ryzen 9 9950X 16-Core Processor | 2026-08-11T01:29:53Z |
| Betterleaks | version: betterleaks version dev<br>executable SHA-256: `466f7d34e1ebcf12ecd5939494f509c17125e54416226976fced2f046da56ba4` | mirror; 15,000 fixtures; 3,000 positivos etiquetados; 2,431,242 bytes | hostname SHA-256/12: `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 -->
| 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 |
<!-- BENCH:perf:end -->

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

<!-- BENCH:gaps:start -->
_Corte de recall diagnóstico solamente. 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 | KeyHog P/R/F1 | KeyHog TP/FN | Mejor competidor P/R/F1 | 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>Detector Set: 926 (926-4168e2c6c93a16ca)<br>Build Target: x86_64-linux<br>ML Model Version: moe-v1-246a05b92bec9aa3<br>ML Model Card: recorded 2026-07-15; features 55; synthetic F1 0.971 / P 0.945 / R 0.999; real F1 0.832 / P 0.753 / R 0.931 / [email protected] 0.938; zero-recall detectors 2/32; six-scanner differential unavailable`; 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 |
|---|---:|
| Soportado | 0 |
| No soportado | 0 |
| Erróneo | 0 |

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

### Evidencia de 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 workspace | `d87e8b3d086e9ffa4c8a94f35a717ec710d5224e52e5b4fc7e71db30677609c9` |
| Digest del detector 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 del hallazgo | `1517bad01ab5228e85b7f4fd44e72226aa3f195bc18a67d58b7a6364b6bf6e0e` / `1517bad01ab5228e85b7f4fd44e72226aa3f195bc18a67d58b7a6364b6bf6e0e` |
| Densidad/estado de 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 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/HEAD/benchmarks/README.md)
para conocer los corpus (mirror, territorio local de los 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 único 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 agrupa 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 el inventario de repositorios o particiones en la 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 montaje, sistema de archivos de red, límite de espacio y privilegios antes de ejecutarlo. Consulta [triage de todo el sistema](https://santhreal.github.io/keyhog/guides/system-wide-triage.html).

## Bloquea escaneos locales sensibles

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

Los métodos de biblioteca predeterminados son referencias de CPU portátiles deterministas. Los métodos de backend explícitos 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értalos con `RawMatch::to_redacted`, o use 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/HEAD/docs/src/architecture.md) define la propiedad de las crates, los contratos de backend, los recibos de recuperación, los ayudantes de fuente y los límites seguros de generación de informes. La documentación de Rust a nivel de crate posee la API completa.

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

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

[scan]
severity = "high"
incremental = true

[system]
gpu = "auto"

Las definiciones de detectores permanecen como datos en `detectors/`. `keyhog-core` es responsable de
los tipos de detectores y hallazgos, `keyhog-scanner` es responsable del emparejamiento y la ejecución
de backends, `keyhog-sources` es responsable de la adquisición de entradas, `keyhog-verifier` es responsable de las comprobaciones
en vivo, y `keyhog-cli` es responsable de los flujos de trabajo del operador.

Comienza con la [guía de arquitectura](https://github.com/santhreal/keyhog/blob/HEAD/docs/src/architecture.md) para el mapa
del repositorio, la dirección de dependencias, el pipeline de bytes a hallazgos, la propiedad del enrutamiento y
los puntos de entrada de profiling.

## Inspecciona y amplía la instalación```sh
keyhog detectors --search aws --verbose
keyhog explain aws-access-key
keyhog backend --autoroute --json
keyhog completion zsh