Objectifs de certification


Introduction

Pretty Good Privacy (en français : « assez bonne confidentialité »), plus connu sous le sigle PGP, est un logiciel de chiffrement cryptographique, développé et diffusé aux États-Unis par Philip Zimmermann en 1991.

PGP se propose de garantir la confidentialité et l’authentification pour la communication des données. Il est souvent utilisé pour la signature de données, le chiffrement et le déchiffrement des textes, des courriels, fichiers, répertoires et partitions de disque entier pour accroître la sécurité des communications par courriel. Utilisant la cryptographie asymétrique mais également la cryptographie symétrique, il fait partie des logiciels de cryptographie hybride.

PGP et les produits similaires suivent le standard OpenPGP (RFC 4880) pour le chiffrement et le déchiffrement de données.

1. Fonctionnement de PGP

Avec PGP, il devient possible de vérifier si un message provient bien de l’origine (via les signatures cryptographiques), ainsi que de chiffrer des messages afin qu’un seul destinataire puisse les lire. En bref, chaque utilisateur crée une paire de clés de chiffrement asymétriques (une publique, l’autre privée), et distribue la clé publique. Les signatures effectuées avec la clé privée peuvent être vérifiées en utilisant la clé publique correspondante et les messages chiffrés utilisant la clé publique sont déchiffrables en utilisant la clé privée correspondante. Ce fonctionnement a été initialement décrit dans le document RFC 19917.

PGP offre des services d’authentification, de confidentialité, de compression et de segmentation, tout en étant compatible avec de nombreux systèmes de messagerie électronique.

2. Authentification

L’expéditeur crée un condensat de son message (avec par exemple SHA-1), chiffre ce condensat avec sa clé privée et l’ajoute en début de message. Le destinataire déchiffre l’ajout en début de message avec la clé publique de l’émetteur et en extrait le condensat. Il calcule ensuite lui-même un condensat du message en utilisant la même fonction de condensat et le compare à celui qu’il a déchiffré ; même résultat ⇒ expéditeur authentifié et message intègre. Le couple clé publique/clé privée peut être fourni par RSA ou DSA ;

3. Confidentialité

(chiffrer des messages à transmettre ou des fichiers à enregistrer) : génération d’une clé secrète de taille 128 bits par exemple (nommée clé de session, valable pour un seul fichier ou un seul message). Le message ou le fichier est chiffré au moyen de cette clé de session avec un algorithme de cryptographie symétrique. Puis cette clé secrète est chiffrée au moyen de la clé publique RSA ou DSA du destinataire et ajoutée au début du message ou du fichier. Le destinataire du message déchiffre l’en-tête du message avec sa clé privée RSA ou DSA et en extrait la clé secrète qui lui permet de déchiffrer le message. Pour que la sécurité de l’échange soit plus sûr il ne faudrait pas utiliser le chiffrement sans authentification. PGP générant des clés très souvent (à chaque fichier ou message), le générateur aléatoire associé à PGP doit être particulièrement efficace afin de ne pas générer des séquences de clés prévisibles ;

4. Compression

Utilisation de ZIP appliqué après la signature mais avant le chiffrement (l’entropie induite par la compression rend plus difficile la cryptanalyse du fichier ou du message) ;

5. Compatibilité

Comme certains systèmes de messagerie ne permettent l’utilisation que du format ASCII, PGP contourne cette limitation en convertissant chaque flot binaire de 8 bits en caractères ASCII imprimables (conversion Radix-64 : 3 octets binaires sont convertis en 4 octets ASCII tout en contenant un CRC pour détecter les erreurs de transmission) ; la taille des messages grossit de 33 % mais la compression compense largement ce phénomène. PGP applique une conversion Radix-64 systématiquement, que le message original soit déjà au format ASCII ou pas ;

6. Segmentation et ré-assemblage

