Utilisation basique de GPG

dim. 25 févr. 2018 by Marmotte

GNU Privacy Guard (GPG) est un logiciel permettant de chiffrer et/ou signer des documents (fichiers, emails, commits git...), fonctionnant principalement à partir d'un système de paires de clés publique et privée.

Cet article est simplement un résumé des commandes basiques nécessaires à l'utilisation de GPG. J'explique ici l'utilisation de GPG version 2, mais l'utilisation est très proche de la version 1.

Installation

Debian propose toujours des paquets pour la version 1, le paquet pour la version 2 est donc nommé gnupg2. Le paquet gnupg-agent contient un démon permettant de gérer les clés privées, par exemple pour conserver la phrase de passe en cache.

$ sudo apt install --no-install-recommends gnupg2 gnupg-agent

Gestion des clés

Génération d'une paire de clés

La première opération à faire pour utiliser GPG est de générer une paire de clés.

$ gpg2 --gen-key
$ gpg2 --full-gen-key

La commande gpg2 --full-gen-key utilise moins de valeurs par défaut, et demande de manière interactive les valeurs correspondantes (type et taille de clé, par exemple).

Lister les clés

Il est possible de lister simplement les clés connues, ou d'afficher en plus quelques informations, comme par quelle clé elles sont signées, ou leur empreinte.

$ gpg2 --list-keys
$ gpg2 --check-sigs
$ gpg2 --fingerprint
$ gpg2 --list-secret-keys

Pour chaque clé, l'identifiant est affiché, ainsi que la liste des identités et les sous-clés liées.

Signer une clé

GPG repose sur le principe de la chaîne de confiance (Web of Trust). Cela signifie qu'une clé ne peut être utilisée que si elle est considérée de confiance.

Pour cela, il est nécessaire de signer les clés auxquelles on fait directement confiance. Ensuite, toute autre clé signée par une ou plusieurs clés auxquelles on fait déjà confiance est considérée de confiance aussi. Le nombre de clés signées requises pour attribuer sa confiance à une clé dépend de l'algorithme utilisé. L'algorithme par défaut, PGP, attribue la confiance à une clé signée par une clé qui a un niveau de confiance ultime, ou par au moins trois clés qui ont un niveau de confiance total.

Signer une clé se fait en utilisant la commande :

$ gpg2 --sign-key <key>

Pour éviter qu'une confirmation ne soit demandée, il est possible de demander la signature à partir de l'empreinte de la clé :

$ gpg2 --quick-sign-key <key fingerprint>

Modifier les informations d'une clé

Il est parfois nécessaire de modifier les informations d'une clé, pour ajouter une identité, ajouter une sous-clé ou encore modifier la phrase de passe, par exemple.

Afin d'effectuer des modifications, il faut lancer la commande :

$ gpg2 --edit-key <key>

<key> est soit un identifiant de clé, soit une identité liée à la clé à modifier.

Un interpréteur interactif est alors ouvert, dans lequel nous pouvons taper plusieurs commandes. Celles que j'utilise sont :

  • uid <X> : Sélection d'une identité à modifier.
  • key <X> : Sélection d'une clé à modifier.
  • adduid : Ajout d'une identité à la clé sélectionnée.
  • addkey : Ajout d'une sous-clé à la clé sélectionnée.
  • revuid : Révoquer l'identité sélectionnée.
  • revkey : Révoquer la clé sélectionnée.
  • expire : Modification de la date d'expiration de la clé sélectionnée.
  • passwd : Modification de la phrase de passe de la clé sélectionnée.
  • sign : Signer la clé sélectionnée.
  • trust : Modifier le niveau de confiance de la clé sélectionnée.
  • save : Sauvegarder les modifications effectuées et quitter l'interpréteur interactif.

Certaines de ces commandes disposent d'un raccourci utilisable directement depuis le shell :

$ # Modifier la phrase de passe de la clé
$ gpg2 --passwd <key>
$ # Signer la clé
$ gpg2 --sign-key <key>

Exporter une clé

Pour que d'autres utilisateurs puissent vérifier les signatures effectuées par une clé, ou qu'ils puissent chiffrer des données à destination de celle-ci, il est nécessaire qu'ils disposent de la clé publique associée. Il faut donc exporter cette clé publique afin de pouvoir leur transmettre.

Exporter la clé privée est aussi nécessaire en cas de changement de machine, ou à des fins de sauvegarde. Dans le cas de l'export de la clé privée, il est nécessaire de faire très attention afin d'éviter que d'autres personnes ne puissent s'en emparer.

Vers un fichier

L'export de la clé vers un fichier permet de la transmettre directement, par exemple par clé USB, par email ou sur un site internet.

$ # Export de la clé publique
$ gpg2 --export --output <filename.public.key>
$ # Export de la clé privée
$ gpg2 --export-secret-keys --output <filename.private.key>

Note : Il est possible d'ajouter le paramètre --armor afin de générer un fichier ASCII au lieu d'un fichier binaire.

Vers un serveur de clés

