1. Prevenire l'ingresso di nuovi segreti nella base di codice,
2. Rilevare se tali prevenzioni vengono esplicitamente ignorate, e
3. Fornire una checklist di segreti da ruotare e migrare verso uno storage più sicuro.

In questo modo, si crea una separazione delle responsabilità: accettando che possano esserci attualmente segreti nascosti nel vostro grande repository (questo è ciò che chiamiamo una baseline), ma impedendo che il problema diventi più grande, senza dover affrontare lo sforzo potenzialmente enorme di spostare i segreti esistenti.

Lo fa eseguendo output diff periodici rispetto a espressioni regex costruite euristicamente, per identificare se è stato commesso un nuovo segreto. In questo modo, evita l'overhead di scavare in tutta la storia di git, così come la necessità di scansionare l'intero repository ogni volta.

Per dare un'occhiata ai cambiamenti recenti, consultare CHANGELOG.md.

Se desideri contribuire, consulta CONTRIBUTING.md.

Per documentazione più dettagliata, dai un'occhiata alla nostra altra documentazione.

Esempi

Avvio rapido:

Crea una baseline dei potenziali segreti attualmente trovati nel tuo repository git.```bash $ detect-secrets scan > .secrets.baseline

Scansione dei file non tracciati da git:```bash $ detect-secrets scan test_data/ --all-files > .secrets.baseline

Per baseline più vecchie della versione 0.9, basta ricrearle.

Avvisi per segreti appena aggiunti:

Scansione solo dei file in staging:```bash $ git diff --staged --name-only -z | xargs -0 detect-secrets-hook --baseline .secrets.baseline

Visualizzare tutti i plugin abilitati:```bash

$ detect-secrets scan --list-all-plugins ArtifactoryDetector AWSKeyDetector AzureStorageKeyDetector BasicAuthDetector CloudantDetector DiscordBotTokenDetector GitHubTokenDetector GitLabTokenDetector Base64HighEntropyString HexHighEntropyString IbmCloudIamDetector IbmCosHmacDetector IPPublicDetector JwtTokenDetector KeywordDetector MailchimpDetector NpmDetector OpenAIDetector PrivateKeyDetector PypiTokenDetector SendGridDetector SlackDetector SoftlayerDetector SquareOAuthDetector StripeDetector TelegramBotTokenDetector TwilioKeyDetector

Se vuoi solo eseguire un plugin specifico, puoi fare:```bash $ detect-secrets scan --list-all-plugins |
grep -v 'BasicAuthDetector' |
sed "s#^#--disable-plugin #g" |
xargs detect-secrets scan test_data

Utilizzo in altri script Python

Uso base:```python from detect_secrets import SecretsCollection from detect_secrets.settings import default_settings

secrets = SecretsCollection() with default_settings(): secrets.scan_file('test_data/config.ini')

import json print(json.dumps(secrets.json(), indent=2))

Installazione```bash

$ pip install detect-secrets ✨🍰✨

Utilizzo

detect-secrets viene fornito con tre diversi strumenti, e c'è spesso confusione su quale usare. Usa questa pratica checklist per aiutarti a decidere:

1. Vuoi aggiungere segreti al tuo baseline? Se sì, usa detect-secrets scan.
2. Vuoi ricevere avvisi per nuovi segreti non presenti nel baseline? Se sì, usa detect-secrets-hook.
3. Stai analizzando il baseline stesso? Se sì, usa detect-secrets audit.

Aggiungere Segreti al Baseline```

$ detect-secrets scan --help usage: detect-secrets scan [-h] [--string [STRING]] [--only-allowlisted] [--all-files] [--baseline FILENAME] [--force-use-all-plugins] [--slim] [--list-all-plugins] [-p PLUGIN] [--base64-limit [BASE64_LIMIT]] [--hex-limit [HEX_LIMIT]] [--disable-plugin DISABLE_PLUGIN] [-n | --only-verified] [--exclude-lines EXCLUDE_LINES] [--exclude-files EXCLUDE_FILES] [--exclude-secrets EXCLUDE_SECRETS] [--word-list WORD_LIST_FILE] [-f FILTER] [--disable-filter DISABLE_FILTER] [path [path ...]]

