[OpenPGP - primaire hors ligne] Garder le secret hors de la machine

Publiez la clé publique pour permettre la vérification des signatures et le chiffrement des messages qui vous sont destinés. Protégez les clés privées qui autorisent vos opérations. Séparez leurs capacités :

Enregistrez ce modèle sous primary_gpg_key_constructor.tpl en remplaçant le nom et l’adresse électronique. Expire-Date: 0 crée ici une clé principale sans expiration ; choisissez une échéance si votre politique l’exige. GnuPG demande la phrase de passe via pinentry.

%echo Generating a RSA key 8192
Key-Type: RSA
Key-Length: 8192
Key-Usage: cert
Name-Real: My Name
Name-Email: something@something
Expire-Date: 0
%commit
%echo done

gpg --batch --generate-key --enable-large-rsa primary_gpg_key_constructor.tpl
gpg --list-secret-keys

Cet exemple utilise --enable-large-rsa pour la clé de 8192 bits. Vérifiez que la clé principale affiche uniquement [C]. La sortie ci-dessous est illustrative :

sec   rsa8192 2023-01-14 [C]
      E6B0933DD47E3B2F823334F0A567B3B17C27BF6D
uid           [ultimate] My Name <something@something>

gpg --expert --edit-key E6B0933DD47E3B2F823334F0A567B3B17C27BF6D

À l’invite gpg>, ajoutez les sous-clés :

• Signature : addkey, RSA (signature seule), 4096 bits, puis une échéance.
• Chiffrement : addkey, RSA (chiffrement seul), 4096 bits, puis une échéance.
• Authentification : addkey, RSA (capacités personnalisées). Désactivez S et E, activez A, puis choisissez la taille et l’échéance.

Les numéros des menus peuvent varier. Choisissez selon la capacité et vérifiez le résultat. Utilisez save pour enregistrer, puis affichez toutes les empreintes :

gpg --fingerprint --fingerprint E6B0933DD47E3B2F823334F0A567B3B17C27BF6D

pub   rsa8192 2023-01-14 [C]
      E6B0 933D D47E 3B2F 8233  34F0 A567 B3B1 7C27 BF6D
uid           [ultimate] My Name <something@something>
sub   rsa4096 2023-01-14 [S] [expires: 2030-01-12]
      61DF 146E F7F6 0971 5E60  46B8 8C75 87C8 6EAC 2F2F
sub   rsa4096 2023-01-14 [E] [expires: 2030-01-12]
      DBBC AE3F 8166 9FF4 75B7  5F35 51D8 8833 7727 23AD
sub   rsa4096 2023-01-14 [A] [expires: 2030-01-12]
      F4CF F234 E969 2304 CC58  D55B D13A E6B6 5E8B E723

Lors du remplacement d’une clé principale, vous pouvez certifier la nouvelle avec l’ancienne avant de retirer celle-ci. Sélectionnez explicitement l’ancienne clé de signature, sans dépendre du choix par défaut de GnuPG :

gpg --local-user "$OLD_FINGERPRINT" --sign-key "$NEW_FINGERPRINT"

Si vous n’avez pas besoin de certification OpenPGP, envisagez age pour chiffrer les fichiers et des clés SSH dédiées pour les connexions. Si votre clé principale OpenPGP reste sur l’ordinateur quotidien, protégez-la par une phrase de passe, conservez un certificat de révocation et testez une sauvegarde chiffrée. Cette configuration expose la clé principale à cet ordinateur ; documentez cette limite.

Exécutez ces exemples dans Bash. Vérifiez d’abord le répertoire GnuPG actif :

gpgconf --list-dirs homedir

Définissez la destination et l’empreinte. Vérifiez que le support chiffré attendu est monté. mountpoint vérifie la présence d’un montage, pas le chiffrement ni l’identité du support.

set -euo pipefail
umask 077
ENCRYPTED_MOUNT="/run/media/user/Encrypted_Device"
EXPORT_DIR="$ENCRYPTED_MOUNT/secrets/gpg"
EXPORT_FILENAME="MySelf_Master_MyComment_private_rsa8192"
EXPORT_FINGERPRINT="E6B0933DD47E3B2F823334F0A567B3B17C27BF6D"
if ! mountpoint -q -- "$ENCRYPTED_MOUNT"; then
    echo "Encrypted device is not mounted at $ENCRYPTED_MOUNT" >&2
    exit 1
