Changements récents - Rechercher:

Espace Wiki ∂'Alembert
Documentation générale


Espace Guide de survie du SysAdmin
Documentation technique


Espace Guide de survie du Développeur
Pour les développeurs


Espace Institut ∂’Alembert
L'institut


Le Site
À propos du Site
Liste complète des Pages


Aide PmWikiFr

Help PmWiki

GSSA /

GNU Privacy Guard

Page mise à jour le 05/07/2023 17:59

Vous êtes dans un espace restreint en écriture.

(:numbered-sections format=0.A.1.a:)

GNU Privacy Guard [GnuPG] est une application libre du standard OpenPGP (également connu sous le nom PGP) qui permet de chiffrer et signer vos données et vos communications, dispose d'un système polyvalent de gestion de clés ainsi que des modules d'accès pour toutes sortes de clés publiques.

Présentation

Définitions

GnuPG est l'abréviation de GNU Privacy Guard.

GnuPG est une implémentation libre (au sens de la GNU Public Licence) de PGP.

GnuPG permet de chiffrer des fichiers par le biais d'un algorithme de chiffrement à clés asymétriques, c'est à dire qu'une clé permet de chiffrer le texte, et qu'une autre clé sert à déchiffrer le texte.

Chiffrement par clés asymétriques

Les algorithmes de chiffrement par clés asymétriques fonctionnent grâce à deux clés: une clé publique et une clé privée.

Votre clé publique permet à n'importe qui de chiffrer un message qui vous est destiné, alors que votre clé privée vous permettra de déchiffrer ce message. Votre clé privée sert aussi à signer un message que vous envoyez, et votre clé publique permet à la personne à qui vous envoyez le message de vérifier que vous en êtes bien l'auteur.

Échange de clés

Le problème de ce type de système par chiffrement à clés asymétriques est qu'il faut être sûr que la clé que vous possédez appartient bien à la personne à qui vous pensez qu'elle appartient.

En effet, si cela est mal vérifié, ou n'est pas vérifie du tout, quelqu'un de mal intentionné (C) pourrait se placer entre vous (A) et la personne avec qui vous voulez communiquer (B).

Il faut donc trouver un moyen de vérifier que la clé publique de (B) que vous avez proviens réellement de (B).

Pour cela, il suffit de donner à (B), en vérifiant son identité, le fingerprint (empreinte) de sa propre clé publique. Ceci se fait généralement lorsque l'on rencontre physiquement une autre personnes utilisant GPG, en vérifiant mutuellement l'identité de l'autre personne grâce à la présentation d'une pièce d'identité, et par l'échange de cartes de visites sur lesquelles figurent l'identifiant et le fingerprint des clés GPG de chacun.

Patrick Cao Huu Thien <patrick.cao_huu_thien@upmc.fr>
GnuPG key 58D16D27
D7B8 7DFB 479C A02E 48A2 383C 0005 4A33 58D1 6D27

58D16D27 est l'identifiant de ma clé : il permet par exemple de la télécharger depuis un serveur de clés (nous verrons ça plus loin). Il se compose de la taille de la clé, suivi des 8 derniers caractères du fingerprint.

D7B8 7DFB 479C A02E 48A2 383C 0005 4A33 58D1 6D27 est le fingerprint : c'est une sorte d'empreinte digitale de ma clé publique. Si deux empreintes sont identiques, alors c'est que les clés d'origines de ces deux empreintes sont identiques. Il faut ensuite signer la clef: cela certifie que l'identité de la personne a été vérifiée.

Pour réaliser un échange de clé securisée il faut donc :

  1. S'échanger les cartes de visites en vérifiant les identités.
  2. Récupérer la clé dont l'identifiant se trouve sur la carte de visite. (voir serveur de clés publiques)
  3. Vérifier que le fingerprint calculé à partir de cette clé est identique à celui imprimé sur la carte de visite.
  4. Signer la clef.
  5. Exporter la clé signée sur le serveur de clés publiques précédemment utilisé

Réseau de confiance

Il y a maintenant une autre difficulté: comment faire confiance à des gens qu'on n'a jamais rencontré et/ou qu'on ne pourra jamais rencontrer ? Il n'est en effet pas possible de faire un échange de clés de façon securisé avec tout le monde.

