Skip to content
KitploitKITPLOIT
FerramentasExploitsBlog
Log in
Enviar
FerramentasExploitsBlog
Enviar

Ferramentas de Hacking, PenTest e Cibersegurança para o seu Arsenal de Segurança!

Kitploit é um diretório de ferramentas de hacking, cibersegurança e pentesting. Descubra as últimas atualizações de projetos para encontrar vulnerabilidades, analisar sistemas, automatizar testes e fortalecer sua segurança.

FeedsContatoPrivacidade© 2026 Kitploit

Diretório de Ferramentas

Categorias

Ver todas as categorias
Loading categories
trufflehog — Encontre, verifique e analise credenciais vazadas | Kitploit
Ferramentas/GitHubGitHub/trufflesecurity/trufflehog
Scanners de VulnerabilidadesAnálise Dinâmica (Sandboxing)Análise de CódigoSegurança na NuvemDevSecOpsDetecção de SegredosInteligência de AmeaçasSegurança da Cadeia de SuprimentosResposta a IncidentesTop em DevSecOps nº4
27.4k2.5k302há 22h 46mRevisado pelo Kitploit
Top em Detecção de Segredos nº2
Top em Segurança da Cadeia de Suprimentos nº19
GitHubtrufflesecurity/trufflehog

trufflehog

Encontre, verifique e analise credenciais vazadas

Ver RepositórioSite

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 O kit definitivo de OSINT: grafo de investigação, pontuação de confiança, famílias de alias, mapa, linha do tempo e relatórios. 49 módulos, mais de 400 sites, sem necessidade de chaves de API.

    1.0k
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Aplicativo de Execução em Um Toque GhostLock (CVE-2026-43499)

    593
  • 3

    looking-glass

    anonghosty/looking-glass

    Plataforma CSIRT que ingere relatórios do Shadowserver no MongoDB e os reproduz como mapas interativos, análises, descobertas, avisos e painéis executivos.

    371
  • 4

    redforge

    cybersecurity91/redforge

    Kit de ferramentas de red team do lado do navegador com 102 ferramentas offline para reconhecimento, geração de payloads, ataques a credenciais, criptografia, codificação e relatórios de engajamento.

    336
  • 5

    ARTEX

    baarai/artex

    Plataforma autônoma de testes de penetração multiagente com LLM, com agentes planejador/executor, grafos de ativos e de exploração, registro de tráfego MITM e reteste de vulnerabilidades.

    326
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    O sistema de ação para cibersegurança nativa em IA—onde a intenção se torna execução governada, a evidência se torna memória operacional, e cada operação melhora a próxima.

    322

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →
Compartilhar
<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">Encontre credenciais vazadas.</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: _Escaneando agora_

<div align="center">

<img src="https://raw.githubusercontent.com/trufflesecurity/trufflehog/HEAD/assets/scanning_logos.svg">

**...e mais**