fi
install -d -m 0700 -- "$EXPORT_DIR"

Utilisez de nouveaux noms pour chaque version de sauvegarde. Conservez la dernière sauvegarde testée jusqu’à validation de la suivante. Exportez la clé privée complète, les sous-clés opérationnelles, la clé publique et les valeurs ownertrust :

gpg --armor --output "$EXPORT_DIR/$EXPORT_FILENAME.private-key.sec" \
    --export-secret-keys "$EXPORT_FINGERPRINT"
gpg --armor --output "$EXPORT_DIR/$EXPORT_FILENAME.subkeys.sec" \
    --export-secret-subkeys "$EXPORT_FINGERPRINT"
gpg --armor --output "$EXPORT_DIR/$EXPORT_FILENAME.pubkey.asc" \
    --export "$EXPORT_FINGERPRINT"
gpg --list-secret-keys --fingerprint --with-keygrip "$EXPORT_FINGERPRINT" \
    > "$EXPORT_DIR/$EXPORT_FILENAME.keygrip.txt"
gpg --export-ownertrust > "$EXPORT_DIR/gnupg-ownertrust.txt"

Générez les certificats de révocation tant que la clé privée principale est disponible. Protégez-les : toute personne qui en obtient un peut publier la révocation. Ces exemples couvrent les quatre motifs :

printf '%s\n' y 0 "" y | gpg --no-tty --command-fd 0 --armor \
    --output "$EXPORT_DIR/revoke.no-reason.asc" --gen-revoke "$EXPORT_FINGERPRINT"
printf '%s\n' y 1 "" y | gpg --no-tty --command-fd 0 --armor \
    --output "$EXPORT_DIR/revoke.compromised.asc" --gen-revoke "$EXPORT_FINGERPRINT"
printf '%s\n' y 2 "" y | gpg --no-tty --command-fd 0 --armor \
    --output "$EXPORT_DIR/revoke.superseded.asc" --gen-revoke "$EXPORT_FINGERPRINT"
printf '%s\n' y 3 "" y | gpg --no-tty --command-fd 0 --armor \
    --output "$EXPORT_DIR/revoke.no-longer-used.asc" --gen-revoke "$EXPORT_FINGERPRINT"
