Skip to content
KitploitKITPLOIT
HerramientasExploitsBlog
Log in
Enviar
HerramientasExploitsBlog
Enviar

¡Herramientas de Hacking, PenTest y Ciberseguridad para tu Arsenal de Seguridad!

Kitploit es un directorio de herramientas de hacking, ciberseguridad y pentesting. Descubre las últimas actualizaciones de proyectos para encontrar vulnerabilidades, analizar sistemas, automatizar pruebas y fortalecer tu seguridad.

FeedsContactoPrivacidad© 2026 Kitploit

Directorio de Herramientas

Categorías

Ver todas las categorías
Loading categories
trufflehog — Encontrar, verificar y analizar credenciales filtradas | Kitploit
Herramientas/GitHubGitHub/trufflesecurity/trufflehog
Escáneres de VulnerabilidadesAnálisis Dinámico (Sandboxing)Análisis de CódigoSeguridad en la NubeDevSecOpsDetección de SecretosInteligencia de AmenazasSeguridad de Cadena de SuministroRespuesta a IncidentesTop en DevSecOps #4
27.4k2.5k302hace 22h 46mRevisado por Kitploit
Top en Detección de Secretos #2
Top en Seguridad de Cadena de Suministro #19
GitHubtrufflesecurity/trufflehog

trufflehog

Encontrar, verificar y analizar credenciales filtradas

Ver RepositorioSitio web

Más Populares

Ver todos →

Descubre las herramientas más usadas por nuestra comunidad.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 El kit de herramientas OSINT definitivo: grafo de investigación, puntuación de confianza, familias de alias, mapa, línea de tiempo e informes. 49 módulos, más de 400 sitios, sin necesidad de claves API.

    1.0k
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Aplicación de Ejecución con un Solo Toque GhostLock (CVE-2026-43499)

    593
  • 3

    looking-glass

    anonghosty/looking-glass

    Plataforma CSIRT que ingiere informes de Shadowserver en MongoDB y los reproduce como mapas interactivos, análisis, hallazgos, avisos y paneles ejecutivos.

    371
  • 4

    redforge

    cybersecurity91/redforge

    Kit de herramientas de red team del lado del navegador con 102 herramientas offline para reconocimiento, generación de payloads, ataques de credenciales, criptografía, codificación y elaboración de informes de compromiso.

    336
  • 5

    ARTEX

    baarai/artex

    Plataforma de pruebas de penetración autónoma multiagente basada en LLM con agentes planificadores/trabajadores, grafos de activos y de exploración, registro de tráfico MITM y reevaluación de vulnerabilidades.

    326
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    El sistema de acción para la ciberseguridad nativa de IA—donde la intención se convierte en ejecución gobernada, la evidencia se convierte en memoria operativa y cada operación mejora la siguiente.

    322

Explora todas las herramientas

Explora nuestra colección de herramientas

Ver todas las herramientas →
Compartir
<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">

[![Go Report Card](https://goreportcard.com/badge/github.com/trufflesecurity/trufflehog/v3)](https://goreportcard.com/report/github.com/trufflesecurity/trufflehog/v3)
[![License](https://img.shields.io/badge/license-AGPL--3.0-brightgreen)](/LICENSE)
[![Total Detectors](https://img.shields.io/github/directory-file-count/trufflesecurity/truffleHog/pkg/detectors?label=Total%20Detectors&type=dir)](/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

![GitHub scanning demo](https://storage.googleapis.com/truffle-demos/non-interactive.svg)

```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>

#### &nbsp;&nbsp;&nbsp;&nbsp;Unix

```bash
docker run --rm -it -v "$PWD:/pwd" trufflesecurity/trufflehog:latest github --repo https://github.com/trufflesecurity/test_keys
```

#### &nbsp;&nbsp;&nbsp;&nbsp;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
```

#### &nbsp;&nbsp;&nbsp;&nbsp;Windows PowerShell

```bash
docker run --rm -it -v "${PWD}:/pwd" trufflesecurity/trufflehog github --repo https://github.com/trufflesecurity/test_keys
```

#### &nbsp;&nbsp;&nbsp;&nbsp;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)
Descargar herramienta