Logotipo do GoReleaser

TruffleHog

Encontre credenciais vazadas.

🔎 Escaneando Agora

...e mais

Para saber mais sobre o TruffleHog e seus recursos e capacidades, visite nossa página do produto.

🌐 TruffleHog Enterprise

Você está interessado em monitorar continuamente Git, Jira, Slack, Confluence, Microsoft Teams, Sharepoint (e muito mais) por credenciais? Nós temos um produto empresarial que pode ajudar! Saiba mais em https://trufflesecurity.com/trufflehog-enterprise.

Nós usamos a receita do produto empresarial para financiar mais projetos open source incríveis dos quais toda a comunidade pode se beneficiar.

O que é o TruffleHog 🐽

TruffleHog é a ferramenta mais poderosa de Descoberta, Classificação, Validação e Análise de segredos. Nesse contexto, segredo se refere 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, armazenamentos de objetos, sistemas de arquivos e muito mais.

Classificação 📁

O TruffleHog classifica mais de 800 tipos de segredos, mapeando-os de volta para a 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 saber olhando, então o TruffleHog classifica tudo que encontra.

Validação ✅

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

Análise 🔬

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

📢 Junte-se à Nossa Comunidade

Tem perguntas? Feedback? Entre no Slack ou Discord e converse conosco.

Junte-se à nossa Comunidade no Slack

Junte-se ao Discord de Escaneamento de Segredos

📺 Demonstração

Demonstração de escaneamento do GitHub ```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 do MacOS```bash
brew install trufflehog

Docker:

