thoughtworks/talismanGit-Hook-basierter Secret-Scanner, der Tokens, Passwörter und private Schlüssel in ausgehenden Changesets erkennt und verhindert, dass sensible Daten in Repositories committet oder gepusht werden.
Ein Werkzeug, um Geheimnisse zu erkennen und zu verhindern, dass sie eingecheckt werden
Talisman ist ein Werkzeug, das Git-Änderungssätze scannt, um sicherzustellen, dass potenzielle Geheimnisse oder sensible Informationen die Entwicklerworkstation nicht verlassen.
Es validiert den ausgehenden Änderungssatz auf verdächtige Dinge – wie potenzielle SSH-Schlüssel, Autorisierungstoken, private Schlüssel usw.
Talisman unterstützt MAC OSX, Linux und Windows.
Talisman kann auf eine der folgenden Arten installiert und verwendet werden:
Talisman kann als Pre-Commit- oder Pre-Push-Hook in den Git-Repositories eingerichtet werden.
Die Anweisungen finden Sie unten.
Haftungsausschluss: Geheimnisse, die durch einen erzwungenen Push in ein Git-Repository gelangen, können von Talisman nicht erkannt werden. Ein erzwungener Push gilt auf seine Weise als berüchtigt, und wir empfehlen Git-Repository-Administratoren, geeignete Maßnahmen zu ergreifen, um solche Aktivitäten zu autorisieren.
Wir empfehlen, talisman in Ihren Pfad zu installieren, sodass es für Git-Hook-Frameworks und Skripte verfügbar ist. Wählen Sie das richtige Binärprogramm für Ihr System von unserer Release-Seite aus oder führen Sie unser Installationsskript aus:```bash
bash -c "$(curl --silent https://raw.githubusercontent.com/thoughtworks/talisman/main/install.sh)"
Oder setzen Sie die Umgebungsvariable `INSTALL_LOCATION` zur Angabe eines benutzerdefinierten Speicherorts für die Binärdatei:```bash
INSTALL_LOCATION=/usr/local/bin bash -c "$(curl --silent https://raw.githubusercontent.com/thoughtworks/talisman/main/install.sh)"
Oder setze die Umgebungsvariable VERSION auf einen veröffentlichten Tag, um eine bestimmte Version zu installieren::```bash
VERSION=v1.36.0 bash -c "$(curl --silent https://raw.githubusercontent.com/thoughtworks/talisman/main/install.sh)"
Oder mit linuxbrew unter Linux und homebrew unter macOS, indem Sie den folgenden Befehl im Terminal ausführen:```bash
brew install talisman
Wir bieten Skripte an, die Talisman als Pre-commit-Git-Hook-Vorlage installieren, da dies dazu führt, dass Talisman nicht nur in Ihren bestehenden Git-Repositories, sondern auch in jedem neuen Repository, das Sie 'init' oder 'clone', vorhanden ist.
Als Pre-commit-Hook: ``` bash -c "$(curl --silent https://raw.githubusercontent.com/thoughtworks/talisman/main/global_install_scripts/install.bash)"
ODER
Als Pre-Push-Hook: ```
bash -c "$(curl --silent https://raw.githubusercontent.com/thoughtworks/talisman/main/global_install_scripts/install.bash)" -- pre-push
TALISMAN_HOME nicht in Ihrem $PATH eingerichtet haben, werden Sie nach einem geeigneten Ort gefragt, um es einzurichten. Wählen Sie die Optionsnummer, bei der Sie die Profil-Quelldatei auf Ihrem Rechner setzen.Denken Sie daran, source auf die Pfad-Datei auszuführen oder Ihr Terminal neu zu starten.
Wenn Sie sich entscheiden, den $PATH später zu setzen, exportieren Sie bitte TALISMAN_HOME=$HOME/.talisman/bin in den Pfad.
SEARCH_ROOT mit dem Pfad des Basisverzeichnisses setzen, bevor Sie die Installation ausführen, damit Sie es während der Installation nicht manuell eingeben müssen.Die globale Installation von Talisman als Hook überschreibt keine vorhandenen Hooks. Wenn das Installationsskript vorhandene Hooks findet, zeigt es dies lediglich in der Konsole an. Um mehrere Hooks auszuführen, empfehlen wir die Verwendung eines Hook-Frameworks wie pre-commit oder husky. Diese Anweisungen setzen voraus, dass die ausführbare Talisman-Datei irgendwo im Pfad Ihres Systems installiert ist.
Verwenden Sie pre-commit, um vorhandene Hooks zusammen mit
Talisman zu verwalten. Referenzieren Sie unsere pre-commit-hooks in Ihrer
.pre-commit-config.yaml:```yaml
### Husky
[husky](https://typicode.github.io/husky) ist ein npm-Modul zur Verwaltung von Hooks.
Fügen Sie die folgende Zeile zur Husky-Pre-Commit-Konfiguration in Ihrer
`package.json` hinzu:```
talisman --githook pre-commit
Sobald die ausführbare Talisman-Datei installiert ist, können Sie einen eigenständigen Pre-Commit-Hook für ein Git-Repository konfigurieren:```bash cd my-git-project echo "talisman -g pre-commit" >> .git/hooks/pre-commit chmod +x .git/hooks/pre-commit
# Aktualisierung
Seit Version v0.4.4 aktualisiert Talisman <b>automatisch</b> die Binärdatei auf die neueste Version, wenn der Hook ausgelöst wird (bei pre-commit/pre-push, wie eingerichtet). Lehnen Sie sich also zurück, entspannen Sie sich und verwenden Sie weiterhin das neueste Talisman ohne zusätzlichen Aufwand.
Die folgenden Umgebungsvariablen können gesetzt werden:
1. TALISMAN_SKIP_UPGRADE: Auf true setzen, wenn die automatische Upgrade-Prüfung übersprungen werden soll. Standard ist false
2. TALISMAN_UPGRADE_CONNECT_TIMEOUT: Maximale Verbindungszeitüberschreitung, bevor das Upgrade abgebrochen wird (in Sekunden). Standard sind 10 Sekunden.
Falls Sie ein manuelles Upgrade durchführen müssen, hier sind die Schritte:
<br>[Empfohlen] Aktualisieren Sie die Talisman-Binärdatei und die Hook-Skripte auf die neueste 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
Aktualisieren Sie nur die Talisman-Binärdatei durch Ausführung von:```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 Aktion
Nach erfolgreicher Installation führt Talisman automatisch Prüfungen auf offensichtliche Geheimnisse vor jedem Commit oder Push (wie bei der Installation ausgewählt) durch. Falls Sicherheitslücken erkannt werden, zeigt talisman einen detaillierten Fehlerbericht an:```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 |
+-----------------+-------------------------------------------------------------------------------+
Im obigen Beispiel wurde die Datei danger.pem aus den folgenden Gründen als Sicherheitsverstoß gekennzeichnet:
Wenn Sie Talisman als Pre-Commit-Hook installiert haben, wird nur der Diff innerhalb jedes Commits gescannt. Das bedeutet, dass nur Fehler für die Teile der Datei gemeldet werden, die geändert wurden.
Falls Sie Talisman als Pre-Push-Hook installiert haben, wird die gesamte Datei gescannt, in der Änderungen vorgenommen werden. Wie oben erwähnt, wird empfohlen, Talisman als Pre-Commit-Hook zu verwenden.
Die folgenden Detektoren werden gegen die Änderungssätze ausgeführt, um Geheimnisse/sensible Informationen zu erkennen:
Wenn Sie wirklich sicher sind, dass Sie diese Datei pushen möchten, können Sie sie in der .talismanrc-Datei im Projektstamm konfigurieren. Die erforderlichen Inhalte zum Ignorieren Ihrer fehlgeschlagenen Dateien werden von Talisman direkt nach dem Talisman-Fehlerbericht auf der Konsole ausgegeben:```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:
Wenn Sie dies in die `.talismanrc`-Datei einfügen, wird Talisman die Datei `danger.pem` ignorieren, solange die Prüfsumme mit dem im Feld `checksum` angegebenen Wert übereinstimmt.
### Interaktiver Modus
**Nur für Nicht-Windows-Benutzer verfügbar**
Wenn es zu mühsam ist, bei jedem Fehler von Talisman den Inhalt in die `.talismanrc` zu kopieren, können Sie den interaktiven Modus aktivieren und Talisman dabei helfen lassen, Ihnen das Hinzufügen der zu ignorierenden Dateien vorzuschlagen.
Befolgen Sie einfach die einfachen Schritte:
1. Öffnen Sie Ihr Bash-Profil, in dem Ihre Umgebungsvariablen gesetzt sind (.bashrc, .bash_profile, .profile oder ein anderer Ort).
2. Sie sehen die Variable `TALISMAN_INTERACTIVE` unter `# >>> talisman >>>`.
3. Falls noch nicht auf true gesetzt, fügen Sie `export TALISMAN_INTERACTIVE=true` hinzu.
4. Vergessen Sie nicht, die Datei zu speichern und zu sourcen.
Das war's! Jedes Mal, wenn der Talisman-Hook während des Pre-Push/Pre-Commit einen Fehler findet, folgen Sie einfach den Anweisungen, die Talisman vorschlägt.
Seien Sie vorsichtig, keine Datei zu ignorieren, ohne den Inhalt zu überprüfen. Sie müssen sicher sein, dass kein Geheimnis preisgegeben wird.
### Bestimmte Detektoren ignorieren
Nachfolgend finden Sie eine detaillierte Beschreibung der verschiedenen Felder, die in der `.talismanrc`-Datei konfiguriert werden können:
* `filename` : Dieses Feld sollte den vollqualifizierten Dateinamen enthalten.
* `checksum` : Dieses Feld sollte immer den von Talisman in der oben angezeigten Meldung angegebenen Wert enthalten. Wenn an der Datei eine Änderung vorgenommen wird, führt dies zu einer neuen Prüfsumme und Talisman scannt die Datei erneut auf potenzielle Sicherheitsbedrohungen.
* `ignore_detectors` : Dieses Feld deaktiviert bestimmte Detektoren für eine bestimmte Datei.
Wenn beispielsweise der Dateiname `init-env.sh` eine Warnung auslöst, können Sie nur diese Warnung deaktivieren,
während Sie weiterhin benachrichtigt werden, wenn andere Dinge schiefgehen (z.B. Dateiinhalt):```yaml
fileignoreconfig:
- filename: init-env.sh
checksum: cf97abd34cebe895417eb4d97fbd7374aa138dcb65b1fe7f6b6cc1238aaf4d48
ignore_detectors: [filename, filesize]
Hinweis: Hier werden sowohl der Dateinamen- als auch der Dateigrößen-Detektor für init-env.sh ignoriert, aber der Dateiinhalts-Detektor wird weiterhin für init-env.sh aktiv.
At the moment, you can ignore
filecontentfilenamefilesizeDa einige Ihrer Dateien Schlüsselwörter wie key oder pass enthalten könnten, die nicht unbedingt mit Geheimnissen zusammenhängen, möchten Sie diese Schlüsselwörter möglicherweise ignorieren, um die Anzahl der Fehlalarme zu reduzieren.
Dies kann durch die Verwendung des Feldes allowed_patterns auf Datei- und/oder Repository-Ebene erreicht werden:```yaml
fileignoreconfig:
Im vorherigen Beispiel ist `key` in der `test`-Datei erlaubt, `keyword` und `pass` sind auf Repository-Ebene erlaubt.
Das `allowed_patterns`-Feld unterstützt auch Golang reguläre Ausdrücke. Hier ist ein einfaches Codebeispiel, bei dem Golang RegExp nützlich sein kann:```sh
export AWS_ACCESS_KEY_ID = AKIAIO5FODNN7EXAMPLE
export AWS_ACCESS_KEY_ID=$(vault read -field=value path/to/aws-access-key-id)
Standardmäßig wird Talisman für beide Zeilen warnen. In der zweiten Zeile extrahieren wir die AWS Access Key ID aus Hashicorp Vault, was das Geheimnis nicht dem Code preisgibt. Wenn diese Art der Verwendung in Ihrem Code üblich ist, möchten Sie Talisman möglicherweise mitteilen, dass es nicht warnen soll, wenn Sie einen Vault verwenden. Dies kann mit einer Konfiguration wie folgt erreicht werden:```yaml allowed_patterns:
### Ignorieren mehrerer Dateien desselben Typs (mit Platzhaltern)
Sie können wählen, alle Dateien eines bestimmten Typs zu ignorieren, weil Sie wissen, dass sie immer sicher sind, und nicht möchten, dass Talisman sie scannt.
Schritte:
1. Formatieren Sie ein Platzhaltermuster für die Dateien, die Sie ignorieren möchten. Zum Beispiel `*.lock`
2. Verwenden Sie den [checksum calculator](#checksum-calculator), um das Muster einzugeben und eine kollektive Prüfsumme zu erhalten. Zum Beispiel `talisman --checksum="*.lock" `
3. Kopieren Sie den auf der Konsole ausgegebenen fileconfig-Block in die Datei .talismanrc.
Wenn eine der Dateien geändert wird, scannt Talisman die Dateien erneut, es sei denn, Sie berechnen die neue Prüfsumme neu und ersetzen sie in der .talismanrc-Datei.
### Ignorieren von Dateien durch Angabe des Sprachbereichs
Sie können wählen, Dateien zu ignorieren, indem Sie den Sprachbereich für Ihr Projekt in Ihrer talismanrc angeben.```yaml
scopeconfig:
- scope: go
- scope: node
- scope: images
- scope: php
- scope: python
Talisman ist so konfiguriert, dass es bestimmte Dateien basierend auf dem angegebenen Scope ignoriert. Zum Beispiel verhindert die Angabe des node-Scopes in der scopeconfig, dass Talisman Dateien wie yarn.lock oder package-lock.json scannt.
Sie können mehrere Scopes angeben.
Derzeit unterstützt .talismanrc nur scopeconfig für go, node, php und images. Weitere Scopes werden in Kürze hinzugefügt.
Sie können benutzerdefinierte Regex-Muster angeben, nach denen im aktuellen Repository gesucht werden soll.```yaml custom_patterns:
<br/><i>
**Hinweis**: Die Verwendung von .talismanignore ist veraltet. Die Datei .talismanrc ersetzt es, weil:
* .talismanrc hat ein viel lesbareres YAML-Format
* Es bringt auch sicherere Praktiken bei jeder Änderung einer Datei mit einem potenziell sensiblen Wert, der überprüft werden muss.
* Das neue Format bringt auch die Erweiterbarkeit, um neue nutzbare Funktionalitäten einzuführen. Haltet Ausschau nach weiteren Neuerungen.</i>
## Schwellenwert für den Schweregrad konfigurieren
Jede Validierung ist mit einem Schweregrad verknüpft
1. Niedrig
2. Mittel
3. Hoch
Sie können einen Schwellenwert in Ihrer .talismanrc-Datei angeben:```yaml
threshold: medium
Dies wird alle Probleme mit mittlerem Schweregrad und höher melden (Potenzielle Risiken unterhalb des Schwellenwerts werden in den Warnungen gemeldet)
Sie können die Sicherheitsstufen der von Talisman bereitgestellten Detektoren in der .talismanrc-Datei anpassen:```yaml custom_severities:
Durch die Verwendung benutzerdefinierter Schweregrade und eines Schweregrad-Schwellenwerts kann Talisman so konfiguriert werden, dass es nur auf das basierend auf Ihrem Kontext Wichtige alarmiert. Dies kann nützlich sein, um die Anzahl der Fehlalarme zu reduzieren.
## Talisman als CLI-Dienstprogramm
Wenn Sie `talisman` in der Befehlszeile ausführen, können Sie alle Parameteroptionen anzeigen, die Sie übergeben können.```
-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
Wenn Sie regelmäßig zu viele Dateien haben, die vom Talisman-Hook markiert werden und von denen Sie wissen, dass sie problemlos eingecheckt werden können, können Sie diese Funktion nutzen, um Talisman den Vorgang für Sie zu erleichtern. Der interaktive Modus ermöglicht es Talisman, Sie direkt aufzufordern, Dateien, die Sie ignorieren möchten, über die Eingabeaufforderung direkt zur .talismanrc hinzuzufügen. Um diese Funktion zu aktivieren, müssen Sie die Variable TALISMAN_INTERACTIVE in Ihrer Bash-Datei auf true setzen.
Sie können Talisman im interaktiven Modus auf eine der folgenden zwei Arten aufrufen:
Öffnen Sie Ihre Bash-Datei und fügen Sie hinzuexport 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: Wenn Sie die Versionskontrollintegration einer IDE für Git-Operationen verwenden, funktioniert diese Funktion nicht. Sie können den vorgeschlagenen Dateinamen und die Prüfsumme weiterhin manuell in die Datei .talismanrc eingeben.
Sie können Talisman jetzt über die CLI ausführen und potenziell zu Ihren CI/CD-Pipelines hinzufügen, um den Git-Verlauf Ihres Repositorys nach sensiblen Inhalten zu durchsuchen. Dies schließt auch das Scannen der in der .talismanrc-Datei aufgeführten Dateien ein.
Schritte:
cd <directory to scan>talisman --scantalisman --scan --reportdirectory=/Users/username/DesktopSie können die anderen Optionen wie oben angegeben zum Scannen verwenden.
Talisman unterstützt derzeit das Ignorieren von Dateien beim Scannen nicht.
Der Talisman-Prüfsummenrechner gibt ein YAML-Format aus, das Sie direkt in die .talismanrc-Datei kopieren und einfügen können, um bestimmte Dateiformate von Talisman-Detektoren zu ignorieren.
Führen Sie zum Ausführen der Prüfsumme bitte "cd" in das Stammverzeichnis Ihres Repositorys aus und führen Sie den folgenden Befehl aus:
Zum Beispiel:
talisman --checksum="*.pem *.txt"
Beispielausgabe:
.talismanrc format for given file names / patterns
fileignoreconfig:
- filename: '*.pem'
checksum: f731b26be086fd2647c40801630e2219ef207cb1aacc02f9bf0559a75c0855a4
ignore_detectors: []
- filename: '*.txt'
checksum: d9e9e94868d7de5b2a0706b8d38d0f79730839e0eb4de4e9a2a5a014c7c43f35
ignore_detectors: []
Hinweis: Der Prüfsummenrechner berücksichtigt die bereitgestellten Dateien (staged files) bei der Berechnung der kollektiven Prüfsumme der Dateien.
Unterstützt durch 
Das Talisman-CLI-Tool talisman bietet auch die Möglichkeit, detaillierte und teilbare HTML-Berichte zu erstellen. Nachdem Sie Talisman installiert haben, folgen Sie den Schritten in talisman-html-report, um das Berichtspaket im .talisman-Ordner zu installieren. Führen Sie zum Erstellen des HTML-Berichts Folgendes aus:
talisman --scanWithHtmlDies scannt das Repository und erstellt einen Ordner talisman_html_report im gescannten Repository. Wir müssen einen HTTP-Server innerhalb dieses Repositorys starten, um auf den Bericht zuzugreifen. Im Folgenden wird ein empfohlener Ansatz zum Starten eines HTTP-Servers vorgestellt:
python -m SimpleHTTPServer <port> (z.B. 8000)Sie können jetzt auf den Bericht zugreifen, indem Sie zu folgender Adresse navigieren:
http://localhost:8000
Hinweis: Sie müssen keinen Server starten, wenn Sie Talisman in CI oder einer anderen gehosteten Umgebung ausführen
Der Deinstallationsprozess hängt davon ab, wie Sie Talisman installiert haben. Sie könnten sich entschieden haben, es als globale Hook-Vorlage oder in einem einzelnen Repository zu installieren.
Bitte befolgen Sie die untenstehenden Schritte, je nachdem, welche Option Sie bei der Installation gewählt haben.
Führen Sie den folgenden Befehl in Ihrem Terminal aus, um Talisman global von Ihrem Rechner zu deinstallieren.
Für Pre-Commit-Hook:``` bash -c "$(curl --silent https://raw.githubusercontent.com/thoughtworks/talisman/main/global_install_scripts/uninstall.bash)"
Für pre-push hook:```
bash -c "$(curl --silent https://raw.githubusercontent.com/thoughtworks/talisman/main/global_install_scripts/uninstall.bash)" -- pre-push
Dies wird
Sie müssen TALISMAN_HOME manuell aus Ihren Umgebungsvariablen entfernen
Als Sie Talisman installiert haben, muss es während der Installation einen Pre-Commit- oder Pre-Push-Hook (je nach Auswahl) in Ihrem Repository erstellt haben.
Sie können den Hook manuell entfernen, indem Sie den Talisman Pre-Commit- oder Pre-Push-Hook aus dem .git/hooks-Ordner im Repository löschen.
Um zu Talisman beizutragen, werfen Sie einen Blick auf unseren Beitragsleitfaden.