Logotipo de GoReleaser

TruffleHog

Encuentra credenciales filtradas.

🔎 Escaneando ahora

...y más

Para obtener más información sobre TruffleHog y sus características y capacidades, visita nuestra página de producto.

🌐 TruffleHog Enterprise

¿Estás interesado en monitorear continuamente Git, Jira, Slack, Confluence, Microsoft Teams, Sharepoint (y más) en busca de credenciales? ¡Tenemos un producto empresarial que puede ayudarte! Obtén más información en https://trufflesecurity.com/trufflehog-enterprise.

Obtenemos ingresos del producto empresarial para financiar más proyectos de código abierto increíbles de los que toda la comunidad pueda beneficiarse.

¿Qué es TruffleHog 🐽

TruffleHog es la herramienta más poderosa de Descubrimiento, Clasificación, Validación y Análisis de secretos. En este contexto, secreto se refiere a una credencial que una máquina utiliza para autenticarse ante otra máquina. Esto incluye claves API, contraseñas de bases de datos, claves de cifrado privadas y más.

Descubrimiento 🔍

TruffleHog puede buscar secretos en muchos lugares, incluyendo Git, chats, wikis, registros, plataformas de prueba de API, almacenes de objetos, sistemas de archivos y más.

Clasificación 📁

TruffleHog clasifica más de 800 tipos de secretos, mapeándolos de vuelta a la identidad específica a la que pertenecen. ¿Es un secreto de AWS? ¿Secreto de Stripe? ¿Secreto de Cloudflare? ¿Contraseña de Postgres? ¿Clave privada SSL? A veces es difícil saberlo con solo mirarlo, por lo que TruffleHog clasifica todo lo que encuentra.

Validación ✅

Por cada secreto que TruffleHog puede clasificar, también puede iniciar sesión para confirmar si ese secreto está activo o no. Este paso es crítico para saber si hay un peligro presente activo o no.

Análisis 🔬

Para aproximadamente 20 de los tipos de credenciales más comúnmente filtrados, en lugar de enviar una solicitud para verificar si el secreto puede iniciar sesión, TruffleHog puede enviar muchas solicitudes para aprender todo lo que hay que saber sobre el secreto. ¿Quién lo creó? ¿A qué recursos puede acceder? ¿Qué permisos tiene sobre esos recursos?

📢 Únete a Nuestra Comunidad

¿Tienes preguntas? ¿Comentarios? Salta a Slack o Discord y pasa el rato con nosotros.

Únete a nuestra Comunidad de Slack

Únete al Discord de Escaneo de Secretos

📺 Demostración

Demostración de escaneo de GitHub ```bash docker run --rm -it -v "$PWD:/pwd" trufflesecurity/trufflehog:latest github --org=trufflesecurity

# :floppy_disk: Instalación

Varias opciones están disponibles para ti:

### Usuarios de MacOS```bash
brew install trufflehog

Docker:

_{Asegúrate de que Docker engine esté en ejecución antes de ejecutar los siguientes comandos:}

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

Windows PowerShell```bash

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

#### &nbsp;&nbsp;&nbsp;&nbsp;M1 y M2 Mac```bash
docker run --platform linux/arm64 --rm -it -v "$PWD:/pwd" trufflesecurity/trufflehog:latest github --repo https://github.com/trufflesecurity/test_keys

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

Usando el script de instalación```bash

curl -sSfL https://raw.githubusercontent.com/trufflesecurity/trufflehog/main/scripts/install.sh | sh -s -- -b /usr/local/bin

### Usar el script de instalación, verificar la firma de checksum (requiere tener cosign instalado)```bash
curl -sSfL https://raw.githubusercontent.com/trufflesecurity/trufflehog/main/scripts/install.sh | sh -s -- -v -b /usr/local/bin

Usando 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

# :closed_lock_with_key: Verificación de los artefactos

