Petit Guide pour GnuPG

ven. 01 février 2019

Un peu de théorie

Les fonctions de hachage

Une fonction de hachage une fonction particulière qui calcule une empreinte de taille fixe servant à identifier rapidement la donnée initiale, et dont la propriété essentielle est qu'elle est pratiquement impossible à inverser

Le chiffrement symétrique

La cryptographie symétrique est la plus ancienne forme de chiffrement. Elle permet à la fois de chiffrer et de déchiffrer des messages à l'aide d'un même mot clé.

Le chiffrement de bloc et les modes déchiffrement

Les méthodes de cryptographie symétrique moderne sont basées sur le chiffrement par bloc, c'est-à-dire que le chiffrement transforme un bloc de donnée en un autre bloc. De ce fait, si utilisé sans autre considération deux blocs identiques se voient chiffré de la même manière, ce qui peut permettre à un attaquant de connaitre des informations sur les données envoyées.

Pour remédier à ça, les chiffrements sont utilisés avec un mode d'opération, d'on le but est de modifier soit la donnée soit la clé de chiffrement à chaque bloc.

Le chiffrement asymétrique

Le chiffrement asymétrique contrairement au chiffrement symétrique utilise deux clés différentes : une clé dite publique et l'autre privé. Ces deux clés sont générées conjointement, et elle possède des caractéristiques complémentaires. Il est cependant difficile de déduire l'une de l'autre.

La clé dite publique est là pour chiffrer les messages et la clé privée est utilisée pour déchiffrer les messages. Le principal avantage est que le partage des clés n'est pas un problème, la clé publique peut être diffusée sans limitation et sans réduction de la sécurité.

Les signatures numériques

Une signature numérique est un croisement entre les fonctions de hachage et le chiffrement asymétrique. Le principe est de chiffrer l'empreinte du message avec une clé privée, ainsi l'origine du message en comparant l'empreinte du message calculé avec l'empreinte du message déchiffré par la clé publique.

Le chiffrement hybride

PGP (et par expansion GnuPG) utilise un chiffrement hybride. Le chiffrement asymétrique est très sûr, mais très lourd en calcule, contrairement au chiffrement symétrique. Pour pallier a ce problème, une clé de session aléatoire est générée qui chiffré de manière asymétrique. Cette clé de session peut alors être utilisée pour chiffrer un message. Une fois associé, ces deux pièces forment le chiffrement hybride.

Cette méthode est aussi robuste que le plus faible des chiffrements utilisés. C'est dans cette optique qu'il est nécessaire d'associer des méthodes de sécurité égale pour sécuriser vos messages. Vous pouvez trouvé un tableau de comparaison ici

La pratique

Configuré GnuGP

$ cat ~/.gnupg/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 0x042480B1719B2B56


#-----------------------------
# 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
#-----------------------------

# 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 CAMELLIA256 AES256 CAMELLIA192 AES192 CAMELLIA128 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

# list of personal compression
personal-compress-preferences ZLIB BZIP2 ZIP Uncompressed

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

# symetrique
s2k-digest-algo SHA512
s2k-cipher-algo CAMELLIA256

# This preference list is used for new keys and becomes the default for
# "setpref" in the edit menu
default-preference-list SHA512 SHA384 SHA256 CAMELLIA256 AES256 CAMELLIA192 AES192 CAMELLIA128 AES CAST5 ZLIB BZIP2 ZIP Uncompressed

Création des clés

La création des clés est une étape sensible pour la sécurité des futurs messages envoyés. Pour avoir une sécurité optimale, il est forcement conseillé de faire ces opérations sur un système d'exploitation temporaire comme Tails et de vérifier l'entropie disponible.

$ cat /proc/sys/kernel/random/entropy_avail
721

Il est nessecaire d'avoir un minimum de 3000 pour ne pas avoir de problèmes. Dans mon cas, GPG refusera même de générer les clés.

Dans les sections suivantes, nous allons créer une clé primaire, et des clés secondaires qui seront signées par cette clé primaire. Elles pourront donc être utilisées au nom de la clé primaire. Nous faisons ça pour garder la clé primaire au maximum hors ligne et hors d'atteinte de toute attaque.