Para saber mais sobre o TruffleHog e seus recursos e capacidades, visite nossa [página do produto](https://trufflesecurity.com/trufflehog?gclid=CjwKCAjwouexBhAuEiwAtW_Zx5IW87JNj97Ci7heFnA5ar6-DuNzT2Y5nIl9DuZ-FOUqx0Qg3vb9nxoClcEQAvD_BwE).

</div>

# :globe_with_meridians: TruffleHog Enterprise

Você tem interesse em monitorar continuamente **Git, Jira, Slack, Confluence, Microsoft Teams, Sharepoint (e mais)** em busca de credenciais? Temos um produto enterprise que pode ajudar! Saiba mais em <https://trufflesecurity.com/trufflehog-enterprise>.

Usamos a receita do produto enterprise para financiar mais projetos open source incríveis dos quais toda a comunidade pode se beneficiar.

</div>

# O que é o TruffleHog 🐽

O TruffleHog é a ferramenta mais poderosa de **Descoberta, Classificação, Validação** e **Análise** de segredos. Neste contexto, segredo refere-se a uma credencial que uma máquina usa para se autenticar em outra máquina. Isso inclui chaves de API, senhas de banco de dados, chaves de criptografia privadas e muito mais.

## Descoberta 🔍

O TruffleHog pode procurar segredos em muitos lugares, incluindo Git, chats, wikis, logs, plataformas de teste de API, object stores, sistemas de arquivos e mais.

## Classificação 📁

O TruffleHog classifica mais de 800 tipos de segredos, mapeando-os de volta à identidade específica à qual pertencem. É um segredo da AWS? Segredo do Stripe? Segredo do Cloudflare? Senha do Postgres? Chave privada SSL? Às vezes é difícil dizer apenas olhando, então o TruffleHog classifica tudo o que encontra.

## Validação ✅

Para cada segredo que o TruffleHog consegue classificar, ele também consegue fazer login para confirmar se esse segredo está ativo ou não. Esta etapa é crítica para saber se há um perigo ativo presente ou não.

## Análise 🔬

Para cerca de 20 dos tipos de credenciais mais comumente vazadas, em vez de enviar uma única requisição para verificar se o segredo consegue fazer login, o TruffleHog pode enviar muitas requisições para descobrir tudo o que há para saber sobre o segredo. Quem o criou? A quais recursos ele pode acessar? Quais permissões ele tem nesses recursos?

# :loudspeaker: Junte-se à nossa comunidade

Tem dúvidas? Feedback? Entre no Slack ou Discord e fique à vontade com a gente.

Junte-se à nossa [Comunidade no Slack](https://join.slack.com/t/trufflehog-community/shared_invite/zt-pw2qbi43-Aa86hkiimstfdKH9UCpPzQ)

Junte-se ao [Secret Scanning Discord](https://discord.gg/8Hzbrnkr7E)

# :tv: Demonstração

![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: Instalação

Várias opções estão disponíveis para você:

### Usuários de MacOS

```bash
brew install trufflehog
```

### Docker:

<sub><i>_Certifique-se de que o Docker engine esteja em execução antes de executar os seguintes 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;Prompt de Comando do 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 e M2

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

### Versões binárias

```bash
Download and unpack from https://github.com/trufflesecurity/trufflehog/releases
```

### Compilar a partir do código-fonte

```bash
git clone https://github.com/trufflesecurity/trufflehog.git
cd trufflehog; go install
```

### Usando o script de instalação

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

### Usando o script de instalação, verifique a assinatura do checksum (requer que o cosign esteja instalado)

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

### Usando o script de instalação para instalar uma versão 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: Verificando os artefatos

Checksums são aplicados a todos os artefatos, e o arquivo de checksum resultante é assinado usando cosign.

Você precisa da seguinte ferramenta para verificar a assinatura:

- [Cosign](https://docs.sigstore.dev/cosign/system_config/installation/)

As etapas de verificação são as seguintes:

1. Baixe os arquivos de artefato que você deseja, e os seguintes arquivos da 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. Verifique a assinatura:

   ```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. Depois que a assinatura for confirmada como válida, você pode prosseguir para validar se as somas SHA256 correspondem ao artefato baixado:

   ```shell
   sha256sum --ignore-missing -c trufflehog_{version}_checksums.txt
   ```

Substitua `{version}` pela versão dos arquivos baixados

Alternativamente, se estiver a utilizar o script de instalação, passe a opção `-v` para realizar a verificação de assinatura.
Isto requer que o binário Cosign esteja instalado antes de executar o script de instalação.

# :rocket: Início Rápido

## 1: Analisar um repositório apenas para segredos 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 uma Organização do GitHub apenas para segredos verificados

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

## 3: Escanear uma Org do GitHub excluindo repositórios arquivados

```bash
trufflehog github --org=trufflesecurity --exclude-archived
```

## 4: Escaneie um Repositório GitHub apenas para segredos verificados e obtenha saída 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}
...
```

O TruffleHog também pode gerar [SARIF](https://docs.oasis-open.org/sarif/sarif/v2.1.0/sarif-v2.1.0.html) com `--sarif` em vez de `--json`. O GitHub code scanning entende SARIF nativamente, portanto, ao enviá-lo, os achados são exibidos diretamente nos diffs de pull requests e na aba Security do repositório, e os achados são rastreados como novos/corrigidos entre varreduras, em vez de relatar o mesmo achado a cada execução — consulte a seção [TruffleHog Github Action](#octocat-trufflehog-github-action) abaixo para saber como enviá-lo. Observe que, diferentemente dos outros formatos de saída, os resultados SARIF são armazenados em memória durante toda a varredura e gravados ao final, pois o SARIF exige um único documento JSON em vez de um stream — o que é adequado para varreduras típicas, mas varreduras que produzem um número muito grande de resultados usarão proporcionalmente mais memória.

## 5: Escanear um Repositório do GitHub + suas Issues e Pull Requests

```bash
trufflehog github --repo=https://github.com/trufflesecurity/test_keys --issue-comments --pr-comments
```

## 6: Escaneie um bucket S3 em busca de resultados de alta confiança (verificados + desconhecidos)

```bash
trufflehog s3 --bucket=<bucket name> --results=verified,unknown
```

## 7: Escanear buckets S3 usando IAM Roles

```bash
trufflehog s3 --role-arn=<iam role arn>
```

## 8: Escanear um Repositório do Github usando autenticação SSH no Docker

```bash
docker run --rm -v "$HOME/.ssh:/root/.ssh:ro" trufflesecurity/trufflehog:latest git ssh://github.com/trufflesecurity/test_keys
```

## 9: Escanear arquivos ou diretórios individuais

```bash
trufflehog filesystem path/to/file1.txt path/to/file2.txt path/to/dir
```

## 10: Escanear um repositório git local

Clone o repositório git. Por exemplo, o repositório [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
```

Execute o trufflehog a partir do diretório pai (fora do repositório git).
```bash
trufflehog git file://test_keys --results=verified,unknown
```

Para se proteger contra configurações git maliciosas na verificação local (consulte CVE-2025-41390), o TruffleHog clona repositórios git locais para um diretório temporário antes da verificação. Isso segue as [práticas recomendadas de segurança do Git](https://git-scm.com/docs/git#_security). Se você quiser especificar um caminho personalizado para clonar o repositório (em vez de tmp), pode usar a flag `--clone-path`. Se você quiser pular o processo de clonagem local e verificar o repositório diretamente (faça isso apenas para repositórios confiáveis), pode usar a flag `--trust-local-git-config`.

## 11: Verificar buckets GCS apenas para segredos verificados

```bash
trufflehog gcs --project-id=<project-ID> --cloud-environment --results=verified
```

## 12: Escanear uma imagem Docker apenas para segredos verificados

Use a flag `--image` várias vezes para escanear várias imagens.

```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: Escanear em CI

Defina a flag `--since-commit` para o seu branch padrão no qual as pessoas fazem merge (ex: "main"). Defina a flag `--branch` para o nome do branch do seu PR (ex: "feature-1"). Dependendo da plataforma de CI/CD que você utiliza, esse valor pode ser obtido dinamicamente (ex: [CIRCLE_BRANCH no Circle CI](https://circleci.com/docs/variables/) e [TRAVIS_PULL_REQUEST_BRANCH no Travis CI](https://docs.travis-ci.com/user/environment-variables/)). Se o repositório for clonado e o branch de destino já estiver com checkout feito durante o fluxo de trabalho de CI/CD, então `--branch HEAD` deve ser suficiente. A flag `--fail` retornará um código de erro 183 se credenciais válidas forem encontradas.

```bash
trufflehog git file://. --since-commit main --branch feature-1 --results=verified,unknown --fail
```

## 14: Escanear um workspace do Postman

Use as flags `--workspace-id`, `--collection-id`, `--environment` várias vezes para escanear múltiplos alvos.

```bash
trufflehog postman --token=<postman api token> --workspace-id=<workspace id>
```

## 15: Escanear um servidor Jenkins

```bash
trufflehog jenkins --url https://jenkins.example.com --username admin --password admin
```

## 16: Escanear um servidor Elasticsearch

### Escanear um cluster local

Existem duas formas de autenticar em um cluster local com o TruffleHog: (1) nome de usuário e senha, (2) token de serviço.

#### Conectar-se a um cluster local com nome de usuário e senha

```bash
trufflehog elasticsearch --nodes 192.168.14.3 192.168.14.4 --username truffle --password hog
```

#### Conectar-se a um cluster local com um token de serviço

```bash
trufflehog elasticsearch --nodes 192.168.14.3 192.168.14.4 --service-token ‘AAEWVaWM...Rva2VuaSDZ’
```

### Escanear um Cluster do Elastic Cloud

Para escanear um cluster no Elastic Cloud, você precisará de um Cloud ID e de uma chave de API.

```bash
trufflehog elasticsearch \
  --cloud-id 'search-prod:dXMtY2Vx...YjM1ODNlOWFiZGRlNjI0NA==' \
  --api-key 'MlVtVjBZ...ZSYlduYnF1djh3NG5FQQ=='
```

## 17. Escanear um Repositório GitHub em Busca de Referências de Objetos Entre Forks e Commits Excluídos

O comando a seguir enumerará commits excluídos e ocultos em um repositório GitHub e, em seguida, os escaneará em busca de segredos. Este é um recurso de versão alfa.

```bash
trufflehog github-experimental --repo https://github.com/<USER>/<REPO>.git --object-discovery
```

Além da saída normal do TruffleHog, a flag `--object-discovery` cria dois arquivos em um novo diretório `$HOME/.trufflehog`: `valid_hidden.txt` e `invalid.txt`. Eles são usados para rastrear o estado durante a enumeração de commits, bem como para fornecer aos usuários uma lista completa de todos os commits ocultos e excluídos (`valid_hidden.txt`). Se você quiser remover automaticamente esses arquivos após a verificação, adicione a flag `--delete-cached-data`.

**Nota**: Enumerar todos os commits válidos em um repositório usando este método leva entre 20 minutos e algumas horas, dependendo do tamanho do seu repositório. Adicionamos uma barra de progresso para mantê-lo atualizado sobre quanto tempo a enumeração levará. A verificação real de segredos é executada extremamente rápido.

Para mais informações sobre Cross Fork Object References, [leia nossa postagem no blog](https://trufflesecurity.com/blog/anyone-can-access-deleted-and-private-repo-data-github).

## 18. Verificar o Hugging Face

### Verificar um Modelo, Dataset, Space ou Bucket do Hugging Face

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

### Escanear todos os Modelos, Datasets, Spaces e Buckets pertencentes a uma Organização ou Usuário do Hugging Face

```bash
trufflehog huggingface --org <orgname> --user <username>
```

(Opcionalmente) Ao escanear uma organização ou usuário, você pode pular uma classe inteira de recursos com `--skip-all-models`, `--skip-all-datasets`, `--skip-all-spaces`, `--skip-all-buckets` OU um recurso específico com `--ignore-models <model_id>`, `--ignore-datasets <dataset_id>`, `--ignore-spaces <space_id>`, `--ignore-buckets <bucket_id>`.

### Escanear Discussões e Comentários de PR

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

## 19. Escanear entrada de stdin

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

# :question: FAQ

- Tudo o que vejo é `🐷🔑🐷  TruffleHog. Unearth your secrets. 🐷🔑🐷` e o programa encerra, o que significa isso?
  - Isso significa que nenhum segredo foi detectado
- Por que a varredura demora muito quando faço a varredura de uma organização do GitHub
  - Varreduras não autenticadas do GitHub têm limites de taxa. Para melhorar seus limites de taxa, inclua a flag `--token` com um token de acesso pessoal
- Diz que uma chave privada foi verificada, o que isso significa?
  - Um resultado verificado significa que o TruffleHog confirmou que a credencial é válida testando-a contra a API do serviço. Para chaves privadas, confirmamos que a chave pode ser usada ativamente para autenticação SSH ou SSL. Confira nosso post no blog Driftwood para saber mais [Blog post](https://trufflesecurity.com/blog/driftwood-know-if-private-keys-are-sensitive/)
- Existe uma maneira fácil de ignorar segredos específicos?
  - Se a fonte varrida [suporta números de linha](https://github.com/trufflesecurity/trufflehog/blob/d6375ba92172fd830abb4247cca15e3176448c5d/pkg/engine/engine.go#L358-L365), então você pode adicionar um comentário `trufflehog:ignore` na linha que contém o segredo para ignorar esse segredo.
- Posso encontrar segredos com `trufflehog:ignore` incluído?
  - Passe `--no-ignore-tag` para relatar resultados mesmo quando a linha contiver um comentário `trufflehog:ignore`. Isso é útil para revisar descobertas aceitas anteriormente.

# :newspaper: O que há de novo na v3?

O TruffleHog v3 é uma reescrita completa em Go com muitos recursos novos e poderosos.

- **Adicionamos mais de 700 detectores de credenciais que suportam verificação ativa contra suas respectivas APIs**.
- Também adicionamos **suporte nativo para varredura de GitHub, GitLab, Docker, sistemas de arquivos, S3, GCS, Circle CI e Travis CI**.
- **Verifique instantaneamente chaves privadas** contra milhões de usuários do github e **bilhões** de certificados TLS usando nossa tecnologia [Driftwood](https://trufflesecurity.com/blog/driftwood).
- Varra binários, documentos e outros formatos de arquivo
- Disponível como GitHub Action e pre-commit hook

## O que é verificação de credenciais?

Para cada credencial potencial detectada, implementamos meticulosamente a verificação programática contra a API à qual acreditamos que ela pertence. A verificação elimina falsos positivos e fornece três status de resultado:

- **verified**: Credencial confirmada como válida e ativa por meio de teste de API
- **unverified**: Credencial detectada, mas não confirmada como válida (pode ser inválida, expirada ou com verificação desativada)  
- **unknown**: Verificação tentada, mas falhou devido a erros, como falha de rede ou de API

Por exemplo, o [detector de credenciais AWS](https://github.com/trufflesecurity/trufflehog/blob/main/pkg/detectors/aws/access_keys/accesskey.go) executa uma chamada de API `GetCallerIdentity` contra a API da AWS para verificar se uma credencial AWS está ativa.

# :memo: Uso

O TruffleHog tem um subcomando para cada fonte de dados que você pode querer varrer:

- git
- github
- gitlab
- huggingface
- docker
- s3
- filesystem (arquivos e diretórios)
- syslog
- circleci
- travisci
- gcs (Google Cloud Storage)
- postman
- jenkins
- elasticsearch
- stdin
- multi-scan

Cada subcomando pode ter opções que você pode ver com a flag `--help` fornecida ao 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 exemplo, para escanear um repositório `git`, comece com

```
trufflehog git https://github.com/trufflesecurity/trufflehog.git
```

## Configuração

O TruffleHog suporta a definição de [detectores regex personalizados](#custom-regex-detector-alpha)
e múltiplas fontes num ficheiro de configuração fornecido através da flag `--config`.
Os detectores regex podem ser utilizados com qualquer subcomando, enquanto as fontes definidas
na configuração são apenas para o subcomando `multi-scan`.

O formato de configuração para fontes pode ser encontrado na
[página de documentação de configuração de fontes](https://trufflesecurity.com/docs/connect-sources) da Truffle Security.

Exemplo de configuração de fonte GitHub e [referência de opções](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
```

Você pode definir múltiplas conexões sob a chave `sources` (veja acima), e o TruffleHog irá escanear todas as fontes simultaneamente.

Para ver logs de depuração de apenas uma fonte, adicione `debug: true` a ela. Essa fonte escreve todos os seus logs de depuração, e todas as outras fontes mantêm o nível de log normal. Isso é útil quando uma fonte entre muitas está se comportando de forma incorreta:

```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 ativar logs de depuração para todas as fontes, use `--log-level=5` em vez disso.

## S3

A fonte S3 suporta a assunção de roles IAM para varredura, além de usuários IAM. Isso facilita para os usuários a varredura de múltiplas contas AWS sem precisar depender de credenciais codificadas para cada conta.

A identidade IAM que o TruffleHog usa inicialmente precisará ter privilégios `AssumeRole` como principal na [política de confiança](https://aws.amazon.com/blogs/security/how-to-use-trust-policies-with-iam-roles/) de cada role IAM a ser assumida.

Para varrer um bucket específico usando credenciais definidas localmente ou metadados de instância, caso esteja em uma instância EC2:

```bash
trufflehog s3 --bucket=<bucket-name>
```

Para verificar um bucket específico usando uma role assumida:

```bash
trufflehog s3 --bucket=<bucket-name> --role-arn=<iam-role-arn>
```

Várias roles podem ser passadas como argumentos separados. O comando a seguir tentará escanear todos os buckets que cada role tem permissão para listar na API do S3:

```bash
trufflehog s3 --role-arn=<iam-role-arn-1> --role-arn=<iam-role-arn-2>
```

### Restringindo uma varredura a objetos específicos

Buckets grandes frequentemente contêm dados que nunca vale a pena escanear, como arquivos compactados, mídia e artefatos de build. Dois conjuntos de flags mantêm esses objetos fora de uma varredura. Ambos são comparados com a chave do objeto antes de o objeto ser baixado, portanto um objeto ignorado não custa nenhuma requisição GET.

Escanear apenas os objetos sob um ou mais prefixos de chave:

```bash
trufflehog s3 --bucket=<bucket-name> --include-prefix=infra/ --include-prefix=services/
```

Ignorar os objetos sob um prefixo de chave:

```bash
trufflehog s3 --bucket=<bucket-name> --exclude-prefix=projects/archived/
```

Ambas as flags de prefixo podem ser usadas em conjunto para escanear uma subárvore enquanto se deixa de fora uma parte dela. Um objeto que corresponde a um prefixo de exclusão é sempre ignorado, mesmo que também corresponda a um prefixo de inclusão:

```bash
trufflehog s3 --bucket=<bucket-name> --include-prefix=src/ --exclude-prefix=src/vendor/
```

Os prefixos são correspondidos literalmente, não como globs, e não estão confinados a um limite de caminho. `--include-prefix=log` corresponde tanto a `logs/app.txt` quanto a `logs-archive/app.txt`.

As extensões de arquivo são filtradas separadamente. Escreva-as sem um ponto 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
```

Ao contrário das flags de prefixo, `--include-extension` e `--exclude-extension` não podem ser combinadas, porque nomear as extensões a serem verificadas já exclui todas as outras. Usar ambas falha na inicialização.

A correspondência de extensões não diferencia maiúsculas de minúsculas, portanto `--exclude-extension=zip` também ignora `BACKUP.ZIP`. Um objeto cuja chave não tem extensão alguma, como `Makefile`, não corresponde a nenhuma entrada: é ignorado quando `--include-extension` está definido, e mantido quando apenas `--exclude-extension` está definido.

Duas coisas a observar ao usar `--include-extension`. Um dotfile conta como extensão inteira, então `.env` tem a extensão `env` e qualquer lista de inclusão que omita `env` ignorará todos os arquivos `.env` no bucket. Como os arquivos `.env` são um local comum para segredos residirem, adicione `--include-extension=env` a menos que você pretenda ignorá-los. E apenas a última extensão conta, então `backup.tar.gz` tem a extensão `gz`: `--exclude-extension=tar.gz` não corresponde a nada, enquanto `--exclude-extension=gz` funciona.

Essas flags também se aplicam apenas às chaves de objetos, não aos arquivos dentro de um arquivo compactado. `--exclude-extension=mp4` ignora `clip.mp4` presente no bucket, mas não um `clip.mp4` empacotado dentro de `media.zip`. Excluir `zip` ignora o arquivo compactado por completo.

O TruffleHog solicita ao S3 que liste apenas as chaves sob os prefixos de inclusão, então um prefixo que cobre uma pequena parte de um bucket grande é listado rapidamente. Prefixos e extensões de exclusão são aplicados após a listagem, então eles reduzem o custo de baixar objetos, mas não o custo de listá-los.

Prefixos e extensões são aplicados em conjunto. Um objeto precisa passar por ambos para ser verificado, então o comando abaixo verifica `src/main.tf` mas ignora tanto `src/bundle.zip` quanto `docs/guide.tf`:

```bash
trufflehog s3 --bucket=<bucket-name> --include-prefix=src/ --exclude-extension=zip
```

Essas flags restringem os objetos dentro de um bucket. Para restringir quais buckets são verificados, use `--bucket` ou `--ignore-bucket`, que, diferentemente das flags de prefixo, não podem ser usadas juntas.

Códigos de saída:

- 0: Nenhum erro e nenhum resultado foram encontrados.
- 1: Um erro foi encontrado. As fontes podem não ter concluído as verificações.

---

[Read more](https://github.com/trufflesecurity/trufflehog)
Baixar ferramenta