<!doctype linuxdoc system>

<article>

<!--
    Utilisation de PGP/GPG
    Copyright (C) 2000  Emmanuel Fleury <fleury@lsv.ens-cachan.fr>

    This document is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License as
    published by the Free Software Foundation; either version 2 of the
    License, or (at your option) any later version.

    This work is distributed in the hope that it will be useful, but
    WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
    General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this work; see the file COPYING. If not, write to the
    Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
    USA.
-->

<!--
$Log:$
-->

<title>Utilisation de PGP/GPG
<author>par <htmlurl name="Emmanuel Fleury" url="mailto:fleury@lsv.ens-cachan.fr
">
<date>03/02/2000

<abstract>
Ce document traite du fonctionnement et de l'utilisation courante des
logiciels cryptographiques PGP (Pretty Good Privacy) et GPG (GNU Privacy 
Guard).
</abstract>

<toc>

<sect>Copyright<p>

Copyright (c) 1999
<url name="Emmanuel Fleury" url="mailto:fleury@lsv.ens-cachan.fr">

Ce document peut être reproduit et distribué, dans son intégralité ou
partiellement, par quelque moyen physique que ce soit. Il reste malgré
tout sujet aux conditions suivantes :

<p><itemize>
<item> La mention du copyright doit être conservée, et la présente
section préservée dans son intégralité sur toute copie intégrale ou
partielle.

<item>Si vous distribuez ce travail en partie, vous devez mentionner
comment obtenir une version intégrale de ce document et être en mesure
de la fournir.

<item>Des portions de ce document peuvent être utilisées comme
illustrations d'une présentation ou comme remarques sans autorisation
préalable si les citations d'usage sont réalisées.
</itemize>

<sect>Introduction<p>

<sect1>À propos de ce document<p> Ce document ne se veut absolument pas
exhaustif. Il est d'ailleurs conseillé de se reporter aux pages de
manuel et aux différentes documentations disponibles sur le Web sur les
différents logiciels cités. Ce document a pour but d'être une
introduction à l'utilisation sous Unix des programmes cryptographiques
PGP et GPG.

<sect1>Les algorithmes à clefs asymétriques<p>
Le principe des algorithmes cryptographiques à clefs asymétrique repose
sur deux clefs. L'une privée (Ks), qui sera l'information secrète.
L'autre publique (Kp), que l'on distribue à tout le monde. L'algorithme
de cryptage est f(m,K)=m' avec K une clef, m un message et m' le message 
crypté.

Le couple de clefs est choisi de telle sorte que
f(f(.,Ks),Kp)=f(f(.,Kp),Ks)=Id.

<sect1>À quoi ça sert?<p>
La propriété de cet algorithme de cryptage permet de réaliser un certain
nombre d'opérations.

<sect2>Échange de messages cryptés<p>
C'est l'utilisation la plus classique. Considérons qu'Alice veuille
envoyer un message m à Bob.
<enum>
<item>Alice crypte m avec la clef publique de Bob,
<item>Alice envoie le message crypté à Bob,
<item>Bob décrypte le message avec sa clef privée.
</enum>

<sect2>Authentification<p>
Comment Bob peut-il s'assurer que c'est bien Alice qui lui a écrit?
<enum>
<item>Alice crypte m avec sa clef privée,
<item>Alice envoie m suivi du message crypté par sa clef privée à Bob,
<item>Bob reçoit le message et s'assure qu'il provient bien d'Alice en
décryptant le message attaché avec la clef publique d'Alice et en
comparant le message résultant avec le message reçu en clair.
</enum>

On peut évidemment combiner l'opération d'authentification avec celle du 
cryptage simple.