Choisir un mot de passe solide

Je vous laisse assez voir XKCD et Computerphile pour comprendre la science derrière la création d'un mot de passe fort. Mais pour faire court, la meilleure manière de générer un mot de passe fort et facile à apprendre est d'utiliser un Diceware.

L'idée d'un Diceware est de prendre aléatoirement plusieurs mots dans un dictionnaire à l'aide d'un dé. En ajoutant plusieurs (5 à 6, 10 si vous être paranoïaque) mots, l'un après l'autre ou obtient un mot de passe très difficile à casser. Vous pouvez trouver le dictionnaire en français ici.

Création de la clé primaire

$ gpg --full-generate-key --expert
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)
   (7) DSA (indiquez vous-même les capacités)
   (8) RSA (indiquez vous-même les capacités)
   (9) ECC et ECC
  (10) ECC (signature seule)
  (11) ECC (indiquez vous-même les capacités)
  (13) Clef existante
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) 0
La clef n'expire pas du tout
Est-ce correct ? (o/N) o

GnuPG doit construire une identité pour identifier la clef.

Nom réel : Mr Example
Adresse électronique : example@why.not
Commentaire :
Vous avez sélectionné cette identité :
    « Mr Example <example@why.not> »

Changer le (N)om, le (C)ommentaire, l'(A)dresse électronique
ou (O)ui/(Q)uitter ? 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.
gpg: clef 0xD3E4AC4173953DCA marquée de confiance ultime.
gpg: revocation certificate stored as '~/.gnupg/openpgp-revocs.d/3C803E93C6CD84CE1EE59A46D3E4AC4173953DCA.rev'
les clefs publique et secrète ont été créées et signées.

Remarquez que cette clef ne peut pas être utilisée pour chiffrer. Vous pouvez
utiliser la commande « --edit-key » pour générer une sous-clef à cette fin.
pub   rsa4096/0xD3E4AC4173953DCA 2019-02-01 [SC]
 Empreinte de la clef = 3C80 3E93 C6CD 84CE 1EE5  9A46 D3E4 AC41 7395 3DCA
uid                              Mr Example <example@why.not>
$ export KEYID=0xD3E4AC4173953DCA

Création des clés secondaire

$ gpg --expert --edit-key $KEYID

La clef secrète est disponible.

gpg: vérification de la base de confiance
gpg: marginals needed: 3  completes needed: 1  trust model: pgp
gpg: profondeur : 0  valables :   6  signées :   0
     confiance : 0 i., 0 n.d., 0 j., 0 m., 0 t., 6 u.
gpg: la prochaine vérification de la base de confiance aura lieu le 2019-10-12
sec  rsa4096/0xD3E4AC4173953DCA
     créé : 2019-02-01  expire : jamais      utilisation : SC
     confiance : ultime        validité : ultime
[  ultime ] (1). Mr Example <example@why.not>

Clé de signature

gpg> addkey
Sélectionnez le type de clef désiré :
   (3) DSA (signature seule)
   (4) RSA (signature seule)
   (5) Elgamal (chiffrement seul)
   (6) RSA (chiffrement seul)
   (7) DSA (indiquez vous-même les capacités)
   (8) RSA (indiquez vous-même les capacités)
  (10) ECC (signature seule)
  (11) ECC (indiquez vous-même les capacités)
  (12) ECC (chiffrement seul)
  (13) Clef existante
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 Dim 31 jan 10:36:02 2021 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.

sec  rsa4096/0xD3E4AC4173953DCA
     créé : 2019-02-01  expire : jamais      utilisation : SC
     confiance : ultime        validité : ultime
ssb  rsa4096/0xFDE1BB9027F9214D
     créé : 2019-02-01  expire : 2021-01-31  utilisation : S
[  ultime ] (1). Mr Example <example@why.not>

Clé de chiffrement

gpg> addkey
Sélectionnez le type de clef désiré :
   (3) DSA (signature seule)
   (4) RSA (signature seule)
   (5) Elgamal (chiffrement seul)
   (6) RSA (chiffrement seul)
   (7) DSA (indiquez vous-même les capacités)
   (8) RSA (indiquez vous-même les capacités)
  (10) ECC (signature seule)
  (11) ECC (indiquez vous-même les capacités)
  (12) ECC (chiffrement seul)
  (13) Clef existante
