cryptographie:gnupg [d2air]

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
====== Utilisation de GNU Privacy Guard ======
Ce logiciel est installé par défaut sous Linux, au moins sur Debian et Ubuntu. Vous devriez toujours préférer une implémentation OpenPGP libre. L’implémentation libre canonique d’OpenPGP est GnuPG, et elle est disponible pour tous les systèmes d’exploitation modernes et répandus.
Il existe une version 1 et une version 2, elles sont compatibles entre elles et utilisent les mêmes fichiers de configuration. À ma connaissance la différence principale entre elles est la gestion des cartes à puce, mais la version 2.1 de GnuPG ajoute [[https://www.gnupg.org/documentation/manuals/dirmngr/|dirmngr]], un gestionnaire de liste de révocation (CRLs).
===== Générer de l'entropie =====
==== RNG-Tools ====
Avant de générer des clefs, il est nécessaire de créer de l'entropie sur le système. Pour cela une des solutions est d'installer le paquet ''rng-tools'' (sous Debian).
<code>
sudo apt-get update && sudo apt-get install rng-tools
</code>
Pour configuer ''rng-tools'' il faut éditer le fichier ''/etc/default/rng-tools'', mais c'est normalement inutile celui-ci pouvant reconnaître seul les sources d'entropie. Il faudra surtout éviter de le configurer avec ''/dev/urandom'' comme source.
===== Configuration de GNUPG =====
Il existe un très bon guide sur [[https://help.riseup.net/fr/security/message-security/openpgp/best-practices|help.riseup.net]] et une mise en application du fichier de configuration sur le GIT [[https://github.com/ioerror/duraconf/|duraconf]]
==== Serveur de clés ====
Si les clés publiques ne sont pas régulièrement rafraîchis, nous ne serons pas informé à temps des expirations ou des révocations, or il faut absolument que vous soyons au courant de ce genre d’événements! Il y a deux étapes nécessaires pour recevoir les mises à jour de clés. Beaucoup d’utilisateurs envoient leurs mises à jour de clés à des serveurs de clés. Afin de récupérer ces mises à jour, nous devons d’abord nous assurer que nous utilisons un serveur de clés qui fonctionne correctement. Nous devons ensuite configurer notre machine pour recevoir les mises à jour de clés de façon régulière.
Nous utiliserons le [[https://sks-keyservers.net/overview-of-pools.php|groupe de serveur de clés sks]]. Le bon fonctionnement des machines de ce groupe est vérifié par des contrôles de routine réguliers. Si un serveur ne fonctionne pas bien, il sera automatiquement retiré du groupe. Nous devons aussi nous assurer que nous communiquons avec le groupe de serveurs de clés au travers d’un canal chiffré, en utilisant un protocole qui s’appelle ''hkps''. Pour utiliser ''hkps'', nous devons d’abord installer ''gnupg-curl'' :
<code>
sudo apt-get install gnupg-curl
</code>
Ensuite, pour utiliser le groupe de serveurs de clés, il faut télécharger [[https://sks-keyservers.net/sks-keyservers.netCA.pem|l’autorité de certification de sks-keyservers.net]]
<code>
cd; curl -O https://sks-keyservers.net/sks-keyservers.netCA.pem
sudo cp sks-keyservers.netCA.pem /usr/share/ca-certificates/
echo sks-keyservers.netCA.pem | sudo tee -a /etc/ca-certificates.conf
sudo update-ca-certificates
</code>
Il faudra ensuite utiliser les paramètres suivants dans ''~/.gnupg/gpg.conf'' et spécifier le chemin d’accès complet où vous avez sauvegardé le fichier de l'autorité de certification :
<file sh gpg.conf>
keyserver hkps://hkps.pool.sks-keyservers.net
keyserver-options ca-cert-file=/etc/ssl/certs/sks-keyservers.netCA.pem.pem
</file>
Pour les versions supérieures à la 2.1 de GnuPG, il faut enlever l'option devenue obsolète ''ca-cert-file'' du fichier ''gpg.conf'' et ajouter sa remplaçante ''hkp-cacert'' en bas du fichier ''dirmngr.conf''.
<file sh dirmngr.conf>
hkp-cacert /etc/ssl/certs/sks-keyservers.netCA.pem.pem
</file>
Avec cette configuration les interactions avec le serveur de clés seront chiffrées avec ''hkps'', qui masquera notre réseau de relations sociales pour éviter qu’il soit divulgué à quiconque intercepterait le trafic réseau. Par exemple, si vous faites ''gpg --refresh-keys'' sur un serveur de clés qui ne supporte que ''hkp'', quelqu’un surveillant le trafic pourrait voir toutes les clés que nous possédons dans notre trousseau en observant les demandes de mises à jour envoyées pour chacune d’entre elles. C’est là une information plutôt intéressante!
Note : [[hkps://keys.indymedia.org|hkps://keys.indymedia.org]], [[hkps://keys.mayfirst.org|hkps://keys.mayfirst.org]] et [[hkps://keys.riseup.net|hkps://keys.riseup.net]] sont d’autres serveurs qui proposent ce service mais il est préférable de leur préférer un groupe de serveurs.
=== Forcer l'utilisation de notre serveur ===
Un utilisateur qui crée sa clé peut indiquer un serveur de clés spécifique auquel s’adresser pour récupérer les nouvelles versions de sa clé. Il est recommandé d’utiliser l’option suivante dans ''~/.gnupg/gpg.conf'', qui ignorera de telles instructions :
<file sh gpg.conf>
keyserver-options no-honor-keyserver-url
</file>
C’est une bonne chose à faire car
  - ça évite que les gens indiquent des méthodes non-sécurisées pour télécharger des mises à jour de leurs clés et
  - même si le serveur choisi utilise ''hkps'', le rafraîchissement échouera parce que le ''ca-cert'' ne correspondra pas, donc la clé ne sera jamais mise à jour.
  - Notez aussi qu’un attaquant pourrait désigner un serveur de clés sous son contrôle afin de surveiller à quel moment et depuis quel endroit nous rafraîchissons les clés.
=== Rafraîchir automatiquement les clefs  ===
Nous devons nous assurer que les clés se rafraîchissent régulièrement. La meilleure façon de le faire avec Debian ou Ubuntu est d’utiliser ''parcimonie'' :
<code>
sudo apt-get install parcimonie
</code>
[[https://gaffer.ptitcanardnoir.org/intrigeri/code/parcimonie/|Parcimonie]] est un démon qui rafraîchit lentement votre trousseau de clés à partir d’un serveur de clés en passant par [[https://www.torproject.org/|Tor]]. Il utilise un délai aléatoire, et un nouveau circuit Tor pour chaque clé. Le but est de compliquer la vie d’un attaquant qui voudrait corréler les mises à jour de clés avec votre trousseau.
Vous ne devriez pas utiliser ''gpg --refresh-keys'' ou la fonction équivalente de votre client de messagerie pour rafraîchir les clés, parce que vous dévoilerez ainsi à toute personne qui vous écoute, et à l’opérateur du serveur de clés, la totalité des clés que vous désirez rafraîchir.
=== Ne pas faire confiance aux serveurs de clefs ===
N’importe qui peut envoyer des clés sur les serveurs et il n’y a pas de raison de croire que celles que vous téléchargez appartiennent vraiment à la personne dont elles indiquent le nom. Nous devons donc vérifier personnellement avec le propriétaire l’empreinte entière de sa clé. Nous devrons faire cette vérification face à face ou par téléphone. Une fois que nous aurons vérifié l’empreinte, nous pourrons télécharger la bonne clé depuis un serveur :
<code>
gpg --recv-key '<fingerprint>'
</code>
Attention aux apostrophes droites ci-dessus (‘) qu’il faut placer autour de l'empreinte complète et qui sont nécessaires pour que la commande fonctionne. Les guillemets droits (") fonctionnent également.
Ne vous fiez pas à l’identifiant de clé
=== Méfiance avec l'identifiant de la clef ===
Les identifiants courts pour les clés OpenPGP, par exemple 0×2861A790, sont d’une longueur de 32 bits. Il fut démontré la [[http://www.asheesh.org/note/debian/short-key-ids-are-bad-news.html|possibilité de les usurper]] avec une autre clé qui a le même identifiant. Les identifiants longs pour les clés OpenPGP (par exemple 0xA1E6148633874A3D) sont d’une longueur de 64 bits. Il est [[http://thread.gmane.org/gmane.ietf.openpgp/7413|trivial]] de générer des collisions dessus, ce qui est également un [[https://www.debian-administration.org/users/dkg/weblog/105|problème potentiellement sérieux]]. L'utilisation du ''fingerprint'' est préférable.

==== Le fichier gpg.conf ====
La configuration utilisateur se fait dans le fichier ''gpg.conf'' du répertoire par défaut de l'application. Si ce fichier n'existe pas il faut le créer et lui attribuer des droits limités :
<code>
nano ~/.gnupg/gpg.conf
chmod 600 ~/.gnupg/gpg.conf
</code>
<file sh gpg.conf>
#
# This is an implementation of the Riseup OpenPGP Best Practices
# https://help.riseup.net/en/security/message-security/openpgp/best-practices
#


#-----------------------------
# default key
#-----------------------------

# The default key to sign with. If this option is not used, the default key is
# the first key found in the secret keyring

#default-key 0xD8692123C4065DEA5E0F3AB5249B39D24F25E3B6


#-----------------------------
# behavior
#-----------------------------

# Disable inclusion of the version string in ASCII armored output
no-emit-version

# Disable comment string in clear text signatures and ASCII armored messages
no-comments

# Display long key IDs
keyid-format 0xlong

# List all keys (or the specified ones) along with their fingerprints
with-fingerprint

# Display the calculated validity of user IDs during key listings
list-options show-uid-validity
verify-options show-uid-validity

# Try to use the GnuPG-Agent. With this option, GnuPG first tries to connect to
# the agent before it asks for a passphrase.
use-agent


#-----------------------------
# keyserver
#-----------------------------

# This is the server that --recv-keys, --send-keys, and --search-keys will
# communicate with to receive keys from, send keys to, and search for keys on
keyserver hkps://hkps.pool.sks-keyservers.net

# Provide a certificate store to override the system default
# Get this from https://sks-keyservers.net/sks-keyservers.netCA.pem
# Comment this option for GnuPG 2.1 and higher versions
keyserver-options ca-cert-file=/etc/ssl/certs/sks-keyservers.netCA.pem.pem

# Set the proxy to use for HTTP and HKP keyservers - default to the standard
# local Tor socks proxy
# It is encouraged to use Tor for improved anonymity. Preferrably use either a
# dedicated SOCKSPort for GnuPG and/or enable IsolateDestPort and
# IsolateDestAddr
#keyserver-options http-proxy=socks5-hostname://127.0.0.1:9050

# Don't leak DNS, see https://trac.torproject.org/projects/tor/ticket/2846
# keyserver-options no-try-dns-srv (no-try-dns-srv in now deprecated)

# When using --refresh-keys, if the key in question has a preferred keyserver
# URL, then disable use of that preferred keyserver to refresh the key from
keyserver-options no-honor-keyserver-url

# When searching for a key with --search-keys, include keys that are marked on
# the keyserver as revoked
keyserver-options include-revoked


#-----------------------------
# algorithm and ciphers
#-----------------------------

# list of personal digest preferences. When multiple digests are supported by
# all recipients, choose the strongest one
personal-cipher-preferences AES256 AES192 AES CAST5

# list of personal digest preferences. When multiple ciphers are supported by
# all recipients, choose the strongest one
personal-digest-preferences SHA512 SHA384 SHA256 SHA224

# message digest algorithm used when signing a key
cert-digest-algo SHA512

# This preference list is used for new keys and becomes the default for
# "setpref" in the edit menu
default-preference-list SHA512 SHA384 SHA256 SHA224 AES256 AES192 AES CAST5 ZLIB BZIP2 ZIP Uncompressed
</file>
==== Le fichier dirmngr.conf ====
Pour les versions supérieures à la 2.1 de GnuPG, il faut ajouter en bas du fichier ''dirmngr.conf'' la ligne suivante :
<file sh dirmngr.conf>
hkp-cacert /etc/ssl/certs/sks-keyservers.netCA.pem.pem
</file>
===== Configuration de la clef =====
==== Clef primaire robuste ====
Il est recommandé de générer une clé RSA de 4096 bits avec l’algorithme de hachage SHA-512.
==== Transition d'une ancienne clef ====
En cas transition, une méthode est de rédiger un [[https://riseup.net/fr/security/message-security/openpgp/key-transition|communiqué de transition]] signé par les deux clés, puis en informer les gens. [[http://ekaia.org/blog/2009/05/10/creating-new-gpgkey/|Cette page]] détaille le processus à suivre pour générer une telle clé en s’assurant d’utiliser le bon algorithme de hachage (ça peut être compliqué avec des versions de GnuPG plus anciennes que la 1.4.10).
==== Délai d'expiration ====
Mettre une date d’expiration sur sa clé est une bonne chose. Pourquoi? Parce que vous pouvez toujours étendre votre date d’expiration, même une fois qu’elle est passée! Cette expiration est plutôt une sorte de valve de sûreté ou un ''dispositif de l’homme mort'' qui se déclenchera automatiquement à un certain moment. Si vous avez accès à la clé privée, vous pouvez le désamorcer. L’idée est de configurer un mécanisme qui désactivera votre clé au cas où vous n’y accéderiez plus (et ne disposez pas d’un certificat de révocation).
Paramétrer une date d’expiration vous obligera à repousser cette date quand elle approchera. C’est une petite chose que vous devrez vous souvenir de faire .

Vous pouvez penser que c’est pénible et que vous ne voulez pas vous en occuper, mais c’est en fait une bonne chose de faire cela de façon régulière pour maintenir à niveau vos compétences OpenPGP. Cela indique aux utilisateurs que la clé est toujours active, que le détenteur de la clé l’utilise toujours, et cela vous donne une occasion de vérifier l’état actuel de vos outils, et vos bonnes pratiques. Du reste, beaucoup de personnes refuseront de signer une clé qui n’a pas de date d’expiration!

Si vous avez déjà généré une clé sans date d’expiration, vous pouvez en spécifier une sur votre clé existante en utilisant la commande suivante :
<code>
gpg --edit-key '<fingerprint>'
</code>
À présent, sélectionnez la sous-clé pour laquelle vous voulez paramétrer une date d’expiration (par exemple la première), ou aucune pour paramétrer l’expiration de votre clé primaire, puis invoquez la commande "expire" :
<code>
gpg> key 1
gpg> expire
</code>
Ajustez ensuite la date à une valeur raisonnable (par exemple deux ans plus tard), puis sauvegardez la clé et quittez
<code>
Key is valid for? (0) 2y 
gpg> save
</code>
Vous pouvez alors envoyer votre clé aux serveurs de clés pour publier ce changement :
<code>
gpg --send-key '<fingerprint>'
</code>
==== Générer une paire de clefs ====
<code>
gpg2 --gen-key 
gpg (GnuPG) 2.0.28; Copyright (C) 2015 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

Sélectionnez le type de clef désiré :
   (1) RSA et RSA (par défaut)
   (2) DSA et Elgamal
   (3) DSA (signature seule)
   (4) RSA (signature seule)
Quel est votre choix ? 1
les clefs RSA peuvent faire une taille comprise entre 1024 et 4096 bits.
Quelle taille de clef désirez-vous ? (2048) 4096
La taille demandée est 4096 bits
Veuillez indiquer le temps pendant lequel cette clef devrait être valable.
         0 = la clef n'expire pas
      <n>  = la clef expire dans n jours
      <n>w = la clef expire dans n semaines
      <n>m = la clef expire dans n mois
      <n>y = la clef expire dans n ans
Pendant combien de temps la clef est-elle valable ? (0) 2y
La clef expire le mar. 31 oct. 2017 23:59:59 CET
Est-ce correct ? (o/N) o

GnuPG doit construire une identité pour identifier la clef.

Nom réel : John Doe
Adresse électronique : john@domaine.eu
Commentaire : 
Vous avez sélectionné cette identité :
    « John Doe <john@domaine.eu> »

Faut-il modifier le (N)om, le (C)ommentaire, l'(A)dresse électronique
ou (O)ui/(Q)uitter ? O
Une phrase secrète est nécessaire pour protéger votre clef secrète.

De nombreux octets aléatoires doivent être générés. 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'obtenir suffisamment d'entropie.
De nombreux octets aléatoires doivent être générés. 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'obtenir suffisamment d'entropie.
gpg: clef 0xA0B00000000000FF marquée de confiance ultime.
les clefs publique et secrète ont été créées et signées.

gpg: vérification de la base de confiance
gpg: 3 marginale(s) nécessaire(s), 1 complète(s) nécessaire(s),
     modèle de confiance PGP
gpg: profondeur : 0  valables :   1  signées :   0
     confiance : 0 i., 0 n.d., 0 j., 0 m., 0 t., 1 u.
gpg: la prochaine vérification de la base de confiance aura lieu le 2017-10-31
pub   4096R/0xA0B00000000000FF 2015-11-01 [expire : 2017-10-31]
      Empreinte de la clef = A0B0 00FF 0000 FF00 1111  1111 A0B0 0000 0000 00FF
uid                [  ultime ] John Doe <john@domaine.eu>
sub   4096R/0xB0FFFFFFFFFFFF00 2015-11-01 [expire : 2017-10-31]
</code>
=== Base de confiance ===
Les clés sont identifiées par une valeur hexadécimale. 0xA0B00000000000FF est notre clé maîtresse et nous lui accordons une confiance ultime (donc au-delà de "complète" et de "marginale") puisqu'il s'agit de notre propre clé. GnuPG rappelle aussi les règles (le modèle de confiance) utilisées par défaut pour considérer une clé publique comme valide, une clé doit être signée par un utilisateur à qui nous accordons une confiance "complète" ou par trois utilisateurs à qui nous accordons une confiance "marginale". Notre clé publique est considérée comme valide puisque nous lui accordons une confiance ultime, ''1 u.'' sur la dernière ligne du code ci-dessous :
<code>
gpg: 3 marginale(s) nécessaire(s), 1 complète(s) nécessaire(s),
     modèle de confiance PGP
gpg: profondeur : 0  valables :   1  signées :   0
     confiance : 0 i., 0 n.d., 0 j., 0 m., 0 t., 1 u.
</code>
Le niveau de confiance est précisé avec la nomenclature :
  * i. : inconnu (non calculable)
  * n.d. : non décidé, pas d'avis, je ne sais pas
  * j. : aucune, pas de confiance
  * m. : confiance marginale
  * t. : confiance totale ou complète
  * u. : confiance ultime
Ces informations peuvent s'afficher avec la commande :
<code>
gpg2 --check-trustdb
</code>
=== Sous-clef générée ===
La dernière ligne de sortie de la commande ''gpg2 --gen-key'' indique la création d'une sous clé notée **sub**.
<code>
sub   4096R/0xB0FFFFFFFFFFFF00 2015-11-01 [expire : 2017-10-31]
</code>
Il faut utiliser la commande ''gpg2 --edit-key'' pour obtenir plus d'informations :
<code>
gpg2 --edit-key 'A0B000FF0000FF0011111111A0B00000000000FF'
La clef secrète est disponible.

pub  4096R/0xA0B00000000000FF  créé : 2015-11-01  expire : 2017-10-31  utilisation : SC  
                               confiance : ultime        validité : ultime
sub  4096R/0xB0FFFFFFFFFFFF00  créé : 2015-11-01  expire : 2017-10-31  utilisation : E   
[  ultime ] (1). John Doe <john@domaine.eu>
</code>
Le champ **utilisation** nous indique l'usage possible avec ces clés.
  * C : certificate ou signer la clé publique d'un utilisateur
  * S : signer un document (mail, fichier...)
  * E : chiffrer un document
  * A : authentification (SSH, TLS...) 
Pour voir les clefs privées associées, il faut utiliser la commande ''toggle''.

Avec la commande de génération de clés, GnuPG ne crée pas une paire mais deux. La première est utilisable pour signer d'autres clés ainsi que des documents mais c'est une sous-clé (subkey ou clé subordonnée) qui est utilisée pour chiffrer.

Pourquoi? Pour des raisons de sécurité mais surtout de praticité, tout le fonctionnement du réseau de confiance repose sur la signature des clefs publiques des utilisateurs. Si la clé de chiffrement est corrompue (par exemple un attaquant souhaitant lire nos messages et qui réussit) elle pourra être révoquée et une nouvelle pourra être créer, cette nouvelle clé sera rattachée à la clé maîtresse qui ne sera pas corrompue (enfin normalement) et il ne sera pas nécessaire de reconstruire les signatures sur la clé publique détruisant par la même le réseau de confiance. 

GnuPG fait cela par défaut avec les options 1 et 2 du processus de génération de clefs de la commande ''gpg2 --gen-key''. Les options 3 et 4 de ce processus permettent de créer une seule et unique paire maîtresse.
=== Générer une seconde sous-clef ===
Après la génération d'une paire de clés, nous disposons d'une paire de clés maîtresse et d'une sous-clef pour le chiffrement. L'idée est ici de créer une nouvelle sous-clé pour la signature des documents afin de ne pas avoir à utiliser la clé principale pour autre chose que la signature d'autres clés publiques, cette tâche ne pouvant pas être déléguée à une sous-clé. 
<code>
gpg2 --edit-key 'A0B000FF0000FF0011111111A0B00000000000FF'
gpg (GnuPG) 2.0.28; Copyright (C) 2015 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

La clef secrète est disponible.

pub  4096R/0xA0B00000000000FF  créé : 2015-11-01  expire : 2017-10-31  utilisation : SC  
                               confiance : ultime        validité : ultime
sub  4096R/4096R/0xB0FFFFFFFFFFFF00  créé : 2015-11-01  expire : 2017-10-31  utilisation : E   
[  ultime ] (1). John Doe <john@domaine.eu>

gpg> addkey
La clef est protégée.

Une phrase secrète est nécessaire pour déverrouiller la clef secrète de
l'utilisateur : « John Doe <john@domaine.eu> »
clef RSA de 4096 bits, identifiant 0xA0B00000000000FF, créée le 2015-11-01

Sélectionnez le type de clef désiré :
   (3) DSA (signature seule)
   (4) RSA (signature seule)
   (5) Elgamal (chiffrement seul)
   (6) RSA (chiffrement seul)
Quel est votre choix ? 4
les clefs RSA peuvent faire une taille comprise entre 1024 et 4096 bits.
Quelle taille de clef désirez-vous ? (2048) 4096
La taille demandée est 4096 bits
Veuillez indiquer le temps pendant lequel cette clef devrait être valable.
         0 = la clef n'expire pas
      <n>  = la clef expire dans n jours
      <n>w = la clef expire dans n semaines
      <n>m = la clef expire dans n mois
      <n>y = la clef expire dans n ans
Pendant combien de temps la clef est-elle valable ? (0) 2y
La clef expire le mar. 31 oct. 2017 23:59:59 CET
Est-ce correct ? (o/N) o
Faut-il vraiment la créer ? (o/N) o
De nombreux octets aléatoires doivent être générés. 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'obtenir suffisamment d'entropie.

ppub  4096R/0xA0B00000000000FF  créé : 2015-11-01  expire : 2017-10-31  utilisation : SC  
                               confiance : ultime        validité : ultime
sub  4096R/4096R/0xB0FFFFFFFFFFFF00  créé : 2015-11-01  expire : 2017-10-31  utilisation : E   
sub  4096R/0xB0FFFFFFFFFFFF22  créé : 2015-11-01  expire : 2017-10-31  utilisation : S   
[  ultime ] (1). John Doe <john@domaine.eu>
</code>
=== Préférences des clefs ===
Il est possible de vérifier et de définir les préférences d'utilisation des algorithmes de chiffrement, de hachage et de compression directement pour chaque clef avec ces commandes :
<code>
gpg2 --edit-key 'A0B000FF0000FF0011111111A0B00000000000FF'
gpg (GnuPG) 2.0.28; Copyright (C) 2015 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

La clef secrète est disponible.

pub  4096R/0xA0B00000000000FF  créé : 2015-11-01  expire : 2017-10-31  utilisation : SC  
                               confiance : ultime        validité : ultime
sub  4096R/4096R/0xB0FFFFFFFFFFFF00  créé : 2015-11-01  expire : 2017-10-31  utilisation : E   
sub  4096R/0xB0FFFFFFFFFFFF22  créé : 2015-11-01  expire : 2017-10-31  utilisation : S   
[  ultime ] (1). John Doe <john@domaine.eu>

gpg> showpref
[  ultime ] (1). John Doe <john@domaine.eu>
     Chiffrement : AES256, AES192, AES, CAST5, 3DES
     Hachage : SHA512, SHA384, SHA256, SHA224, SHA1
     Compression : ZLIB, BZIP2, ZIP, Non compressé
     Fonctionnalités : MDC, Serveur de clefs sans modification

gpg> setpref SHA512 SHA384 SHA256 SHA224 AES256 AES192 AES CAST5 ZLIB BZIP2 ZIP Uncompressed
Définir la liste de préférences en :
     Chiffrement : AES256, AES192, AES, CAST5, 3DES
     Hachage : SHA512, SHA384, SHA256, SHA224, SHA1
     Compression : ZLIB, BZIP2, ZIP, Non compressé
     Fonctionnalités : MDC, Serveur de clefs sans modification
Faut-il vraiment mettre à jour les préférences ? (o/N) 
</code>
Les algorithmes 3DES (chiffrement) et [[https://debian-administration.org/users/dkg/weblog/48|SHA1]] (hachage) ne doivent être plus être utilisés. Ils doivent se trouver à la fin des préférences d'utilisation, à cause de la [[https://lists.gnupg.org/pipermail/gnupg-devel/2009-May/024964.html|RFC 4880]] il est impossible de les enlever même avec la commande des préférences recommandées excluant ceux-ci :
<code>
setpref SHA512 SHA384 SHA256 SHA224 AES256 AES192 AES CAST5 ZLIB BZIP2 ZIP Uncompressed
</code>
==== Ajouter une alerte dans le calendrier ====
Il vaut mieux paramétrer une alerte dans un agenda pour nous rappeler la date d’expiration, si possible avant la date, afin de pouvoir faire le changement un peu en avance. Cependant il sera toujours possible de reporter la date d’expiration de la clé même après son expiration.
==== Certificat de révocation ====
La génération d'un certificat de révocation est un étape importante dans la création de clés. En cas d'oubli de la phrase de passe ou si la clé privée est compromise ou perdue, il faudra attendre que la clé expire sauf si avec un certificat de révocation qui pourra être publier sur les serveurs de clés pour signaler aux autres utilisateurs que la clé a été révoquée.

Une clé révoquée peut encore être utilisée pour vérifier ses anciennes signatures ou pour déchiffrer des données (à condition d'avoir accès à la clé privée), mais elle ne peut plus être utilisée pour chiffrer de nouveaux messages à notre intention.
<code>
gpg --output revoke.asc --gen-revoke '<fingerprint>'
</code>
Ce qui donne avec notre clef :
<code>
gpg2 --output revoke.asc --gen-revoke 'A0B000FF0000FF0011111111A0B00000000000FF'

sec  4096R/0xAABBCCDDEEFF0011 2015-11-01 John Doe <john@domaine.eu>

Faut-il créer un certificat de révocation pour cette clef ? (o/N) o
choisissez la cause de la révocation :
  0 = Aucune raison indiquée
  1 = La clef a été compromise
  2 = La clef a été remplacée
  3 = La clef n'est plus utilisée
  Q = Annuler
(Vous devriez sûrement sélectionner 1 ici)
Quelle est votre décision ? 0
Entrez une description facultative, en terminant par une ligne vide :
> 
Cause de révocation : Aucune raison indiquée
(Aucune description donnée)
Est-ce d'accord ? (o/N) o

Une phrase de passe est nécessaire pour déverrouiller la clef secrète de
l'utilisateur : « John Doe <john@domaine.eu> »
clef RSA de 4096 bits, identifiant 0xAABBCCDDEEFF0011, créée le 2015-11-01

gpg: gpg-agent n'est pas disponible dans cette session
sortie forcée avec armure ASCII.
Certificat de révocation créé.

Veuillez le déplacer sur un support que vous pouvez cacher ; toute personne
accédant à ce certificat peut l'utiliser pour rendre votre clef inutilisable.
Imprimer ce certificat et le stocker ailleurs est une bonne idée, au cas où le
support devienne illisible. Attention quand même : le système d'impression
utilisé pourrait stocker ces données et les rendre accessibles à d'autres.
</code>
=== Révocation d'une sous-clef ===
Révoquer une sous-clé ne nécessite pas de certificat de révocation, cela peut se faire directement depuis l'interface interactive avec la commande ''gpg2 --edit-keys'' suivi de l'identifiant de la clé maîtresse. Il faudra ensuite utiliser la commande ''key'' avec la valeur de sa position (la position se compte à partir de 0) pour sélectionner la sous-clé et puis ensuite la commande ''revkey''.
<code>
gpg2 --edit-key 'A0B000FF0000FF0011111111A0B00000000000FF'                    
gpg (GnuPG) 2.0.28; Copyright (C) 2015 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

La clef secrète est disponible.

pub  4096R/0xA0B00000000000FF  créé : 2015-11-01  expire : 2017-10-31  utilisation : SC  
                               confiance : ultime        validité : ultime
sub  4096R/4096R/0xB0FFFFFFFFFFFF00  créé : 2015-11-01  expire : 2017-10-31  utilisation : E   
[  ultime ] (1). John Doe <john@domaine.eu>

gpg> key 1

pub  4096R/0xA0B00000000000FF  créé : 2015-11-01  expire : 2017-10-31  utilisation : SC  
                               confiance : ultime        validité : ultime
sub*  4096R/0xB0FFFFFFFFFFFF00  créé : 2015-11-01  expire : 2017-10-31  utilisation : E   
[  ultime ] (1). John Doe <john@domaine.eu>

gpg> revkey
Voulez-vous vraiment révoquer cette sous-clef ? (o/N) 
</code>
Le caractère ''*'' placé sur la ligne de la sous-clé après **sub** indique qu'elle est bien sélectionnée.
==== Utilisation sans clefs primaires ====
La clé primaire est nécessaire que pour la certification (signature de clefs publiques), cette tache se réalise peu fréquemment. Il est possible de supprimer la clé secrète afin de n'utiliser que les sous-clés pour le chiffrement et la signature de documents.  
=== Sauvegarde des clefs ===
Il est recommandé de faire avant toutes manipulations une copie du répertoire ''~/.gnupg/'' :
<code>
cd; tar cjvf gnupg-`date +%Y%m%d`.tbz2 ~/.gnupg
</code>
=== Exportation des clefs ===
Il faut exporter les clefs dans des fichiers :
<code>
gpg2 --armor --export 0xA0B00000000000FF > clepublique.asc
gpg2 --armor --export-secret-key 0xA0B00000000000FF > clesecrete.asc
gpg2 --armor --export-secret-subkeys 0xA0B00000000000FF > sousclessecretes.asc
</code>
Avec ces commandes, la clef publique est exportée dans le fichier ''clepublique.asc'', la clé privée dans le fichier ''clesecrete.asc'' et les clés secrètes des sous-clés dans le fichier ''sousclessecretes.asc''. La commande ''--armor'' n'est pas obligatoire mais elle permet d'imprimer les fichiers produits en les créant en ASCII. Aucun mot de passe est demandé à l'exportation des clés secrètes car elles sont exportées crypter.
=== Suppression des clefs secrètes ===
Après les avoir sauvegardées, il faut maintenant supprimer les clés secrètes de notre trousseau :
<code>
gpg2 --delete-secret-keys 0xA0B00000000000FF                               
gpg (GnuPG) 2.0.28; Copyright (C) 2015 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.


sec  4096R/0xA0B00000000000FF 2015-11-01 John Doe <john@domaine.eu>

Faut-il supprimer cette clef du porte-clefs ? (o/N) o
C'est une clef secrète — faut-il vraiment la supprimer ? (o/N) o
</code>
La commande ''gpg2 --list-secret-keys'' confirmera la suppression par une sortie vide.
=== Réimporter les sous-clefs secrètes ===
Afin de pouvoir utiliser notre configuration uniquement avec des sous-clés nous devons les réimporter :
<code>
gpg2 --import sousclesecrete.asc 
gpg: clef 0xAAAAAAAAFFFFFFFF : clef secrète importée
gpg: clef 0xAAAAAAAAFFFFFFFF : « John Doe <john@domaine.eu> » n'est pas modifiée
gpg: Quantité totale traitée : 1
gpg:              non modifiées : 1
gpg:       clefs secrètes lues : 1
gpg:   clefs secrètes importées : 1
</code>
La commande ''gpg2 --list-secret-keys'' affichera :
<code>
gpg2 --list-secret-keys
/home/john/.gnupg/secring.gpg
------------------------------
sec#  4096R/0xA0B00000000000FF 2015-11-01 [expire : 2017-10-31]
      Empreinte de la clef = AAAA BBBB CCCC DDDD EEEE  FFFF 0000 1111 2222 3333
uid                            John Doe <john@domaine.eu>
ssb   4096R/0xB0FFFFFFFFFFFF00 2015-11-01
ssb   4096R/0xB0FFFFFFFFFFFF22 2015-11-01
</code>
Le caractère ''#'' placé sur la ligne de la clé privée après **sec** indique qu'elle n'est pas disponible mais les deux sous-clefs privées sont bien présentes. Cette configuration peut être utiliser pour chiffrer et signer des documents.

En éditant la clef des fonctionnalités ne seront plus disponibles à cause de l'absence de la clef privée maîtresse, par exemple :
<code>
gpg> addkey
Les parties secrètes de la clef principale ne sont pas disponibles.
gpg: Échec de génération de la clef : Pas de clef secrète
</code>
=== Configuration alternative externe ===
Pour éviter de manipuler l'importation et l'exportation de fichiers pour les opérations de signature de clefs ou de création de sous-clés, il est possible de créer sur un support amovible (disque, clef USB...) une autre configuration de GnuPG. Je recommande de faire cela sur un volume crypté avec [[https://veracrypt.codeplex.com/|VeraCrypt]].
<code>
gpg2 --home=/media/veracrypt1 --import clepublique.asc clesecrete.asc 
gpg: Attention : les droits du répertoire personnel « /media/veracrypt1 »
            ne sont pas sûrs
gpg: le porte-clefs « /media/veracrypt1/secring.gpg » a été créé
gpg: le porte-clefs « /media/veracrypt1/pubring.gpg » a été créé
gpg: /media/veracrypt1/trustdb.gpg : base de confiance créée
gpg: clef 000000FF : clef publique « John Doe <john@domaine.eu> » importée
gpg: clef 000000FF : clef secrète importée
gpg: clef 000000FF : « John Doe <john@domaine.eu> » n'est pas modifiée
gpg: Quantité totale traitée : 2
gpg:               importées : 1  (RSA: 1)
gpg:              non modifiées : 1
gpg:       clefs secrètes lues : 1
gpg:   clefs secrètes importées : 1
</code>
Pour supprimer l'avertissement de cette sortie ''gpg: Attention : les droits du répertoire personnel « /media/veracrypt1 » ne sont pas sûrs'' il faut accorder des permissions en lecture et écriture uniquement à l'utilisateur courant (nous).
<code>
chmod 700 /media/veracrypt1
</code>
=== Utilisation du répertoire alternatif ===
Il est possible d'utiliser ce répertoire seulement comme avec ''.gnupg'' mais aussi avec celui ci. Pour ce type d'utilisation, par exemple pour modifier sa clé ou signer celle d'un autre utilisateur il suffit de monter la volume contenant notre répertoire alternatif.
Pour éditer notre clef avec les deux répertoires la commande est la suivante :
<code>
gpg2 --home=/media/veracrypt1 --keyring ~/.gnupg/pubring.gpg --secret-keyring ~/.gnupg/secring.gpg --trustdb-name ~/.gnupg/trustdb.gpg --edit-key 'A0B000FF0000FF00111111110000AAAAFFFFFFFF'
gpg (GnuPG) 2.0.28; Copyright (C) 2015 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

La clef secrète est disponible.

pub  4096R/000000FF  créé : 2015-11-01  expire : 2017-10-31  utilisation : SC  
                               confiance : ultime        validité : ultime
sub  4096R/FFFFFF00  créé : 2015-11-01  expire : 2017-10-31  utilisation : E   
sub  4096R/FFFFFF22  créé : 2015-11-01  expire : 2017-10-31  utilisation : S   
[  ultime ] (1). John Doe <john@domaine.eu>

gpg> 
</code>
Toutes les opérations nécessitant la clé privée principale deviennent possibles, mais attention car tous les changements se feront dans le répertoire alternatif ''/media/veracrypt1'', ainsi l'ajout d'une sous clé devra être répercuté manuellement dans le répertoire courant.
<code>
gpg2 --home=/media/veracrypt1 --armor --export 0xA0B00000000000FF > maj-clepublique.asc
</code>
Attention cette commande mettra à jour que la partie publique des clés. Il faudra faire la même opération pour les clés privées mais il existe un **problème de fusion des sous-clés**, il n'existe pas de mise à jour des sous-clés secrètes. Pour contrer ce problème il faut effacer toutes les clés privées du répertoire courant (celui sans la clé privée maîtresse) puis exporter les sous-clés secrètes du répertoire alternatif pour les importer dans le répertoire courant.
<code>
gpg2 --delete-secret-keys 0xA0B00000000000FF
gpg2 --home=/media/veracrypt1 --armor --export-secret-subkeys 0xA0B00000000000FF > maj-sousclesecrete.asc
gpg2 --import maj-sousclesecrete.asc
</code>
==== Publication de la clef publique ====
Pour publier la clef publique, il faut utiliser la commande :
<code>
gpg --send-keys 0xA0B00000000000FF
</code> 
===== Usage des clefs  =====
==== Certification d'une clef publique  ====
Pour signer une clef publique avec le répertoire alternatif, après avoir vérifier le fingerprint avec le correspondant, il faut utiliser la commande pour éditer la clef :
<code>
gpg --home=/media/veracrypt1 --keyring ~/.gnupg/pubring.gpg --secret-keyring ~/.gnupg/secring.gpg --trustdb-name ~/.gnupg/trustdb.gpg --edit-key 0xBBAACC001122334455
</code>
puis dans la console les commandes ''sign'' et ''trust'' puis ''save'' pour finir.
===== Références =====
  * Bonnes pratiques pour [[https://help.riseup.net/fr/security/message-security/openpgp/best-practices|l'utilisation d'OpenPGP]]
  * [[https://github.com/ioerror/duraconf/|duraconf]], a collection of hardened configuration files for SSL/TLS services par Jacob Appelbaum
  * [[https://www.debian-administration.org/users/dkg/weblog/105|OpenPGP Key IDs are not useful]]
  * [[https://debian-administration.org/users/dkg/weblog/48|HOWTO prep for migration off of SHA-1]] in OpenPGP