<sect2>Gestion des clefs<p>
Le principe des algorithmes à clef publique repose sur un problème
fondamental, celui de la gestion des clefs. Effectivement, faut-il faire
confiance à une autorité centrale qui gère les clefs publiques de tout
le monde, ou bien peut-on diluer cette confiance en attribuant des degré
de confiance aux clefs publiques que l'on trouve? PGP/GPG ont résolu le
problème en utilisant la deuxième solution (confiance diluée). Ces
logiciels permettent d'ailleurs de gérer efficacement une liste de clefs
(<em>ring key</em>) avec leur degré de confiance.

Néammoins, il faut savoir qu'il existe un certain nombre de serveur de
clefs publiques sur Internet, la confiance qu'on peut leur accorder est
toute relative, mais ils restent cependant utile pour se procurer la
clef de quelqu'un ou faciliter la tâche de gens qui cherchent à vous
contacter (Par exemple <url name="keyserver"
url="http://www.keyserver.net/en/">).

<sect1>PGP (Pretty Good Privacy)<p>
PGP est un logiciel de cryptage qui a vu le jour en 1991. Il a été écrit
par Phil R. Zimmerman et a été très largement distribué sur Internet,
violant ainsi la loi américaine qui interdit l'exportation de logiciels
cryptographiques. Son usage s'est très vite imposé parmi les
utilisateurs assidus d'Internet et il est devenu un standard de fait.

Ce logiciel est basé sur un cryptage à base de clefs asymétriques de
type RSA.

<sect1>GPG (GNU Privacy Guard)<p>
GnuPG est une implantation complete et libre de PGP. N'utilisant ni l'IDEA
ou le RSA, il peut être utilisé sans aucune restriction d'aucun type.
GnuPG est une application RFC2440 (OpenPGP).

La version 1.0.0 est distribuée depuis le 7 septembre 1999 et le projet
est soutenu par la gouvernement Allemand (Ministère Fédéral de l'Économie
et de la Technologie) et devrait être utilisé par l'administration
fédérale allemande d'ici peu.

Il possède les mêmes fonctionnalités que PGP, mais ses auteurs affirment
qu'il est plus sûr.

<bf>Ce logiciel est entièrement compatible avec PGP.</bf> C'est à dire
que tous les messages encryptés avec l'un sont décryptables par l'autre
et vice-versa De plus, les clefs générés par l'un sont utilisables par
l'autre et vice-versa.

<sect2>Pourquoi utiliser GPG plutôt que PGP<p>
PGP est développé par une entreprise dont les sources de revenus
proviennent de la vente de ce logiciel. Les versions librement
téléchageables et internationales ont quelques versions de retard par
rapport à la version courante (mais sont distribué avec les sources). De
plus, la pérénité de ce logiciel dépend fortement de la maison mère.
À l'inverse, GPG est totalement libre. Vous pouvez toujours accéder
librement à la dernière version et le projet ne dépend pas d'une
entreprise ou d'un gouvernement.

<sect>Quelques conseils pratiques<p>
<sect1>Principe de confiance<p>
Dans des logiciels comme PGP/GPG, les clefs sont gérées selon un critère
de confiance. Suivant que l'on est sûr ou pas qu'une clef correspond
bien à son interlocuteur, on accorde un certain degré de confiance à
cette clef (de 1 = pas sûr à 4 = extrêmement sûr).

On accorde, suivant ses propres critères, un certain degré de confiance
à une clef récupérée sur une page Web ou par l'intermédiaire d'un tiers
ou encore auprès de la personne elle-même.

La gestion de ces degrés de confiance est à l'entière discrétion des
utilisateurs et peut s'avérer une faille importante si on est trop
laxiste en ce qui les concernes. Mais, d'un autre coté, cela permet de
se passer d'un tiers de confiance qui centraliserait tout.

<sect1>Stockage des clefs privés<p>
Le stockage de la clef privée se fait sur son disque dur. Afin de
rendre la récupération de cette clef plus difficile, cette clef privée
est cryptée et on y accède via une «&nbsp;pass-phrase&nbsp;».

