GnuPG

GnuPG (GNU Privacy Guard) est une implémentation libre du standard de chiffrement OpenPGP, qui fonctionne sur un système de clefs asymétriques.

Pour envoyer un message chiffré (quel que soit le protocole utilisé) à une personne, il vous faut à tous les deux un couple de clefs, composé d'une clef privée (que, comme son nom l'indique, chacun garde pour lui) et une clef publique (qui, comme son nom l'indique, est mise à disposition de tout un chacun). Le message que vous allez envoyer sera chiffré avec votre clef privée et la clef publique du destinataire. Pour le décrpyter, ce dernier utilisera sa clef privée et votre clef publique.

Configuration : utiliser SHA-2

L'ancien algorithme SHA-1, utilisé par défaut par GnuPG (pour des raisons de protocoles), donne des signes de faiblesses. La migration vers la famille SHA-2 est entamée. Pour générer une clef robuste, ajoutez les lignes suivantes au fichier ~/.gnupg/gpg.conf (créez-le s'il n'existe pas encore) :

personal-digest-preferences SHA256
cert-digest-algo SHA256
default-preference-list SHA512 SHA384 SHA256 SHA224 AES256 AES192 AES CAST5 ZLIB BZIP2 ZIP Uncompressed

La dernière ligne indique que toute nouvelle clef sera créée avec l'algorithme SHA512 si possible.

L'inconvénient d'utiliser une clef en SHA-2 est que les (très) anciennes implémentations ne le supportent pas forcément. Cependant, ça fait un bon moment que GnuPG l'intègre, on peut donc franchir le pas sans trop de risque.

Générer un couple de clefs

Il me semble que le programme GnuPG est installé par défaut dans la plupart des distributions. Sous Debian le paquet s'appelle tout simplement gnupg.

aptitude install gnupg

En premier lieu, il faut donc générer un couple de clefs :

gpg --gen-key

Les choix par défaut conviennent très bien (validez simplement chaque étape par <Entrée>). Si vous êtes à un degré de paranoïa plus élevé que la moyenne, vous pouvez éventuellement augmenter la longueur de la clef ELG-E (deuxième question), ce qui sera plus sécurisé mais augmentera légèrement les temps de chiffrement/déchiffrement. Vous pouvez aussi fixer une durée de validité de la clef (troisième question), mais cela est inutile si vous générez et mettez en sûreté un certificat de révocation, que vous utiliserez si la clef venait à être corrompue. Dites ensuite que c'est correct en tapant 'o', puis renseignez les champs :

• Nom réel : mettez votre nom ou pseudonyme.
• Adresse e-mail : mettez l'adresse pour laquelle vous désirez chiffrer les messages. Si vous ne destinez pas cette clef à du chiffrement de courriels (et même si c'est le cas), une adresse bidon ou un JID (Jabber ID, pour les incultes) doit fonctionner.
• Commentaire : mettez ce que vous voulez, comme une phrase caractéristique qui permettra de reconnaître votre clef. Exemple : « Oui, c'est bien moi. » si votre pseudo est du genre « Dark Lord » ou « Sangoku », permettra de trouver facilement votre clef parmis les 4569 « Dark Lord » ou « Sangoku » référencés sur le serveur de clefs. Mais je m'égare...

Validez ensuite en tapant 'o'.

On vous demande alors d'« entrer la phrase de passe ». Pas de panique, ne vous cassez pas la tête pour trouver une phrase, c'est simplement d'un mot de passe qu'il s'agit. Et vous aurez à le taper par la suite, donc s'il fait un peu moins de 50 caractères c'est mieux. D'ailleurs on vous demande de la taper une deuxième fois immédiatement.

Voici à présent une étape fort sympathique qui va vous permettre de vous muscler les bras. Voici le message qui apparaît :

Un grand nombre d'octets aléatoires doit être généré. Vous devriez faire
autre-chose (taper au clavier, déplacer la souris, utiliser les disques)
pendant la génération de nombres premiers; cela donne au générateur de
nombres aléatoires une meilleure chance d'avoir assez d'entropie.

