📋 Copia tutti i tartufi Comandi Hog_HTML_TAG_93___ HTML_TAG_94_📄 Generare TruffleHog PDF Guida_HTML_TAG_95 Traduzione:

Truffle # Hog Cheatsheet

Installazione

Tabella_98_

Comandi di base

Tabella_99

Uso avanzato

Tabella_100_

Configurazione

Configurazione personalizzata del rivelatore

Creare un file di configurazione del rivelatore personalizzato per definire i propri modelli segreti:

# custom-detectors.yaml
detectors:
  - name: CustomAPIKey
    keywords:
      - custom_api_key
      - customapikey
    regex:
      apikey: '[A-Za-z0-9]{32}'
    verify:
      - endpoint: 'https://api.example.com/verify'
        unsafe: false
        headers:
          - 'Authorization: Bearer {apikey}'
        successIndicators:
          - '"status":"valid"'
        failureIndicators:
          - '"status":"invalid"'

  - name: InternalToken
    keywords:
      - internal_token
      - company_token
    regex:
      token: 'int_[A-Za-z0-9]{40}'

Variabili ambientali

# GitHub token for scanning private repositories
export GITHUB_TOKEN=ghp_xxxxxxxxxxxxx

# GitLab token for scanning
export GITLAB_TOKEN=glpat-xxxxxxxxxxxxx

# AWS credentials for S3 scanning
export AWS_ACCESS_KEY_ID=AKIAXXXXXXXXXXXXX
export AWS_SECRET_ACCESS_KEY=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
export AWS_REGION=us-east-1

Exclude Patterns File

Creare un file .trufflehogignore__ per escludere modelli specifici:

# .trufflehogignore
# Exclude test files
**/test/**
**/tests/**
**/*_test.go

# Exclude dependencies
node_modules/
vendor/
.venv/

# Exclude specific false positives
docs/examples/fake-credentials.md
scripts/test-data.json

Configurazione di integrazione CI/CD

GitHub Azioni

# .github/workflows/trufflehog.yml
name: TruffleHog Secret Scanning
on: [push, pull_request]

jobs:
  scan:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v3
        with:
          fetch-depth: 0

      - name: TruffleHog Scan
        uses: trufflesecurity/trufflehog@main
        with:
          path: ./
          base: ${{ github.event.repository.default_branch }}
          head: HEAD
          extra_args: --only-verified --fail

GitLab CI

# .gitlab-ci.yml
trufflehog-scan:
  stage: security
  image: trufflesecurity/trufflehog:latest
  script:
    - trufflehog git file://. --only-verified --fail --json > trufflehog-report.json
  artifacts:
    reports:
      sast: trufflehog-report.json
    when: always
  allow_failure: false

# Jenkins Pipeline

// Jenkinsfile
pipeline {
    agent any
    stages {
        stage('Secret Scanning') {
            steps {
                sh '''
                    docker run --rm -v $(pwd):/scan \
                    trufflesecurity/trufflehog:latest \
                    git file:///scan --only-verified --fail
                '''
            }
        }
    }
}

Common Use Cases

Use Case 1: Pre-Commit Hook for Secret Prevention

Impedire ai segreti di essere impegnati nel tuo repository:

# Create pre-commit hook
cat > .git/hooks/pre-commit << 'EOF'
#!/bin/bash
echo "Running TruffleHog secret scan..."
trufflehog git file://. --since-commit=HEAD --only-verified --fail

if [ $? -ne 0 ]; then
    echo "⚠️  TruffleHog detected secrets! Commit aborted."
    exit 1
fi
echo "✓ No secrets detected"
EOF

# Make executable
chmod +x .git/hooks/pre-commit

Use Case 2: Full Repository Audit Before Going Public

Controllare un intero repository prima di renderlo pubblico:

# Comprehensive scan of entire history
trufflehog git file://. --json --no-update > full-audit.json

# Review verified secrets only
trufflehog git file://. --only-verified --json | jq '.[] | {detector: .DetectorName, file: .SourceMetadata.Data.Git.file, commit: .SourceMetadata.Data.Git.commit}'

# Generate summary report
trufflehog git file://. --json | jq -r '.[] | "\(.DetectorName): \(.SourceMetadata.Data.Git.file)"' | sort | uniq -c | sort -rn

Use Case 3: Scanning Multiple Repositories in Organization

Automatizzare la scansione su tutti i repository organizzativi:

#!/bin/bash
# scan-org.sh

ORG_NAME="mycompany"
GITHUB_TOKEN="ghp_xxxxxxxxxxxxx"
OUTPUT_DIR="./scan-results"

mkdir -p $OUTPUT_DIR

# Scan entire organization
trufflehog github \
  --org=$ORG_NAME \
  --token=$GITHUB_TOKEN \
  --only-verified \
  --json > $OUTPUT_DIR/org-scan-$(date +%Y%m%d).json