Il est aussi possible d'exporter une clé publique vers un serveur de clés. Cela permet aux autres utilisateurs de récupérer facilement la clé depuis ce serveur.

$ gpg2 --keyserver <keyserver.example.com> --send-keys <key>

Note : Faites bien attention à bien vérifier les informations présentes dans une clé avant de l'exporter vers un serveur de clés. En effet, il est impossible de supprimer des informations du serveur de clés. Les informations erronées qui y sont envoyées peuvent toujours être révoquées, mais resteront présentes.

Importer une clé

L'opération d'import est le pendant de l'opération d'export. Elle permet d'ajouter une clé publique ou privée dans le trousseau.

Depuis un fichier

Lorsque la clé est reçue sous forme d'un fichier, il est possible de l'importer au moyen de la commande :

$ gpg2 --import <filename>

Il est possible de donner plusieurs fichiers à importer dans la même commande.

Depuis un serveur de clés

Importer la clé depuis un serveur de clés se fait au moyen de la commande :

$ gpg2 --keyserver <keyserver.example.com> --recv-keys <key>

Si l'identifiant de la clé n'est pas connu, il est possible de chercher par adresse email avec cette commande :

$ gpg2 --keyserver <keyserver.example.com> --search-keys <adresse.email@example.com>

La clé sélectionnée parmi celles trouvées sera alors automatiquement importée.

Supprimer une clé

Lorsqu'une clé est devenue inutile, il est possible de la supprimer du trousseau.

$ # Suppression d'une clé publique
$ gpg2 --delete-keys <key>
$ # Suppression d'une clé privée
$ gpg2 --delete-secret-keys <key>
$ # Suppression d'une paire de clés
$ gpg2 --delete-secret-and-public-keys <key>

Signer un document

Signer un document est une opération nécessitant uniquement une clé privée. Cela permet à la fois de confirmer l'intégrité (pas de modification pendant le transfert) et l'authenticité (l'auteur est bien celui qu'il prétend être) du document signé.

La signature du document est un hash, permettant d'assurer l'intégrité du document. Elle est ensuite chiffrée en utilisant une clé privée, ce qui permet alors de vérifier l'authenticité de la signature, et donc du document signé, par le proriétaire de la clé privée utilisée.

$ # Génère un fichier contenant le document et sa signature
$ gpg2 --sign <fichier>
$ # Génère un fichier contenant le document en clair, suivi de sa signature
$ gpg2 --clearsign <fichier>
$ # Génère la signature dans un fichier séparé du document d'origine
$ # Cette méthode utile pour signer des données binaires
$ gpg2 --detach-sign <fichier>

Note : Il est possible d'ajouter le paramètre --armor afin de générer un fichier ASCII au lieu d'un fichier binaire.

Attention : Même si le contenu du document signé n'est pas présent en clair dans le fichier généré par la commande gpg2 --sign, la confidentialité de son contenu n'est pas pour autant assurée. En effet, la signature étant chiffrée en utilisant une clé privée, le résultat est alors déchiffrable en utilisant la clé publique associée, qui est, par définition... publique.

Vérifier la signature d'un document

Vérifier une signature nécessite de disposer de la clé publique correspondant à la clé privée utilisée pour signer. La vérification est une opération permettant simplement de s'assurer que la signature associée au document est valide, c'est à dire que ni la signature, ni le document, n'ont été falsifiés.

$ gpg2 --verify <fichier>

Chiffrer un document

Chiffrer un document nécessite de disposer de la clé publique du ou des destinataires du document.

Le chiffrement permet de rendre le document illisible pour toute personne ne possédant pas la clé de déchiffrement. Cela permet donc d'assurer la confidentialité lors d'une transmission de données.

$ gpg2 --encrypt <fichier>

Le paramètre --recipient (abrégé -r) permet de préciser le ou les destinataires du document dans la commande. Il est possible de le donner plusieurs fois pour définir plusieurs destinataires.

L'opération de chiffrement n'inclue pas automatiquement de signature, mais il est bien évidemment possible de signer et chiffrer le document dans la même commande :

$ gpg2 --encrypt --sign <fichier>

Note : Il est possible d'ajouter le paramètre --armor afin de générer un fichier ASCII au lieu d'un fichier binaire.

Chiffrement symétrique

GPG est aussi capable d'utiliser un chiffrement symétrique, ce qui ne nécessite pas de clé. Dans ce cas, une phrase de passe est demandée lors du chiffrement du fichier, et la même doit être donnée pour déchiffrer le contenu. Ce mécanisme peut être utilisé en même temps que le chiffrement asymétrique et les signatures.

$ gpg2 --symmetric <fichier>

Déchiffrer un document

Déchiffrer un document nécessite uniquement la clé privée associée à la clé publique ayant permis de le chiffrer, ou la phrase de passe, dans le cas d'un chiffrement symétrique. Cette opération consiste simplement à retrouver le contenu du document d'origine à partir d'un document chiffré.

$ gpg2 --decrypt <fichier>