Pour outrepasser certaines contraintes (taille maximum des messages), après tous les traitements précédents PGP peut tronçonner le message original en segments de taille fixe. L’en-tête contenant la clé secrète ne sera positionnée que dans le premier segment. Le destinataire met en mémoire la clé secrète, récupère tous les segments, en retire les en-têtes inutiles, ré-assemble le message avant de le déchiffrer, le décompresser et vérifier sa signature.

8. Exercices GPG

8.1. Chiffrer un texte clair avec GPG

$ echo "test" > texte.txt
$ gpg --symmetric texte.txt

┌──────────────────────────────────────────────────────────┐
│ Entrez la phrase de passe                                │
│                                                          │
│                                                          │
│ Phrase de passe ********________________________________ │
│                                                          │
│        <OK>                                <Cancel>	   │
└──────────────────────────────────────────────────────────┘

$ ls texte.*
texte.txt  texte.txt.gpg

$ $ cat texte.txt.gpg
 ih�J��$)��cg��q�͆�H]<�JW�ķÐdcC�_6��=q�[

8.2. Déchiffrer un texte gpg

$ gpg --decrypt texte.txt.gpg
gpg: données chiffrées avec CAST5
gpg: chiffré avec 1 phrase de passe
test
gpg: Attention : l'intégrité du message n'était pas protégée
$ gpg --output texte.txt.dec --decrypt texte.txt.gpg
gpg: données chiffrées avec CAST5
gpg: chiffré avec 1 phrase de passe
gpg: Attention : l'intégrité du message n'était pas protégée

$ cat texte.txt.dec
test

8.3. Chiffrer et signer des messages

Dans ce scénario Bob envoit un message chiffré à Alice et Alice signe un message à destination de Bob. Dans notre cas, Alice et Bob sont deux utilisateurs du système.

  • Créer des utilisateurs alice et bob
# adduser alice
# echo testtest | passwd --stdin alice
# gpasswd -a alice wheel

# adduser bob
# echo testtest | passwd --stdin bob
# gpasswd -a bob wheel
  • Création d’un dossier partagé

/tmp est un lieu partagé par excellence

# ls -ld /tmp
drwxrwxrwt. 20 root root 4096 28 sep 18:43 /tmp
  • Créer des clés dans la session de Alice Alice <alice@localhost>
$ su - alice
$ sudo gpg --gen-key

[sudo] password for alice:
gpg (GnuPG) 2.0.22; Copyright (C) 2013 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.

gpg: répertoire « /root/.gnupg » créé
gpg: nouveau fichier de configuration « /root/.gnupg/gpg.conf » créé
gpg: Attention : les options de « /root/.gnupg/gpg.conf » ne sont pas encore actives cette fois
gpg: le porte-clefs « /root/.gnupg/secring.gpg » a été créé
gpg: le porte-clefs « /root/.gnupg/pubring.gpg » a été créé
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 ?
les clefs RSA peuvent faire entre 1024 et 4096 bits de longueur.
Quelle taille de clef désirez-vous ? (2048)
La taille demandée est 2048 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)
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 : Alice
Adresse électronique : alice@localhost
Commentaire :
Vous avez sélectionné cette identité :
    « Alice <alice@localhost> »

Faut-il modifier le (N)om, le (C)ommentaire, l'(A)dresse électronique
ou (O)ui/(Q)uitter ? O
Une phrase de passe 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: /root/.gnupg/trustdb.gpg : base de confiance créée
gpg: clef CDB148EC 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.
pub   2048R/CDB148EC 2016-09-28
 Empreinte de la clef = 7E68 6D3E 937C F4B0 AA5D  787C C638 9CF9 CDB1 48EC
uid                  Alice <alice@localhost>
sub   2048R/FF629C2C 2016-09-28
  • Exportation et publication de la clé
sudo gpg --armor --export "Alice" > /tmp/alice.asc
  • Bob importe la clé publique d’Alice