_{Certifique-se de que o mecanismo Docker está em execução antes de executar os seguintes 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;Prompt de Comando do 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;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

Lançamentos binários```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 script de instalação```bash

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

### Usando script de instalação, verificar assinatura de checksum (requer 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 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

# :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 desejados 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"

Assim que a assinatura for confirmada como válida, pode prosseguir para validar que as somas SHA256 coincidem com o artefato baixado: ```shell sha256sum --ignore-missing -c trufflehog_{version}_checksums.txt

Substitua {version} pela versão dos ficheiros descarregados

Alternativamente, se estiver a usar 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.

🚀 Início Rápido

1: Digitalizar um repositório apenas por segredos verificados

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

.```
🐷🔑🐷  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: Analisar uma organização do GitHub apenas para segredos verificados```bash

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

## 3: Digitalizar uma Organização do GitHub excluindo repositórios arquivados```bash
trufflehog github --org=trufflesecurity --exclude-archived

4: Analisar um repositório do GitHub apenas por segredos verificados e obter saída JSON

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

Saída 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: Analisar um Repositório do GitHub + seus Issues e Pull Requests```bash

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

## 6: Analisar um bucket S3 para 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=

## 8: Analisar 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: Digitalizar 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 [chaves de teste](https://github.com/trufflesecurity/trufflehog/blob/HEAD/[email protected]:trufflesecurity/test_keys.git) repositório.```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 proteger contra configurações git maliciosas na varredura local (veja CVE-2025-41390), o TruffleHog clona repositórios git locais para um diretório temporário antes da varredura. Isso segue as [melhores práticas 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 escanear o repositório diretamente (faça isso apenas para repositórios confiáveis), pode usar a flag `--trust-local-git-config`.

## 11: Escanear buckets do GCS apenas por segredos verificados```bash
trufflehog gcs --project-id=<project-ID> --cloud-environment --results=verified

12: Digitalizar uma imagem Docker apenas por segredos verificados

Use a flag --image várias vezes para digitalizar 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 na CI

Defina a flag `--since-commit` para a sua branch padrão na qual as pessoas fazem merge (exemplo: "main"). Defina a flag `--branch` para o nome da branch do seu PR (exemplo: "feature-1"). Dependendo da plataforma CI/CD que você usa, esse valor pode ser obtido dinamicamente (exemplo: [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 a branch de destino já estiver selecionada durante o fluxo de trabalho 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= --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 TruffleHog: (1) nome de usuário e senha, (2) token de serviço.

Conectar 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 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’

Analisar um Cluster do Elastic Cloud

Para analisar um cluster no Elastic Cloud, você precisará de um Cloud ID e API key.```bash trufflehog elasticsearch
--cloud-id 'search-prod:dXMtY2Vx...YjM1ODNlOWFiZGRlNjI0NA=='
--api-key 'MlVtVjBZ...ZSYlduYnF1djh3NG5FQQ=='

## 17. Analisar um Repositório do GitHub para Referências de Objetos entre Forks e Commits Excluídos

O seguinte comando enumerará commits excluídos e ocultos em um repositório do GitHub e depois 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ê deseja remover automaticamente esses arquivos após a varredura, 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 varredura real de segredos é extremamente rápida.

Para mais informações sobre Referências de Objetos Cross Fork, leia nosso post no blog.

18. Varredura do Hugging Face

Varredura de 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, Conjuntos de Dados, Espaços 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>.

Escaneamento de Discussão e Comentários de 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

❓ Perguntas Frequentes

Tudo o que vejo é 🐷🔑🐷 TruffleHog. Unearth your secrets. 🐷🔑🐷 e o programa termina, o que está acontecendo?
- Isso significa que nenhum segredo foi detectado
Por que a verificação está demorando quando escaneio uma organização do GitHub?
- Verificações 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 ao vivo para autenticação SSH ou SSL. Confira nossa postagem no blog Driftwood para saber mais Postagem no blog
Existe uma maneira fácil de ignorar segredos específicos?
- Se a fonte verificada suportar números de linha, então você pode adicionar um comentário trufflehog:ignore na linha que contém o segredo para ignorar esse segredo.

📰 O que há de novo na v3?

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

Adicionamos mais de 700 detectores de credenciais que suportam verificação ativa contra suas respectivas APIs.
Também adicionamos suporte nativo para verificar 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.
Verifique binários, documentos e outros formatos de arquivo
Disponível como uma GitHub Action e um hook de pré-commit

O que é verificação de credenciais?

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

verificado: Credencial confirmada como válida e ativa por teste de API
não verificado: Credencial detectada mas não confirmada válida (pode ser inválida, expirada, ou verificação desabilitada)
desconhecido: Verificação tentada mas falhou devido a erros, como falha de rede ou de API

Por exemplo, o detector de credenciais AWS realiza uma chamada de API GetCallerIdentity contra a API da AWS para verificar se uma credencial AWS está ativa.

📝 Uso

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

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

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 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 de regex personalizados e múltiplas fontes em um arquivo de configuração fornecido via a flag --config. Os detectores de regex podem ser usados 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 da Truffle Security.

Exemplo de configuração de fonte GitHub e referência de opções:```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 várias conexões sob a chave `sources` (veja acima), e o
TruffleHog irá escanear todas as fontes concorrentemente.

## S3

A fonte S3 suporta a assunção de funções IAM para escanear, além de usuários IAM. Isso facilita para os usuários escanear múltiplas contas AWS sem depender de credenciais fixas para cada conta.

A identidade IAM que o TruffleHog utiliza 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 função IAM a ser assumida.

Para escanear um bucket específico usando credenciais configuradas localmente ou metadados da instância, se estiver em uma instância EC2:```bash
trufflehog s3 --bucket=<bucket-name>

Para escanear um bucket específico usando uma função assumida:```bash trufflehog s3 --bucket= --role-arn=

Várias funções podem ser passadas como argumentos separados. O seguinte comando tentará verificar cada bucket que cada função tem permissão para listar na API S3:```bash
trufflehog s3 --role-arn=<iam-role-arn-1> --role-arn=<iam-role-arn-2>

Códigos de Saída:

0: Nenhum erro e nenhum resultado encontrado.
1: Um erro foi encontrado. As fontes podem não ter completado as varreduras.
183: Nenhum erro foi encontrado, mas resultados foram encontrados. Será retornado apenas se a flag --fail for usada.

:octocat: TruffleHog Github Action

Uso Geral```

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

No exemplo de configuração acima, estamos escaneando segredos vivos em todos os PRs e Pushes para `main`. Apenas as alterações de código nos commits referenciados são escaneadas. Se você deseja escanear um branch inteiro, consulte a seção "Uso Avançado" abaixo.

### Shallow Cloning

Se você está incorporando o TruffleHog em um fluxo de trabalho autônomo e não está executando nenhuma outra ferramenta de CI/CD junto com o TruffleHog, recomendamos usar [Shallow Cloning](https://git-scm.com/docs/git-clone#Documentation/git-clone.txt---depthltdepthgt) para acelerar seu fluxo de trabalho. Aqui está um exemplo de como fazer isso:```
...
      - 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
...

Dependendo do tipo de evento (push ou PR), calculamos o número de commits presentes. Em seguida, adicionamos 2, para que possamos referenciar um commit base antes das nossas alterações de código. Passamos esse valor inteiro para a flag fetch-depth na ação de checkout, além do branch relevante. Agora nosso processo de checkout deve ser muito mais curto.

Detecção de Canary

TruffleHog detecta estaticamente https://canarytokens.org/.

imagem

Uso Avançado```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:

Se você quiser especificar refs `base` e `head` específicas, pode usar o argumento `base` (flag `--since-commit` na CLI do TruffleHog) e o argumento `head` (flag `--branch` na CLI do TruffleHog). Recomendamos usar esses argumentos apenas para casos de uso muito específicos, onde o comportamento padrão não funciona.

#### Uso Avançado: Escanear branch inteira```
- name: scan-push
        uses: trufflesecurity/trufflehog@main
        with:
          base: ""
          head: ${{ github.ref_name }}
          extra_args: --results=verified,unknown

TruffleHog GitLab CI

Exemplo 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"'

No pipeline de exemplo acima, estamos escaneando segredos ativos em todos os diretórios e arquivos do repositório. Este job é executado apenas quando a origem do pipeline é um evento de merge request, ou seja, é acionado quando um novo merge request é criado.

## Hook de Pré-commit

TruffleHog pode ser usado em um hook de pré-commit para evitar que credenciais vazem antes mesmo de saírem do seu computador.

Consulte a [documentação do hook de pré-commit](https://github.com/trufflesecurity/trufflehog/blob/HEAD/PreCommit.md) para mais informações.

## Detector de Regex Personalizado (alpha)

TruffleHog suporta detecção e verificação de expressões regulares personalizadas.
Para detecção, é necessário pelo menos uma **expressão regular** e uma **palavra-chave**.
Uma **palavra-chave** é um identificador de string literal fixo que aparece dentro ou ao redor
da regex a ser detectada. Para permitir máxima flexibilidade na verificação, um
webhook é utilizado contendo as correspondências da expressão regular.

TruffleHog enviará uma requisição JSON POST contendo as correspondências da regex para um
endpoint de webhook configurado. Se o endpoint responder com um código de status `200 OK`,
o segredo é considerado verificado. Se a verificação falhar devido a erros de rede/API,
o resultado é marcado como desconhecido.

Detectores Personalizados suportam alguns mecanismos de filtragem: entropia, regex direcionando
a correspondência inteira, regex direcionando o segredo capturado, e listas de palavras
excluídas verificadas contra o segredo (grupo capturado se presente, correspondência inteira
se o grupo de captura não estiver presente). Note que se seu detector personalizado tiver
múltiplos conjuntos `regex` (neste exemplo `hogID` e `hogToken`), os filtros são aplicados
a cada regex. [Aqui](https://github.com/trufflesecurity/trufflehog/blob/HEAD/examples/generic_with_filters.yml) está um exemplo de um detector
personalizado usando esses filtros.

**NB:** Este recurso está em alpha e sujeito a alterações.

### Exemplo de Detector Regex
[Aqui](https://github.com/trufflesecurity/trufflehog/blob/HEAD/pkg/custom_detectors/CUSTOM_DETECTORS.md) está como configurar um detector de regex
personalizado com servidor de verificação.

## Detecção Genérica de JWT

TruffleHog suporta detecção e verificação de um subconjunto de JWTs genéricos que encontra.
Especificamente, se um JWT usa criptografia de chave pública em vez de HMAC e a chave pública
pode ser obtida, TruffleHog pode determinar se o JWT está ativo ou não.

## :mag: Analisar

TruffleHog suporta a execução de uma análise mais profunda de uma credencial para visualizar
suas permissões e os recursos aos quais ela tem acesso.```bash
trufflehog analyze

❤️ Contribuidores

Este projeto existe graças a todas as pessoas que contribuem. [Contribuir].

💻 Contribuindo

Contribuições são muito bem-vindas! Consulte primeiro as nossas diretrizes de contribuição.

Não aceitamos mais contribuições para o TruffleHog v2, mas esse código está disponível no branch v2.

Adicionando novos detectores de segredos

Publicamos alguma documentação e ferramentas para começar a adicionar novos detectores de segredos. Vamos melhorar a deteção juntos!

Uso como biblioteca

Atualmente, o trufflehog está em desenvolvimento intenso e nenhuma garantia pode ser dada sobre a estabilidade das APIs públicas neste momento.

Alteração de licença

Desde a v3.0, o TruffleHog é distribuído sob uma licença AGPL 3, incluída em LICENSE. O TruffleHog v3.0 não utiliza nenhuma da base de código anterior, mas foi tomado cuidado para preservar a retrocompatibilidade na interface de linha de comando. O trabalho anterior a este lançamento ainda está disponível licenciado sob GPL 2.0 no histórico deste repositório e nos lançamentos e tags de pacotes anteriores. Um CLA preenchido é necessário para aceitarmos contribuições futuras.

Ler mais

trufflehog v3.97.0

Categorias