Quel est votre choix ? 6
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 Dim 31 jan 10:37:45 2021 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.

sec  rsa4096/0xD3E4AC4173953DCA
     créé : 2019-02-01  expire : jamais      utilisation : SC
     confiance : ultime        validité : ultime
ssb  rsa4096/0xFDE1BB9027F9214D
     créé : 2019-02-01  expire : 2021-01-31  utilisation : S
ssb  rsa4096/0x4880A758F3BB20C5
     créé : 2019-02-01  expire : 2021-01-31  utilisation : E
[  ultime ] (1). Mr Example <example@why.not>

Clé d'authentification

gpg> addkey
Sélectionnez le type de clef désiré :
   (3) DSA (signature seule)
   (4) RSA (signature seule)
   (5) Elgamal (chiffrement seul)
   (6) RSA (chiffrement seul)
   (7) DSA (indiquez vous-même les capacités)
   (8) RSA (indiquez vous-même les capacités)
  (10) ECC (signature seule)
  (11) ECC (indiquez vous-même les capacités)
  (12) ECC (chiffrement seul)
  (13) Clef existante
Quel est votre choix ? 8

Actions possibles pour une clef RSA : Signer Chiffrer Authentifier
Actions actuellement permises : Signer Chiffrer

   (S) Inverser la capacité de signature
   (C) Inverser la capacité de chiffrement
   (A) Inverser la capacité d'authentification
   (Q) Terminé

Quel est votre choix ? s

Actions possibles pour une clef RSA : Signer Chiffrer Authentifier
Actions actuellement permises : Chiffrer

   (S) Inverser la capacité de signature
   (C) Inverser la capacité de chiffrement
   (A) Inverser la capacité d'authentification
   (Q) Terminé

Quel est votre choix ? c

Actions possibles pour une clef RSA : Signer Chiffrer Authentifier
Actions actuellement permises :

   (S) Inverser la capacité de signature
   (C) Inverser la capacité de chiffrement
   (A) Inverser la capacité d'authentification
   (Q) Terminé

Quel est votre choix ? a

Actions possibles pour une clef RSA : Signer Chiffrer Authentifier
Actions actuellement permises : Authentifier

   (S) Inverser la capacité de signature
   (C) Inverser la capacité de chiffrement
   (A) Inverser la capacité d'authentification
   (Q) Terminé

Quel est votre choix ? q
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 Dim 31 jan 10:38:58 2021 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.

sec  rsa4096/0xD3E4AC4173953DCA
     créé : 2019-02-01  expire : jamais      utilisation : SC
     confiance : ultime        validité : ultime
ssb  rsa4096/0xFDE1BB9027F9214D
     créé : 2019-02-01  expire : 2021-01-31  utilisation : S
ssb  rsa4096/0x4880A758F3BB20C5
     créé : 2019-02-01  expire : 2021-01-31  utilisation : E
ssb  rsa4096/0x91AC028367D9A8B2
     créé : 2019-02-01  expire : 2021-01-31  utilisation : À
[  ultime ] (1). Mr Example <example@why.not>

Exporté les clés

$ gpg --list-secret-keys $KEYID
sec   rsa4096/0xD3E4AC4173953DCA 2019-02-01 [SC]
 Empreinte de la clef = 3C80 3E93 C6CD 84CE 1EE5  9A46 D3E4 AC41 7395 3DCA
uid                  [  ultime ] Mr Example <example@why.not>
ssb   rsa4096/0xFDE1BB9027F9214D 2019-02-01 [S] [expire : 2021-01-31]
ssb   rsa4096/0x4880A758F3BB20C5 2019-02-01 [E] [expire : 2021-01-31]
ssb   rsa4096/0x91AC028367D9A8B2 2019-02-01 [A] [expire : 2021-01-31]
$ gpg --armor --export-secret-keys $KEYID | gpg --symmetric > mastersub.key
$ gpg --armor --export-secret-subkeys $KEYID | gpg --symmetric > sub.key
$ gpg --armor --export $KEYID > pubkey.txt

À ce moment-là, il est nécessaire de garder votre clé primaire en sécurité.