Scans a repository for secrets in code. The generated output is compatible with detect-secrets-hook --baseline.

positional arguments: path Scans the entire codebase and outputs a snapshot of currently identified secrets.

optional arguments: -h, --help show this help message and exit --string [STRING] Scans an individual string, and displays configured plugins' verdict. --only-allowlisted Only scans the lines that are flagged with allowlist secret. This helps verify that individual exceptions are indeed non-secrets.

scan options: --all-files Scan all files recursively (as compared to only scanning git tracked files). --baseline FILENAME If provided, will update existing baseline by importing settings from it. --force-use-all-plugins If a baseline is provided, detect-secrets will default to loading the plugins specified by that baseline. However, this may also mean it doesn't perform the scan with the latest plugins. If this flag is provided, it will always use the latest plugins --slim Slim baselines are created with the intention of minimizing differences between commits. However, they are not compatible with the audit functionality, and slim baselines will need to be remade to be audited.

plugin options: Configure settings for each secret scanning ruleset. By default, all plugins are enabled unless explicitly disabled.

--list-all-plugins Lists all plugins that will be used for the scan. -p PLUGIN, --plugin PLUGIN Specify path to custom secret detector plugin. --base64-limit [BASE64_LIMIT] Sets the entropy limit for high entropy strings. Value must be between 0.0 and 8.0, defaults to 4.5. --hex-limit [HEX_LIMIT] Sets the entropy limit for high entropy strings. Value must be between 0.0 and 8.0, defaults to 3.0. --disable-plugin DISABLE_PLUGIN Plugin class names to disable. e.g. Base64HighEntropyString

filter options: Configure settings for filtering out secrets after they are flagged by the engine.