Se aplican sumas de verificación a todos los artefactos, y el archivo de suma de verificación resultante se firma usando 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 artefacto que desees, y los siguientes archivos de la página de [lanzamientos](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"

Una vez que la firma se confirme como válida, puedes proceder a validar que las sumas SHA256 coinciden con el artefacto descargado: ```shell sha256sum --ignore-missing -c trufflehog_{version}_checksums.txt

Reemplaza {version} con la versión de los archivos descargados

Si estás usando el script de instalación, pasa la opción -v para realizar la verificación de firmas. Esto requiere que el binario Cosign esté instalado antes de ejecutar el script de instalación.

🚀 Inicio Rápido

1: Escanea un repositorio en busca de solo secretos verificados

Comando:```bash trufflehog git https://github.com/trufflesecurity/test_keys --results=verified

Salida esperada:```
🐷🔑🐷  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 GitHub Org solo para secretos verificados```bash

trufflehog github --org=trufflesecurity --results=verified

## 3: Escanear una organización de GitHub excluyendo 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

Salida esperada:```
{"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}
...

5: Escanea un Repo 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 S3 para resultados de alta confianza (verificado + desconocido)```bash
trufflehog s3 --bucket=<bucket name> --results=verified,unknown

7: Escanear buckets S3 usando roles de IAM```bash

trufflehog s3 --role-arn=

## 8: Escanea 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 [claves de prueba](https://github.com/trufflesecurity/trufflehog/blob/HEAD/[email protected]:trufflesecurity/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 git maliciosas en el escaneo local (consulte CVE-2025-41390), TruffleHog clona los repositorios git locales a un directorio temporal antes del escaneo. Esto sigue las [mejores 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 indicador `--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 indicador `--trust-local-git-config`.

## 11: Escanear buckets de GCS solo para secretos verificados```bash
trufflehog gcs --project-id=<project-ID> --cloud-environment --results=verified

12: Escanear una imagen de Docker solo para secretos verificados

Usa la bandera --image varias veces para escanear múltiples 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 la bandera `--since-commit` en tu rama predeterminada en la que se fusiona (ej.: "main"). Establece la bandera `--branch` en el nombre de la rama de tu PR (ej.: "feature-1"). Dependiendo de la plataforma de 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 de destino ya está actualizada durante el flujo de trabajo de CI/CD, entonces `--branch HEAD` debería ser suficiente. La bandera `--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

Use las banderas --workspace-id, --collection-id, --environment múltiples veces para escanear múltiples objetivos.```bash trufflehog postman --token= --workspace-id=

## 15: Escanear un servidor Jenkins```bash
trufflehog jenkins --url https://jenkins.example.com --username admin --password admin

16: Escanear un servidor 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.

Conectar 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

#### Conectar 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 ID de Cloud 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 a 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 función en versión alfa.```bash
trufflehog github-experimental --repo https://github.com/<USER>/<REPO>.git --object-discovery

Además de la salida normal de TruffleHog, la bandera --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 desea eliminar automáticamente estos archivos después del escaneo, agregue la bandera --delete-cached-data.

Nota: Enumerar todos los commits válidos en un repositorio usando este método toma entre 20 minutos y unas pocas horas, dependiendo del tamaño de su repositorio. Agregamos una barra de progreso para mantenerlo informado sobre cuánto tiempo tomará la enumeración. El escaneo real de secretos se ejecuta extremadamente rápido.

Para obtener más información sobre Cross Fork Object References, por favor lea nuestra publicación en el blog.

18. Escanear Hugging Face

Escanear un Modelo, Dataset, Espacio o Bucket de Hugging Face```bash

trufflehog huggingface
--model <model_id>
--dataset <dataset_id>
--space <space_id>
--bucket <bucket_id>

### Escanea todos los Modelos, Datasets, Spaces y Buckets que pertenecen 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 particular con --ignore-models <model_id>, --ignore-datasets <dataset_id>, --ignore-spaces <space_id>, --ignore-buckets <bucket_id>.

Escanear Comentarios de Discusión y PR```bash

trufflehog huggingface --model <model_id> --include-discussions --include-prs

## 19. Escanear entrada stdin```bash
aws s3 cp s3://example/gzipped/data.gz - | gunzip -c | trufflehog stdin

❓ FAQ

Todo lo que veo es 🐷🔑🐷 TruffleHog. Unearth your secrets. 🐷🔑🐷 y el programa se cierra, ¿qué pasa?
- Significa que no se detectaron secretos
¿Por qué el escaneo tarda tanto cuando escaneo una organización de GitHub?
- Los escaneos no autenticados de GitHub tienen límites de tasa. Para mejorar tus límites de tasa, incluye la bandera --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 claves privadas, hemos confirmado que la clave se puede usar en vivo para autenticación SSH o SSL. Consulta nuestra publicación de blog sobre Driftwood para obtener más información Publicación de blog
¿Hay alguna forma fácil de ignorar secretos específicos?
- Si la fuente escaneada admite números de línea, entonces puedes agregar un comentario trufflehog:ignore en la línea que contiene el secreto para ignorar ese secreto.

📰 Novedades en v3

TruffleHog v3 es una reescritura completa en Go con muchas características nuevas y potentes.

Hemos agregado más de 700 detectores de credenciales que admiten verificación activa contra sus respectivas API.
También hemos agregado soporte nativo para escanear GitHub, GitLab, Docker, sistemas de archivos, S3, GCS, Circle CI y Travis CI.
Verifica instantáneamente claves privadas contra millones de usuarios de GitHub y miles de millones de certificados TLS utilizando nuestra tecnología Driftwood.
Escanea binarios, documentos y otros formatos de archivo
Disponible como una acción de GitHub y un hook de pre-commit

¿Qué es la verificación de credenciales?

Por 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 falsos positivos y proporciona tres estados de resultado:

verificado: Credencial confirmada como válida y activa mediante pruebas de API
no verificado: Credencial detectada pero no confirmada como válida (puede ser inválida, expirada o la verificación deshabilitada)
desconocido: Se intentó la verificación pero falló debido a errores, como una falla de red o de API

Por ejemplo, el detector de credenciales de AWS realiza una llamada a la API GetCallerIdentity contra la API de AWS para verificar si una credencial de AWS está activa.

📝 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 la bandera --help proporcionada al subcomando:``` $ trufflehog git --help usage: TruffleHog [] [ ...]

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. --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 [...] Show help.

git []

Find credentials in git repositories.

github [] Find credentials in GitHub repositories.

github-experimental --repo=REPO [] Run an experimental GitHub scan. Must specify at least one experimental sub-module to run: object-discovery.

gitlab --token=TOKEN [] Find credentials in GitLab repositories.

filesystem [] [...] Find credentials in a filesystem.

s3 [] Find credentials in S3 buckets.

gcs [] Find credentials in GCS buckets.

syslog --format=FORMAT [] Scan syslog

circleci --token=TOKEN Scan CircleCI

docker [] Scan Docker Image

travisci --token=TOKEN Scan TravisCI

postman [] Scan Postman

elasticsearch [] Scan Elasticsearch

jenkins --url=URL [] Scan Jenkins

huggingface [] Find credentials in HuggingFace datasets, models and spaces.

stdin Find credentials from stdin.

multi-scan Find credentials in multiple sources defined in configuration.

json-enumerator [...] Find credentials from a JSON enumerator input.

analyze Analyze API keys for fine-grained permissions information.

Por ejemplo, para escanear un repositorio `git`, comience con```
trufflehog git https://github.com/trufflesecurity/trufflehog.git

Configuración

TruffleHog soporta la definición de detectores de expresiones regulares personalizados y múltiples fuentes en un archivo de configuración proporcionado mediante la bandera --config. Los detectores de expresiones regulares 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 fuentes se puede encontrar en la página de documentación de configuración de fuentes de Truffle Security. página de documentación de configuración de fuentes.

Ejemplo de configuración de fuente de GitHub y referencia de opciones:```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

Puede definir múltiples conexiones bajo la clave `sources` (ver arriba), y
TruffleHog escaneará todas las fuentes de forma concurrente.

## S3

La fuente S3 admite asumir roles IAM para escaneo además de usuarios IAM. Esto facilita a los usuarios escanear múltiples cuentas AWS sin necesidad de depender de credenciales fijas para cada cuenta.

La identidad IAM que TruffleHog utiliza inicialmente necesitará tener privilegios `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 IAM a asumir.

Para escanear un bucket específico usando credenciales configuradas localmente o metadatos de instancia si se está en una instancia EC2:```bash
trufflehog s3 --bucket=<bucket-name>

Para escanear un bucket específico usando un rol asumido:```bash trufflehog s3 --bucket= --role-arn=

Se pueden pasar múltiples roles como argumentos separados. El siguiente comando intentará escanear cada bucket al 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>

Códigos de salida:

0: Sin errores y no se encontraron resultados.
1: Se encontró un error. Es posible que las fuentes no hayan completado los escaneos.
183: No se encontraron errores, pero se encontraron resultados. Solo se devolverá si se utiliza la bandera --fail.

:octocat: TruffleHog Github Action

Uso general```

on: push: branches: - main pull_request:

jobs: test: runs-on: ubuntu-latest steps: - name: Checkout code uses: actions/checkout@v4 with: fetch-depth: 0 - name: Secret Scanning uses: trufflesecurity/trufflehog@main with: extra_args: --results=verified,unknown

En el ejemplo de configuración anterior, estamos escaneando secretos activos en todas las PR y Pushes a `main`. Solo se escanean los cambios de código en los commits referenciados. Si deseas escanear una rama completa, consulta la sección "Uso Avanzado" a continuación.

### Clonación Superficial

Si estás incorporando TruffleHog en un flujo de trabajo independiente y no ejecutas ninguna otra herramienta CI/CD junto con TruffleHog, entonces recomendamos usar [Clonación Superficial](https://git-scm.com/docs/git-clone#Documentation/git-clone.txt---depthltdepthgt) para acelerar tu flujo de trabajo. Aquí tienes un ejemplo de cómo hacerlo:```
...
      - shell: bash
        run: |
          if [ "${{ github.event_name }}" == "push" ]; then
            echo "depth=$(($(jq length <<< '${{ toJson(github.event.commits) }}') + 2))" >> $GITHUB_ENV
            echo "branch=${{ github.ref_name }}" >> $GITHUB_ENV
          fi
          if [ "${{ github.event_name }}" == "pull_request" ]; then
            echo "depth=$((${{ github.event.pull_request.commits }}+2))" >> $GITHUB_ENV
            echo "branch=${{ github.event.pull_request.head.ref }}" >> $GITHUB_ENV
          fi
      - uses: actions/checkout@v3
        with:
          ref: ${{env.branch}}
          fetch-depth: ${{env.depth}}
      - uses: trufflesecurity/trufflehog@main
        with:
          extra_args: --results=verified,unknown
...

Dependiendo del tipo de evento (push o PR), calculamos la cantidad de commits presentes. Luego sumamos 2, para poder hacer referencia a un commit base anterior a nuestros cambios de código. Pasamos ese valor entero a la bandera fetch-depth en la acción de checkout, además de la rama correspondiente. Ahora nuestro proceso de checkout debería ser mucho más corto.

Detección de canarios

TruffleHog detecta estáticamente https://canarytokens.org/.

Uso avanzado```yaml

name: TruffleHog uses: trufflesecurity/trufflehog@main with:
Repository path
path:
Start scanning from here (usually main branch).
base:
Scan commits until here (usually dev branch).
head: # optional
Extra args to be passed to the trufflehog cli.
extra_args: --log-level=2 --results=verified,unknown
Scan with a specific TruffleHog version (default: latest).
version:
Docker image to pull. Override to use a registry mirror (default: ghcr.io/trufflesecurity/trufflehog).
image:

Si deseas especificar referencias `base` y `head` concretas, puedes usar el argumento `base` (indicador `--since-commit` en la CLI de TruffleHog) y el argumento `head` (indicador `--branch` en la CLI de TruffleHog). Solo recomendamos usar estos argumentos para casos de uso muy específicos, donde el comportamiento predeterminado no funcione.

#### Uso Avanzado: Escanear toda la rama```
- name: scan-push
        uses: trufflesecurity/trufflehog@main
        with:
          base: ""
          head: ${{ github.ref_name }}
          extra_args: --results=verified,unknown

TruffleHog GitLab CI

Ejemplo de uso```yaml

stages:

security

security-secrets: stage: security allow_failure: false image: alpine:latest variables: SCAN_PATH: "." # Set the relative path in the repo to scan before_script: - apk add --no-cache git curl jq - curl -sSfL https://raw.githubusercontent.com/trufflesecurity/trufflehog/main/scripts/install.sh | sh -s -- -b /usr/local/bin script: - trufflehog filesystem "$SCAN_PATH" --results=verified,unknown --fail --json | jq rules: - if: '$CI_PIPELINE_SOURCE == "merge_request_event"'

En el ejemplo de pipeline anterior, estamos escaneando en busca de secretos activos en todos los directorios y archivos del repositorio. Este trabajo se ejecuta solo cuando el origen del pipeline es un evento de merge request, lo que significa que se activa cuando se crea una nueva solicitud de fusión.

## Hook de Pre-commit

TruffleHog se puede usar en un hook de pre-commit para evitar que las credenciales se filtren antes de que salgan de tu computadora.

Consulta la [documentación del hook de pre-commit](https://github.com/trufflesecurity/trufflehog/blob/HEAD/PreCommit.md) para más información.

## Detector de Expresiones Regulares Personalizado (alfa)

TruffleHog admite la detección y verificación de expresiones regulares personalizadas.
Para la detección, se requiere al menos una **expresión regular** y una **palabra clave**.
Una **palabra clave** es un identificador de cadena literal fijo que aparece dentro o alrededor
de la regex que se va a detectar. Para permitir la máxima flexibilidad en la verificación, se
utiliza un webhook que contiene las coincidencias de la expresión regular.

TruffleHog enviará una solicitud JSON POST que contiene las coincidencias de la expresión regular a un
punto final de webhook configurado. Si el punto final responde con un código de estado `200 OK`,
el secreto se considera verificado. Si la verificación falla debido a errores de red/API, el resultado se marca como desconocido.

Los detectores personalizados admiten algunos mecanismos de filtrado diferentes: entropía, regex dirigida a la coincidencia completa, regex dirigida al secreto capturado,
y listas de palabras excluidas verificadas contra el secreto (grupo capturado si está presente, coincidencia completa si no hay grupo de captura). Tenga en cuenta que si
su detector personalizado tiene múltiples `regex` configurados (en este ejemplo `hogID` y `hogToken`), entonces los filtros se aplican a cada regex. [Aquí](https://github.com/trufflesecurity/trufflehog/blob/HEAD/examples/generic_with_filters.yml) hay un ejemplo de un detector personalizado que utiliza estos filtros.

**NB:** Esta característica está en alfa y sujeta a cambios.

### Ejemplo de Detector de Regex

[Aquí](https://github.com/trufflesecurity/trufflehog/blob/HEAD/pkg/custom_detectors/CUSTOM_DETECTORS.md) se explica cómo configurar un detector de regex personalizado con un servidor de verificación.

## Detección Genérica de JWT

TruffleHog admite la detección y verificación de un subconjunto de JWTs genéricos que encuentra.
Específicamente, si un JWT utiliza criptografía de clave pública en lugar de HMAC y se puede obtener la clave pública, TruffleHog puede determinar si el JWT está activo o no.

## :mag: Analizar

TruffleHog admite la ejecución de un análisis más profundo de una credencial para ver sus permisos y los recursos a los que tiene acceso.```bash
trufflehog analyze

❤️ Contribuyentes

Este proyecto existe gracias a todas las personas que contribuyen. [Contribuye].

💻 Contribuciones

¡Las contribuciones son muy bienvenidas! Por favor, consulta primero nuestras guías de contribución.

Ya no aceptamos contribuciones para TruffleHog v2, pero ese código está disponible en la rama v2.

Añadiendo nuevos detectores de secretos

Hemos publicado algo de documentación y herramientas para empezar a añadir nuevos detectores de secretos. ¡Mejoremos la detección juntos!

Uso como biblioteca

Actualmente, trufflehog está en pleno desarrollo y no se pueden ofrecer garantías sobre la estabilidad de las API públicas en este momento.

Cambio de licencia

Desde v3.0, TruffleHog se publica bajo una licencia AGPL 3, incluida en LICENSE. TruffleHog v3.0 no utiliza nada del código base anterior, pero se tuvo cuidado de preservar la compatibilidad hacia atrás en la interfaz de línea de comandos. El trabajo anterior a este lanzamiento aún está disponible bajo licencia GPL 2.0 en el historial de este repositorio y en los lanzamientos y etiquetas de paquetes anteriores. Se requiere un CLA completo para que aceptemos contribuciones en adelante.

trufflehog v3.97.0

Categorías