# Generate summary
jq -r '.[] | "\(.SourceMetadata.Data.Github.repository): \(.DetectorName)"' \
  $OUTPUT_DIR/org-scan-$(date +%Y%m%d).json | \
  sort | uniq -c | sort -rn > $OUTPUT_DIR/summary.txt

echo "Scan complete. Results in $OUTPUT_DIR"

Use Case 4: Docker Image Security Scanning

Scansione delle immagini Docker prima dell'implementazione:

# Scan production image
trufflehog docker --image=myapp:latest --only-verified --json > docker-scan.json

# Scan multiple images
for image in nginx:latest postgres:14 redis:alpine; do
    echo "Scanning $image..."
    trufflehog docker --image=$image --only-verified
done

# Scan local images
docker images --format "{{.Repository}}:{{.Tag}}" | \
  grep -v "<none>" | \
  xargs -I {} trufflehog docker --image={}

Use Case 5: Monitoraggio continuo con scansioni programmate

Impostare la scansione giornaliera automatizzata:

# Create monitoring script
cat > /usr/local/bin/trufflehog-monitor.sh << 'EOF'
#!/bin/bash
REPOS_DIR="/opt/repositories"
REPORT_DIR="/var/log/trufflehog"
DATE=$(date +%Y%m%d)

mkdir -p $REPORT_DIR

for repo in $REPOS_DIR/*; do
    if [ -d "$repo/.git" ]; then
        repo_name=$(basename $repo)
        echo "Scanning $repo_name..."

        cd $repo
        git pull --quiet

        trufflehog git file://. --only-verified --json \
          > $REPORT_DIR/${repo_name}-${DATE}.json

        # Alert if secrets found
        if [ $(jq length $REPORT_DIR/${repo_name}-${DATE}.json) -gt 0 ]; then
            echo "⚠️  Secrets found in $repo_name" | \
              mail -s "TruffleHog Alert: $repo_name" security@company.com
        fi
    fi
done
EOF

chmod +x /usr/local/bin/trufflehog-monitor.sh

# Add to crontab (daily at 2 AM)
echo "0 2 * * * /usr/local/bin/trufflehog-monitor.sh" | crontab -

Migliori Pratiche

• Scan Early e Spesso: Integrare il tartufo Introduci nel tuo canale CI/CD per catturare i segreti prima che raggiungano la produzione. Utilizzare ganci pre-commit per feedback immediato per gli sviluppatori.

• Focus on Verified Secrets First: Usa la bandiera --only-verified per priorizzare le credenziali valide attivamente che pongono rischi di sicurezza immediati. Le partite non verificate possono includere falsi positivi o credenziali scadute.

• Scan Complete History: Quando l'auditing repositorys, sempre la scansione dell'intera cronologia git (trufflehog git file://._ senza limiti di commit) come i segreti possono esistere in vecchi commit che sono ancora accessibili.

• Utilizza Rilevatori personalizzati per sistemi interni: Crea configurazioni di rivelatori personalizzate per chiavi API proprietarie, gettoni interni e modelli segreti specifici dell'azienda che i rilevatori incorporati non catturano.

• Implementa i flussi di lavoro di riparazione automatizzati: Quando i segreti vengono rilevati, hanno un processo documentato per la rotazione delle credenziali immediate, la revoca dell'accesso e la registrazione degli incidenti di sicurezza.

• Escludi i falsi positivi sistematicamente... Utilizzare i file .trufflehogignore_ per escludere i dati di prova, gli esempi di documentazione e i falsi positivi conosciuti piuttosto che ignorare intere directory inutilmente.

• "Monitor ThirdParty Dependencies" Scansione regolare codice fornitore, dipendenze open source e immagini di base Docker in quanto possono contenere segreti o credenziali incorporati.

• Combina con strumenti di gestione segreta: Usa il tartufo Hog per il rilevamento ma implementare soluzioni di gestione segrete corrette (HashiCorp Vault, AWS Secrets Manager) per evitare che i segreti entrino in codice in primo luogo.

• Set Appropriato Entropy Thresholds: Regolare --filter-entropy in base al codice base per bilanciare tra catturare segreti e minimizzare i falsi positivi (default 3.0 funziona per la maggior parte dei casi).

• Archive and Analyze Scan Results: Conservare i risultati della scansione con i timestamp per la verifica della conformità, l'analisi della tendenza e dimostrare miglioramenti della postura di sicurezza nel tempo.

Risoluzione dei problemi

Traduzione: Rilevatori personalizzati non funzionanti | Convalida sintassi YAML in file di configurazione, assicurarsi che i modelli regex siano correttamente evasi, verificare che i nomi dei rivelatori siano unici e testare i modelli regex separatamente. #