Obéissez donc, bougez la souris dans tous les sens, lancez des programmes, tapez comme une brute sur votre clavier, etc. Plus vous y mettrez du votre et plus la génération de la clef sera rapide (il est prouvé que le degré de pression appliqué sur les touches du clavier est un facteur direct de la vitesse d'exécution de ce processus). ls -R / fonctionne assez bien aussi.

Un message apparaît, ressemblant à :

gpg: clé XXXXXXXX marquée comme ayant une confiance ultime.
les clés publique et secrète ont été créées et signées.

où XXXXXXXX est une chaîne de huit caractères (chiffres et lettres). Il s'agit des huit derniers caractères de l'empreinte (ou fingerprint dans la langue de Cheik Spir) de la clef publique, qui forment son identifiant. Notez cet identifiant, nous en aurons besoin dans l'étape suivante. C'est en outre lui qui vous permettra d'effectuer toutes les actions possibles sur la clef.

Pour retrouver l'identifiant d'une clef, exécutez :

gpg --list-keys

ou, pour afficher également les empreintes des clefs :

gpg --fingerprint

Localisez la clef qui vous intéresse dans la liste. Au début de la première ligne lui correspondant (celle qui commence par "pub"), on a la longueur et le type de la clef (normalement 1024D), suivi d'une barre oblique puis de l'identifiant de la clef, ce qui donne quelque chose du genre :

pub   1024D/XXXXXXXX 2006-02-15 [expire: 2006-02-16]

Mettre à disposition sa clef publique

Il faut à présent que nos contacts puissent obtenir facilement notre clef publique. Vous pouvez tout simplement placer le fichier généré sur votre site, ou même l'envoyer aux personnes vous le demandant, mais la meilleure solution consiste à l'envoyer sur un serveur de clefs.

Exporter la clef

Si l'on veut simplement envoyer la clef au cas par cas, ou la mettre sur un site quelconque, il faut l'exporter dans un fichier :

gpg --export -a -o ma_clef.asc id_clef

où ma_clef.asc est le fichier où sera enregistrée votre clef publique, et id_clef l'identifiant de ladite clef publique.

Utiliser un serveur de clefs

Deux solutions s'offrent à nous pour mettre une clef sur un serveur de clefs.

Méthode HTTP

Une solution simple est de passer par l'interface web du serveur de clés, si elle existe. Par exemple depuis la page d'accueil de subkeys.pgp.net ou keyserver.net, cliquez sur "envoyer votre clef"i ("submit your key"), puis entrez simplement le chemin du fichier ma_clef.asc que vous venez de générer (ou copiez-collez son contenu, selon les serveurs) et envoyez (bouton "submit").

C'est facile, mais c'est tellement simple que ça vallait à peine le coup d'en parler !

Méthode gpg pur

Voyons maintenant la méthode "autonome", utilisant à 100% notre chère commande gpg.

Votre fichier ~/.gnupg/gpg.conf contient (à la ligne 112 chez moi, mais bon...) une liste de serveurs. Ce sont des lignes de la forme :

keyserver hkp://subkeys.pgp.net

Au départ il ne contient même que cette ligne-là. Libre à vous d'en ajouter. A noter que c'est le dernier serveur déclaré qui est utilisé par défaut.

La commande qui va envoyer votre clef sur le serveur est, si vous voulez utiliser le serveur par défaut de votre gpg.conf :

gpg --send-key id_clef

ou si vous voulez spécifier un serveur :

gpg --send-key --keyserver serveur id_clef

où serveur est l'adresse du serveur, de la forme protocole://nom_DNS (comme dans gpg.conf).

Importer et signer une clef

Maintenant que nous disposons d'un couple de clefs, et que nous avons mis à disposition notre clef publique, on va récupérer les clefs publiques des gens à qui l'on souhaite pouvoir envoyer des messages chiffrés (ou simplement signés).

Importer la clef

La première chose à faire est de télécharger et d'importer la clef.

Méthode "fichier"

On peut vous envoyer, ou vous inviter à télécharger un fichier contenant la clef publique à importer.

Une fois que l'on dispose de ce fichier, on place la clef publique dans notre trousseau par la commande :

gpg --import id_clef.asc

où id_clef.asc est le fichier en question.

Méthode gpg pur

On peut aussi simplement vous indiquer un serveur de clefs (on trouve souvent ce type de messages dans les signatures : « Ma clef publique se trouve sur http://keyserver.net »). Il y a deux cas : soit on vous donne l'identifiant de la clef (ou l'empreinte complète), soit vous disposez seulement de l'adresse ou du nom associés.

Dans le premier cas, tapez :

gpg --recv-key id_clef

si le serveur où la clef se trouve figure dans votre ~/.gnupg/gpg.conf, ou, si elle ne s'y trouve pas :

gpg --keyserver serveur --recv-key id_clef

Dans le second cas (vous ne disposez pas de l'identifiant de la clef), il va nous falloir chercher ce dernier :

gpg --search-key nom

où nom est un morceau du nom, du commentaire, ou de l'adresse (s'il contient des espaces, mettez le tout entre guillemets).

Comme d'habitude, si le serveur de clefs à utiliser ne figure pas dans votre fichier de configuration, utilisez plutôt :

gpg --keyserver serveur --search-key nom

Si la recherche fournit des résultats, une liste de clefs correspondant au critère de recherche apparaît, terminée par une ligne de la forme :

Keys 1-11 of 219 for "nom".  Entrez le(s) nombre(s), S)uivant, ou Q)uitter >