-n, --no-verify Disables additional verification of secrets via network call. --only-verified Only flags secrets that can be verified. --exclude-lines EXCLUDE_LINES If lines match this regex, it will be ignored. --exclude-files EXCLUDE_FILES If filenames match this regex, it will be ignored. --exclude-secrets EXCLUDE_SECRETS If secrets match this regex, it will be ignored. --word-list WORD_LIST_FILE Text file with a list of words, if a secret contains a word in the list we ignore it. -f FILTER, --filter FILTER Specify path to custom filter. May be a python module path (e.g. detect_secrets.filters.common.is_invalid_file) or a local file path (e.g. file://path/to/file.py::function_name). --disable-filter DISABLE_FILTER Specify filter to disable. e.g. detect_secrets.filters.common.is_invalid_file

Raccomandiamo di impostarlo come hook pre-commit. Un modo per farlo è utilizzare il framework pre-commit:```yaml

.pre-commit-config.yaml

repos:

• repo: https://github.com/Yelp/detect-secrets rev: v1.5.0 hooks:
  • id: detect-secrets args: ['--baseline', '.secrets.baseline'] exclude: package.lock.json

o```javascript // pragma: allowlist nextline secret const secret = "hunter2";

Configurazione

Questo strumento opera attraverso un sistema di plugin e filtri.

• Plugin trovano segreti nel codice
• Filtri ignorano i falsi positivi per aumentare la precisione della scansione

Puoi regolare entrambi per adattarli alle tue esigenze di precisione/richiamo.

Plugin

Utilizziamo tre diverse strategie per cercare di trovare segreti nel codice:

1. Regole basate su Regex

   Queste sono il tipo di plugin più comune e funzionano bene con segreti ben strutturati. Questi segreti possono opzionalmente essere verificati, il che aumenta la precisione della scansione. Tuttavia, dipendere esclusivamente da esse può influenzare negativamente il richiamo della tua scansione.

2. Rilevatore di Entropia

   Cerca stringhe "dall'aspetto segreto" attraverso una varietà di approcci euristici. Questo è ottimo per segreti non strutturati, ma potrebbe richiedere un'ottimizzazione per regolare la precisione della scansione.

3. Rilevatore di Parole Chiave

   Ignora il valore del segreto e cerca nomi di variabili spesso associati all'assegnazione di segreti con valori hard-coded. Questo è ottimo per stringhe "dall'aspetto non segreto" (ad es. password le3tc0de), ma potrebbe richiedere l'ottimizzazione dei filtri per regolare la precisione della scansione.

Vuoi trovare un segreto che attualmente non rileviamo? Puoi anche (facilmente) sviluppare il tuo plugin e usarlo con il motore! Per maggiori informazioni, consulta la documentazione dei plugin.

Filtri

detect-secrets include diversi filtri integrati che potrebbero soddisfare le tue esigenze.

--exclude-lines

A volte, si desidera poter permettere globalmente certe righe nella scansione, se corrispondono a un pattern specifico. Puoi specificare una regola regex come segue:```bash $ detect-secrets scan --exclude-lines 'password = (blah|fake)'

--exclude-files

A volte, potresti voler ignorare determinati file durante la scansione. Puoi specificare un pattern regex per farlo, e se il nome del file corrisponde a questo pattern regex, non verrà scansionato:```bash $ detect-secrets scan --exclude-files '.*.signature$'

--exclude-secrets

A volte, potresti voler ignorare determinati valori segreti nella tua scansione. Puoi specificare una regola regex in questo modo:```bash $ detect-secrets scan --exclude-secrets '(fakesecret|${.*})'

Allowlisting Inline

A volte, si desidera applicare un'esclusione a una riga specifica, piuttosto che escluderla globalmente. È possibile farlo con l'allowlisting inline come segue:```python API_KEY = 'this-will-ordinarily-be-detected-by-a-plugin' # pragma: allowlist secret

Puoi anche usare:```python

pragma: allowlist nextline secret

API_KEY = 'WillAlsoBeIgnored'

Vuoi scrivere più logica personalizzata per filtrare i falsi positivi? Scopri come fare nella nostra documentazione sui filtri.

Estensioni

wordlist

Il flag --exclude-secrets permette di specificare regole regex per escludere valori segreti. Tuttavia, se invece vuoi specificare una lunga lista di parole, puoi usare il flag --word-list.

Per utilizzare questa funzionalità, assicurati di installare il pacchetto pyahocorasick, o semplicemente usa:```bash $ pip install detect-secrets[word_list]

Gibberish Detector

Il Gibberish Detector è un semplice modello di ML, che tenta di determinare se un valore segreto è effettivamente senza senso, partendo dal presupposto che i veri valori segreti non assomigliano a parole.

Per utilizzare questa funzionalità, assicurati di installare il pacchetto gibberish-detector, oppure usa:```bash $ pip install detect-secrets[gibberish]

Questo non è un plugin predefinito, dato che ignorerà segreti come password.

Caveats

Non è pensato per essere una soluzione infallibile per impedire che i segreti entrino nel codebase. Solo una corretta educazione degli sviluppatori può veramente raggiungere questo obiettivo. Questo hook pre-commit implementa semplicemente diverse euristiche per cercare di prevenire casi evidenti di commit di segreti.

Cose che non verranno impedite:

• Segreti su più righe
• Password predefinite che non attivano il KeywordDetector (ad es. login = "hunter2")

FAQ

General

• Avviso "Did not detect git repository." incontrato, anche se mi trovo in un repository git.

  Controlla se la tua versione di git è >= 1.8.5. In caso contrario, aggiornala e riprova. Maggiori dettagli qui.

Windows

• detect-secrets audit mostra "Not a valid baseline file!" dopo aver creato la baseline.

  Assicurati che la codifica del file della baseline sia UTF-8. Maggiori dettagli qui.