Table des matières

GPG

Il est important d'exporter la variable suivante dans le shell (à placer dans .bashrc, donc):

export GPG_TTY=$(tty)

L'application seahorse permet de gérer les clés GPG.

Créer une clé GPG

gpg --full-generate-key

Sélectionner RSA and RSA, une longueur de 4096 bits, une date d'expiration (jamais), les informations personnelles et une passphrase.

Lister les clés connues

gpg --list-keys
gpg --list-secret-keys --keyid-format LONG

Ce qui se trouve après rsa4096/ est l'ID de la clé, c'est cet identifiant qui est utilisé pour manipuler la clé.

Afficher la clé publique

gpg --armor --export <id>

--output public-key.asc sauvegarde directement la clé dans un fichier.

Importer une clé publique

# depuis le serveur par défaut dans la configuration de GnuPG:
gpg --search-keys edward-fr@fsf.org
 
# en précisant le serveur de clés:
gpg --keyserver hkp://pool.sks-keyservers.net --search-keys edward-fr@fsf.org
 
# depuis un fichier:
gpg --import edward.asc
 
# depuis l'ID:
gpg --recv-keys DEADBEEF
# ou:
gpg --recv-keys 0xDEADBEEF

Ensuite, il faut signer la clé importée, pour la marquer comme valide:

gpg --edit-key edward-fr@fsf.org
 
# afficher l'empreinte:
gpg> fpr
 
# si l'empreinte correspond à ce qui est annoncé, on peut la signer avec notre clé:
gpg> sign
gpg> quit

Il est possible de préciser avec quelle clé signer la clé:

gpg -u ID --edit-key edward-fr@fsf.org

Chiffrer et déchiffrer un contenu

Pour chiffrer:

gpg --output config.js.gpg --encrypt --recipient ${adresse_mail} .thelounge/config.js

L'adresse mail fournie sert à identifier la clé à utiliser pour chiffrer.

Pour déchiffrer:

gpg --decrypt encrypted.asc

Vérifier la signature d'un fichier

gpg --verify fichier.sig fichier

La clé publique utilisée pour la signature doit être dans le trousseau de GPG.

Ajouter une identité à une clé

gpg --edit-key <id>
gpg> adduid
[...]
gpg> save

La nouvelle adresse sera marquée en confiance ultime une fois les modifications à la clé sauvegardées.

Définir une clé comme principale:

gpg --edit-key <id>
gpg> <numéro de l identité à définir comme principale>
gpg> primary
gpg> save

Supprimer une clé

gpg --delete-keys <id>

Communiquer avec un serveur de clé

Rafraîchir les clés connues:

gpg --refresh-keys

Publier sa clé (ou mettre à jour sa clé sur un serveur de clés):

gpg --send-keys alice@example.org

Rajouter --keyserver certserver.pgp.com pour préciser le serveur de clés à utiliser.

Quelques serveurs de clés:

On peut configurer le serveur par défaut dans ~/.gnupg/gpg.conf:

keyserver hkps://keys.openpgp.org

Signer des clés

Faire signer sa clé :

  1. distribuer le résultat de
    gpg --fingerprint DEADBEEF
  2. une fois sa clé signée reçue par mail:
    gpg --import key.signed.asc
    # ou
    gpg -d fichier.asc | gpg --import
  3. mettre à jour sa clé sur les serveurs de clés:
    gpg --send-keys DEADBEEF

Signer une clé :

  1. importer la clé :
    gpg --recv-keys DEADBEEF
  2. s'assurer que le fingerprint et l'identité clamée correspond à ce que dit le propriétaire de la clé
  3. signer la clé:
    gpg --sign-key DEADBEEF
  4. exporter la clé signée et l'envoyer par mail à son propriétaire :
    gpg --armor --output DEADBEEF.signed.asc --export DEADBEEF

Avec caff (du paquet signing-party), pour facilement signer toutes les sous-clés et envoyer les mails nécessaires (page Debian, un post de blog) :

caff DEADBEEF

Divers

Il est possible de voir les signatures des clés:

gpg --list-sigs

Avec les programmes fournis par le paquet signing-party, il est possible de générer une liste de fingerprints prêts à imprimer:

gpg-key2latex DEADBEEF > gpg.tex

Il est possible de visualiser le graphe des signatures des clés connues localement:

gpg --list-sigs --keyid-format long | sig2dot > sigs.dot 
springgraph < sigs.dot > sigs.png

Prolonger la validité d'une clé

gpg --edit-key DEADBEEF
gpg> expire
gpg> 1y
gpg> key 1
gpg> expire
gpg> 1y
gpg> save

Envoyer la clé sur les serveurs de clés.

Redémarrer l'agent GPG

gpg-connect-agent reloadagent /bye

Sauvegardes

# Sauvegarde aussi de la clé privée:
gpg -o backup.gpg --export-secret-keys alice@example.org
 
# Sauvegarde de toutes les clés publiques connues:
gpg -o public-keys.gpg --export
gpg --export-ownertrust > trust.txt
 
# tous les certificats de révocation sont dans ~/.gnupg/openpgp-revocs.d/

Restauration:

gpg --import backup.gpg
gpg --import public-keys.gpg
gpg --import-ownertrust < trust.txt

Installer sur MacOS

brew install gnupg pinentry-mac
brew link gnupg
 
echo "pinentry-program $(which pinentry-mac)" >>  ~/.gnupg/gpg-agent.conf
gpg-connect-agent reloadagent /bye

Forwarder l'agent GPG par SSH

Envoyer le trousseau de clés publiques sur la machine distante :

scp ~/.gnupg/pubring.kbx remote:.gnupg/

Trouver où sont les sockets, à la fois sur la machine locale et distante :

gpgconf --list-dirs agent-socket

Supprimer les sockets potentiellement déjà existants.

Sur la machine distante, gpg-agent ne doit pas être lancé. Pour éviter le démarrage automatique :

echo no-autostart >> "$HOME/.gnupg/gpg.conf"

Sur la machine distante, il faut ajouter une option au serveur SSH :

echo "StreamLocalBindUnlink yes" | sudo tee -a /etc/ssh/sshd_config

Se connecter en forwardant la socket :

# -R socket_distante:socket_locale
ssh -R /run/user/1000/gnupg/S.gpg-agent:/Users/philippe/.gnupg/S.gpg-agent -o "StreamLocalBindUnlink=yes" vm-debian-sid

Sur la machine distante, on peut ensuite tester :

gpg-connect-agent "KEYINFO --list" /bye
gpg --clear-sign $file_to_sign

Dumper le contenu d'une clé GPG

https://cirw.in/gpg-decoder (https://github.com/ConradIrwin/gpg-decoder)