====== GPG ======

  * [[git:gpg|Utilisation avec Git]]

  * [[https://help.github.com/articles/generating-a-new-gpg-key/]]
  * [[https://help.ubuntu.com/community/GnuPrivacyGuardHowto]]
  * [[https://riseup.net/en/security/message-security/openpgp/best-practices]]
  * [[https://riseup.net/en/security/message-security/openpgp/gpg-keys]]
  * [[https://superuser.com/questions/624343/keep-gnupg-credentials-cached-for-entire-user-session]]
  * [[https://net-security.fr/security/gnupg-introduction-cheat-sheet/]]

  * [[https://linuxfr.org/users/gouttegd/journaux/bien-demarrer-avec-gnupg]]
  * [[https://linuxfr.org/users/gouttegd/journaux/de-la-distribution-des-clefs-openpgp]]
  * [[https://linuxfr.org/users/gouttegd/journaux/de-la-gestion-des-clefs-openpgp]]
  * [[https://linuxfr.org/users/gouttegd/journaux/de-la-confiance-dans-le-monde-openpgp]]

  * [[https://blog.chimrod.com/2021/02/sauvegarder-sa-clef-privee-gpg/|Sauvegarder sa clef privée GPG]]
  * [[https://une-tasse-de.cafe/blog/yubikey/|Yubikey et GPG : sécuriser ses communications]]

  * [[https://9x0rg.com/posts/tech/pgp-je-ne-chiffre-plus-les-emails/|PGP - Je ne chiffre plus les emails]]


Il est important d'exporter la variable suivante dans le shell (à placer dans ''.bashrc'', donc):
<code bash>
export GPG_TTY=$(tty)
</code>


L'application ''seahorse'' permet de gérer les clés GPG.


==== Créer une clé GPG ====

<code bash>
gpg --full-generate-key
</code>
Sélectionner //RSA and RSA//, une longueur de 4096 bits, une date d'expiration (jamais), les informations personnelles et une passphrase.



==== Lister les clés connues ====

<code bash>
gpg --list-keys
gpg --list-secret-keys --keyid-format LONG
</code>

Ce qui se trouve après ''rsa4096/'' est l'ID de la clé, c'est cet identifiant qui est utilisé pour manipuler la clé.



==== Afficher la clé publique ====

<code bash>
gpg --armor --export <id>
</code>
''%%--%%output public-key.asc'' sauvegarde directement la clé dans un fichier.



==== Importer une clé publique ====

<code bash>
# depuis le serveur par défaut dans la configuration de GnuPG:
gpg --search-keys edward-fr@fsf.org

# en précisant le serveur de clés:
gpg --keyserver hkp://pool.sks-keyservers.net --search-keys edward-fr@fsf.org

# depuis un fichier:
gpg --import edward.asc

# depuis l'ID:
gpg --recv-keys DEADBEEF
# ou:
gpg --recv-keys 0xDEADBEEF
</code>

Ensuite, il faut signer la clé importée, pour la marquer comme valide:
<code bash>
gpg --edit-key edward-fr@fsf.org

# afficher l'empreinte:
gpg> fpr

# si l'empreinte correspond à ce qui est annoncé, on peut la signer avec notre clé:
gpg> sign
gpg> quit
</code>

Il est possible de préciser avec quelle clé signer la clé:
<code>
gpg -u ID --edit-key edward-fr@fsf.org
</code>



==== Chiffrer et déchiffrer un contenu ====

  * [[https://www.gnupg.org/gph/en/manual/x110.html]]

Pour chiffrer:
<code bash>
gpg --output config.js.gpg --encrypt --recipient ${adresse_mail} .thelounge/config.js
</code>
L'adresse mail fournie sert à identifier la clé à utiliser pour chiffrer.

  * Pour répondre par défaut oui aux questions, ajouter l'option ''%%--%%yes''.
  * Pour qu'il ne pose pas de question si la clé n'est pas signée, ajouter l'option ''%%--%%trust-model always''.

Pour déchiffrer:
<code bash>
gpg --decrypt encrypted.asc
</code>


==== Vérifier la signature d'un fichier ====

  * [[https://www.gnupg.org/gph/en/manual/x135.html]]

<code bash>
gpg --verify fichier.sig fichier
</code>
La clé publique utilisée pour la signature doit être dans le trousseau de GPG.



==== Ajouter une identité à une clé ====

<code bash>
gpg --edit-key <id>
gpg> adduid
[...]
gpg> save
</code>
La nouvelle adresse sera marquée en confiance ultime une fois les modifications à la clé sauvegardées.

Définir une clé comme principale:
<code bash>
gpg --edit-key <id>
gpg> <numéro de l identité à définir comme principale>
gpg> primary
gpg> save
</code>



==== Supprimer une clé ====

<code bash>
gpg --delete-keys <id>
</code>



==== Communiquer avec un serveur de clé ====

Rafraîchir les clés connues:
<code bash>
gpg --refresh-keys
</code>

Publier sa clé (ou mettre à jour sa clé sur un serveur de clés):
<code bash>
gpg --send-keys alice@example.org
</code>
Rajouter ''%%--%%keyserver certserver.pgp.com'' pour préciser le serveur de clés à utiliser.

Quelques serveurs de clés:
  * https://keyserver.pgp.com/
  * http://pgp.mit.edu/
  * http://keys.gnupg.net/
  * https://keys.openpgp.org (''%%hkps://keys.openpgp.org%%'', serveur de clé utilisé par défaut dans les nouvelles versions de GPG packagées dans Debian)
  * http://keyserver.ubuntu.com

On peut configurer le serveur par défaut dans ''~/.gnupg/gpg.conf'':
<code>
keyserver hkps://keys.openpgp.org
</code>



==== Signer des clés ===

=== Faire signer sa clé : ===
  - distribuer le résultat de<code bash>
gpg --fingerprint DEADBEEF
</code>
  - une fois sa clé signée reçue par mail:<code bash>
gpg --import key.signed.asc
# ou
gpg -d fichier.asc | gpg --import
</code>
  - mettre à jour sa clé sur les serveurs de clés:<code bash>
gpg --send-keys DEADBEEF
</code>

=== Signer une clé : ===

  * [[https://wiki.debian.org/Keysigning]]
  - importer la clé :<code bash>
gpg --recv-keys DEADBEEF
</code>
  - s'assurer que le fingerprint et l'identité clamée correspond à ce que dit le propriétaire de la clé
  - signer la clé:<code bash>
gpg --sign-key DEADBEEF
</code>
  - exporter la clé signée et l'envoyer par mail à son propriétaire :<code bash>
gpg --armor --output DEADBEEF.signed.asc --export DEADBEEF
</code>

Avec ''caff'' (du paquet ''signing-party''), pour facilement signer toutes les sous-clés et envoyer les mails nécessaires ([[https://wiki.debian.org/caff|page Debian]], [[http://www.xryan.net/p/258|un post de blog]]) :
<code bash>
caff DEADBEEF
</code>


=== Divers ===

Il est possible de voir les signatures des clés:
<code bash>
gpg --list-sigs
</code>


Avec les programmes fournis par le paquet ''signing-party'', il est possible de générer une liste de fingerprints prêts à imprimer:
<code bash>
gpg-key2latex DEADBEEF > gpg.tex
</code>

Il est possible de visualiser le graphe des signatures des clés connues localement:
<code bash>
gpg --list-sigs --keyid-format long | sig2dot > sigs.dot 
springgraph < sigs.dot > sigs.png
</code>


==== Prolonger la validité d'une clé ====

<code bash>
gpg --edit-key DEADBEEF
gpg> expire
gpg> 1y
gpg> key 1
gpg> expire
gpg> 1y
gpg> save
</code>
Envoyer la clé sur les serveurs de clés.



==== Redémarrer l'agent GPG ====

<code bash>
gpg-connect-agent reloadagent /bye
</code>



==== Sauvegardes ====

<code bash>
# Sauvegarde aussi de la clé privée:
gpg -o backup.gpg --export-secret-keys alice@example.org

# Sauvegarde de toutes les clés publiques connues:
gpg -o public-keys.gpg --export
gpg --export-ownertrust > trust.txt

# tous les certificats de révocation sont dans ~/.gnupg/openpgp-revocs.d/
</code>

Restauration:
<code bash>
gpg --import backup.gpg
gpg --import public-keys.gpg
gpg --import-ownertrust < trust.txt
</code>


==== Installer sur MacOS ====

    * [[https://alexnorell.com/post/set-up-gpg/|https://alexnorell.com/post/set-up-gpg/]]

<code bash>
brew install gnupg pinentry-mac
brew link gnupg

echo "pinentry-program $(which pinentry-mac)" >>  ~/.gnupg/gpg-agent.conf
gpg-connect-agent reloadagent /bye
</code>


==== Forwarder l'agent GPG par SSH ====

  * [[https://benjamintoll.com/2023/06/07/on-gpg-agent-forwarding/|On gpg-agent Forwarding]]
  * [[https://superuser.com/questions/161973/how-can-i-forward-a-gpg-key-via-ssh-agent]]

Envoyer le trousseau de clés publiques sur la machine distante :
<code bash>
scp ~/.gnupg/pubring.kbx remote:.gnupg/
</code>

Trouver où sont les sockets, à la fois sur la machine locale et distante :
<code bash>
gpgconf --list-dirs agent-socket
</code>
Supprimer les sockets potentiellement déjà existants.

Sur la machine distante, ''gpg-agent'' ne doit pas être lancé. Pour éviter le démarrage automatique :
<code bash>
echo no-autostart >> "$HOME/.gnupg/gpg.conf"
</code>

Sur la machine distante, il faut ajouter une option au serveur SSH :
<code bash>
echo "StreamLocalBindUnlink yes" | sudo tee -a /etc/ssh/sshd_config
</code>

Se connecter en forwardant la socket :
<code bash>
# -R socket_distante:socket_locale
ssh -R /run/user/1000/gnupg/S.gpg-agent:/Users/philippe/.gnupg/S.gpg-agent -o "StreamLocalBindUnlink=yes" vm-debian-sid
</code>

Sur la machine distante, on peut ensuite tester :
<code bash>
gpg-connect-agent "KEYINFO --list" /bye
gpg --clear-sign $file_to_sign
</code>


==== Dumper le contenu d'une clé GPG ====

https://cirw.in/gpg-decoder ([[https://github.com/ConradIrwin/gpg-decoder]])