$ gpg --send-key $KEYID
$ gpg --keyserver pgp.mit.edu --send-key $KEYID
$ gpg --keyserver keys.gnupg.net --send-key $KEYID

Sauvegarder les clés

Dans cette section nous allons créer une copie papier et chiffrer des clés.

cat mastersub.key | paperkey --output-type raw | base64 > temp
split temp -n 4 IMG
for f in IMG``*``; do cat $f | qrencode -o $f.png; done

Pour restaurer les clés

for f in IMG``*``.png; do zbarimg --raw $f | head -c -1 > $f.out ; done
cat ``*``.out | base64 -d | paperkey --pubring ~/.gnupg/pubring.gpg | gpg --import

Nettoyage

$ gpg --delete-secret-key $KEYID

À cette étape, si vous utilisez un système d'exploitation temporaire, sauvegarder le fichier sub.key et mastersub.key et redémarrer sur votre système d'exploitation principal.

Importer les clés

$ gpg --decrypt | gpg --import sub.key
$ sudo srm sub.key

Chiffrement

$ echo "Hello World" | gpg --encrypt --armor --recipient $KEYID
-----BEGIN PGP MESSAGE-----

hQIMA0iAp1jzuyDFAQ//ZZNyYuta/WaQAI3TblayGDCO1Z045zHXUtY5h1H4Mdz4
t96D6fwPmd1w6yx/uetodX6ZMyBESoX3t5nDzIUyWEf9m3AUcP61i+2g6HnKAvc3
ZnArPkuMUmN4hz+9ATJtDWeOjZSERQrTQ0wKHj6fN3XyXSLumeX18t46mWQ5Z5vX
PnqBL4hPtlbImOy9Xxi4E4sXuhPtDsMqGDJ9GOl8DZ7LXhMZRxhxQwgddjOTxaN0
yqQ4SYCNAQvO6kaihc9OT0ZigKJ7FGGlLq9i405YZNMA/doSgk5WnbJF7ONb4M/q
WicXLcGLXZoG9pwiFO9YWwCq8hDIAORFOwwsVWOW3/6a1buB+hveSs8NCj0zVwxc
OONypS2kHCe+dapsw5LZiKBRkWBHs8RrSfcn02iC4ctnU0Je/2lG86vu0jZjbV9X
qMlirAEvf4YbS2bXllskIpMsbY6M2rcLEHxIqRl0nOgrOEc3SkU5bjKCI2gvlAXD
SjQbpzXdsKCxzEk8dz9tValpADA8BiWyybzdqGNu0ywxSPoArBymnp1GjUyjsRoB
J3f+VP4IwlvC9nMeHv3c/YiCOZisY/PsmAb1mA4TZvOffsnND9tROLtnUTnvqvR2
ZbULhm9MVz3ScY4bSHjQlhCgO8SN5LvpYUdx/A2rzazWWUWTnTQd94dYA0rTCs/S
RwGj6pXegIXGzsdIEBw06WBpF5CuPV73DfzvrldnWjoIlGTE9BqrlCwFjup0GaFF
v0/GK6Oma81z4ClTm8azA4Bv4B/IJFZx
=JyC1
-----END PGP MESSAGE-----

Déchiffrement

$ gpg --decrypt --armor
-----BEGIN PGP MESSAGE-----