Si vous ne voyez pas la clef qui vous intéresse, entrez 's' pour afficher la page suivante. Lorsque vous la voyez, entrez son numéro (le nombre tout à gauche dans la liste), et validez. La clef est automatiquement téléchargée et importée.

Bien sûr vous pouvez aussi passer par l'interface web du serveur de clefs pour effectuer la recherche et télécharger un fichier contenant la clef, mais c'est moins amusant (cela revient à la première méthode).

Signer la clef

Si l'on a confiance dans l'origine de la clef et que l'on est certain de l'identité de son possesseur (typiquement, on l'a rencontré en personne et comparé les empreintes des clefs à cette occasion), on peut signer la clef avec sa propre clef privée :

gpg --sign-key id_clef

Vous aurez à confirmer, puis à entrer la phrase de passe de votre clef privée.

En général, on envoie au propriétaire de la clef le fichier contenant la signature, et il se chargera de mettre à jour sa clef sur un serveur de clefs si tel est son souhait. Ce fichier est créé en exportant la clef comme vu précédemment :

gpg --export -a -o clef.asc id_clef

Si le propriétaire de la clef vous le demande, vous pouvez aussi directement renvoyer la clef sur un serveur par la commande vue précédemment :

gpg --send-key id_clef

Dans tous les cas, signer une clef signifie que vous apportez votre garantie sur l'authenticité de la clef et l'identité de son possesseur.

Régler le niveau de confiance des clefs de vos correspondants

La commande suivante permet de démarrer GPG en mode interactif, afin d'accorder un niveau de confiance aux clefs que vous avez importées (et que vous n'avez pas traitées) :

gpg --update-trustdb

Pour chaque clef non configurée, GPG vous demandera quel niveau de confiance vous accordez à son utilisateur, et vous répondrez par un chiffre pour choisir le niveau voulu. N'accordez le plus haut niveau de confiance qu'aux gens que vous avez réellement rencontrés !

Mettre à jour le trousseau

De temps en temps, il est bon de mettre à jour les clefs de notre trousseau, afin de mettre à jour les signatures, les UID, mais aussi pour savoir su une clef a été révoquée. Pour cela, on utilise la commande suivante :

gpg --refresh-keys

ou, si on veut utiliser un autre serveur de clefs que celui qui est déclaré dans ~/.gnupg/gpg.conf :

gpg --refresh-keys --keyserver uri_du_serveur_de_clefs

Le serveur de clef par défaut, ou celui spécifié par l'option --keyserver, sera utilisé pour toutes les clefs qui n'ont pas spécifié de serveur préféré.

Signer des clefs en masse

Au cours d'une « keysigning party », on signe en général les clefs de nombreuses personnes. Pour faciliter la tâche, il existe des outils qui signent et envoient les signatures par courriel aux gens. Je décris ici l'utilisation de PIUS (PGP Individual UID Signer).

