Encontrar, verificar y analizar credenciales filtradas
<p align="center">
<img alt="GoReleaser Logo" src="https://assets.kitploit.com/production/public/readmes/3815/31dbdb577b88b3a967e2c18f9b0f3d4a7031dafe7e392c51320178aba6352603.png" height="140" />
<h2 align="center">TruffleHog</h2>
<p align="center">Encuentra credenciales filtradas.</p>
</p>
---
<div align="center">
[](https://goreportcard.com/report/github.com/trufflesecurity/trufflehog/v3)
[](/LICENSE)
[](/pkg/detectors)
</div>
---
# :mag_right: _Ahora escaneando_
<div align="center">
<img src="https://raw.githubusercontent.com/trufflesecurity/trufflehog/HEAD/assets/scanning_logos.svg">
**...y más**
Para obtener más información sobre TruffleHog y sus características y capacidades, visite nuestra [página de producto](https://trufflesecurity.com/trufflehog?gclid=CjwKCAjwouexBhAuEiwAtW_Zx5IW87JNj97Ci7heFnA5ar6-DuNzT2Y5nIl9DuZ-FOUqx0Qg3vb9nxoClcEQAvD_BwE).
</div>
# :globe_with_meridians: TruffleHog Enterprise
¿Está interesado en monitorear continuamente **Git, Jira, Slack, Confluence, Microsoft Teams, Sharepoint (y más)** en busca de credenciales? ¡Tenemos un producto empresarial que puede ayudarle! Obtenga más información en <https://trufflesecurity.com/trufflehog-enterprise>.
Destinamos los ingresos del producto empresarial a financiar más proyectos de código abierto increíbles de los que toda la comunidad pueda beneficiarse.
</div>
# Qué es TruffleHog 🐽
TruffleHog es la herramienta más potente de **Descubrimiento, Clasificación, Validación** y **Análisis** de secretos. En este contexto, un secreto se refiere a una credencial que una máquina utiliza para autenticarse ante otra máquina. Esto incluye claves de API, contraseñas de bases de datos, claves de cifrado privadas y más.
## Descubrimiento 🔍
TruffleHog puede buscar secretos en muchos lugares, incluidos Git, chats, wikis, registros, plataformas de pruebas de API, almacenes de objetos, sistemas de archivos y más.
## Clasificación 📁
TruffleHog clasifica más de 800 tipos de secretos, asignándolos a la identidad específica a la que pertenecen. ¿Es un secreto de AWS? ¿Un secreto de Stripe? ¿Un secreto de Cloudflare? ¿Una contraseña de Postgres? ¿Una clave privada SSL? A veces es difícil saberlo con solo mirarlo, por lo que TruffleHog clasifica todo lo que encuentra.
## Validación ✅
Para cada secreto que TruffleHog puede clasificar, también puede iniciar sesión para confirmar si ese secreto está activo o no. Este paso es fundamental para saber si existe un peligro activo presente o no.
## Análisis 🔬
Para los 20 tipos de credenciales más comúnmente filtradas, en lugar de enviar una sola solicitud para comprobar si el secreto puede iniciar sesión, TruffleHog puede enviar muchas solicitudes para conocer todo lo que hay que saber sobre el secreto. ¿Quién lo creó? ¿A qué recursos puede acceder? ¿Qué permisos tiene sobre esos recursos?
# :loudspeaker: Únase a nuestra comunidad
¿Tiene preguntas? ¿Comentarios? Únase a Slack o Discord y pase el rato con nosotros.
Únase a nuestra [Comunidad de Slack](https://join.slack.com/t/trufflehog-community/shared_invite/zt-pw2qbi43-Aa86hkiimstfdKH9UCpPzQ)
Únase al [Discord de Secret Scanning](https://discord.gg/8Hzbrnkr7E)
# :tv: Demostración

```bash
docker run --rm -it -v "$PWD:/pwd" trufflesecurity/trufflehog:latest github --org=trufflesecurity
```
# :floppy_disk: Instalación
Hay varias opciones disponibles para ti:
### Usuarios de MacOS
```bash
brew install trufflehog
```
### Docker:
<sub><i>_Asegúrate de que el motor de Docker esté en ejecución antes de ejecutar los siguientes comandos:_</i></sub>
#### Unix
```bash
docker run --rm -it -v "$PWD:/pwd" trufflesecurity/trufflehog:latest github --repo https://github.com/trufflesecurity/test_keys
```
#### Símbolo del sistema de Windows
```bash
docker run --rm -it -v "%cd:/=\%:/pwd" trufflesecurity/trufflehog:latest github --repo https://github.com/trufflesecurity/test_keys
```
#### Windows PowerShell
```bash
docker run --rm -it -v "${PWD}:/pwd" trufflesecurity/trufflehog github --repo https://github.com/trufflesecurity/test_keys
```
#### Mac M1 y M2
```bash
docker run --platform linux/arm64 --rm -it -v "$PWD:/pwd" trufflesecurity/trufflehog:latest github --repo https://github.com/trufflesecurity/test_keys
```
### Versiones binarias
```bash
Download and unpack from https://github.com/trufflesecurity/trufflehog/releases
```
### Compilar desde el código fuente
```bash
git clone https://github.com/trufflesecurity/trufflehog.git
cd trufflehog; go install
```
### Uso del script de instalación
```bash
curl -sSfL https://raw.githubusercontent.com/trufflesecurity/trufflehog/main/scripts/install.sh | sh -s -- -b /usr/local/bin
```
### Uso del script de instalación, verificación de la firma del checksum (requiere que cosign esté instalado)
```bash
curl -sSfL https://raw.githubusercontent.com/trufflesecurity/trufflehog/main/scripts/install.sh | sh -s -- -v -b /usr/local/bin
```
### Uso del script de instalación para instalar una versión específica
```bash
curl -sSfL https://raw.githubusercontent.com/trufflesecurity/trufflehog/main/scripts/install.sh | sh -s -- -b /usr/local/bin <ReleaseTag like v3.56.0>
```
# :closed_lock_with_key: Verificación de los artefactos
Se aplican sumas de verificación a todos los artefactos, y el archivo de sumas de verificación resultante se firma con cosign.
Necesitas la siguiente herramienta para verificar la firma:
- [Cosign](https://docs.sigstore.dev/cosign/system_config/installation/)
Los pasos de verificación son los siguientes:
1. Descarga los archivos de artefactos que desees y los siguientes archivos de la página de [releases](https://github.com/trufflesecurity/trufflehog/releases).
- trufflehog\_{version}\_checksums.txt
- trufflehog\_{version}\_checksums.txt.pem
- trufflehog\_{version}\_checksums.txt.sig
2. Verifica la firma:
```shell
cosign verify-blob <path to trufflehog_{version}_checksums.txt> \
--certificate <path to trufflehog_{version}_checksums.txt.pem> \
--signature <path to trufflehog_{version}_checksums.txt.sig> \
--certificate-identity-regexp 'https://github\.com/trufflesecurity/trufflehog/\.github/workflows/.+' \
--certificate-oidc-issuer "https://token.actions.githubusercontent.com"
```
3. Una vez confirmado que la firma es válida, puede proceder a validar que las sumas SHA256 coincidan con el artefacto descargado:
```shell
sha256sum --ignore-missing -c trufflehog_{version}_checksums.txt
```
Reemplace `{version}` con la versión de los archivos descargados
Alternativamente, si está utilizando el script de instalación, pase la opción `-v` para realizar la verificación de firma.
Esto requiere que el binario de Cosign esté instalado antes de ejecutar el script de instalación.
# :rocket: Inicio rápido
## 1: Escanear un repositorio solo en busca de secretos verificados
Comando:
```bash
trufflehog git https://github.com/trufflesecurity/test_keys --results=verified
```
Expected output:
```
🐷🔑🐷 TruffleHog. Unearth your secrets. 🐷🔑🐷
Found verified result 🐷🔑
Detector Type: AWS
Decoder Type: PLAIN
Raw result: AKIAYVP4CIPPERUVIFXG
Line: 4
Commit: fbc14303ffbf8fb1c2c1914e8dda7d0121633aca
File: keys
Email: counter <[email protected]>
Repository: https://github.com/trufflesecurity/test_keys
Timestamp: 2022-06-16 10:17:40 -0700 PDT
...
```
## 2: Escanear una organización de GitHub solo en busca de secretos verificados
```bash
trufflehog github --org=trufflesecurity --results=verified
```
## 3: Escanear una organización de GitHub excluyendo los repositorios archivados
```bash
trufflehog github --org=trufflesecurity --exclude-archived
```
## 4: Escanear un repositorio de GitHub solo para secretos verificados y obtener salida JSON
Comando:
```bash
trufflehog git https://github.com/trufflesecurity/test_keys --results=verified --json
```
Expected output:
```
{"SourceMetadata":{"Data":{"Git":{"commit":"fbc14303ffbf8fb1c2c1914e8dda7d0121633aca","file":"keys","email":"counter \[email protected]\u003e","repository":"https://github.com/trufflesecurity/test_keys","timestamp":"2022-06-16 10:17:40 -0700 PDT","line":4}}},"SourceID":0,"SourceType":16,"SourceName":"trufflehog - git","DetectorType":2,"DetectorName":"AWS","DecoderName":"PLAIN","Verified":true,"Raw":"AKIAYVP4CIPPERUVIFXG","Redacted":"AKIAYVP4CIPPERUVIFXG","ExtraData":{"account":"595918472158","arn":"arn:aws:iam::595918472158:user/canarytokens.com@@mirux23ppyky6hx3l6vclmhnj","user_id":"AIDAYVP4CIPPJ5M54LRCY"},"StructuredData":null}
...
```
TruffleHog también puede generar [SARIF](https://docs.oasis-open.org/sarif/sarif/v2.1.0/sarif-v2.1.0.html) con `--sarif` en lugar de `--json`. El escaneo de código de GitHub entiende SARIF de forma nativa, por lo que subirlo muestra los hallazgos en línea en los diffs de las pull requests y en la pestaña Security del repositorio, y realiza un seguimiento de los hallazgos como nuevos/corregidos entre escaneos en lugar de reportar el mismo hallazgo en cada ejecución; consulta la sección [TruffleHog Github Action](#octocat-trufflehog-github-action) más abajo para saber cómo subirlo. Ten en cuenta que, a diferencia de los demás formatos de salida, los resultados SARIF se almacenan en búfer en memoria durante todo el escaneo y se escriben al final, ya que SARIF requiere un único documento JSON en lugar de un flujo; esto está bien para escaneos típicos, pero los escaneos que producen una cantidad muy grande de resultados usarán proporcionalmente más memoria.
## 5: Escanear un repositorio de GitHub + sus issues y pull requests
```bash
trufflehog github --repo=https://github.com/trufflesecurity/test_keys --issue-comments --pr-comments
```
## 6: Escanear un bucket de S3 en busca de resultados de alta confianza (verificados + desconocidos)
```bash
trufflehog s3 --bucket=<bucket name> --results=verified,unknown
```
## 7: Escanear buckets de S3 usando Roles de IAM
```bash
trufflehog s3 --role-arn=<iam role arn>
```
## 8: Escanear un repositorio de Github usando autenticación SSH en Docker
```bash
docker run --rm -v "$HOME/.ssh:/root/.ssh:ro" trufflesecurity/trufflehog:latest git ssh://github.com/trufflesecurity/test_keys
```
## 9: Escanear archivos o directorios individuales
```bash
trufflehog filesystem path/to/file1.txt path/to/file2.txt path/to/dir
```
## 10: Escanear un repositorio git local
Clona el repositorio git. Por ejemplo, el repositorio [test keys](https://github.com/trufflesecurity/trufflehog/blob/main/git%40github.com%3Atrufflesecurity/test_keys.git).
```bash
git clone [email protected]:trufflesecurity/test_keys.git
```
Ejecuta trufflehog desde el directorio padre (fuera del repositorio git).
```bash
trufflehog git file://test_keys --results=verified,unknown
```
Para protegerse contra configuraciones de git maliciosas en el escaneo local (véase CVE-2025-41390), TruffleHog clona los repositorios git locales en un directorio temporal antes de escanear. Esto sigue las [buenas prácticas de seguridad de Git](https://git-scm.com/docs/git#_security). Si desea especificar una ruta personalizada para clonar el repositorio (en lugar de tmp), puede usar el flag `--clone-path`. Si desea omitir el proceso de clonación local y escanear el repositorio directamente (hágalo solo para repositorios de confianza), puede usar el flag `--trust-local-git-config`.
## 11: Escanear buckets de GCS solo en busca de secretos verificados
```bash
trufflehog gcs --project-id=<project-ID> --cloud-environment --results=verified
```
## 12: Escanear una imagen de Docker en busca de secretos solo verificados
Usa la flag `--image` varias veces para escanear varias imágenes.
```bash
# to scan from a remote registry
trufflehog docker --image trufflesecurity/secrets --results=verified
# to scan from the local docker daemon
trufflehog docker --image docker://new_image:tag --results=verified
# to scan from an image saved as a tarball
trufflehog docker --image file://path_to_image.tar --results=verified
```
## 13: Escaneo en CI
Establece el flag `--since-commit` en tu rama por defecto a la que las personas hacen merge (ej: "main"). Establece el flag `--branch` en el nombre de la rama de tu PR (ej: "feature-1"). Dependiendo de la plataforma CI/CD que uses, este valor puede obtenerse dinámicamente (ej: [CIRCLE_BRANCH en Circle CI](https://circleci.com/docs/variables/) y [TRAVIS_PULL_REQUEST_BRANCH en Travis CI](https://docs.travis-ci.com/user/environment-variables/)). Si el repositorio se clona y la rama destino ya está checkouteada durante el flujo de trabajo de CI/CD, entonces `--branch HEAD` debería ser suficiente. El flag `--fail` devolverá un código de error 183 si se encuentran credenciales válidas.
```bash
trufflehog git file://. --since-commit main --branch feature-1 --results=verified,unknown --fail
```
## 14: Escanear un espacio de trabajo de Postman
Usa los flags `--workspace-id`, `--collection-id`, `--environment` varias veces para escanear múltiples objetivos.
```bash
trufflehog postman --token=<postman api token> --workspace-id=<workspace id>
```
## 15: Escanear un servidor Jenkins
```bash
trufflehog jenkins --url https://jenkins.example.com --username admin --password admin
```
## 16: Escanear un servidor de Elasticsearch
### Escanear un clúster local
Hay dos formas de autenticarse en un clúster local con TruffleHog: (1) nombre de usuario y contraseña, (2) token de servicio.
#### Conectarse a un clúster local con nombre de usuario y contraseña
```bash
trufflehog elasticsearch --nodes 192.168.14.3 192.168.14.4 --username truffle --password hog
```
#### Conectarse a un clúster local con un token de servicio
```bash
trufflehog elasticsearch --nodes 192.168.14.3 192.168.14.4 --service-token ‘AAEWVaWM...Rva2VuaSDZ’
```
### Escanear un clúster de Elastic Cloud
Para escanear un clúster en Elastic Cloud, necesitarás un Cloud ID y una clave API.
```bash
trufflehog elasticsearch \
--cloud-id 'search-prod:dXMtY2Vx...YjM1ODNlOWFiZGRlNjI0NA==' \
--api-key 'MlVtVjBZ...ZSYlduYnF1djh3NG5FQQ=='
```
## 17. Escanear un repositorio de GitHub en busca de referencias de objetos entre forks y commits eliminados
El siguiente comando enumerará los commits eliminados y ocultos en un repositorio de GitHub y luego los escaneará en busca de secretos. Esta es una característica de versión alfa.
```bash
trufflehog github-experimental --repo https://github.com/<USER>/<REPO>.git --object-discovery
```
Además de la salida normal de TruffleHog, el flag `--object-discovery` crea dos archivos en un nuevo directorio `$HOME/.trufflehog`: `valid_hidden.txt` e `invalid.txt`. Estos se utilizan para realizar un seguimiento del estado durante la enumeración de commits, así como para proporcionar a los usuarios una lista completa de todos los commits ocultos y eliminados (`valid_hidden.txt`). Si deseas eliminar automáticamente estos archivos después del escaneo, añade el flag `--delete-cached-data`.
**Nota**: Enumerar todos los commits válidos en un repositorio usando este método tarda entre 20 minutos y unas pocas horas, dependiendo del tamaño de tu repositorio. Añadimos una barra de progreso para mantenerte informado sobre cuánto tiempo tomará la enumeración. El escaneo de secretos real se ejecuta extremadamente rápido.
Para obtener más información sobre Cross Fork Object References, [lee nuestra publicación del blog](https://trufflesecurity.com/blog/anyone-can-access-deleted-and-private-repo-data-github).
## 18. Escanear Hugging Face
### Escanear un modelo, dataset, space o bucket de Hugging Face
```bash
trufflehog huggingface \
--model <model_id> \
--dataset <dataset_id> \
--space <space_id> \
--bucket <bucket_id>
```
### Escanear todos los Modelos, Datasets, Spaces y Buckets pertenecientes a una Organización o Usuario de Hugging Face
```bash
trufflehog huggingface --org <orgname> --user <username>
```
(Opcionalmente) Al escanear una organización o usuario, puedes omitir una clase completa de recursos con `--skip-all-models`, `--skip-all-datasets`, `--skip-all-spaces`, `--skip-all-buckets` O un recurso en particular con `--ignore-models <model_id>`, `--ignore-datasets <dataset_id>`, `--ignore-spaces <space_id>`, `--ignore-buckets <bucket_id>`.
### Escanear discusiones y comentarios de PR
```bash
trufflehog huggingface --model <model_id> --include-discussions --include-prs
```
## 19. Escanear la entrada de stdin
```bash
aws s3 cp s3://example/gzipped/data.gz - | gunzip -c | trufflehog stdin
```
# :question: Preguntas frecuentes
- Lo único que veo es `🐷🔑🐷 TruffleHog. Unearth your secrets. 🐷🔑🐷` y el programa finaliza, ¿qué significa?
- Significa que no se detectaron secretos
- ¿Por qué el escaneo tarda mucho cuando escaneo una organización de GitHub?
- Los escaneos de GitHub no autenticados tienen límites de velocidad. Para mejorar tus límites de velocidad, incluye el flag `--token` con un token de acceso personal
- Dice que se verificó una clave privada, ¿qué significa eso?
- Un resultado verificado significa que TruffleHog confirmó que la credencial es válida probándola contra la API del servicio. Para las claves privadas, hemos confirmado que la clave puede usarse en vivo para autenticación SSH o SSL. Consulta nuestra entrada de blog de Driftwood para obtener más información [Entrada de blog](https://trufflesecurity.com/blog/driftwood-know-if-private-keys-are-sensitive/)
- ¿Hay una forma sencilla de ignorar secretos específicos?
- Si la fuente escaneada [admite números de línea](https://github.com/trufflesecurity/trufflehog/blob/d6375ba92172fd830abb4247cca15e3176448c5d/pkg/engine/engine.go#L358-L365), entonces puedes añadir un comentario `trufflehog:ignore` en la línea que contiene el secreto para ignorar ese secreto.
- ¿Puedo encontrar secretos que incluyan `trufflehog:ignore`?
- Pasa `--no-ignore-tag` para reportar resultados incluso cuando su línea lleve un comentario `trufflehog:ignore`. Esto es útil para revisar hallazgos aceptados previamente.
# :newspaper: ¿Qué hay de nuevo en la v3?
TruffleHog v3 es una reescritura completa en Go con muchas nuevas y potentes funcionalidades.
- **Hemos añadido más de 700 detectores de credenciales que admiten verificación activa contra sus respectivas API**.
- También hemos añadido **soporte nativo para escanear GitHub, GitLab, Docker, sistemas de archivos, S3, GCS, Circle CI y Travis CI**.
- **Verifica al instante claves privadas** contra millones de usuarios de github y **miles de millones** de certificados TLS usando nuestra tecnología [Driftwood](https://trufflesecurity.com/blog/driftwood).
- Escanea binarios, documentos y otros formatos de archivo
- Disponible como GitHub Action y como hook de pre-commit
## ¿Qué es la verificación de credenciales?
Para cada credencial potencial que se detecta, hemos implementado minuciosamente una verificación programática contra la API a la que creemos que pertenece. La verificación elimina los falsos positivos y proporciona tres estados de resultado:
- **verified**: credencial confirmada como válida y activa mediante pruebas de API
- **unverified**: credencial detectada pero no confirmada como válida (puede ser inválida, estar caducada o tener la verificación deshabilitada)
- **unknown**: se intentó la verificación pero falló debido a errores, como un fallo de red o de API
Por ejemplo, el [detector de credenciales de AWS](https://github.com/trufflesecurity/trufflehog/blob/main/pkg/detectors/aws/access_keys/accesskey.go) realiza una llamada a la API `GetCallerIdentity` contra la API de AWS para verificar si una credencial de AWS está activa.
# :memo: Uso
TruffleHog tiene un subcomando para cada fuente de datos que puedas querer escanear:
- git
- github
- gitlab
- huggingface
- docker
- s3
- filesystem (archivos y directorios)
- syslog
- circleci
- travisci
- gcs (Google Cloud Storage)
- postman
- jenkins
- elasticsearch
- stdin
- multi-scan
Cada subcomando puede tener opciones que puedes ver con el flag `--help` proporcionado al subcomando:
```
$ trufflehog git --help
usage: TruffleHog [<flags>] <command> [<args> ...]
TruffleHog is a tool for finding credentials.
Flags:
-h, --[no-]help Show context-sensitive help (also try --help-long and --help-man).
--log-level=0 Logging verbosity on a scale of 0 (info) to 5 (trace). Can be
disabled with "-1".
--[no-]profile Enables profiling and sets a pprof and fgprof server on :18066.
-j, --[no-]json Output in JSON format.
--[no-]json-legacy Use the pre-v3.0 JSON format. Only works with git, gitlab,
and github sources.
--[no-]github-actions Output in GitHub Actions format.
--[no-]sarif Output in SARIF format for upload to GitHub code scanning (e.g.
via github/codeql-action/upload-sarif).
--concurrency=12 Number of concurrent workers.
--[no-]no-verification Don't verify the results.
--results=RESULTS Specifies which type(s) of results to output: verified (confirmed
valid by API), unknown (verification failed due to error),
unverified (detected but not verified), filtered_unverified
(unverified but would have been filtered out). Defaults to
verified,unverified,unknown.
--[no-]no-color Disable colorized output
--[no-]allow-verification-overlap
Allow verification of similar credentials across detectors
--[no-]filter-unverified Only output first unverified result per chunk per detector if there
are more than one results.
--filter-entropy=FILTER-ENTROPY
Filter unverified results with Shannon entropy. Start with 3.0.
--config=CONFIG Path to configuration file.
--[no-]print-avg-detector-time
Print the average time spent on each detector.
--[no-]no-update Don't check for updates.
--[no-]fail Exit with code 183 if results are found.
--[no-]fail-on-scan-errors
Exit with non-zero error code if an error occurs during the scan.
--verifier=VERIFIER ... Set custom verification endpoints.
--[no-]custom-verifiers-only
Only use custom verification endpoints.
--detector-timeout=DETECTOR-TIMEOUT
Maximum time to spend scanning chunks per detector (e.g., 30s).
--archive-max-size=ARCHIVE-MAX-SIZE
Maximum size of archive to scan. (Byte units eg. 512B, 2KB, 4MB)
--archive-max-depth=ARCHIVE-MAX-DEPTH
Maximum depth of archive to scan.
--archive-timeout=ARCHIVE-TIMEOUT
Maximum time to spend extracting an archive.
--include-detectors="all" Comma separated list of detector types to include. Protobuf name or
IDs may be used, as well as ranges.
--exclude-detectors=EXCLUDE-DETECTORS
Comma separated list of detector types to exclude. Protobuf name
or IDs may be used, as well as ranges. IDs defined here take
precedence over the include list.
--[no-]no-verification-cache
Disable verification caching
--[no-]force-skip-binaries
Force skipping binaries.
--[no-]force-skip-archives
Force skipping archives.
--[no-]skip-additional-refs
Skip additional references.
--user-agent-suffix=USER-AGENT-SUFFIX
Suffix to add to User-Agent.
--[no-]version Show application version.
Commands:
help [<command>...]
Show help.
git [<flags>] <uri>
Find credentials in git repositories.
github [<flags>]
Find credentials in GitHub repositories.
github-experimental --repo=REPO [<flags>]
Run an experimental GitHub scan. Must specify at least one experimental sub-module to run:
object-discovery.
gitlab --token=TOKEN [<flags>]
Find credentials in GitLab repositories.
filesystem [<flags>] [<path>...]
Find credentials in a filesystem.
s3 [<flags>]
Find credentials in S3 buckets.
gcs [<flags>]
Find credentials in GCS buckets.
syslog --format=FORMAT [<flags>]
Scan syslog
circleci --token=TOKEN
Scan CircleCI
docker [<flags>]
Scan Docker Image
travisci --token=TOKEN
Scan TravisCI
postman [<flags>]
Scan Postman
elasticsearch [<flags>]
Scan Elasticsearch
jenkins --url=URL [<flags>]
Scan Jenkins
huggingface [<flags>]
Find credentials in HuggingFace datasets, models, spaces and buckets.
stdin
Find credentials from stdin.
multi-scan
Find credentials in multiple sources defined in configuration.
json-enumerator [<path>...]
Find credentials from a JSON enumerator input.
analyze
Analyze API keys for fine-grained permissions information.
```
Por ejemplo, para escanear un repositorio `git`, comienza con
```
trufflehog git https://github.com/trufflesecurity/trufflehog.git
```
## Configuración
TruffleHog permite definir [detectores regex personalizados](#custom-regex-detector-alpha)
y múltiples fuentes en un archivo de configuración proporcionado mediante el flag `--config`.
Los detectores regex se pueden usar con cualquier subcomando, mientras que las fuentes definidas
en la configuración son solo para el subcomando `multi-scan`.
El formato de configuración para las fuentes se puede encontrar en la
[página de documentación de configuración de fuentes](https://trufflesecurity.com/docs/connect-sources) de Truffle Security.
Ejemplo de configuración de fuente de GitHub y [referencia de opciones](https://docs.trufflesecurity.com/github#Fvm1I):
```yaml
sources:
- connection:
'@type': type.googleapis.com/sources.GitHub
repositories:
- https://github.com/trufflesecurity/test_keys.git
unauthenticated: {}
name: example config scan
type: SOURCE_TYPE_GITHUB
verify: true
```
Puedes definir múltiples conexiones bajo la clave `sources` (ver arriba), y
TruffleHog escaneará todas las fuentes de forma concurrente.
Para ver los registros de depuración de una sola fuente, añade `debug: true` a ella. Esa fuente
escribe todos sus registros de depuración, y todas las demás fuentes mantienen el nivel de registro normal.
Esto es útil cuando una fuente entre muchas se está comportando de forma anómala:
```yaml
sources:
- connection:
'@type': type.googleapis.com/sources.GitHub
repositories:
- https://github.com/trufflesecurity/test_keys.git
unauthenticated: {}
name: example config scan
type: SOURCE_TYPE_GITHUB
debug: true
```
Para activar los registros de depuración para cada origen, utilice `--log-level=5` en su lugar.
## S3
El origen S3 admite la asunción de roles de IAM para el escaneo, además de los usuarios de IAM. Esto facilita a los usuarios el escaneo de múltiples cuentas de AWS sin necesidad de depender de credenciales codificadas para cada cuenta.
La identidad de IAM que TruffleHog utiliza inicialmente deberá tener privilegios de `AssumeRole` como principal en la [política de confianza](https://aws.amazon.com/blogs/security/how-to-use-trust-policies-with-iam-roles/) de cada rol de IAM que se vaya a asumir.
Para escanear un bucket específico utilizando credenciales configuradas localmente o metadatos de instancia si se está en una instancia de EC2:
```bash
trufflehog s3 --bucket=<bucket-name>
```
Para escanear un bucket específico usando un rol asumido:
```bash
trufflehog s3 --bucket=<bucket-name> --role-arn=<iam-role-arn>
```
Se pueden pasar varios roles como argumentos separados. El siguiente comando intentará escanear cada bucket que cada rol tenga permisos para listar en la API de S3:
```bash
trufflehog s3 --role-arn=<iam-role-arn-1> --role-arn=<iam-role-arn-2>
```
### Restringir un escaneo a objetos específicos
Los buckets grandes suelen contener datos que nunca vale la pena escanear, como archivos, medios y artefactos de compilación. Dos conjuntos de flags mantienen esos objetos fuera de un escaneo. Ambos se comparan con la clave del objeto antes de que este se descargue, por lo que un objeto omitido no cuesta ninguna solicitud GET.
Escanear solo los objetos bajo uno o más prefijos de clave:
```bash
trufflehog s3 --bucket=<bucket-name> --include-prefix=infra/ --include-prefix=services/
```
Omitir los objetos bajo un prefijo de clave:
```bash
trufflehog s3 --bucket=<bucket-name> --exclude-prefix=projects/archived/
```
Ambos indicadores de prefijo pueden usarse juntos para escanear un subárbol mientras se deja fuera una parte de él. Un objeto que coincide con un prefijo de exclusión siempre se omite, incluso si también coincide con un prefijo de inclusión:
```bash
trufflehog s3 --bucket=<bucket-name> --include-prefix=src/ --exclude-prefix=src/vendor/
```
Los prefijos se comparan literalmente, no como globs, y no están confinados a un límite de ruta. `--include-prefix=log` coincide tanto con `logs/app.txt` como con `logs-archive/app.txt`.
Las extensiones de archivo se filtran por separado. Escríbelas sin un punto inicial:
```bash
trufflehog s3 --bucket=<bucket-name> --exclude-extension=zip --exclude-extension=mp4
```
```bash
trufflehog s3 --bucket=<bucket-name> --include-extension=tf --include-extension=yaml
```
A diferencia de los flags de prefijo, `--include-extension` y `--exclude-extension` no se pueden combinar, porque nombrar las extensiones que se van a escanear ya excluye todas las demás. Usar ambos falla al iniciar.
La coincidencia de extensiones no distingue entre mayúsculas y minúsculas, por lo que `--exclude-extension=zip` también omite `BACKUP.ZIP`. Un objeto cuya clave no tiene ninguna extensión, como `Makefile`, no coincide con ninguna entrada: se omite cuando se establece `--include-extension`, y se conserva cuando solo se establece `--exclude-extension`.
Hay dos cosas a tener en cuenta al usar `--include-extension`. Un archivo de punto cuenta como extensión completa, por lo que `.env` tiene la extensión `env` y cualquier lista de inclusión que omita `env` omitirá todos los archivos `.env` del bucket. Dado que los archivos `.env` son un lugar común donde suelen residir secretos, añade `--include-extension=env` a menos que quieras omitirlos. Y solo cuenta la última extensión, por lo que `backup.tar.gz` tiene la extensión `gz`: `--exclude-extension=tar.gz` no coincide con nada, mientras que `--exclude-extension=gz` funciona.
Estos flags también se aplican solo a las claves de los objetos, no a los archivos dentro de un archivo comprimido. `--exclude-extension=mp4` omite `clip.mp4` que se encuentra en el bucket, pero no un `clip.mp4` empaquetado dentro de `media.zip`. Excluir `zip` omite el archivo comprimido por completo.
TruffleHog solicita a S3 que liste solo las claves bajo los prefijos de inclusión, por lo que un prefijo que cubre una pequeña parte de un bucket grande se lista rápidamente. Los prefijos y extensiones de exclusión se aplican después del listado, por lo que reducen el coste de descargar objetos pero no el coste de listarlos.
Los prefijos y las extensiones se aplican juntos. Un objeto tiene que pasar ambos para ser escaneado, por lo que el siguiente comando escanea `src/main.tf` pero omite tanto `src/bundle.zip` como `docs/guide.tf`:
---
[Read more](https://github.com/trufflesecurity/trufflehog)