thoughtworks/talismanScanner di segreti basato su hook Git che rileva token, password e chiavi private nei changeset in uscita, impedendo che dati sensibili vengano committati o inviati ai repository.
Uno strumento per rilevare e prevenire che i segreti vengano inseriti nel repository
Talisman è uno strumento che scansiona i changeset git per garantire che potenziali segreti o informazioni sensibili non lascino la workstation dello sviluppatore.
Convalida il changeset in uscita per individuare elementi sospetti, come potenziali chiavi SSH, token di autorizzazione, chiavi private, ecc.
Talisman supporta MAC OSX, Linux e Windows.
Talisman può essere installato e utilizzato in uno dei seguenti modi:
Talisman può essere configurato come hook pre-commit o pre-push sui repository git.
Trova le istruzioni qui sotto.
Avvertenza: I segreti che si insinuano tramite un push forzato in un repository git non possono essere rilevati da Talisman. Un push forzato è considerato notoriamente problematico, e suggeriamo agli amministratori del repository git di adottare misure appropriate per autorizzare tali attività.
Ti consigliamo di installare talisman nel PATH in modo che sia disponibile per framework di hook git e script. Scegli il binario corretto per il tuo sistema dalla nostra Pagina delle Release, oppure esegui il nostro script di installazione:```bash
bash -c "$(curl --silent https://raw.githubusercontent.com/thoughtworks/talisman/main/install.sh)"
Oppure imposta la variabile d'ambiente `INSTALL_LOCATION` per specificare una posizione personalizzata per il binario:```bash
INSTALL_LOCATION=/usr/local/bin bash -c "$(curl --silent https://raw.githubusercontent.com/thoughtworks/talisman/main/install.sh)"
Oppure imposta la variabile d'ambiente VERSION su un tag rilasciato per installare una versione specifica::```bash
VERSION=v1.36.0 bash -c "$(curl --silent https://raw.githubusercontent.com/thoughtworks/talisman/main/install.sh)"
Oppure usando linuxbrew in Linux e homebrew in macOS eseguendo il seguente comando nel terminale:```bash
brew install talisman
Offriamo script che installeranno Talisman come template di hook git pre-commit, poiché ciò farà sì che Talisman sia presente non solo nei repository git esistenti, ma anche in qualsiasi nuovo repository che inizializzi ('init') o cloni ('clone').
Come hook pre-commit: ``` bash -c "$(curl --silent https://raw.githubusercontent.com/thoughtworks/talisman/main/global_install_scripts/install.bash)"
O
Come hook pre-push: ```
bash -c "$(curl --silent https://raw.githubusercontent.com/thoughtworks/talisman/main/global_install_scripts/install.bash)" -- pre-push
$PATH, ti verrà chiesto un luogo appropriato per impostarlo. Scegli il numero dell'opzione in cui imposti il source del profilo sulla tua macchina.Ricorda di eseguire source sul file di percorso o riavviare il terminale.
Se scegli di impostare il $PATH in seguito, esporta TALISMAN_HOME=$HOME/.talisman/bin nel path.
Installare globalmente talisman come hook non sovrascriverà alcun hook esistente. Se lo script di installazione trova hook esistenti, lo indicherà solo nella console. Per eseguire più hook, suggeriamo di utilizzare un hook framework, come pre-commit o husky. Queste istruzioni presuppongono che l'eseguibile talisman sia installato in qualche punto nel path del tuo sistema.
Usa pre-commit per gestire gli hook esistenti insieme a Talisman. Fai riferimento ai nostri pre-commit-hooks nel tuo .pre-commit-config.yaml:```yaml
### Husky
[husky](https://typicode.github.io/husky) è un modulo npm per la gestione degli hook.
Aggiungi la seguente riga alla configurazione pre-commit di husky nel tuo
`package.json`:```
talisman --githook pre-commit
Una volta che l'eseguibile di talisman è installato è possibile configurare un hook pre-commit autonomo per un repository git:```bash cd my-git-project echo "talisman -g pre-commit" >> .git/hooks/pre-commit chmod +x .git/hooks/pre-commit
# Aggiornamento
Dalla release v0.4.4, Talisman <b>aggiorna automaticamente</b> il binario all'ultima release, quando l'hook viene invocato (in pre-commit/pre-push, come configurato). Quindi, siediti, rilassati e continua a usare l'ultima versione di Talisman senza sforzi aggiuntivi.
Si possono impostare le seguenti variabili d'ambiente:
1. TALISMAN_SKIP_UPGRADE: Imposta a true se vuoi saltare il controllo automatico dell'aggiornamento. Il valore predefinito è false
2. TALISMAN_UPGRADE_CONNECT_TIMEOUT: Timeout massimo di connessione prima che l'aggiornamento venga annullato (in secondi). Il valore predefinito è 10 secondi.
Se dovessi aver bisogno di un aggiornamento manuale, ecco i passaggi:
<br>[Consigliato] Aggiorna il binario di Talisman e gli script di hook all'ultima release:```bash
curl --silent https://raw.githubusercontent.com/thoughtworks/talisman/main/global_install_scripts/update_talisman.bash > /tmp/update_talisman.bash && /bin/bash /tmp/update_talisman.bash
Aggiorna solo il binario di Talisman eseguendo:```bash curl --silent https://raw.githubusercontent.com/thoughtworks/talisman/main/global_install_scripts/update_talisman.bash > /tmp/update_talisman.bash && /bin/bash /tmp/update_talisman.bash talisman-binary
# Talisman in azione
Dopo un'installazione riuscita, Talisman esegue automaticamente controlli per individuare segreti evidenti prima di ogni commit o push (come scelto durante l'installazione). In caso di rilevamento di violazioni di sicurezza, talisman mostrerà un rapporto dettagliato degli errori:```bash
$ git push
Talisman Report:
+-----------------+-------------------------------------------------------------------------------+
| FILE | ERRORS |
+-----------------+-------------------------------------------------------------------------------+
| danger.pem | The file name "danger.pem" |
| | failed checks against the |
| | pattern ^.+\.pem$ |
+-----------------+-------------------------------------------------------------------------------+
| danger.pem | Expected file to not contain hex encoded texts such as: |
| | awsSecretKey=c64e8c79aacf5ddb02f1274db2d973f363f4f553ab1692d8d203b4cc09692f79 |
+-----------------+-------------------------------------------------------------------------------+
Nell'esempio sopra, il file danger.pem è stato segnalato come una violazione di sicurezza per i seguenti motivi:
Se hai installato Talisman come hook pre-commit, scannerà solo il diff all'interno di ogni commit. Ciò significa che segnalerà errori solo per le parti del file che sono state modificate.
Nel caso in cui tu abbia installato Talisman come hook pre-push, scannerà l'intero file in cui vengono apportate le modifiche. Come menzionato sopra, si raccomanda di utilizzare Talisman come hook pre-commit.
I seguenti rilevatori vengono eseguiti sui changeset per rilevare segreti/informazioni sensibili:
Se sei davvero sicuro di voler inviare quel file, puoi configurarlo nel file .talismanrc nella root del progetto. I contenuti necessari per ignorare i file non superati verranno stampati da Talisman sulla console subito dopo il Talisman Error Report:```bash
If you are absolutely sure that you want to ignore the above files from talisman detectors, consider pasting the following format in .talismanrc file in the project root
fileignoreconfig:
Inserire questo nel file `.talismanrc` garantirà che Talisman ignori il file `danger.pem` finché il checksum corrisponde al valore indicato nel campo `checksum`.
### Modalità interattiva
**Disponibile solo per utenti non Windows**
Se è troppo fastidioso copiare continuamente il contenuto in .talismanrc ogni volta che si verifica un errore da Talisman, puoi abilitare la modalità interattiva e lasciare che Talisman ti assista nel suggerire le aggiunte dei file da ignorare.
Basta seguire i semplici passaggi:
1. Apri il tuo profilo bash dove sono impostate le variabili d'ambiente (.bashrc, .bash_profile, .profile o qualsiasi altra posizione)
2. Vedrai la variabile `TALISMAN_INTERACTIVE` sotto `# >>> talisman >>>`
3. Se non è già impostata su true, aggiungi `export TALISMAN_INTERACTIVE=true`
4. Non dimenticare di salvare e fare source del file
Ecco fatto! Ogni volta che l'hook di Talisman trova un errore durante pre-push/pre-commit, segui le istruzioni come suggerito da Talisman.
Fai attenzione a non ignorare un file senza verificarne il contenuto. Devi essere certo che nessun segreto venga divulgato.
### Ignorare rilevatori specifici
Di seguito una descrizione dettagliata dei vari campi che possono essere configurati nel file `.talismanrc`:
* `filename` : Questo campo deve indicare il nome del file completo.
* `checksum` : Questo campo deve avere sempre il valore specificato da Talisman nel messaggio mostrato sopra. Se a un certo punto viene apportata una nuova modifica al file, si otterrà un nuovo checksum e Talisman scansionerà nuovamente il file per eventuali minacce di sicurezza.
* `ignore_detectors` : Questo campo disabiliterà rilevatori specifici per un particolare file.
Ad esempio, se il nome del file `init-env.sh` attiva un avviso, puoi disabilitare solo
questo avviso pur essendo ancora avvisato se altre cose vanno male (ad esempio il contenuto del file):```yaml
fileignoreconfig:
- filename: init-env.sh
checksum: cf97abd34cebe895417eb4d97fbd7374aa138dcb65b1fe7f6b6cc1238aaf4d48
ignore_detectors: [filename, filesize]
Nota: Qui sia i rilevatori di nomefile che di dimensione file vengono ignorati per init-env.sh, ma il rilevatore di contenuto file si attiverà comunque su init-env.sh
Al momento, puoi ignorare
filecontentfilenamefilesizePoiché alcuni dei tuoi file potrebbero contenere parole chiave come key o pass che non sono necessariamente correlate a segreti, potresti voler ignorare queste parole chiave per ridurre il numero di falsi positivi.
Ciò può essere ottenuto utilizzando il campo allowed_patterns a livello di file e/o a livello di repository:```yaml
fileignoreconfig:
Nell'esempio precedente, `key` è consentito nel file `test`, `keyword` e `pass` sono consentiti a livello di repository.
Il campo `allowed_patterns` supporta anche le espressioni regolari di Golang. Ecco un semplice esempio di codice in cui le RegExp di Golang possono essere utili:```sh
export AWS_ACCESS_KEY_ID = AKIAIO5FODNN7EXAMPLE
export AWS_ACCESS_KEY_ID=$(vault read -field=value path/to/aws-access-key-id)
Per impostazione predefinita, Talisman avviserà per entrambe le righe. Nella seconda riga, stiamo estraendo l'AWS Access Key ID da Hashicorp Vault, che non espone il segreto al codice. Se questo tipo di utilizzo è comune nel tuo codice, potresti voler dire a Talisman di non avvisare quando utilizzi un Vault. Ciò può essere ottenuto con una configurazione come:```yaml allowed_patterns:
### Ignorare più file dello stesso tipo (con wildcard)
Puoi scegliere di ignorare tutti i file di un certo tipo, perché sai che saranno sempre sicuri e non vorresti che Talisman li scansionasse.
Passaggi:
1. Formatta un pattern con wildcard per i file che vuoi ignorare. Ad esempio, `*.lock`
2. Usa il [checksum calculator](#checksum-calculator) per inserire il pattern e ottenere un checksum collettivo. Ad esempio, `talisman --checksum="*.lock"`
3. Copia il blocco fileconfig, stampato sulla console, nel file .talismanrc.
Se uno qualsiasi dei file viene modificato, talisman scansionerà di nuovo i file, a meno che tu non ricalcoli il nuovo checksum e lo sostituisca nel file .talismanrc.
### Ignorare file specificando l'ambito del linguaggio
Puoi scegliere di ignorare file specificando l'ambito del linguaggio per il tuo progetto nel tuo talismanrc.```yaml
scopeconfig:
- scope: go
- scope: node
- scope: images
- scope: php
- scope: python
Talisman è configurato per ignorare determinati file in base all'ambito specificato. Ad esempio, menzionare l'ambito node nel scopeconfig impedirà a talisman di scansionare file come yarn.lock o package-lock.json.
Puoi specificare più ambiti.
Attualmente .talismanrc supporta il scopeconfig solo per gli ambiti go, node, php e images. Altri ambiti verranno aggiunti a breve.
Puoi specificare espressioni regolari personalizzate da cercare nel repository corrente```yaml custom_patterns:
<br/><i>
**Nota**: L'uso di .talismanignore è stato deprecato. Il file .talismanrc lo sostituisce perché:
* .talismanrc ha un formato yaml molto più leggibile
* Introduce anche pratiche più sicure con ogni modifica di un file con un valore potenzialmente sensibile da revisionare
* Il nuovo formato porta anche l'estensibilità per introdurre nuove funzionalità utilizzabili. Tieni d'occhio per altri aggiornamenti </i>
## Configurazione della soglia di gravità
Ogni validazione è associata a una gravità
1. Bassa
2. Media
3. Alta
Puoi specificare una soglia nel tuo .talismanrc:```yaml
threshold: medium
Questo segnalerà tutti i problemi di gravità Media e superiori (i rischi potenziali al di sotto della soglia verranno segnalati negli avvisi)
Puoi personalizzare i livelli di sicurezza dei rilevatori forniti da Talisman nel file .talismanrc:```yaml custom_severities:
Utilizzando severità personalizzate e una soglia di severità, Talisman può essere configurato per avvisare solo su ciò che è importante in base al tuo contesto. Questo può essere utile per ridurre il numero di falsi positivi.
## Talisman come utilità CLI
Se esegui `talisman` sulla riga di comando, potrai visualizzare tutte le opzioni dei parametri che puoi passare```
-c, --checksum string checksum calculator calculates checksum and suggests .talismanrc format
-d, --debug enable debug mode (warning: very verbose)
-g, --githook string either pre-push or pre-commit (default "pre-push")
--ignoreHistory scanner scans all files on current head, will not scan through git commit history
-i, --interactive interactively update talismanrc (only makes sense with -g/--githook)
-p, --pattern string pattern (glob-like) of files to scan (ignores githooks)
-r, --reportdirectory string directory where the scan reports will be stored
-s, --scan scanner scans the git commit history for potential secrets
-w, --scanWithHtml generate html report (**Make sure you have installed talisman_html_report to use this, as mentioned in Readme**)
-v, --version show current version of talisman
Quando regolarmente hai troppi file che vengono segnalati dall'hook di talisman, che sai che dovrebbero andare bene per il check-in, puoi utilizzare questa funzione per far sì che talisman semplifichi il processo. La modalità interattiva permetterà a Talisman di chiederti di aggiungere direttamente i file che vuoi ignorare a .talismanrc dal prompt dei comandi.
Per abilitare questa funzione, devi impostare la variabile TALISMAN_INTERACTIVE su true nel tuo file bash.
Puoi invocare talisman in modalità interattiva in uno dei seguenti 2 modi:
Apri il tuo file bash e aggiungiexport TALISMAN_INTERACTIVE=true
Don't forget to source the bash file for the variable to take effect!
Alternatively, you can also invoke the interactive mode by using the CLI utility
(for using pre-commit hook)
talisman -i -g pre-commit
Nota: Se utilizzi l'integrazione del controllo versione dell'IDE per le operazioni Git, questa funzionalità non funzionerà. Puoi comunque utilizzare il nome file suggerito e il checksum da inserire manualmente nel file .talismanrc.
Ora puoi eseguire Talisman dalla CLI e potenzialmente aggiungerlo alle tue pipeline CI/CD per scansionare la cronologia Git del tuo repository e trovare contenuti sensibili. Ciò include anche la scansione dei file elencati nel file .talismanrc.
Passaggi:
cd <directory da scansionare>talisman --scantalisman --scan --reportdirectory=/Users/username/DesktopPuoi utilizzare le altre opzioni per la scansione come indicato sopra.
Attualmente Talisman non supporta l'ignorare file per la scansione.
Il calcolatore di checksum di Talisman restituisce un formato YAML che puoi copiare e incollare direttamente nel file .talismanrc per ignorare formati di file specifici dai rilevatori di Talisman.
Per eseguire il checksum, accedi tramite "cd" alla radice del tuo repository ed esegui il comando seguente
Per esempio:
talisman --checksum="*.pem *.txt"
Esempio di output:
.talismanrc format for given file names / patterns
fileignoreconfig:
- filename: '*.pem'
checksum: f731b26be086fd2647c40801630e2219ef207cb1aacc02f9bf0559a75c0855a4
ignore_detectors: []
- filename: '*.txt'
checksum: d9e9e94868d7de5b2a0706b8d38d0f79730839e0eb4de4e9a2a5a014c7c43f35
ignore_detectors: []
Nota: Il calcolatore di checksum considera i file in staging durante il calcolo del checksum collettivo dei file.
Realizzato da 
Lo strumento CLI di Talisman talisman offre anche la possibilità di fornire un report HTML dettagliato e condivisibile. Dopo aver installato Talisman, segui i passaggi menzionati in talisman-html-report, per installare il pacchetto di reporting nella cartella .talisman. Per generare il report HTML, esegui:
talisman --scanWithHtmlQuesto scansionerà il repository e creerà una cartella talisman_html_report all'interno del repository scansionato. Dobbiamo avviare un server HTTP all'interno di questo repository per accedere al report. Di seguito un approccio consigliato per avviare un server HTTP:
python -m SimpleHTTPServer <port> (ad es.: 8000)Ora puoi accedere al report navigando a:
http://localhost:8000
Nota: Non è necessario avviare un server se stai eseguendo Talisman in un ambiente CI o in qualsiasi altro ambiente ospitato
Il processo di disinstallazione dipende da come hai installato Talisman. Potresti aver scelto di installarlo come modello di hook globale o in un singolo repository.
Segui i passaggi seguenti in base all'opzione scelta durante l'installazione.
Esegui il comando seguente sul tuo terminale per disinstallare Talisman globalmente dalla tua macchina.
Per l'hook pre-commit:``` bash -c "$(curl --silent https://raw.githubusercontent.com/thoughtworks/talisman/main/global_install_scripts/uninstall.bash)"
Per pre-push hook:```
bash -c "$(curl --silent https://raw.githubusercontent.com/thoughtworks/talisman/main/global_install_scripts/uninstall.bash)" -- pre-push
Questo
Dovrai rimuovere manualmente TALISMAN_HOME dalle variabili d'ambiente
Quando hai installato Talisman, deve aver creato un hook pre-commit o pre-push (come selezionato) nel tuo repository durante l'installazione.
Puoi rimuovere l'hook manualmente cancellando l'hook pre-commit o pre-push di Talisman dalla cartella .git/hooks nel repository.
Per contribuire a Talisman, dai un'occhiata alla nostra guida per contribuire.