PIUS ne récupère pas automatiquement les clefs sur les serveurs de clefs, mais traite un trousseau local. On va donc créer un fichier contenant la liste des empreintes des clefs à signer, récupérer ces clefs sur un serveur de clefs, puis signer les clefs avec PIUS.

J'ai généré, à partir du fichier regroupant la liste des clefs (créé par l'organisateur de la keysigning party), un fichier contenant uniquement les empreintes des clefs des gens que j'ai rencontrés. Après avoir supprimé du fichier original les gens que vous n'avez pas rencontrés (ce qui donne un fichier gens.txt, supprimez toutes les informations inutiles à grands coups de grep et sed :

grep fingerprint gens.txt | \
  sed '{s/^.*fingerprint = // ; s/ \+//g}' >/tmp/clefs

On a donc généré un fichier /tmp/clefs qui contient la liste des empreintes. Il faut à présent récupérer les clefs sur un serveur de clefs et les enregistrer dans un trousseau à part, que nous nommerons ici keysigning.gpg :

touch ~/.gnupg/keysigning.gpg
gpg --keyserver keyserver.ubuntu.com --keyring=keysigning.gpg \
  --no-default-keyring --recv-keys $(cat /tmp/clefs)

Si toutes les clefs n'ont pas été récupérées avec succès, essayez un autre serveur de clefs.

On peut ensuite lancer PIUS, qui va se charger de signer les clefs, de préparer un mail et de l'envoyer à chaque UID présent dans chacune des clefs.

pius --signer id_clef --encrypt-outfiles \
  --mail 'Mon Nom <mon.adresse@example.com>' \
  --mail-host smtp.example.com --mail-user mon.user --mail-tls \
  --keyring ~/.gnupg/keysigning.gpg --all-keys

Les valeurs à remplacer sont :

• id_clef : votre clef.
• Mon Nom <mon.adresse@example.com> : l'émetteur des mails.
• smtp.example.com : votre serveur SMTP, utilisé pour l'envoi des mails.
• mon.user : le login du serveur SMTP.

L'option --mail-tls est facultative, supprimez-la si vous utilisez un serveur SMTP sans connexion sécurisée. Pour plus d'information sur les options :

man pius

PIUS vous demandera, pour chacune des clefs, de sélectionner un niveau de confiance. Bizarrement, les niveaux proposés (de 0 à 3) ne correspondent pas à ceux de GPG (de 1 à 5), j'ai donc sélectionné 3 pour chaque clef.

Si tout se passe bien, les mails seront correctement envoyés à chaque UID, et vous recevrez une copie.

Révoquer une clef

Si vous cessez d'utiliser une clef, par exemple parce qu'elle a été compromise (quelqu'un a forcé votre clef privée par exemple), il est préférable de créer un certificat de révocation.

gpg --gen-revoke id_clef > revoke_id_clef

Confirmez par 'o' que vous voulez bel et bien générer un certificat de révocation, puis donnez un motif pour la révocation. Vous avez ensuite le choix de renseigner une "description optionnelle", qui vous permet d'expliquer en long en large et en travers, avec force détails, les raisons qui vous ont poussé à commettre cet acte (de révocation). Comme on vous le demande, revenez à la ligne depuis une ligne vide pour terminer la description, dites que c'est d'accord, et enfin entrez la phrase de passe de la clef.

Nous voilà en possession d'un beau fichier revoke_id_clef contenant le certificat de révocation de notre clef. GnuPG vous invite à prendre moult précautions à son sujet.

Importez maintenant ce certificat par la commande :

gpg --import revoke_id_clef

afin de marquer la clef comme révoquée dans votre trousseau.

Si vous n'avez pas utilisé de serveur de clefs, vous pouvez mettre ce fichier à disposition comme bon vous semble, vos contacts devront eux aussi l'importer pour marquer la clef comme révoquée chez eux.

Dans le cas contraire, après avoir importé le certificat de révocation chez vous, renvoyez la clef sur le serveur comme expliqué plus haut (gpg --send-key). Vos contacts devront quant à eux réimporter la clef pour mettre à jour leur trousseau.

Supprimer une clef

Il est parfois utile de pouvoir supprimer une clef de votre trousseau, soit la clef publique de quelqu'un avec qui vous avez cessé de communiquer, soit une clef expirée ou révoquée, ou encore une paire de clefs vous appartenant mais que vous n'utilisez plus (dans ce dernier cas pensez avant tout à générer un certificat de révocation comme vu précédemment).

Pour supprimer une clef publique, tapez :

gpg --delete-key id_clef

Pour supprimer une clef privée, tapez :

gpg --delete-secret-key id_clef

Pour supprimer un couple de clefs (publique et privée), tapez :

gpg --delete-secret-and-public-key id_clef

Modifier une clef

On a parfois besoin de modifier les paramètres d'un couple de clefs, par exemple le mot de passe. Pour entrer dans le mode interactif d'édition de la clef, tapez :

gpg --edit-key id_clef

Après quelques informations relatives au programme, ainsi qu'à la clef, vous obtenez une invite :

Commande>

Tapez "help" ou '?' pour voir la liste des commandes disponibles. Par exemple pour changer la phrase de passe de la clef, la commande est passwd :

Commande> passwd

On vous demande l'ancienne phrase, puis deux fois la nouvelle.

Pour quitter le mode d'édition, tapez 'q', "quit", ou encore appuyez sur <Ctrl>+D. Si des modifications ont été effectuées, on vous demande si vous voulez les enregistrer. Répondez 'o' et voilà.

Commande> q
Enregistrer les changements? (o/N) o

Alternativement, la commande save permet de sauvegarder et quitter sans confirmation.

À noter qu'il est possible de lancer directement une commande dès l'appel du programme. Par exemple :

gpg --edit-key id_clef passwd

lance directement l'invite de changement de la phrase de passe.

Par contre, le programme reste dans le mode d'édition et il faut quitter comme précédemment.

Une fois les changements effectués, n'oubliez pas de renvoyer votre clef à vos correspondants ou à un serveur de clefs avec gpg --send-key (ce qui est tout de même plus simple).

Gestion des adresses (UID)

Pour chaque adresse de courriel supplémentaire que vous comptez utiliser avec cette clef, il faut ajouter un UID, avec l'adresse en question, le nom et éventuellement un commentaire associé.

La commande est adduid. GPG vous demandera donc, comme lors de la création de la clef, d'entrer le nom réel, l'adresse et le commentaire. Vous aurez besoin de la phrase de passe pour terminer l'ajout.

Une fois tous les utilisateurs ajoutés, vous pouvez les lister grâce à la commande uid, les sélectionner avec uid numéro (numéro étant le numéro de l'utilisateur dans la liste), et leur attribuer un niveau de confiance avec trust (le même niveau de confiance sera attribué à tous les utilisateurs sélectionnés).

À noter que les changements sur les niveaux de confiance n'apparaissent pas immédiatement, vous devrez d'abord sauvegarder et relancer l'interface.

Pour supprimer un UID, sélectionnez-le avec uid numéro, puis tapez deluid.

Conclusion

J'ai présenté ici les commandes les plus utiles pour une utilisation de base. Comme d'habitude, man est votre ami :

man gnupg
man gpg

Quelques petites remarques quand même :

• Les options de la forme --*-key peuvent généralement s'écrire --*-keys. Autrement dit le pluriel n'a souvent pas d'importance pour gpg.

• Pour éviter toute ambiguïté, il est possible d'utiliser d'autres méthode pour faire référence à une clef. En effet, il est possible que les huits derniers caractères des empreintes de deux clefs soient identiques. Partout où j'ai écrit "id_clef", on peut donc utiliser l'empreinte complète de la clef (sans espaces). Il y a d'autres possibilités : pour plus d'informations voyez la page de manuel de gpg, sous le titre « How to specify a user ID » (vers la fin).

• Il existe des interfaces graphiques à GnuPG, comme Seahorse pour Gnome ou Kgpg pour KDE. L'extension Enigmail de Thunderbird peut également permettre de gérer son trousseau.

Nous sommes maintenant fin prêts pour chiffrer ses courriels ou des conversations jabber.