Le choix de cette pass-phrase est important car elle vous servira chaque 
fois que vous désirerez utiliser votre clef privée. On doit lui
appliquer les même consignes de sécurité que pour votre mot de passe ou
pour votre code de carte de crédit.

<sect>PGP<p>
PGP s'utilise via quatre commandes&nbsp;:
<itemize>
<item><tt>pgpe</tt> (PGP encrypt)&nbsp;: Qui assure les fonctions de
cryptage et de cryptage avec signature,
<item><tt>pgps</tt> (PGP sign)&nbsp;: Qui assure la fonction de
signature simple,
<item><tt>pgpk</tt> (PGP key)&nbsp;: Qui permet la gestion des clefs
(ajout, création, modification, destruction),
<item><tt>pgpv</tt> (PGP verify)&nbsp;: Qui assure les fonctions de
décryptage et de vérification de signature.
</itemize>

<sect1>Création d'une clef<p>
Tapez la commande <tt>pgpk -g</tt>.

<code>
Choose the type of your public key:
  1)  DSS/Diffie-Hellman - New algorithm for 5.0 (default)
  2)  RSA
Choose 1 or 2: 
</code>

Cette étape permet de choisir l'algorithme qui va générer la clef. Il
faut savoir que l'algorithme DSS/Diffie-Hellman est considéré à l'heure
actuelle comme plus sûr que RSA.

<code>
Pick your public/private keypair key size:
(Sizes are Diffie-Hellman/DSS; Read the user's guide for more information)
 1)   768/768  bits- Commercial grade, probably not currently breakable
 2)  1024/1024 bits- High commercial grade, secure for many years
 3)  2048/1024 bits- "Military" grade, secure for forseeable future(default)
 4)  3072/1024 bits- Archival grade, slow, highest security
Choose 1, 2, 3 or 4, or enter desired number of Diffie-Hellman bits
(768 - 4096): 
</code>

La longueur de la clef détermine la complexité de l'opération de
cryptage/décryptage et en même temps le niveau de sécurité auquel vous
vous situez. En règle générale, le niveau 2 suffit amplement pour un
particulier, mais cela dépend de la législation du pays où vous êtes
(restriction sur la taille des clefs) et des informations que vous allez
avoir à crypter.

<code>
You need a user ID for your public key.  The desired form for this
user ID is your FULL name, followed by your E-mail address enclosed in
<angle brackets>, if you have an E-mail address.  For example:
  Joe Smith <user@domain.com>
If you violate this standard, you will lose much of the benefits of
PGP 5.0's keyserver and email integration.
Enter a user ID for your public key:
</code>

Permet de donner un nom à une clef. Par la suite vous pourrez faire
référence à cette clef simplement par le nom, le prénom ou même
l'adresse électronique.

<code>
Enter the validity period of your key in days from 0 - 999
0 is forever (and the default): 
</code>

Dépend des moyens de calcul que possèdent les gens qui pourraient
vouloir lire vos messages. En cryptanalyse, la puissance de calcul seule
ne veut rien dire. Il faut aussi considérer le temps dont on dispose
pour décrypter l'information avant qu'elle ne perde sa validité. Si vous
n'intéressez que des particuliers, vous pouvez probablement garder votre
paire de clefs indéfiniment.

<code>
You need a pass phrase to protect your private key(s).
Your pass phrase can be any sentence or phrase and may have many
words, spaces, punctuation, or any other printable characters.
Enter pass phrase:
Enter again, for confirmation:
Enter pass phrase:
</code>

La <it>pass-phrase</it> sert à protéger l'accès à votre clef privé sur
le disque-dur. En effet, la clef privée n'est certainement pas écrite en
clair sur votre compte. Cette <it>pass-phrase</it> permet de
reconstituer votre clef privé. Elle vous sera demandée à chaque fois que
vous aurez besoin votre clef privé.

<bf>Ne l'oubliez pas!</bf>

Mais évitez de l'inscrire à un endroit où quelqu'un pourrait la lire.