hQIMA0iAp1jzuyDFAQ//ZZNyYuta/WaQAI3TblayGDCO1Z045zHXUtY5h1H4Mdz4
t96D6fwPmd1w6yx/uetodX6ZMyBESoX3t5nDzIUyWEf9m3AUcP61i+2g6HnKAvc3
ZnArPkuMUmN4hz+9ATJtDWeOjZSERQrTQ0wKHj6fN3XyXSLumeX18t46mWQ5Z5vX
PnqBL4hPtlbImOy9Xxi4E4sXuhPtDsMqGDJ9GOl8DZ7LXhMZRxhxQwgddjOTxaN0
yqQ4SYCNAQvO6kaihc9OT0ZigKJ7FGGlLq9i405YZNMA/doSgk5WnbJF7ONb4M/q
WicXLcGLXZoG9pwiFO9YWwCq8hDIAORFOwwsVWOW3/6a1buB+hveSs8NCj0zVwxc
OONypS2kHCe+dapsw5LZiKBRkWBHs8RrSfcn02iC4ctnU0Je/2lG86vu0jZjbV9X
qMlirAEvf4YbS2bXllskIpMsbY6M2rcLEHxIqRl0nOgrOEc3SkU5bjKCI2gvlAXD
SjQbpzXdsKCxzEk8dz9tValpADA8BiWyybzdqGNu0ywxSPoArBymnp1GjUyjsRoB
J3f+VP4IwlvC9nMeHv3c/YiCOZisY/PsmAb1mA4TZvOffsnND9tROLtnUTnvqvR2
ZbULhm9MVz3ScY4bSHjQlhCgO8SN5LvpYUdx/A2rzazWWUWTnTQd94dYA0rTCs/S
RwGj6pXegIXGzsdIEBw06WBpF5CuPV73DfzvrldnWjoIlGTE9BqrlCwFjup0GaFF
v0/GK6Oma81z4ClTm8azA4Bv4B/IJFZx
=JyC1
-----END PGP MESSAGE-----gpg: chiffré avec une clef RSA de 4096 bits, identifiant 0x4880A758F3BB20C5, créée le 2019-02-01
      « Mr Example <example@why.not> »
Hello World

Signature

$ echo "Hello World" | gpg --sign --clearsign --default-key $KEYID
gpg: using "0xD3E4AC4173953DCA" as default secret key for signing
-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA512

Hello World
-----BEGIN PGP SIGNATURE-----

iQIzBAEBCgAdFiEEtLSN8Tt2ZrN4G+My/eG7kCf5IU0FAlxUF5AACgkQ/eG7kCf5
IU30Ag/9G6XbszvYx2SAzzeGSVqOi/zJFqumjxDOUMnr4/l+DaHT03ju4ilFZEP5
Mipb646am1mdmWND9guIIyOXdDgIgbLgQwrDKlTR45H226BuQ4qD/taCUPVPGUqf
pMhD6zPb2BPsLfqk2BlgpGtSSUVSjgri1w4UPq+HaQTANVMDmphh2UxOk8rU3nmF
0KJoirkAnJWL3X701Evy850lasZqUEfsh50RV89A3F+BouGmKxzQPzLd01mrrQBm
10RsiGAYR3yzRQkiKgnIsrUGftK1rWchO2/ipDRi0yrA+KfGiLa/YU0CjRj6X2vS
sIBVcSxvO9sKeczSnm5PbOqBseHteDd6P4UxSLoWeKi8ULbneXy0LNhemly46T4w
N/AvZoOgaLiXZWmgpBAwwMI2GQwiCwe4KhqsPh+qU6J+N/5/WH+/xsESdhaHdRYb
1E2S8y2BaomHV77ob0ag7qLuEL1IaUswbOa9O/nIF9xaxEHdJXBvsMLBF46CJnKK
QSMC+RQoiDrHlDZsArG6mQw+RxS8fQoSVB57qSXMX2/AGb17oYCO7xxfLmLfjE7j
dVcBx5LniBOLFX55gbObPvQ5hZEQKOtYpYKzqWgOnXOvFWpkWI40P8p8PlFxrDhZ
cHX10JxcIFzjW08Zstm/ziA2+rgI3olIBR6320REb2cKaZuAXaY=
=J0da
-----END PGP SIGNATURE-----

Vérification de signature

$ gpg
gpg: WARNING: no command supplied.  Trying to guess what you mean ...
gpg: Vous pouvez taper votre message…
-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA512

Hello World
-----BEGIN PGP SIGNATURE-----