chmod 0600 -- "$EXPORT_DIR"/*

• private-key.sec : données privées de la clé principale et des sous-clés pour une restauration complète.
• subkeys.sec : sous-clés privées opérationnelles, sans la clé privée principale.
• pubkey.asc : certificat public à distribuer.
• keygrip.txt : identifiants des composants de clé.
• gnupg-ownertrust.txt : valeurs locales de confiance ; vérifiez-les avant de les importer ailleurs.
• revoke.*.asc : certificats de révocation de la clé principale.

Importez la sauvegarde privée complète dans un trousseau temporaire distinct :

umask 077
TEST_GNUPGHOME="$(mktemp -d /dev/shm/gnupg-test.XXXXXX)"
chmod 0700 "$TEST_GNUPGHOME"
gpg --homedir "$TEST_GNUPGHOME" \
    --import "$EXPORT_DIR/$EXPORT_FILENAME.private-key.sec"
gpg --homedir "$TEST_GNUPGHOME" \
    --list-secret-keys --fingerprint --with-keygrip "$EXPORT_FINGERPRINT"

Vérifiez l’empreinte complète, une entrée sec utilisable et les trois entrées ssb. Testez la signature, le déchiffrement d’un fichier de test chiffré auparavant et l’authentification si elle est configurée. Vérifiez également que la clé principale restaurée peut certifier une clé de test. L’affichage du trousseau ne suffit pas à prouver que les clés privées fonctionnent.

Arrêtez les agents temporaires et supprimez uniquement le répertoire de test créé ci-dessus :

case "$TEST_GNUPGHOME" in
    /dev/shm/gnupg-test.*)
        gpgconf --homedir "$TEST_GNUPGHOME" --kill all
        rm -rf -- "$TEST_GNUPGHOME"
        ;;
    *) echo "Unexpected test keyring path" >&2; exit 1 ;;
esac

Partez du répertoire GnuPG normal, sans redéfinition de GNUPGHOME. Dans l’environnement hors ligne de confiance, vérifiez le montage chiffré et importez la sauvegarde dans un répertoire temporaire :

umask 077
ENCRYPTED_MOUNT="/run/media/user/Encrypted_Device"
EXPORT_DIR="$ENCRYPTED_MOUNT/secrets/gpg"
EXPORT_FILENAME="MySelf_Master_MyComment_private_rsa8192"
EXPORT_FINGERPRINT="E6B0933DD47E3B2F823334F0A567B3B17C27BF6D"
mountpoint -q -- "$ENCRYPTED_MOUNT" || exit 1
NORMAL_GNUPGHOME="$(gpgconf --list-dirs homedir)"
GNUPGHOME="$(mktemp -d /dev/shm/gnupg.XXXXXX)"
export GNUPGHOME
chmod 0700 "$GNUPGHOME"
gpg --import "$EXPORT_DIR/$EXPORT_FILENAME.private-key.sec"
gpg --import-ownertrust "$EXPORT_DIR/gnupg-ownertrust.txt"
gpg --list-secret-keys --fingerprint --with-keygrip "$EXPORT_FINGERPRINT"

Vérifiez l’empreinte principale et la disponibilité des composants privés avant de modifier la clé :

gpg --edit-key "$EXPORT_FINGERPRINT"

Les modifications de ce trousseau ne mettent pas à jour les fichiers de sauvegarde. Exportez un nouveau candidat après tout changement de phrase de passe, d’échéance, d’identité, de certification ou de sous-clé :

NEW_BACKUP="$EXPORT_DIR/$EXPORT_FILENAME.private-key.NEW.sec"
gpg --armor --output "$NEW_BACKUP" --export-secret-keys "$EXPORT_FINGERPRINT"
chmod 0600 "$NEW_BACKUP"

Restaurez le candidat dans un second trousseau temporaire et répétez les vérifications. Actualisez et testez aussi les exports des sous-clés et de la clé publique. Archivez ensuite la version précédente et remplacez l’ensemble de sauvegarde. Publiez le certificat public actualisé aux emplacements utilisés par vos correspondants.

case "$GNUPGHOME" in
    /dev/shm/gnupg.*)
        gpgconf --homedir "$GNUPGHOME" --kill all
        rm -rf -- "$GNUPGHOME"
        ;;
    *) echo "Unexpected working keyring path" >&2; exit 1 ;;
esac
unset GNUPGHOME
gpgconf --list-dirs homedir

Vérifiez que le chemin final correspond à NORMAL_GNUPGHOME. Sur l’ordinateur quotidien, importez uniquement le certificat public actualisé et les sous-clés opérationnelles :

gpg --import "$EXPORT_DIR/$EXPORT_FILENAME.pubkey.asc"
gpg --import "$EXPORT_DIR/$EXPORT_FILENAME.subkeys.sec"
gpg --import-ownertrust "$EXPORT_DIR/gnupg-ownertrust.txt"

Vérifiez sec# sur l’ordinateur quotidien et testez les sous-clés opérationnelles. Y importer private-key.sec rend de nouveau la clé privée principale disponible.

Si une sous-clé est compromise, chargez la clé principale dans l’environnement hors ligne et modifiez le certificat :

gpg --expert --edit-key E6B0933DD47E3B2F823334F0A567B3B17C27BF6D

Utilisez key N pour sélectionner la sous-clé concernée. Vérifiez le marqueur de sélection et l’empreinte, exécutez revkey, puis save. Exportez et distribuez le certificat public actualisé. Supprimer localement une clé avec delkey n’informe pas les autres de sa révocation.

Pour une clé principale compromise ou retirée, utilisez le certificat de révocation approprié et distribuez le certificat public révoqué. Conservez les anciennes clés privées de chiffrement si vous devez encore déchiffrer des données historiques, selon votre politique de conservation et de gestion des compromissions.