La solution est en faite très simple. Je vais l'illustrer par un exemple.

Si (A) et (B) se font confiance absolument, si (B) et (C) se font confiance absolument, si (C) et (D) se font confiance absolument, alors (A) et (D) peuvent se faire confiance sans risques. Il existe cinq états pour la méthode de vérification de l'identité:

  1. Ne sais pas (Don't know) (valeur par défaut)
  2. Ne fais pas confiance (I do NOT trust)
  3. Je fais un peu confiance (I trust marginally)
  4. Je fais confiance (I trust fully)
  5. J'ai une confiance absolue (I trust ultimately) (pour ses propres clés)

GnuPG calculera donc automatiquement en fonction du niveau de confiance et de la méthode de vérification de chaque lien le niveau de confiance de quelqu'un dont vous ne pouvez pas vérifier l'identité physiquement.

Ce système permet donc d'établir petit à petit un réseau de confiance d'envergure internationale, qui permet d'établir des communications sécurisées sans risques d'interception de la communication par quelqu'un de malveillant.

Utilisation

Créer une paire de clé

La création d'une paire de clés vous pose plein de question. En cas de doute, laissez la réponse par défaut.

$ gpg --gen-key
[...]

Voir sa paire de clés

Il se peut que vous ayez de nombreuses clés, principalement les clé publiques d'autres personnes,

Exporter une clé dans un fichier

$ gpg --armor --export pcao > ~/patrick-public-key.asc

L'option --armor permet de créer un fichier ascii plus facilement visible et (historiquement) utilisable par email.

Importer une clé depuis un fichier

Ici, il s'agit de récupérer son ancienne paire de clé publique et privée d'une autre machine.

Le principe est le même pour une clé publique des autres personnes

  • copier le fichier secring.gpg de l'ancienne machine avec un moyen sécurisé, par exemple scp
  • importer dans le nouveau gpg
$ gpg --import secring.gpg
gpg: key 58D16D27: secret key imported
gpg: Total number processed: 1
gpg: secret keys read: 1
gpg: secret keys imported: 1
  • vérifier que cette clé est bien une paire de clé publique
$ gpg --list-keys pcao
pub 1024D/58D16D27 2005-06-23
uid Patrick Cao Huu Thien <pcao@ccr.jussieu.fr>
sub 1024g/A98B1F25 2005-06-23
  • et privée (le cas écheant):
$ gpg --list-secret-keys
/home/patrick/.gnupg/secring.gpg
--------------------------------
sec 1024D/58D16D27 2005-06-23
uid Patrick Cao Huu Thien <pcao@ccr.jussieu.fr>
ssb 1024g/A98B1F25 2005-06-23

Chiffrer un fichier

chiffrer un fichier pour moi seulement:

$ gpg --encrypt toto.txt
$ ls toto*
toto.txt toto.txt.gpg

chiffrer un document pour gag seulement:

$ gpg -r gag -e gag.txt
$ ls gag*
gag.txt gag.txt.gpg

chiffrer un fichier pour gag et moi

$ gpg -e -r gag -r pcao gag_moi.txt
$ ls gag_moi*
gag_moi.txt gag_moi.txt.gpg

Messages possibles

You did not specify a user ID. (you may use "-r")
il faut ajouter default-recipient-self dans $HOME/.gnupg/gpg.conf

lors du chiffrement, aucun mot de passe ou phrase de passe n'est demandé. C'est la signature d'un fichier qui en réclame un.

Voir les clés permettant de déchiffrer:

$ gpg --list-packets gag_moi.txt.gpg
gpg: encrypted with 4096-bit RSA key, ID FCFC4BCCCCB1037E, created 2022-10-19
"G.A. Gerolymos <geg@ccr.jussieu.fr>"
gpg: encrypted with 1024-bit ELG key, ID 0ABABD45A98B1F25, created 2005-06-23
"Patrick Cao Huu Thien <patrick.cao_huu_thien@upmc.fr>"
[...]

Déchiffrer un fichier

  • pour déchiffrer un fichier :
$ gpg --decrypt --output toto2.txt toto.txt.gpg
You need a passphrase to unlock the secret key for
user: "Patrick Cao Huu Thien <pcao@ccr.jussieu.fr>"
1024-bit ELG-E key, ID A98B1F25, created 2005-06-23 (main key ID 58D16D27)

Enter passphrase: **********
$ ls toto*
toto.txt toto.txt.gpg toto2.txt

les options doivent être placés avant le fichier à déchiffrer. Y compris --output toto2.txt

  • déchiffrer un fichier « non accessible » pour vous
$ gpg --decrypt gag.txt.gpg
gpg: encrypted with 2048-bit ELG-E key, ID 6378A041, created 2006-03-24
"G.A. Gerolymos (gag) <geg@ccr.jussieu.fr>"
gpg: decryption failed: secret key not available

Signer un fichier

Signer un fichier, c'est authentifier ce fichier avec une paire de clés. Il existe plusieurs façons de signer un fichier :

signature dans un fichier binaire contenant le fichier et la signature (.gpg) :

$ gpg --sign toto.ps
You need a passphrase to unlock the secret key for
user: "Patrick Cao Huu Thien <pcao@ccr.jussieu.fr>"
1024-bit DSA key, ID 58D16D27, created 2005-06-23

Enter passphrase:
  • signature ascii contenant le fichier et la signature (.asc) :
$ gpg --clearsign toto.ps
  • signature binaire seule (.sig) :
$ gpg --detach-sign toto.ps

Il appairait que la signature au format .sig est beaucoup plus petit que les autres. Cependant, la présence du fichier de base est nécessaire contrairement aux autres types de signature.

$ ls -al toto*
-rw-rw-r-- 1 patrick patrick 437397 fv 17 15:03 toto.ps
-rw-r--r-- 1 patrick patrick 437633 mar 28 15:41 toto.ps.asc
-rw-r--r-- 1 patrick patrick 71743 mar 28 15:40 toto.ps.gpg
-rw-r--r-- 1 patrick patrick 65 mar 28 15:56 toto.ps.sig

Vérifier les signatures d'un fichier

$ gpg --verify toto.ps
gpg: Signature made Thu 01 Jul 2001 05:26:41 PM CEST
gpg: using DSA key 58D16D27
gpg: Good signature from "Patrick Cao Huu Thien <pcao@ccr.jussieu.fr>" [ultimate]

Utilisation Avancée

Serveur de clés

Cette partie permet d'importer et exporter des clés pour qu'elle soient accessibles.

Configuration

  • Ajout d'un ou plusieurs serveurs de clé dans *.gnupg/gpg.conf*:
keyserver hkps://keys.openpgp.org
keyserver hkps://pgp.mit.edu

Utilisation

  • rechercher une clé ayant un fingerprint 8657ABB260F056B1E5190839D9C4D26D0E604491 (ca marche aussi avec un email):
gpg --search-keys 8657ABB260F056B1E5190839D9C4D26D0E604491
gpg: data source: https://keys.openpgp.org:443
(1) Matt Caswell <frodo@baggins.org>
Matt Caswell <matt@openssl.org>
2048 bit RSA key D9C4D26D0E604491, created: 2013-04-30
Keys 1-1 of 1 for "8657ABB260F056B1E5190839D9C4D26D0E604491". Enter number(s), N)ext, or Q)uit > n
  • importer une clé :