iQIzBAEBCgAdFiEEtLSN8Tt2ZrN4G+My/eG7kCf5IU0FAlxUF5AACgkQ/eG7kCf5
IU30Ag/9G6XbszvYx2SAzzeGSVqOi/zJFqumjxDOUMnr4/l+DaHT03ju4ilFZEP5
Mipb646am1mdmWND9guIIyOXdDgIgbLgQwrDKlTR45H226BuQ4qD/taCUPVPGUqf
pMhD6zPb2BPsLfqk2BlgpGtSSUVSjgri1w4UPq+HaQTANVMDmphh2UxOk8rU3nmF
0KJoirkAnJWL3X701Evy850lasZqUEfsh50RV89A3F+BouGmKxzQPzLd01mrrQBm
10RsiGAYR3yzRQkiKgnIsrUGftK1rWchO2/ipDRi0yrA+KfGiLa/YU0CjRj6X2vS
sIBVcSxvO9sKeczSnm5PbOqBseHteDd6P4UxSLoWeKi8ULbneXy0LNhemly46T4w
N/AvZoOgaLiXZWmgpBAwwMI2GQwiCwe4KhqsPh+qU6J+N/5/WH+/xsESdhaHdRYb
1E2S8y2BaomHV77ob0ag7qLuEL1IaUswbOa9O/nIF9xaxEHdJXBvsMLBF46CJnKK
QSMC+RQoiDrHlDZsArG6mQw+RxS8fQoSVB57qSXMX2/AGb17oYCO7xxfLmLfjE7j
dVcBx5LniBOLFX55gbObPvQ5hZEQKOtYpYKzqWgOnXOvFWpkWI40P8p8PlFxrDhZ
cHX10JxcIFzjW08Zstm/ziA2+rgI3olIBR6320REb2cKaZuAXaY=
=J0da
-----END PGP SIGNATURE-----Hello World

[Présser Controle-D]

gpg: Signature faite le Ven  1 fév 10:55:28 2019 CET
gpg:                avec la clef RSA B4B48DF13B7666B3781BE332FDE1BB9027F9214D
gpg: Bonne signature de « Mr Example <example@why.not> » [ultime]
Empreinte de clef principale : 3C80 3E93 C6CD 84CE 1EE5  9A46 D3E4 AC41 7395 3DCA
   Empreinte de la sous-clef : B4B4 8DF1 3B76 66B3 781B  E332 FDE1 BB90 27F9 214D

Intégration dans la vie quotidienne

Git

$ git config --global user.name "Mr Example"
$ git config --global user.email example@why.not
$ git config --global user.signingKey $KEYID
$ git config --global commit.gpgSign true

Gitlab et GitHub permettent aussi de partager votre clé publique et la vérification des commits

Pass (password-store)

Pass est un manager de password basé sur GPG, il s'agit d'un simple script shell, se qui le rend très portable.

$ pass init $KEYID
$ pass git init

Intégration

Chrome: chrome-pass (ZX2C4)

Firefox: passff

Android: Password Store

Mutt

RTFM

Facebook

Bon OK, Facebook et la vie privée ça n'est pas compatible, mais rendons a césar ce qui appartiens a césar, ils donnent la possibilité de chiffrée avec GPG tous les mails qui vous sont envoyés, ce qui est une très bonne ligne de défiance si quelqu'un essai de réinitialisé votre mot de passe et a accès a votre boite mail (donc si vous être déjà bien dans la merde).

Pour ça, rendez-vous dans votre profil, rubrique "À propos", section "Informations générales et coordonnées" pour ajouter votre clé publique. Puis dans les paramètres, section "Sécurité et connexion" pour activer "E-mails de notification chiffrés".

SSH

Oui vous pouvez remplacé ssh-agent par gpg-agent, ce qui donne des choses intéressantes si vous être comme moi utilisateur d'un yubikey

$ cat ~/.gnupg/gpg-agent.conf
default-cache-ttl-ssh 600
default-cache-ttl 600
max-cache-ttl 7200
max-cache-ttl-ssh 7200
enable-ssh-support

puis ajouter ceci à votre bashrc

export GPG_TTY="$(tty)"
export SSH_AUTH_SOCK=$(gpgconf --list-dirs agent-ssh-socket)
gpgconf --launch gpg-agent

Vous pouvez alors utilise ssh-add -L pour récupéré votre clé publique et l'utilisé comme n'importe quelle autre clé SSH.

XMPP

GPG est aussi supporté par XMPP (XEP-0373), pour signer et chiffrer vos messages. Cette fonctionnalité est disponible sur un grand nombre de clients (Convertation pour Android et Profanity entre autre). Pour les réglages... RTFM.

blogroll

social