<code>
If you wish to send this new key to a server, enter the URL of the server,
below.  If not, enter nothing.
</code>

Cette étape vient après la création de la paire de clef, elle permet de
mettre à jour automatiquement votre clef sur les serveurs de clefs sur
lesquels vous êtes répertoriés.

Et voila, vous avez maintenant une paire de clefs qui sont stockées dans 
le répertoire <tt>.pgp</tt> situé à votre racine.

<sect1>Gestion des clefs<p>
<sect2>Extraction d'une clef<p>
Vous avez donc une paire de clef. Mais pour pouvoir communiquer, il vous 
faut envoyer votre clef publique à vos correspondants. Pour cela, nous
allons extraire votre clef publique de votre base de clefs avec la
commande <tt>pgpk -x &lt;user-id&gt; -o mykey.pgp</tt>.

Le fichier <tt>mykey.pgp</tt> devrait contenir&nbsp;:
<code>
-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: PGPfreeware 5.0i for non-commercial use

mQGiBDi83BIRBADu3L6QPiVSqk5mw3sc0mpRibwGSNbrhaeuMjoKWw1mNl4rZI3I
w25A/BYXxId50LfIXKCSyKmhykzbzoYTeUMDbDH5OBG8kJQZ2uxQtgjtSnGT4dOJ
fQmJdUHfdT4JTw7hCmBcdZvpBnWggg1KSzlMDY64HYff0B9Zj/c+oee2ZQCg/wj0
...
GeDFyd/IxJE1XYpGPWpGfIkAPwMFGDi9OF5MBlCJG6RMgRECNNQAnioq2StX/5co
jhN/5BoTYpia3O5HAKCV5/UtcCvMQTXgxGpItxoGjsilfg==
=4y8h
-----END PGP PUBLIC KEY BLOCK-----
</code>

Ce fichier contient votre clef publique que vous pouvez envoyer à vos
correspondants. De la même façon, vous pouvez extraire la clef publique
de n'importe quel utilisateur présent dans votre base de clef PGP.

<sect2>Ajout d'une clef<p>
Si l'un de vos correspondants vous communique une clef que vous désirez
ajouter à votre base, il suffit de la sauver dans un fichier et
d'exécuter la commande <tt>pgpk -a &lt;filename&gt;</tt>.

<sect2>Informations sur les clefs répertoriées<p>
Obtenir la liste de toutes les clefs de sa base se fait par un <tt>pgpk
-l</tt>. Pour obtenir encore plus d'informations on peut faire un
<tt>pgpk -ll</tt>.

Il est aussi possible d'extraire des informations sur un seul
utilisateur en spécifiant l'<tt>user-id</tt> de celui-ci&nbsp;:

<tt>pgpk -l &lt;user-id&gt;</tt>

<code>
bash$ pgpk -l dupont
Type Bits KeyID      Created    Expires    Algorithm       Use
sec+ 1024 0x1BA44C81 2000-03-01 ---------- DSS             Sign & Encrypt
sub  1024 0xA0BAC7FA 2000-03-01 ---------- Diffie-Hellman
uid  Jean Dupont <dupont@jean.fr>
</code>

<sect2>Modification d'une clef<p>
Éditer les attributs d'une clef se fait par la commande <tt>pgpk -e
&lt;user-id&gt;</tt>. Lorsqu'il s'agit de sa propre clef, on peut
modifier son <tt>user-id</tt> et sa <it>pass-phrase</it>.

Dans l'exemple, suivant l'utilisateur dupont a deux paires de
clefs&nbsp;:
<code>
bash$ pgpk -e dupont
Please select a key to edit:
 1)
sec+ 1024 0x1BA44C81 2000-03-01 ---------- DSS             Sign & Encrypt
sub  1024 0xA0BAC7FA 2000-03-01 ---------- Diffie-Hellman
uid  Jean Dupont <dupont@jean.fr>
 2)
