=========== git-secrets

Verhindert, dass Passwörter und andere sensible Informationen in ein Git-Repository committet werden.

.. contents:: :depth: 2

Synopsis

git secrets --scan [-r|--recursive] [--cached] [--no-index] [--untracked] [<files>...]
git secrets --scan-history
git secrets --install [-f|--force] [<target-directory>]
git secrets --list [--global]
git secrets --add [-a|--allowed] [-l|--literal] [--global] <pattern>
git secrets --add-provider [--global] <command> [arguments...]
git secrets --register-aws [--global]
git secrets --aws-provider [<credentials-file>]

Description

git-secrets scannt Commits, Commit-Nachrichten und --no-ff-Merges, um zu verhindern, dass Geheimnisse in Ihre Git-Repositories gelangen. Falls ein Commit, eine Commit-Nachricht oder ein beliebiger Commit in einer --no-ff-Merge-Historie einem Ihrer konfigurierten verbotenen regulären Ausdrucksmuster entspricht, wird der Commit abgelehnt.

Installing git-secrets

git-secrets muss irgendwo in Ihrem PATH liegen, damit es von git beim Ausführen von git secrets gefunden wird.

*nix (Linux/macOS)


Sie können das ``install``-Target des mitgelieferten Makefile verwenden, um ``git secrets`` und die Manpage zu installieren.
Sie können den Installationspfad mit den Variablen PREFIX und MANPREFIX anpassen.

::

    make install

Windows
~~~~~~~

Führen Sie das mitgelieferte PowerShell-Skript ``install.ps1`` aus. Dies kopiert die benötigten Dateien
in ein Installationsverzeichnis (standardmäßig ``%USERPROFILE%/.git-secrets``) und fügt
das Verzeichnis zum ``PATH`` des aktuellen Benutzers hinzu.

::

    PS > ./install.ps1

Homebrew (für macOS-Nutzer)

brew install git-secrets

.. warning::

**Sie sind noch nicht fertig! Sie MÜSSEN die Git-Hooks für jedes Repository installieren,
das Sie mit** ``git secrets --install`` **verwenden möchten.**

Hier ein kurzes Beispiel, wie Sie sicherstellen, dass ein Git-Repository bei jedem Commit auf Geheimnisse überprüft wird::

cd /path/to/my/repo
git secrets --install
git secrets --register-aws

Advanced configuration

Fügen Sie eine Konfigurationsvorlage hinzu, wenn Sie Hooks zu allen Repositorys hinzufügen möchten, die Sie in Zukunft initialisieren oder klonen.

git secrets --register-aws --global

Fügen Sie Hooks zu allen Ihren lokalen Repositorys hinzu.

git secrets --install ~/.git-templates/git-secrets
git config --global init.templateDir ~/.git-templates/git-secrets

Fügen Sie benutzerdefinierte Provider hinzu, um nach Sicherheitsanmeldeinformationen zu suchen.

git secrets --add-provider -- cat /path/to/secret/file/patterns

Before making public a repository

Mit git-secrets ist es auch möglich, ein Repository inklusive aller Revisionen zu scannen:

git secrets --scan-history

Options

Operation Modes


Jede dieser Optionen muss als erstes auf der Befehlszeile erscheinen.

``--install``
    Installiert Git-Hooks für ein Repository. Sobald die Hooks für ein Git-Repository installiert sind,
    werden Commits und Non-Fast-Forward-Merges für dieses Repository daran gehindert,
    Geheimnisse zu committen.

``--scan``
    Scannt eine oder mehrere Dateien auf Geheimnisse. Wenn eine Datei ein Geheimnis enthält,
    wird der übereinstimmende Text aus der gescannten Datei in die Standardausgabe geschrieben und das
    Skript beendet sich mit einem Nicht-Null-Statuscode. Jede übereinstimmende Zeile wird mit
    dem Namen der übereinstimmenden Datei, einem Doppelpunkt, der übereinstimmenden Zeilennummer,
    einem Doppelpunkt und dann der übereinstimmenden Textzeile ausgegeben. Wenn keine Dateien angegeben werden,
    werden alle von ``git ls-files`` zurückgegebenen Dateien gescannt.

