thoughtworks/talismanScanner de secrets basé sur des hooks Git qui détecte les jetons, mots de passe et clés privées dans les ensembles de modifications sortants, empêchant ainsi les données sensibles d'être commitées ou poussées vers les dépôts.
Un outil pour détecter et empêcher les secrets d'être commités
Talisman est un outil qui analyse les ensembles de modifications Git pour garantir que les secrets potentiels ou les informations sensibles ne quittent pas le poste de travail du développeur.
Il valide l'ensemble de modifications sortant pour détecter des éléments suspects – comme des clés SSH potentielles, des jetons d'autorisation, des clés privées, etc.
Talisman prend en charge MAC OSX, Linux et Windows.
Talisman peut être installé et utilisé de l'une des manières suivantes :
Talisman peut être configuré comme un hook pre-commit ou pre-push sur les dépôts Git.
Vous trouverez les instructions ci-dessous.
Avertissement : Les secrets qui s'infiltrent via un push forcé dans un dépôt Git ne peuvent pas être détectés par Talisman. Un push forcé est considéré comme notoire à sa manière, et nous suggérons aux administrateurs de dépôts Git de prendre les mesures appropriées pour autoriser de telles activités.
Nous recommandons d'installer talisman dans votre PATH afin qu'il soit disponible pour les frameworks de hooks Git et les scripts. Choisissez le binaire correct pour votre système depuis notre page des versions, ou exécutez notre script d'installation :```bash
bash -c "$(curl --silent https://raw.githubusercontent.com/thoughtworks/talisman/main/install.sh)"
Ou définissez la variable d'environnement `INSTALL_LOCATION` pour spécifier un emplacement personnalisé pour le binaire :```bash
INSTALL_LOCATION=/usr/local/bin bash -c "$(curl --silent https://raw.githubusercontent.com/thoughtworks/talisman/main/install.sh)"
Ou définissez la variable d'environnement VERSION sur un tag de version publiée pour installer une version spécifique::```bash
VERSION=v1.36.0 bash -c "$(curl --silent https://raw.githubusercontent.com/thoughtworks/talisman/main/install.sh)"
Ou en utilisant linuxbrew sous Linux et homebrew sous macOS en exécutant la commande suivante dans le terminal:```bash
brew install talisman
Nous proposons des scripts qui installeront Talisman en tant que modèle de hook git pre-commit, car cela fera en sorte que Talisman soit présent, non seulement dans vos dépôts git existants, mais aussi dans tout nouveau dépôt que vous 'init' ou 'clonez'.
En tant que hook pre-commit : ``` bash -c "$(curl --silent https://raw.githubusercontent.com/thoughtworks/talisman/main/global_install_scripts/install.bash)"
OU
En tant que pre-push hook: ```
bash -c "$(curl --silent https://raw.githubusercontent.com/thoughtworks/talisman/main/global_install_scripts/install.bash)" -- pre-push
$PATH, il vous sera demandé un endroit approprié pour le configurer. Choisissez le numéro de l'option où vous avez défini la source du profil sur votre machine.N'oubliez pas d'exécuter source sur le fichier de chemin ou de redémarrer votre terminal.
Si vous choisissez de définir $PATH plus tard, veuillez exporter TALISMAN_HOME=$HOME/.talisman/bin vers le chemin.
Installer globalement talisman en tant que hook n'écrasera aucun hook existant. Si le script d'installation trouve des hooks existants, il se contentera de l'indiquer dans la console. Pour exécuter plusieurs hooks, nous suggérons d'utiliser un framework de hooks, tel que pre-commit ou husky. Ces instructions supposent que l'exécutable talisman est installé quelque part dans le chemin de votre système.
Utilisez pre-commit pour gérer les hooks existants avec
Talisman. Référencez notre pre-commit-hooks dans votre
.pre-commit-config.yaml:```yaml
### Husky
[husky](https://typicode.github.io/husky) est un module npm pour gérer les hooks.
Ajoutez la ligne suivante à la configuration pre-commit de husky dans votre
`package.json` :
```json```
talisman --githook pre-commit
Une fois l'exécutable talisman installé vous pouvez configurer un hook pre-commit autonome pour un dépôt git :```bash cd my-git-project echo "talisman -g pre-commit" >> .git/hooks/pre-commit chmod +x .git/hooks/pre-commit
# Mise à jour
Depuis la version v0.4.4, Talisman <b>met automatiquement à jour</b> le binaire vers la dernière version, lorsque le hook est invoqué (lors du pre-commit/pre-push, comme configuré). Alors, asseyez-vous, détendez-vous et continuez à utiliser la dernière version de Talisman sans aucun effort supplémentaire.
Les variables d'environnement suivantes peuvent être définies :
1. TALISMAN_SKIP_UPGRADE: Définissez sur true si vous souhaitez ignorer la vérification de mise à jour automatique. Par défaut : false
2. TALISMAN_UPGRADE_CONNECT_TIMEOUT: Délai d'expiration maximum de connexion avant que la mise à jour soit annulée (en secondes). Par défaut : 10 secondes.
Si jamais vous devez effectuer une mise à jour manuelle, voici les étapes :
<br>[Recommandé] Mettre à jour le binaire Talisman et les scripts de hook vers la dernière version :```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
Mettez à jour uniquement le binaire Talisman en exécutant :```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 en action
Après une installation réussie, Talisman exécutera automatiquement des vérifications pour détecter les secrets évidents avant chaque commit ou push (selon le choix effectué lors de l'installation). En cas de détection de brèches de sécurité, Talisman affichera un rapport détaillé des erreurs :```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 |
+-----------------+-------------------------------------------------------------------------------+
Dans l'exemple ci-dessus, le fichier danger.pem a été signalé comme une violation de sécurité pour les raisons suivantes :
Si vous avez installé Talisman comme hook pre-commit, il scannera uniquement le diff dans chaque commit. Cela signifie qu'il ne signalera les erreurs que pour les parties du fichier qui ont été modifiées.
Dans le cas où vous avez installé Talisman comme hook pre-push, il scannera le fichier complet dans lequel des modifications sont apportées. Comme mentionné ci-dessus, il est recommandé d'utiliser Talisman comme hook pre-commit.
Les détecteurs suivants s'exécutent sur les ensembles de modifications pour détecter les secrets/informations sensibles :
Si vous êtes vraiment sûr de vouloir pousser ce fichier, vous pouvez le configurer dans le fichier .talismanrc à la racine du projet. Le contenu nécessaire pour ignorer vos fichiers en échec sera affiché par Talisman sur la console immédiatement après le rapport d'erreur de Talisman :```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:
Entrer ceci dans le fichier `.talismanrc` garantira que Talisman ignore le fichier `danger.pem` tant que la somme de contrôle correspond à la valeur mentionnée dans le champ `checksum`.
### Mode interactif
**Disponible uniquement pour les utilisateurs non-Windows**
S'il est trop fastidieux de copier sans cesse du contenu dans `.talismanrc` à chaque fois que vous rencontrez une erreur de Talisman, vous pouvez activer le mode interactif et laisser Talisman vous aider en vous proposant d'ajouter les fichiers à ignorer.
Suivez simplement ces étapes :
1. Ouvrez votre profil bash où vos variables d'environnement sont définies (.bashrc, .bash_profile, .profile ou tout autre emplacement)
2. Vous verrez la variable `TALISMAN_INTERACTIVE` sous `# >>> talisman >>>`
3. Si elle n'est pas déjà définie à true, ajoutez `export TALISMAN_INTERACTIVE=true`
4. N'oubliez pas de sauvegarder et de sourcer le fichier
C'est tout ! Chaque fois que le hook Talisman rencontre une erreur lors du pre-push/pre-commit, suivez simplement les instructions proposées par Talisman.
Veillez à ne pas ignorer un fichier sans en vérifier le contenu. Vous devez être certain qu'aucun secret ne fuite.
### Ignorer des détecteurs spécifiques
Voici une description détaillée des différents champs pouvant être configurés dans le fichier `.talismanrc` :
* `filename` : Ce champ doit contenir le nom de fichier complet.
* `checksum` : Ce champ doit toujours avoir la valeur spécifiée par Talisman dans le message affiché ci-dessus. Si, à un moment donné, une modification est apportée au fichier, une nouvelle somme de contrôle sera générée et Talisman analysera à nouveau le fichier pour détecter d'éventuelles menaces de sécurité.
* `ignore_detectors` : Ce champ permet de désactiver des détecteurs spécifiques pour un fichier particulier.
Par exemple, si votre nom de fichier `init-env.sh` déclenche un avertissement, vous pouvez désactiver uniquement
cet avertissement tout en restant averti en cas d'autres problèmes (par exemple, le contenu du fichier) :```yaml
fileignoreconfig:
- filename: init-env.sh
checksum: cf97abd34cebe895417eb4d97fbd7374aa138dcb65b1fe7f6b6cc1238aaf4d48
ignore_detectors: [filename, filesize]
Note: Here both filename and filesize detectors are ignored for init-env.sh, but
filecontent detector will still activate on init-env.sh
At the moment, you can ignore
filecontentfilenamefilesizeÉtant donné que certains de vos fichiers peuvent contenir des mots-clés tels que key ou pass qui ne sont pas nécessairement liés à des secrets, vous pouvez souhaiter ignorer ces mots-clés pour réduire le nombre de faux positifs.
Ceci peut être réalisé en utilisant le champ allowed_patterns au niveau du fichier et/ou au niveau du dépôt :```yaml
fileignoreconfig:
Dans l'exemple précédent, `key` est autorisé dans le fichier `test`, `keyword` et `pass` sont autorisés au niveau du dépôt.
Le champ `allowed_patterns` prend également en charge les expressions régulières Golang. Voici un exemple de code simple où Golang RegExp peut être utile :```sh
export AWS_ACCESS_KEY_ID = AKIAIO5FODNN7EXAMPLE
export AWS_ACCESS_KEY_ID=$(vault read -field=value path/to/aws-access-key-id)
Par défaut, Talisman alertera pour les deux lignes. Dans la deuxième ligne, nous extrayons l'ID de clé d'accès AWS depuis Hashicorp Vault, qui n'expose pas le secret au code. Si ce type d'utilisation est courant dans votre code, vous pouvez demander à Talisman de ne pas alerter lorsque vous utilisez Vault. Cela peut être réalisé avec une configuration comme :```yaml allowed_patterns:
### Ignorer plusieurs fichiers du même type (avec des wildcards)
Vous pouvez choisir d'ignorer tous les fichiers d'un certain type, car vous savez qu'ils seront toujours sûrs et vous ne voulez pas que Talisman les analyse.
Étapes :
1. Formatez un motif wildcard pour les fichiers que vous souhaitez ignorer. Par exemple, `*.lock`
2. Utilisez le [calculateur de checksum](#checksum-calculator) pour alimenter le motif et obtenir un checksum collectif. Par exemple, `talisman --checksum="*.lock" `
3. Copiez le bloc fileconfig, affiché dans la console, dans le fichier .talismanrc.
Si l'un des fichiers est modifié, talisman analysera à nouveau les fichiers, sauf si vous recalculez le nouveau checksum et le remplacez dans le fichier .talismanrc.
### Ignorer les fichiers en spécifiant la portée du langage
Vous pouvez choisir d'ignorer des fichiers en spécifiant la portée du langage pour votre projet dans votre talismanrc.```yaml
scopeconfig:
- scope: go
- scope: node
- scope: images
- scope: php
- scope: python
Talisman est configuré pour ignorer certains fichiers en fonction du scope spécifié. Par exemple, mentionner le scope node dans le scopeconfig empêchera talisman de scanner des fichiers tels que yarn.lock ou package-lock.json.
Vous pouvez spécifier plusieurs scopes.
Actuellement, .talismanrc ne prend en charge le support scopeconfig que pour les scopes go, node, php et images. D'autres scopes seront ajoutés prochainement.
Vous pouvez spécifier des modèles regex personnalisés à rechercher dans le dépôt actuel```yaml custom_patterns:
<br/><i>
**Remarque**: L'utilisation de .talismanignore a été dépréciée. Le fichier .talismanrc le remplace car :
* .talismanrc a un format yaml beaucoup plus lisible
* Il apporte également des pratiques plus sécurisées avec chaque modification d'un fichier contenant une valeur potentiellement sensible à examiner
* Le nouveau format apporte également l'extensibilité nécessaire pour introduire de nouvelles fonctionnalités utilisables. Gardez un œil ouvert pour plus d'informations </i>
## Configuration du seuil de gravité
Chaque validation est associée à une gravité
1. Faible
2. Moyen
3. Élevé
Vous pouvez spécifier un seuil dans votre .talismanrc :```yaml
threshold: medium
Cela signalera tous les problèmes de gravité Moyenne et supérieure (Les risques potentiels en dessous du seuil seront signalés dans les avertissements)
Vous pouvez personnaliser les niveaux de sécurité des détecteurs fournis par Talisman dans le fichier .talismanrc :```yaml custom_severities:
En utilisant des sévérités personnalisées et un seuil de sévérité, Talisman peut être configuré pour alerter uniquement sur ce qui est important en fonction de votre contexte. Cela peut être utile pour réduire le nombre de faux positifs.
## Talisman en tant qu'utilitaire CLI
Si vous exécutez `talisman` sur la ligne de commande, vous pourrez voir toutes les options de paramètres que vous pouvez passer```
-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
Lorsque vous avez régulièrement trop de fichiers qui sont signalés par le hook Talisman, et dont vous savez qu'ils devraient pouvoir être soumis sans problème, vous pouvez utiliser cette fonctionnalité pour que Talisman vous simplifie le processus. Le mode interactif permettra à Talisman de vous inviter à ajouter directement les fichiers que vous souhaitez ignorer à .talismanrc depuis l'invite de commande.
Pour activer cette fonctionnalité, vous devez définir la variable TALISMAN_INTERACTIVE sur true dans votre fichier bash.
Vous pouvez invoquer Talisman en mode interactif de l'une des 2 manières suivantes :
Ouvrez votre fichier bash, et ajoutezexport 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
Note : Si vous utilisez l'intégration du contrôle de version d'un IDE pour les opérations git, cette fonctionnalité ne fonctionnera pas. Vous pouvez toujours utiliser le nom de fichier suggéré et la somme de contrôle à saisir manuellement dans le fichier .talismanrc.
Vous pouvez désormais exécuter Talisman depuis la ligne de commande, et potentiellement l'ajouter à vos pipelines CI/CD, pour scanner l'historique git de votre dépôt afin de trouver tout contenu sensible. Cela inclut également l'analyse des fichiers listés dans le fichier .talismanrc.
Étapes :
cd <répertoire à analyser>talisman --scantalisman --scan --reportdirectory=/Users/username/DesktopVous pouvez utiliser les autres options d'analyse comme indiqué ci-dessus.
Talisman ne prend actuellement pas en charge l'ignorance de fichiers lors de l'analyse.
Le calculateur de somme de contrôle de Talisman produit un format yaml que vous pouvez directement copier-coller dans le fichier .talismanrc afin d'ignorer des formats de fichiers particuliers des détecteurs Talisman.
Pour exécuter la somme de contrôle, veuillez utiliser "cd" pour vous placer à la racine de votre dépôt et exécuter la commande suivante
Par exemple :
talisman --checksum="*.pem *.txt"
Exemple de sortie :
.talismanrc format for given file names / patterns
fileignoreconfig:
- filename: '*.pem'
checksum: f731b26be086fd2647c40801630e2219ef207cb1aacc02f9bf0559a75c0855a4
ignore_detectors: []
- filename: '*.txt'
checksum: d9e9e94868d7de5b2a0706b8d38d0f79730839e0eb4de4e9a2a5a014c7c43f35
ignore_detectors: []
Note : Le calculateur de somme de contrôle prend en compte les fichiers en zone de transit (staged) lors du calcul de la somme de contrôle collective des fichiers.
Propulsé par 
L'outil CLI Talisman talisman offre également la possibilité de fournir un rapport HTML détaillé et partageable. Une fois que vous avez installé Talisman, veuillez suivre les étapes mentionnées dans talisman-html-report, pour installer le package de rapport dans le dossier .talisman. Pour générer le rapport HTML, exécutez :
talisman --scanWithHtmlCela analysera le dépôt et créera un dossier talisman_html_report dans le dépôt analysé. Nous devons démarrer un serveur HTTP à l'intérieur de ce dépôt pour accéder au rapport. Voici une approche recommandée pour démarrer un serveur HTTP :
python -m SimpleHTTPServer <port> (par ex. 8000)Vous pouvez maintenant accéder au rapport en naviguant vers :
http://localhost:8000
Note : Vous n'avez pas besoin de démarrer un serveur si vous exécutez Talisman dans un environnement CI ou tout autre environnement hébergé
Le processus de désinstallation dépend de la façon dont vous avez installé Talisman. Vous avez peut-être choisi de l'installer comme modèle de hook global ou sur un seul dépôt.
Veuillez suivre les étapes ci-dessous en fonction de l'option que vous avez choisie lors de l'installation.
Exécutez la commande suivante sur votre terminal pour désinstaller Talisman globalement de votre machine.
Pour le hook pre-commit :``` bash -c "$(curl --silent https://raw.githubusercontent.com/thoughtworks/talisman/main/global_install_scripts/uninstall.bash)"
Pour le hook pre-push :```
bash -c "$(curl --silent https://raw.githubusercontent.com/thoughtworks/talisman/main/global_install_scripts/uninstall.bash)" -- pre-push
Cela va
Vous devrez supprimer manuellement TALISMAN_HOME de vos variables d'environnement
Lorsque vous avez installé Talisman, il a dû créer un hook pre-commit ou pre-push (selon votre choix) dans votre dépôt lors de l'installation.
Vous pouvez supprimer le hook manuellement en supprimant le hook Talisman pre-commit ou pre-push du dossier .git/hooks du dépôt.
Pour contribuer à Talisman, consultez notre guide de contribution.