sec  1024 0x498FBF8C 2000-03-01 ---------- DSS             Sign & Encrypt
sub  1024 0x7AF22D31 2000-03-01 ---------- Diffie-Hellman
uid  Jean Dupont <dupont@jean.fr>
Choose one of the above:  1

  1024 bits, Key ID 0x1BA44C81, created 2000-03-01
   "Jean Dupont <dupont@jean.fr>"

Do you want to unset this key as axiomatic [y/N]? N
Do you want to add a new user ID [y/N]? N
Do you want to change your pass phrase (y/N)? N
Do want to set this as your default key [y/N]? y
Keyrings updated.
</code>

Si la clef en question n'est pas à vous, vous pouvez uniquement modifier 
la confiance que vous avez dans l'utilisateur.

<code>
pub  1024 0x31BF8027 2000-03-01 2002-01-30 DSS             Sign & Encrypt
sub  2048 0xA6CEA8F6 2000-03-01 2002-01-30 Diffie-Hellman
uid  John Doe <doe@john.org>

  1024 bits, Key ID 0x31BF8027, created 2000-03-01
   "John Doe <doe@john.org>"

Would you trust this key owner to act as an introducer and
certify other people's public keys to you?
(1=I don't know. 2=No. 3=Usually. 4=Yes, always?
</code>

<sect2>Destruction d'une clef<p>
Enfin, vous pouvez révoquer (effacer) une clef en faisant <tt>pgpk -r
&lt;user-id&gt;</tt>. En reprenant l'exemple de Jean Dupont qui avait
deux clefs, on a &nbsp;:
<code>
Please select a key to be removed:
 1)
sec+ 1024 0x1BA44C81 2000-03-01 ---------- DSS             Sign & Encrypt
sub  1024 0xA0BAC7FA 2000-03-01 ---------- Diffie-Hellman
uid  Jean Dupont <dupont@jean.fr>
 2)
sec  1024 0x498FBF8C 2000-03-01 ---------- DSS             Sign & Encrypt
sub  1024 0x7AF22D31 2000-03-01 ---------- Diffie-Hellman
uid  Jean Dupont <dupont@jean.fr>
Choose one of the above:  2

The following key has been selected to be removed:

sec  1024 0x498FBF8C 2000-03-01 ---------- DSS             Sign & Encrypt
sub  1024 0x7AF22D31 2000-03-01 ---------- Diffie-Hellman
uid  Jean Dupont <dupont@jean.fr>

Do you wish to remove this key from your public and private keyrings?
[y/N]? y
Removed.
</code>

<sect1>Cryptage<p>
<sect2>Cryptage simple<p>
Le cryptage d'un fichier se fait par la commande&nbsp;:

<tt>pgpe -r &lt;destinataire-id&gt; -a -o &lt;outfile&gt;
&lt;filename&gt;</tt>

L'option <tt>-a</tt> permet de générer un cryptage en ASCII, il est 30%
plus gros, mais passe sans problème par le courrier électronique.

Par exemple, si Jean Dupont veut écrire à John Doe en signant son
message, on aura&nbsp;:

<code>
bash$ pgpe -r doe -s -a -o crypt-message.pgp message
A private key is required to make a signature.
Need a pass phrase to decrypt private key:
  1024 bits, Key ID 1BA44C81, Created 2000-03-01
   "Jean Dupont <dupont@jean.fr>"
Enter pass phrase:
Pass phrase is good.
  1024 bits, Key ID 1FA54D81, Created 2000-03-01
   "John Doe <doe@john.org>"

Creating output file crypt-message.pgp
</code>

<sect2>Cryptage avec signature<p>
On peut combiner l'opération de cryptage d'un message avec l'opération
de signature. il suffit de rajouter l'option <tt>-s</tt>&nbsp;:

<tt>pgpe -r &lt;destinataire-id&gt; -s -a -o &lt;outfile&gt;
&lt;filename&gt;</tt>