gpg --recv-keys 8657ABB260F056B1E5190839D9C4D26D0E604491
gpg: key D9C4D26D0E604491: public key "Matt Caswell <matt@openssl.org>" imported
gpg: Total number processed: 1
gpg: imported: 1
  • exporter sa cle :
gpg --keyserver pgp.mit.edu --send-keys 8657ABB260F056B1E5190839D9C4D26D0E604491

gpg --export votre_adresse_courriel@exemple.net | curl -T - https://keys.openpgp.org
  • aller sur l' URL propose
  • valider votre email via un nouveau email

la commande gpg --send-keys ne permet pas d' ajouter les uid aux cles, sur le serveur keys.openpgp.org

  • mettre a jour les cles depuis les serveurs de cles:
gpg --refresh-keys
gpg: refreshing 152 keys from hkps://pgp.mit.edu

Mise à jour de la clé primaire

Le scénario est la mise à jour de la clé primaire qui utilise un vieil algorithme devenu obsolète.

Il n'est pas vraiment possible de « mettre à jour » une clé.
En revanche on peux créer une nouvelle et la certifier avec l'ancienne.

  1. Voyons ma clé primaire qui est très vieille:
     $ gpg -K cao
     pub   dsa1024 2005-06-23 [SC]
           D7B87DFB479CA02E48A2383C00054A3358D16D27
     uid           [ultimate] Patrick Cao Huu Thien <patrick.cao_huu_thien@sorbonne-universite.fr>
     [...]
     sub   elg1024 2005-06-23 [E]
  2. créer une nouvelle clé avec les bonnes options:
     $ gpg --gen-key --default-new-key-algo=rsa4096/cert,sign+rsa4096/encr
     [...]
     Real name: Patrick Cao Huu Thien
     Email address: patrick.cao_huu_thien@sorbonne-universite.fr
     [...]
     pub   rsa4096 2023-07-05 [SC] [expires: 2025-07-04]
           A8F721C80E43073F40DF8F21B57DBE40C72FBCF4
           A8F721C80E43073F40DF8F21B57DBE40C72FBCF4
     uid                      Patrick Cao Huu Thien <patrick.cao_huu_thien@sorbonne-universite.fr>
     sub   rsa4096 2023-07-05 [E] [expires: 2025-07-04]
    1. vérifier l’existence du certificat de révocation. (Ceci est automatique à partir de gpg 2.1) ...
      $ cat ~/.gnupg/openpgp-revocs.d/A8F721C80E43073F40DF8F21B57DBE40C72FBCF4.rev
      This is a revocation certificate for the OpenPGP key:

      pub   rsa4096 2023-07-05 [SC] [expires: 2025-07-04]
            A8F721C80E43073F40DF8F21B57DBE40C72FBCF4
      uid          Patrick Cao Huu Thien <patrick.cao_huu_thien@sorbonne-universite.fr>

      A revocation certificate is a kind of "kill switch" to publicly
      declare that a key shall not anymore be used.  It is not possible
      to retract such a revocation certificate once it has been published.

      Use it to revoke this key in case of a compromise or loss of
      the secret key.  However, if the secret key is still accessible,
      it is better to generate a new revocation certificate and give
      a reason for the revocation.  For details see the description of
      of the gpg command "--generate-revocation" in the GnuPG manual.

      To avoid an accidental use of this file, a colon has been inserted
      before the 5 dashes below.  Remove this colon with a text editor
      before importing and publishing this revocation certificate.

      :-----BEGIN PGP PUBLIC KEY BLOCK-----
      Comment: This is a revocation certificate
      [...]
    2. ... sinon le créer:
      $ gpg --output A8F721C80E43073F40DF8F21B57DBE40C72FBCF4.rev --gen-revoke A8F721C80E43073F40DF8F21B57DBE40C72FBCF4
  3. ajouter les autres adresses:
     $ gpg --edit-key A8F721C80E43073F40DF8F21B57DBE40C72FBCF4
     Secret key is available.

     gpg: checking the trustdb
     gpg: marginals needed: 3  completes needed: 1  trust model: pgp
     gpg: depth: 0  valid:   4  signed:   4  trust: 0-, 0q, 0n, 0m, 0f, 4u
     gpg: depth: 1  valid:   4  signed:   0  trust: 0-, 0q, 0n, 0m, 4f, 0u
     gpg: next trustdb check due at 2025-07-04
     sec  rsa4096/B57DBE40C72FBCF4
          created: 2023-07-05  expires: 2025-07-04  usage: SC
          trust: ultimate      validity: ultimate
     ssb  rsa4096/6552C12872B67E3B
          created: 2023-07-05  expires: 2025-07-04  usage: E
     [ultimate] (1). Patrick Cao Huu Thien <patrick.cao_huu_thien@sorbonne-universite.fr>

     gpg> adduid
     Real name: Patrick Cao Huu Thien
     Email address: patrick.cao_huu_thien@upmc.fr
     Comment: ancienne email UPMC
     You selected this USER-ID:
        "Patrick Cao Huu Thien (ancienne email UPMC) <patrick.cao_huu_thien@upmc.fr>"

     Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? O

     sec  rsa4096/B57DBE40C72FBCF4
          created: 2023-07-05  expires: 2025-07-04  usage: SC
          trust: ultimate      validity: ultimate
     ssb  rsa4096/6552C12872B67E3B
          created: 2023-07-05  expires: 2025-07-04  usage: E
     [ultimate] (1)  Patrick Cao Huu Thien <patrick.cao_huu_thien@sorbonne-universite.fr>
     [ unknown] (2). Patrick Cao Huu Thien (ancienne email UPMC) <patrick.cao_huu_thien@upmc.fr>

     gpg> save
  4. signer la nouvelle clé avec l'ancienne:
    $ gpg --edit-key A8F721C80E43073F40DF8F21B57DBE40C72FBCF4
    Secret key is available.

    sec  rsa4096/B57DBE40C72FBCF4
         created: 2023-07-05  expires: 2025-07-04  usage: SC
         trust: ultimate      validity: ultimate
    ssb  rsa4096/6552C12872B67E3B
         created: 2023-07-05  expires: 2025-07-04  usage: E
    [ultimate] (1). Patrick Cao Huu Thien <patrick.cao_huu_thien@sorbonne-universite.fr>
    [ultimate] (2)  Patrick Cao Huu Thien (ancienne email UPMC) <patrick.cao_huu_thien@upmc.fr>

    gpg> sign
    Really sign all text user IDs? (y/N) y
    gpg: using "D7B87DFB479CA02E48A2383C00054A3358D16D27" as default secret key for signing

    sec  rsa4096/B57DBE40C72FBCF4
         created: 2023-07-05  expires: 2025-07-04  usage: SC
         trust: ultimate      validity: ultimate
     Primary key fingerprint: A8F7 21C8 0E43 073F 40DF  8F21 B57D BE40 C72F BCF4

         Patrick Cao Huu Thien <patrick.cao_huu_thien@sorbonne-universite.fr>
         Patrick Cao Huu Thien (ancienne email UPMC) <patrick.cao_huu_thien@upmc.fr>

    This key is due to expire on 2025-07-04.
    Are you sure that you want to sign this key with your
    key "Patrick Cao Huu Thien <patrick.cao_huu_thien@upmc.fr>" (00054A3358D16D27)

    Really sign? (y/N) y

    gpg> save
  5. vérifier les signatures de cette clé:
    $ gpg --list-sign A8F721C80E43073F40DF8F21B57DBE40C72FBCF4
    pub   rsa4096 2023-07-05 [SC] [expires: 2025-07-04]
          A8F721C80E43073F40DF8F21B57DBE40C72FBCF4
    uid           [ultimate] Patrick Cao Huu Thien <patrick.cao_huu_thien@sorbonne-universite.fr>
    sig 3        B57DBE40C72FBCF4 2023-07-05  Patrick Cao Huu Thien <patrick.cao_huu_thien@sorbonne-universite.fr>
    sig          00054A3358D16D27 2023-07-05  Patrick Cao Huu Thien <patrick.cao_huu_thien@upmc.fr>
    uid           [ultimate] Patrick Cao Huu Thien (ancienne email UPMC) <patrick.cao_huu_thien@upmc.fr>
    sig 3        B57DBE40C72FBCF4 2023-07-05  Patrick Cao Huu Thien <patrick.cao_huu_thien@sorbonne-universite.fr>
    sig          00054A3358D16D27 2023-07-05  Patrick Cao Huu Thien <patrick.cao_huu_thien@upmc.fr>
    sub   rsa4096 2023-07-05 [E] [expires: 2025-07-04]
    sig          B57DBE40C72FBCF4 2023-07-05  Patrick Cao Huu Thien <patrick.cao_huu_thien@sorbonne-universite.fr>
  6. changer la clé par défaut dans le fichier ~/.gnupg/gpg.conf:
    default-key A8F721C80E43073F40DF8F21B57DBE40C72FBCF4
  7. exporter la nouvelle clé (voir plus haut)

Sources

Liens Externes

  • «Le manuel de GNU Privacy Guard»
À propos du site Licence Creative Commons Cooked with love in 2014-2023 by pcht
Page mise à jour le 05/07/2023 17:59