``--scan-history``
    Scannt das Repository inklusive aller Revisionen. Wenn eine Datei ein Geheimnis enthält,
    wird der übereinstimmende Text aus der gescannten Datei in die Standardausgabe geschrieben und das
    Skript beendet sich mit einem Nicht-Null-Statuscode. Jede übereinstimmende Zeile wird mit
    dem Namen der übereinstimmenden Datei, einem Doppelpunkt, der übereinstimmenden Zeilennummer,
    einem Doppelpunkt und dann der übereinstimmenden Textzeile ausgegeben.

``--list``
    Listet die ``git-secrets``-Konfiguration für das aktuelle Repository oder in der globalen
    Git-Konfiguration auf.

``--add``
    Fügt ein verbotenes oder erlaubtes Muster hinzu.

``--add-provider``
    Registriert einen Geheimnis-Provider. Geheimnis-Provider sind ausführbare Dateien, die
    beim Aufruf verbotene Muster ausgeben, die ``git-secrets`` als verboten behandeln soll.

``--register-aws``
    Fügt gängige AWS-Muster zur Git-Konfiguration hinzu und stellt sicher, dass Schlüssel
    in ``~/.aws/credentials`` in keinem Commit gefunden werden. Die folgenden
    Prüfungen werden hinzugefügt:

    - AWS Access Key IDs via ``(A3T[A-Z0-9]|AKIA|AGPA|AIDA|AROA|AIPA|ANPA|ANVA|ASIA)[A-Z0-9]{16}``
    - Amazon Bedrock API keys. Long-lived via ``ABSK[A-Za-z0-9+/]{109,}=*`` and short-lived via ``bedrock-api-key-YmVkcm9jay5hbWF6b25hd3MuY29t``
    - AWS Secret Access Key assignments via ":" or "=" surrounded by optional
      quotes
    - AWS account ID assignments via ":" or "=" surrounded by optional quotes
    - Allowed patterns for example AWS keys (``AKIAIOSFODNN7EXAMPLE`` and
      ``wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY``)
    - Known credentials from ``~/.aws/credentials``

    .. note::

        While the patterns registered by this command should catch most
        instances of AWS credentials, these patterns are **not** guaranteed to
        catch them **all**. ``git-secrets`` should be used as an extra means of
        insurance -- you still need to do your due diligence to ensure that you
        do not commit credentials to a repository.

``--aws-provider``
    Secret provider that outputs credentials found in an INI file. You can
    optionally provide the path to an INI file.


Options for ``--install``

-f, --force Überschreibt vorhandene Hooks, falls vorhanden.

<target-directory> Wenn angegeben, installiert Git-Hooks in das angegebene Verzeichnis. Das aktuelle Verzeichnis wird angenommen, wenn <target-directory> nicht angegeben ist.

Wenn das angegebene ``<target-directory>`` nicht in einem Git-Repository liegt, wird
das Verzeichnis erstellt und die Hooks werden in ``<target-directory>/hooks`` abgelegt.
Dies kann nützlich sein, um Git-Vorlagenverzeichnisse zu erstellen, die mit
``git init --template <target-directory>`` verwendet werden.

Sie können ``git init`` in einem bereits initialisierten Repository ausführen.
Aus der `git init-Dokumentation <https://git-scm.com/docs/git-init>`_:

    From the git documentation: Running ``git init`` in an existing repository
    is safe. It will not overwrite things that are already there. The
    primary reason for rerunning ``git init`` is to pick up newly added
    templates (or to move the repository to another place if
    ``--separate-git-dir`` is given).

The following git hooks are installed:

1. ``pre-commit``: Used to check if any of the files changed in the commit
   use prohibited patterns.
2. ``commit-msg``: Used to determine if a commit message contains a
   prohibited patterns.