<sect2>Signature simple d'un message<p>
On utilise le programme <tt>pgps</tt> avec les options suivantes&nbsp;:

<tt>pgps -a -o &lt;outfile&gt; &lt;filename&gt;</tt>

<sect2>Décryptage et vérification de signature<p>
On utilise le programme <tt>pgpv</tt> avec les options suivantes&nbsp;:

<tt>pgpv -o &lt;outfile&gt; &lt;filename&gt;</tt>

Par exemple, si John Doe veut lire le message de Jean Dupont, on
aura&nbsp;:
<code>
bash$ pgpv -o message crypt-message.pgp
Message is encrypted.
Need a pass phrase to decrypt private key:
  1024 bits, Key ID A0BAC7FA, Created 2000-03-01
Enter pass phrase:
Pass phrase is good.
Opening file "message" type binary.
Good signature made 2000-03-01 18:17 GMT by key:
  1024 bits, Key ID 1BA44C81, Created 2000-03-01
   "Jean Dupont <dupont@jean.fr>"
</code>

<sect2>Quelques astuces<p>
Vous verrez souvent apparaître le message&nbsp;:

<tt>Cannot open configuration file ~/.pgp/pgp.cfg</tt>

Pour ne plus l'avoir, il suffit de faire un fichier vide
<tt>~/.pgp/pgp.cfg</tt>.

<sect>GPG<p>
GPG est la version GNU de PGP, ce logiciel est entièrement sous licence
GPL, y compris les algorithmes de cryptages utilisés. Il se présente
sous la forme d'un seul programme que l'on dirige via des options en
ligne de commande.

D'une manière générale, il est préférable d'utiliser GPG qui ne dépend
directement d'aucun organisme ou entreprise.

