awslabs/git-secretsVous empêche de valider des secrets et des identifiants dans les dépôts git
.. contents:: :depth: 2
::
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>]
git-secrets analyse les commits, les messages de commit, et les fusions --no-ff afin d'empêcher l'ajout de secrets dans vos dépôts git. Si un commit, un message de commit, ou tout commit dans un historique de fusion --no-ff correspond à l'un de vos motifs d'expression régulière interdits configurés, alors le commit est rejeté.
git-secrets doit être placé quelque part dans votre PATH pour qu'il soit détecté par git lors de l'exécution de git secrets.
*nix (Linux/macOS)
Vous pouvez utiliser la cible ``install`` du Makefile fourni pour installer ``git secrets`` et la page de manuel.
Vous pouvez personnaliser le chemin d'installation en utilisant les variables PREFIX et MANPREFIX.
::
make install
Windows
~~~~~~~
Exécutez le script powershell ``install.ps1`` fourni. Cela copiera les fichiers nécessaires dans un répertoire d'installation (``%USERPROFILE%/.git-secrets`` par défaut) et ajoutera le répertoire au ``PATH`` de l'utilisateur courant.
::
PS > ./install.ps1
Homebrew (pour les utilisateurs macOS)
::
brew install git-secrets
.. attention::
**Vous n'avez pas encore terminé ! Vous DEVEZ installer les hooks git pour chaque dépôt avec lequel vous souhaitez utiliser** ``git secrets --install``.
Voici un exemple rapide de la façon de garantir qu'un dépôt git est scanné pour les secrets à chaque commit ::
cd /path/to/my/repo
git secrets --install
git secrets --register-aws
Ajoutez un modèle de configuration si vous souhaitez ajouter des hooks à tous les dépôts que vous initialiserez ou clônerez à l'avenir.
::
git secrets --register-aws --global
Ajoutez des hooks à tous vos dépôts locaux.
::
git secrets --install ~/.git-templates/git-secrets
git config --global init.templateDir ~/.git-templates/git-secrets
Ajoutez des fournisseurs personnalisés pour détecter les informations d'identification de sécurité.
::
git secrets --add-provider -- cat /path/to/secret/file/patterns
Avec git-secrets, il est également possible de scanner un dépôt en incluant toutes les révisions :
::
git secrets --scan-history
Modes de fonctionnement
Chacune de ces options doit apparaître en premier sur la ligne de commande.
``--install``
Installe les hooks git pour un dépôt. Une fois les hooks installés pour un dépôt git, les commits et les fusions non fast-forward pour ce dépôt seront empêchés de commiter des secrets.
``--scan``
Scanne un ou plusieurs fichiers à la recherche de secrets. Lorsqu'un fichier contient un secret, le texte correspondant du fichier scanné sera écrit sur stdout et le script se terminera avec un code de sortie non nul. Chaque ligne correspondante sera écrite avec le nom du fichier qui a correspond, deux-points, le numéro de ligne correspondant, deux-points, puis la ligne de texte correspondante. Si aucun fichier n'est fourni, tous les fichiers retournés par ``git ls-files`` sont scannés.
``--scan-history``
Scanne le dépôt en incluant toutes les révisions. Lorsqu'un fichier contient un secret, le texte correspondant du fichier scanné sera écrit sur stdout et le script se terminera avec un code de sortie non nul. Chaque ligne correspondante sera écrite avec le nom du fichier qui a correspond, deux-points, le numéro de ligne correspondant, deux-points, puis la ligne de texte correspondante.
``--list``
Liste la configuration ``git-secrets`` pour le dépôt courant ou dans la config git globale.
``--add``
Ajoute un motif interdit ou autorisé.
``--add-provider``
Enregistre un fournisseur de secrets. Les fournisseurs de secrets sont des exécutables qui, lorsqu'ils sont invoqués, produisent des motifs interdits que ``git-secrets`` doit traiter comme interdits.
``--register-aws``
Ajoute les motifs AWS courants à la config git et s'assure que les clés présentes dans ``~/.aws/credentials`` ne se trouvent dans aucun commit. Les vérifications suivantes sont ajoutées :
- Identifiants de clé d'accès AWS via ``(A3T[A-Z0-9]|AKIA|AGPA|AIDA|AROA|AIPA|ANPA|ANVA|ASIA)[A-Z0-9]{16}``
- Clés API Amazon Bedrock. Longue durée via ``ABSK[A-Za-z0-9+/]{109,}=*`` et courte durée via ``bedrock-api-key-YmVkcm9jay5hbWF6b25hd3MuY29t``
- Assignations de clé secrète d'accès AWS via ":" ou "=" entourées de guillemets optionnels
- Assignations d'ID de compte AWS via ":" ou "=" entourées de guillemets optionnels
- Motifs autorisés pour les exemples de clés AWS (``AKIAIOSFODNN7EXAMPLE`` et ``wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY``)
- Informations d'identification connues de ``~/.aws/credentials``
.. note::
Bien que les motifs enregistrés par cette commande devraient détecter la plupart des instances d'informations d'identification AWS, ces motifs ne garantissent pas de tous les détecter. ``git-secrets`` doit être utilisé comme un moyen supplémentaire d'assurance — vous devez toujours faire votre diligence raisonnable pour vous assurer de ne pas commiter d'informations d'identification dans un dépôt.
``--aws-provider``
Fournisseur de secrets qui produit les informations d'identification trouvées dans un fichier INI. Vous pouvez éventuellement fournir le chemin vers un fichier INI.
Options pour ``--install``
-f, --force
Écrase les hooks existants s'ils sont présents.
<target-directory>
Lorsqu'il est fourni, installe les hooks git dans le répertoire donné. Le répertoire courant est supposé si <target-directory> n'est pas fourni.
Si le ``<target-directory>`` fourni n'est pas dans un dépôt git, le répertoire sera créé et les hooks seront placés dans ``<target-directory>/hooks``. Cela peut être utile pour créer des répertoires de modèles git à utiliser avec ``git init --template <target-directory>``.
Vous pouvez exécuter ``git init`` sur un dépôt qui a déjà été initialisé. D'après la documentation `git init <https://git-scm.com/docs/git-init>`_ :
D'après la documentation git : Exécuter ``git init`` dans un dépôt existant est sûr. Cela n'écrasera pas ce qui est déjà présent. La principale raison de réexécuter ``git init`` est d'incorporer les modèles nouvellement ajoutés (ou de déplacer le dépôt à un autre endroit si ``--separate-git-dir`` est donné).
Les hooks git suivants sont installés :
1. ``pre-commit`` : Utilisé pour vérifier si l'un des fichiers modifiés dans le commit utilise des motifs interdits.
2. ``commit-msg`` : Utilisé pour déterminer si un message de commit contient un motif interdit.
3. ``prepare-commit-msg`` : Utilisé pour déterminer si un commit de fusion introduira un historique contenant un motif interdit à un moment donné. Veuillez noter que ce hook n'est invoqué que pour les fusions non fast-forward.
.. note::
Git ne permet l'exécution que d'un seul script par hook. Si le dépôt contient des sous-répertoires de style Debian comme ``pre-commit.d`` et ``commit-msg.d``, alors les hooks git seront installés dans ces répertoires, ce qui suppose que vous avez configuré les hooks correspondants pour exécuter tous les scripts trouvés dans ces répertoires. Si ces sous-répertoires git ne sont pas présents, alors les hooks git seront installés dans le répertoire ``.git/hooks`` du dépôt git.
Exemples ^^^^^^^^
Installer les hooks git dans le répertoire courant ::
cd /path/to/my/repository
git secrets --install
Installer les hooks git dans un dépôt autre que le répertoire courant ::
git secrets --install /path/to/my/repository
Créer un modèle git qui a git-secrets installé, puis copier ce modèle dans un dépôt git ::
git secrets --install ~/.git-templates/git-secrets
git init --template ~/.git-templates/git-secrets
Écraser les hooks existants s'ils sont présents ::
git secrets --install -f
Options pour --scan
``-r, --recursive``
Scanne les fichiers donnés de manière récursive. Si un répertoire est rencontré, il sera scanné. Si ``-r`` n'est pas fourni, les répertoires seront ignorés.
``-r`` ne peut pas être utilisé avec ``--cached``, ``--no-index`` ou ``--untracked``.
``--cached``
Recherche les blobs enregistrés dans le fichier d'index.
``--no-index``
Recherche les fichiers dans le répertoire courant qui ne sont pas gérés par git.
``--untracked``
En plus de la recherche dans les fichiers suivis de l'arbre de travail, ``--scan`` recherche également dans les fichiers non suivis.
``<files>...``
Le chemin vers un ou plusieurs fichiers sur le disque à scanner pour les secrets.
Si aucun fichier n'est fourni, tous les fichiers retournés par ``git ls-files`` sont scannés.
Exemples
^^^^^^^^
Scanner tous les fichiers du dépôt ::
git secrets --scan
Scanne un seul fichier pour les secrets ::
git secrets --scan /path/to/file
Scanne un répertoire de manière récursive pour les secrets ::
git secrets --scan -r /path/to/directory
Scanne plusieurs fichiers pour les secrets ::
git secrets --scan /path/to/file /path/to/other/file
Vous pouvez scanner par glob ::
git secrets --scan /path/to/directory/*
Scanner depuis stdin ::
echo 'hello!' | git secrets --scan -
Options pour ``--list``
--global
Liste uniquement la configuration git-secrets dans la config git globale.
Options pour --add
``--global``
Ajoute des motifs à la config git globale
``-l, --literal``
Échappe les caractères spéciaux des expressions régulières dans le motif fourni afin que le motif soit recherché littéralement.
``-a, --allowed``
Marque le motif comme autorisé au lieu d'interdit. Les motifs autorisés sont utilisés pour filtrer les faux positifs.
``<pattern>``
Le motif regex à rechercher.
Exemples
^^^^^^^^
Ajoute un motif interdit au dépôt courant ::
git secrets --add '[A-Z0-9]{20}'
Ajoute un motif interdit à la config git globale ::
git secrets --add --global '[A-Z0-9]{20}'
Ajoute une chaîne qui est scannée littéralement (``+`` est échappé) ::
git secrets --add --literal 'foo+bar'
Ajoute un motif autorisé ::
git secrets --add -a 'allowed pattern'
Options pour ``--register-aws``
--global
Ajoute des variables de configuration spécifiques à AWS à la config git globale.
Options pour --aws-provider
``[<credentials-file>]``
S'il est fourni, spécifie le chemin personnalisé vers un fichier INI à scanner. S'il n'est pas fourni, ``~/.aws/credentials`` est supposé.
Options pour ``--add-provider``
--global
Ajoute le fournisseur à la config git globale.
<command>
Commande du fournisseur à invoquer. Lorsqu'elle est invoquée, la commande doit écrire des motifs interdits séparés par des sauts de ligne sur stdout. Tous les arguments supplémentaires fournis sont passés à la commande.
Exemples ^^^^^^^^
Enregistre un fournisseur de secrets avec des arguments ::
git secrets --add-provider -- git secrets --aws-provider
Affiche les secrets d'un fichier ::
git secrets --add-provider -- cat /path/to/secret/file/patterns
Les expressions régulières compatibles egrep sont utilisées pour déterminer si un commit ou un message de commit contient des motifs interdits. Ces expressions régulières sont définies à l'aide de la commande git config. Il est important de noter que différents systèmes utilisent différentes versions d'egrep. Par exemple, sous macOS, vous utiliserez une version différente d'egrep que sous Ubuntu (BSD vs GNU).
Vous pouvez ajouter des motifs d'expression régulière interdits à votre config git en utilisant git secrets --add <pattern>.
Parfois, une expression régulière peut correspondre à des faux positifs. Par exemple, les SHA de commit git ressemblent beaucoup aux clés d'accès AWS. Vous pouvez spécifier de nombreux motifs d'expression régulière différents comme faux positifs en utilisant la commande suivante :
::
git secrets --add --allowed 'my regex pattern'
Vous pouvez également ajouter des motifs d'expression régulière pour filtrer les faux positifs dans un fichier .gitallowed situé dans le répertoire racine du dépôt. Les lignes commençant par # sont ignorées (ligne de commentaire) et les lignes vides sont également ignorées.
Tout d'abord, git-secrets extraira toutes les lignes d'un fichier qui contiennent une correspondance interdite. Les résultats correspondants incluront le chemin complet vers le nom du fichier qui a été mis en correspondance, suivi de ':', suivi du numéro de ligne mis en correspondance, suivi de la ligne entière du fichier qui a été mise en correspondance par un motif secret. Ensuite, si vous avez défini des expressions régulières autorisées, git-secrets vérifiera si toutes les lignes mises en correspondance correspondent à au moins une de vos expressions régulières autorisées enregistrées. Si toutes les lignes qui ont été signalées comme secrètes sont annulées par une correspondance autorisée, alors le texte du sujet ne contient aucun secret. Si l'une des lignes correspondantes n'est pas mise en correspondance par une expression régulière autorisée, alors git-secrets échouera au commit/fusion/message.
.. important::
Tout comme il est de mauvaise pratique d'ajouter des motifs interdits trop gourmands, il est également de mauvaise pratique d'ajouter des motifs autorisés trop indulgents. Assurez-vous de tester vos motifs en utilisant des appels ad-hoc à ``git secrets --scan $filename`` pour vous assurer qu'ils fonctionnent comme prévu.
Parfois, vous souhaitez vérifier une correspondance de motif exacte contre un ensemble de secrets connus. Par exemple, vous pourriez vouloir vous assurer qu'aucune information d'identification présente dans ~/.aws/credentials n'apparaît jamais dans un commit. Dans ces cas, il est préférable de laisser ces secrets dans un seul emplacement plutôt que de les disperser dans les dépôts git dans les configurations git. Vous pouvez utiliser des "fournisseurs de secrets" pour récupérer ces types d'informations d'identification. Un fournisseur de secrets est un exécutable qui, lorsqu'il est invoqué, produit des motifs interdits séparés par des sauts de ligne.
Vous pouvez ajouter des fournisseurs de secrets en utilisant la commande --add-provider ::
git secrets --add-provider -- git secrets --aws-provider
Remarquez l'utilisation de --. Cela garantit que tous les arguments associés au fournisseur sont passés au fournisseur à chaque fois qu'il est invoqué lors de l'analyse des secrets.
Prenons un exemple. Avec le texte sujet suivant (stocké dans /tmp/example) ::
This is a test!
password=ex@mplepassword
password=******
More test...
Et les motifs enregistrés suivants :
::
git secrets --add 'password\s*=\s*.+'
git secrets --add --allowed --literal 'ex@mplepassword'
L'exécution de git secrets --scan /tmp/example produira la sortie d'erreur suivante ::
/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
En décomposant cela, la valeur de motif interdite password\s*=\s*.+ correspondra aux lignes suivantes ::
/tmp/example:2:password=ex@mplepassword
/tmp/example:3:password=******
...Mais la première correspondance sera filtrée car elle correspond à l'expression régulière autorisée ex@mplepassword. Parce qu'il reste encore une ligne qui n'a pas été mise en correspondance, elle est considérée comme un secret.
Étant donné que les lignes correspondantes sont placées sur des lignes qui commencent par le nom du fichier et le numéro de ligne (par exemple, /tmp/example:3:...), vous pouvez créer des motifs autorisés qui prennent en compte les noms de fichiers et les numéros de ligne dans l'expression régulière. Par exemple, vous pourriez autoriser un fichier entier en utilisant quelque chose comme ::
git secrets --add --allowed '/tmp/example:.*'
git secrets --scan /tmp/example && echo $?
# Outputs: 0
Alternativement, vous pourriez autoriser un numéro de ligne spécifique d'un fichier si cette ligne est peu susceptible de changer en utilisant quelque chose comme :
::
git secrets --add --allowed '/tmp/example:3:.*'
git secrets --scan /tmp/example && echo $?
# Outputs: 0
Gardez cela à l'esprit lors de la création de motifs autorisés pour vous assurer que vos motifs autorisés ne sont pas involontairement mis en correspondance en raison du fait que le nom du fichier est inclus dans le texte du sujet par rapport auquel les motifs autorisés sont comparés.
Utilisez l'option --no-verify en cas de faux positif lors d'un commit, d'une fusion ou d'un message de commit. Cela ignorera l'exécution du hook git et vous permettra d'effectuer le commit ou la fusion.
Michael Dowling <https://github.com/mtdowling>_https://github.com/awslabs/git-secrets <https://github.com/awslabs/git-secrets>_Copyright 2015 Amazon.com, Inc. or its affiliates. All Rights Reserved.