3. ``prepare-commit-msg``: Used to determine if a merge commit will
   introduce a history that contains a prohibited pattern at any point.
   Please note that this hook is only invoked for non fast-forward merges.

.. note::

    Git allows only a single script per hook. If the repository contains
    Debian-style subdirectories like ``pre-commit.d`` and ``commit-msg.d``,
    then the git hooks will be installed into these directories, which assumes
    that you've configured the corresponding hooks to execute all of the scripts
    found in these directories. If these git subdirectories are not present,
    then the git hooks will be installed to the git repo's ``.git/hooks`` directory.

Examples ^^^^^^^^

Install git hooks to the current directory::

cd /path/to/my/repository
git secrets --install

Install git hooks to a repository other than the current directory::

git secrets --install /path/to/my/repository

Create a git template that has git-secrets installed, and then copy that template into a git repository::

git secrets --install ~/.git-templates/git-secrets
git init --template ~/.git-templates/git-secrets

Overwrite existing hooks if present::

git secrets --install -f

Options for --scan


``-r, --recursive``
    Scannt die angegebenen Dateien rekursiv. Wenn ein Verzeichnis gefunden wird,
    wird das Verzeichnis gescannt. Wenn ``-r`` nicht angegeben ist, werden Verzeichnisse
    ignoriert.

    ``-r`` kann nicht zusammen mit ``--cached``, ``--no-index`` oder
    ``--untracked`` verwendet werden.

``--cached``
    Durchsucht Blobs, die in der Indexdatei registriert sind.

``--no-index``
    Durchsucht Dateien im aktuellen Verzeichnis, die nicht von git verwaltet werden.

``--untracked``
    Zusätzlich zur Suche in den getrackten Dateien im Arbeitsverzeichnis durchsucht
    ``--scan`` auch ungetrackte Dateien.

``<files>...``
    Der Pfad zu einer oder mehreren Dateien auf der Festplatte, die auf Geheimnisse gescannt werden sollen.

    Wenn keine Dateien angegeben werden, werden alle von ``git ls-files`` zurückgegebenen Dateien
    gescannt.


Examples
^^^^^^^^

Scannt alle Dateien im Repository::

    git secrets --scan

Scannt eine einzelne Datei auf Geheimnisse::

    git secrets --scan /path/to/file

Scannt ein Verzeichnis rekursiv auf Geheimnisse::

    git secrets --scan -r /path/to/directory

Scannt mehrere Dateien auf Geheimnisse::

    git secrets --scan /path/to/file /path/to/other/file