GPG reprend exactement les même principes que PGP, on ne s'attardera pas 
sur les explications (se référer aux sections équivalente sur PGP pour
plus d'information).

<sect1>Création d'une clef<p>
La création d'une clef se fait par un appel à la ligne de commande
suivante&nbsp;: <tt>gpg &horbar;&horbar;gen-key</tt>
<code>
gpg (GnuPG) 1.0.1; Copyright (C) 1999 Free Software Foundation, Inc.
This program comes with ABSOLUTELY NO WARRANTY.
This is free software, and you are welcome to redistribute it
under certain conditions. See the file COPYING for details. 

Sélectionnez le type de clé désiré :
   (1) DSA et ElGamal (défaut)
   (2) DSA (signature seule)
   (4) ElGamal (signature et chiffrement)
Votre choix ?

Préparation à la génération d'une nouvelle paire de clés ELG-E.
            la taille minimale est  768 bits
          la taille par défaut est 1024 bits
 la taille maximale conseillée est 2048 bits
Quelle taille de clé désirez-vous ? (1024)

Spécifiez combien de temps cette clé devrait être valide.
         0 = la clé n'expire pas
      <n>  = la clé expire dans n jours
      <n>w = la clé expire dans n semaines
      <n>m = la clé expire dans n mois
      <n>y = la clé expire dans n ans
La clé est valide pour ? (0)

Vous avez besoin d'un nom d'utilisateur pour identifier votre clé ; le
programme le construit à partir du nom réel, d'un commentaire et d'une
adresse e-mail de cette manière:
   « Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de> »
Nom réel :   Jean Dupont
Adresse e-mail : dupont@jean.fr
Commentaire : Ma première clef GPG
Entrez le mot de passe :
Répétez le mot de passe :
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. 
</code>

<sect1>Gestion des clefs<p>
<sect2>Extraction d'une clef<p>
Vous avez donc une paire de clef. Mais pour pouvoir communiquer, il vous 
faut envoyer votre clef publique à vos correspondants. Pour cela, nous
allons extraire votre clef publique de votre base de clefs avec la
commande <tt>gpg &horbar;&horbar;export &horbar;&horbar;armor
&lt;user-id&gt;</tt>

L'option <tt>&horbar;&horbar;armor</tt> est là pour forcer la clef à
être codée en <tt>ASCII</tt>.

On obtient&nbsp;:

<code>
-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: GnuPG v1.0.1 (Linux)
Comment: For info see http://www.gnupg.org

mQGiBDi+PEIRBACYyvjLmmTl/KZq0rHb35SNhRh19ZZI0YZ+MqRg2rWldTAAgxTd
...
-----END PGP PUBLIC KEY BLOCK-----
</code>

<sect2>Ajout d'une clef<p>

<tt>gpg &horbar;&horbar;import &lt;filename&gt;</tt>

Par exemple&nbsp;:

<code>
gpg: clé A4A7E29F : clé publique importée
gpg:        Quantité totale traitée : 1
gpg:                       importée : 1 
</code>

<sect2>Informations sur les clefs répertoriées<p>

<tt>gpg &horbar;&horbar;list-keys</tt>

<code>
pub  1024D/1AB2C904 2000-03-02 Jean Dupont <dupont@jean.fr>
sub  1024g/49D54573 2000-03-02

pub  1024D/31BF8027 2000-03-01 John Doe <doe@john.org>
sub  2048g/A6CEA8F6 2000-03-01

pub  1024D/1BA44C81 2000-03-01 John Smith <smith@john.org>
sub  1024g/A0BAC7FA 2000-03-01
</code>

<sect2>Modification d'une clef<p>

<tt>gpg &horbar;&horbar;edit-key &lt;user-id&gt;</tt>

<code>
La clé secrète est disponible.
pub  1024D/1AB2C904  created: 2000-03-02 expires: never      trust: -/u
sub  1024g/49D54573  created: 2000-03-02 expires: never
(1)  Emmanuel Fleury <fleury@lsv.ens-cachan.fr>
Commande>
</code>
On peut ensuite entre en ligne de commande les différentes modifications 
de sa clef. Pour mémoire, les différentes commandes sont&nbsp;:
<itemize>
<item><tt>quit</tt>&nbsp;: quitter la ligne de commande
<item><tt>save</tt>&nbsp;: enregistrer et quitter
<item><tt>help</tt> ou <tt>?</tt>&nbsp;: afficher cette aide 
<item><tt>fpr</tt>&nbsp;:  afficher l'empreinte
<item><tt>list</tt>&nbsp;: lister la clef et les noms d'utilisateurs
<item><tt>uid</tt>&nbsp;: sélectionner le nom d'utilisateur N
<item><tt>key</tt>&nbsp;: sélectionner la clef secondaire N
<item><tt>check</tt>&nbsp;: lister les signatures
<item><tt>sign</tt> &nbsp;: signer la clef
<item><tt>lsign</tt>&nbsp;: signer la clef localement
<item><tt>adduid</tt>&nbsp;: ajouter un utilisateur
<item><tt>deluid</tt>&nbsp;: enlever un utilisateur
<item><tt>addkey</tt>&nbsp;: ajouter une clef secondaire
<item><tt>delkey</tt>&nbsp;: enlever une clef secondaire
<item><tt>delsig</tt>&nbsp;: supprimer les signatures
<item><tt>expire</tt>&nbsp;: changer la date d'expiration
<item><tt>toggle</tt>&nbsp;: passer de la liste des clefs secrètes aux clefs
privées et inversement
<item><tt>pref</tt>&nbsp;: lister les préférences
<item><tt>passwd</tt>&nbsp;: changer le mot de passe
<item><tt>trust</tt>&nbsp;: changer la confiance
<item><tt>revsig</tt>&nbsp;: révoquer les signatures
<item><tt>revkey </tt>&nbsp;: révoquer une clef secondaire
<item><tt>disable</tt>&nbsp;: désactiver une clef
<item><tt>enable</tt>&nbsp;: activer une clef
</itemize>
<sect2>Destruction d'une clef<p>

Détruire une clef secrète&nbsp;:

<tt>gpgp &horbar;&horbar;delete-secret-key &lt;user-id&gt;</tt>

<code>
sec   768G/A4A7E29F 2000-03-01   John Doe <doe@john.org>
 
Enlever cette clé du porte-clés ? o
C'est une clé secrète - faut-il vraiment l'effacer ? o
</code>

Détruire une clef publique&nbsp;:

<tt>gpg &horbar;&horbar;delete-key &lt;user-id&gt;</tt>

<sect1>Cryptage d'un message<p>
<sect2>Cryptage simple<p>

<tt>gpg &horbar;&horbar;armor &horbar;r &lt;destinataire&gt; -o &lt;output&gt;
&horbar;&horbar;encrypt &lt;filename&gt;</tt>

L'option <tt>&horbar;&horbar;armor</tt> permet de générer un cryptage en
ASCII.

<sect2>Signature simple d'un message<p>

<tt>gpg &horbar;&horbar;sign &lt;filename&gt;</tt>

<sect2>Cryptage avec signature<p>
Il suffit de combiner les options&nbsp;:

<tt>gpg &horbar;&horbar;sign  &horbar;&horbar;armor &horbar;&horbar;encrypt &lt;destinataire&gt;
&lt;filename&gt;</tt>

<sect2>Décryptage et vérification de signature<p>

<tt>gpg &horbar;&horbar;decrypt -o &lt;output&gt; &lt;filename&gt;</tt>

<sect>Les interfaces utilisateurs<p>
Il existe un très grand nombre d'interfaces utilisateurs pour divers
gestionnaires de courriers électroniques (pine, mutt, emacs, ...), nous
ne détaillerons ici que Kmail (qui est le plus simple à utiliser à mon
avis).

Il est tout de même important de signaler que Netscape ne gère pas
PGP/GPG pour des raisons commerciales et historiques. Il faudra attendre
Mozilla (Netscape 5.0) pour avoir un support cryptographique de ce type.

<sect1>Kmail<p>
Kmail est un gestionnaire de courrier électronique sous KDE. Il intègre
notamment des fonctions de cryptage, signature et gestion des clefs du
logiciel PGP. Il nécessite tout de même que vous ayez créé une paire de
clefs avec PGP.

<sect2>Configuration<p>
Aller dans le menu <tt>File</tt> et choisissez <tt>Setting</tt>, puis
cliquez sur l'onglet <tt>PGP</tt>. Dans la case <tt>Identity</tt> mettez 
le <tt>user-id</tt> de votre clef.

<sect2>Utilisation<p>
Lors de la composition d'un mail, le composeur propose des icônes
permettant le cryptage (symbolisé par une clef) et la signature du
message (symbolisé par une plume écrivant). En fonction de l'adresse du
ou des destinataires, le cryptage est fait automatiquement.

Il est aussi possible d'envoyer sa clef publique ou l'une de celle que
vous avez dans votre base de clefs. Choisissez le menu <tt>Attach</tt>,
puis <tt>Attach public key</tt>.

<bf>Note</bf>&nbsp;: L'option <tt>Attach my public key</tt> semble
boguée, évitez de l'utiliser.

<sect>Liens utiles<p>

<itemize>
<item><url name="PGP International" url="http://www.pgpi.org/">
<item><url name="GnuPG" url="http://www.gnupg.org/">
<item><url name="OpenPGP" url="http://www.gnupg.org/rfc2440.html">
<item><url name="Serveur de clefs" url="http://www.keyserver.net/en/">
<item><url name="Mailcrypt"
url="http://www.nb.net/~lbudney/linux/software/mailcrypt.html">
<item><url name="pgp4pine" url="http://azzie.robotics.net/">
</itemize>

<!-- sgml2latex -p a4 -l fr -c latin -o ps pgp.sgml -->

</article>