$ su - bob
$ gpg --armor --import /tmp/alice.asc
gpg: répertoire « /home/bob/.gnupg » créé
gpg: nouveau fichier de configuration « /home/bob/.gnupg/gpg.conf » créé
gpg: Attention : les options de « /home/bob/.gnupg/gpg.conf » ne sont pas encore actives cette fois
gpg: le porte-clefs « /home/bob/.gnupg/secring.gpg » a été créé
gpg: le porte-clefs « /home/bob/.gnupg/pubring.gpg » a été créé
gpg: /home/bob/.gnupg/trustdb.gpg : base de confiance créée
gpg: clef CDB148EC : clef publique « Alice <alice@localhost> » importée
gpg:       Quantité totale traitée : 1
gpg:                     importées : 1  (RSA: 1)

  • Bob envoie un message chiffré à Alice
$ su - bob

$ echo "secret pour Alice" > bob_to_alice.txt

$ sudo gpg -r Alice --encrypt --armor -o /tmp/bob_to_alice.enc bob_to_alice.txt
  • Alice déchiffre le message avec sa clé privée
$ su - alice

$ sudo gpg /tmp/bob_to_alice.enc

Une phrase de passe est nécessaire pour déverrouiller la clef secrète de
l'utilisateur : « Alice <alice@localhost> »
clef RSA de 2048 bits, identifiant FF629C2C, créée le 2016-09-28 (identifiant de clef principale CDB148EC)

gpg: chiffré avec une clef RSA de 2048 bits, identifiant FF629C2C, créée le 2016-09-28
      « Alice <alice@localhost> »
gpg: /tmp/bob_to_alice.enc : suffixe inconnu
Entrez le nouveau nom de fichier [bob_to_alice.txt]:

$ cat bob_to_alice.txt
secret pour Alice
  • Lister son trousseau de clés
$ su - alice

$ sudo gpg --list-public-keys
/root/.gnupg/pubring.gpg
------------------------
pub   2048R/CDB148EC 2016-09-28
uid                  Alice <alice@localhost>
sub   2048R/FF629C2C 2016-09-28

[alice@localhost ~]$ sudo gpg --list-secret-keys
/root/.gnupg/secring.gpg
------------------------
sec   2048R/CDB148EC 2016-09-28
uid                  Alice <alice@localhost>
ssb   2048R/FF629C2C 2016-09-28
  • Alice crée et signe un message
$ su - alice

$ echo "Peux-tu vérifier la signature ? signé Alice" > alice_to_bob.txt

$ sudo gpg --clearsign -u Alice alice_to_bob.txt

Une phrase de passe est nécessaire pour déverrouiller la clef secrète de
l'utilisateur : « Alice <alice@localhost> »
clef RSA de 2048 bits, identifiant CDB148EC, créée le 2016-09-28

$ cp alice_to_bob.txt* /tmp
  • Bob vérifie ce message
$ su - bob
$ cat /tmp/alice_to_bob.txt
Peux-tu vérifier la signature ? signé Alice
$ gpg --verify /tmp/alice_to_bob.txt.asc
gpg: Signature faite le mer 28 sep 2016 19:26:55 CEST avec la clef RSA d'identifiant CDB148EC
gpg: Bonne signature de « Alice <alice@localhost> »
gpg: Attention : cette clef n'est pas certifiée avec une signature de confiance.
gpg:             Rien n'indique que la signature appartient à son propriétaire.
Empreinte de clef principale : 7E68 6D3E 937C F4B0 AA5D  787C C638 9CF9 CDB1 48EC

8.4. Logiciels graphiques PGP

Tous ces exercices sont certainement plus éloquents avec un véritable logiciel de messagerie. Pour inspiration, Mailvelope (https://www.mailvelope.com/) est une solution qui s’intègre aux Webmails comme extension Chrome ou addon Firefox.

Source : https://www.mailvelope.com/en/help, https://www.mailvelope.com/en/faq#keys

Gestion des clés

Message chiffré

Laisser un commentaire