Sie können mit Glob-Mustern scannen::

    git secrets --scan /path/to/directory/*

Scannt von der Standardeingabe::

    echo 'hello!' | git secrets --scan -


Options for ``--list``

--global Listet nur die git-secrets-Konfiguration in der globalen Git-Konfiguration auf.

Options for --add


``--global``
    Fügt Muster zur globalen Git-Konfiguration hinzu

``-l, --literal``
    Escapet spezielle reguläre Ausdruckszeichen im angegebenen Muster, sodass
    das Muster wörtlich gesucht wird.

``-a, --allowed``
    Markiert das Muster als erlaubt anstatt verboten. Erlaubte Muster werden
    verwendet, um Fehlalarme herauszufiltern.

``<pattern>``
    Das zu suchende Regex-Muster.


Examples
^^^^^^^^

Fügt ein verbotenes Muster zum aktuellen Repository hinzu::

    git secrets --add '[A-Z0-9]{20}'

Fügt ein verbotenes Muster zur globalen Git-Konfiguration hinzu::

    git secrets --add --global '[A-Z0-9]{20}'

Fügt eine Zeichenkette hinzu, die wörtlich gescannt wird (``+`` wird escapet)::

    git secrets --add --literal 'foo+bar'

Fügt ein erlaubtes Muster hinzu::

    git secrets --add -a 'allowed pattern'


Options for ``--register-aws``

--global Fügt AWS-spezifische Konfigurationsvariablen zur globalen Git-Konfiguration hinzu.

Options for --aws-provider


``[<credentials-file>]``
    Wenn angegeben, gibt den benutzerdefinierten Pfad zu einer zu scannenden INI-Datei an. Wenn nicht
    angegeben, wird ``~/.aws/credentials`` angenommen.


Options for ``--add-provider``

--global Fügt den Provider zur globalen Git-Konfiguration hinzu.

<command> Provider-Befehl, der ausgeführt werden soll. Beim Aufruf wird erwartet, dass der Befehl verbotene Muster, getrennt durch neue Zeilen, in die Standardausgabe schreibt. Alle zusätzlichen Argumente werden an den Befehl weitergegeben.

Examples ^^^^^^^^

Registriert einen Geheimnis-Provider mit Argumenten::

git secrets --add-provider -- git secrets --aws-provider

Liest Geheimnisse aus einer Datei::

git secrets --add-provider -- cat /path/to/secret/file/patterns

Defining prohibited patterns

egrep-kompatible reguläre Ausdrücke werden verwendet, um festzustellen, ob ein Commit oder eine Commit-Nachricht verbotene Muster enthält. Diese regulären Ausdrücke werden mit dem Befehl git config definiert. Es ist wichtig zu beachten, dass verschiedene Systeme unterschiedliche Versionen von egrep verwenden. Beispielsweise verwenden Sie unter macOS eine andere Version von egrep als unter Ubuntu (BSD vs. GNU).

Sie können verbotene reguläre Ausdrucksmuster zu Ihrer Git-Konfiguration mit git secrets --add <pattern> hinzufügen.

Ignoring false positives

Manchmal kann ein regulärer Ausdruck auf Fehlalarme passen. Beispielsweise sehen Git-Commit-SHAs AWS-Zugriffsschlüsseln sehr ähnlich. Sie können viele verschiedene reguläre Ausdrucksmuster als Fehlalarme mit dem folgenden Befehl angeben:

git secrets --add --allowed 'my regex pattern'

Sie können auch reguläre Ausdrucksmuster zum Filtern von Fehlalarmen in einer .gitallowed-Datei im Stammverzeichnis des Repositorys hinzufügen. Zeilen, die mit # beginnen, werden übersprungen (Kommentarzeilen), und leere Zeilen werden ebenfalls übersprungen.

Zuerst extrahiert git-secrets alle Zeilen aus einer Datei, die eine verbotene Übereinstimmung enthalten. Die übereinstimmenden Ergebnisse enthalten den vollständigen Pfad zum Namen der Datei, gefolgt von ':', gefolgt von der übereinstimmenden Zeilennummer, gefolgt von der gesamten Zeile aus der Datei, die mit einem Geheimnismuster übereinstimmt. Wenn Sie dann erlaubte reguläre Ausdrücke definiert haben, prüft git-secrets, ob alle übereinstimmenden Zeilen mit mindestens einem Ihrer registrierten erlaubten regulären Ausdrücke übereinstimmen. Wenn alle als geheim markierten Zeilen durch eine erlaubte Übereinstimmung aufgehoben werden, enthält der geprüfte Text keine Geheimnisse. Wenn eine der übereinstimmenden Zeilen nicht von einem erlaubten regulären Ausdruck abgedeckt wird, wird git-secrets den Commit/Merge/ die Nachricht ablehnen.

.. important::

So wie es schlechte Praxis ist, zu gierige verbotene Muster hinzuzufügen, ist es auch
schlechte Praxis, zu nachsichtige erlaubte Muster hinzuzufügen. Testen Sie Ihre Muster
unbedingt mit ad-hoc-Aufrufen von ``git secrets --scan $filename``, um sicherzustellen,
dass sie wie beabsichtigt funktionieren.

Secret providers

Manchmal möchten Sie eine exakte Übereinstimmung mit einem Muster gegen eine Reihe bekannter Geheimnisse prüfen. Beispielsweise möchten Sie sicherstellen, dass keine Anmeldeinformationen, die in ~/.aws/credentials vorhanden sind, jemals in einem Commit erscheinen. In solchen Fällen ist es besser, diese Geheimnisse an einem Ort zu belassen, anstatt sie über Git-Repositorys in Git-Konfigurationen zu verteilen. Sie können "Geheimnis-Provider" verwenden, um diese Art von Anmeldeinformationen abzurufen. Ein Geheimnis-Provider ist eine ausführbare Datei, die beim Aufruf verbotene Muster, getrennt durch neue Zeilen, ausgibt.

Sie können Geheimnis-Provider mit dem Befehl --add-provider hinzufügen::

git secrets --add-provider -- git secrets --aws-provider

Beachten Sie die Verwendung von --. Dies stellt sicher, dass alle mit dem Provider verbundenen Argumente jedes Mal an den Provider weitergegeben werden, wenn er beim Scannen auf Geheimnisse aufgerufen wird.

Example walkthrough

Schauen wir uns ein Beispiel an. Gegeben sei der folgende zu prüfende Text (gespeichert in /tmp/example)::

This is a test!
password=ex@mplepassword
password=******
More test...

Und die folgenden registrierten Muster:

git secrets --add 'password\s*=\s*.+'
git secrets --add --allowed --literal 'ex@mplepassword'

Wenn Sie git secrets --scan /tmp/example ausführen, wird die folgende Fehlerausgabe resultieren::

/tmp/example:3:password=******

[ERROR] Matched prohibited pattern

Possible mitigations:
- Mark false positives as allowed using: git config --add secrets.allowed ...
- List your configured patterns: git config --get-all secrets.patterns
- List your configured allowed patterns: git config --get-all secrets.allowed
- Use --no-verify if this is a one-time false positive

Zum Verständnis: Der verbotene Musterwert password\s*=\s*.+ wird mit den folgenden Zeilen übereinstimmen::

/tmp/example:2:password=ex@mplepassword
/tmp/example:3:password=******

...Aber die erste Übereinstimmung wird herausgefiltert, da sie dem erlaubten regulären Ausdruck ex@mplepassword entspricht. Da noch eine verbleibende Zeile nicht übereinstimmt, gilt sie als Geheimnis.

Da die übereinstimmenden Zeilen in Zeilen platziert werden, die mit dem Dateinamen und der Zeilennummer beginnen (z.B. /tmp/example:3:...), können Sie erlaubte Muster erstellen, die Dateinamen und Zeilennummern im regulären Ausdruck berücksichtigen. Beispielsweise könnten Sie eine ganze Datei mit etwas wie::

git secrets --add --allowed '/tmp/example:.*'
git secrets --scan /tmp/example && echo $?
# Outputs: 0

whitelisten. Alternativ könnten Sie eine bestimmte Zeilennummer einer Datei erlauben, wenn diese Zeile voraussichtlich nicht geändert wird, mit etwas wie dem Folgenden:

git secrets --add --allowed '/tmp/example:3:.*'
git secrets --scan /tmp/example && echo $?
# Outputs: 0

Behalten Sie dies beim Erstellen erlaubter Muster im Hinterkopf, um sicherzustellen, dass Ihre erlaubten Muster nicht versehentlich übereinstimmen, da der Dateiname in dem Text enthalten ist, gegen den erlaubte Muster geprüft werden.

Skipping validation

Verwenden Sie die Option --no-verify bei einem Fehlalarm in einem Commit, Merge oder einer Commit-Nachricht. Dies überspringt die Ausführung des Git-Hooks und erlaubt Ihnen den Commit oder Merge.

About

Autor: Michael Dowling <https://github.com/mtdowling>_
Issue-Tracker: Der Quellcode und der Issue-Tracker dieses Projekts sind zu finden unter https://github.com/awslabs/git-secrets <https://github.com/awslabs/git-secrets>_
Besonderer Dank an Adrian Vatchinsky und Ari Juels von der Cornell University für Vorschläge und Feedback.

git-secrets

Beliebteste