web-dev-qa-db-fra.com

Comment rendre la clé publique gpg auto trust?

J'essaie d'ajouter ma clé publique GPG dans le cadre du processus d'installation de notre appliance. L'objectif est de chiffrer tous les fichiers importants, tels que les journaux, avant que l'administrateur les récupère dans son portail local à l'aide de l'administrateur, puis les déchiffre avec une clé privée . en utilisant la commande gpg --import. Mais je me suis rendu compte que la clé est nécessaire pour être approuvé/signé avant de procéder à tout cryptage Comment faire en sorte que cette clé soit approuvée sans aucune intervention humaine au moment de l’installation? nous utilisons kickstart pour automatiser.

Merci d'avance pour toute aide.

encryptionubuntu-12.04gnupgappliance
20
user1366786

Votre question est vraiment "Comment puis-je chiffrer une clé sans que le lecteur ne craigne le fait que la clé n’est pas fiable?"

Une réponse est que vous pouvez signer la clé.

gpg --edit-key YOUR_RECIPIENT
sign
yes
save

L'autre est que vous pourriez dire à gpg d'aller de l'avant et de faire confiance.

gpg --encrypt --recipient YOUR_RECIPIENT --trust-model always YOUR_FILE
12
Ray

Par coïncidence, j'ai une situation similaire à celle de l'OP. J'essaie d'utiliser des clés publiques/privées pour signer et chiffrer les micrologiciels de différents périphériques intégrés. Comme aucune réponse ne montre encore comment ajouter de la confiance à une clé que vous avez déjà importée, voici ma réponse.

Après avoir créé et testé les clés sur une machine de test, je les ai exportées au format ascii:

$ gpg --export -a <hex_key_id> > public_key.asc
$ gpg --export-secret-keys -a <hex_key_id> > private_key.asc

Puis copié de manière sécurisée et importé sur le serveur de compilation:

$ gpg --import public_key.asc
$ gpg --import private_key.asc

Important: ajouter de la confiance

Maintenant, éditez la clé pour ajouter une confiance ultime:

$ gpg --edit-key <[email protected]>

À l'invite gpg>, tapez trust, puis 5 pour une confiance ultime, puis y pour confirmer, puis quit.

Maintenant testez-le avec un fichier test:

$ gpg --sign --encrypt --yes --batch --status-fd 1 --recipient "recipient" --output testfile.gpg testfile.txt

qui rapporte

...
[GNUPG:] END_ENCRYPTION

sans faire confiance, j'obtiens diverses erreurs (non limitées aux suivantes):

gpg: There is no assurance this key belongs to the named user
gpg: testfile.bin: sign+encrypt failed: Unusable public key
11
thinkOfaNumber

Ajoutez trusted-key 0x0123456789ABCDEF à votre ~/.gnupg/gpg.conf en remplaçant le keyid. Cela revient à faire confiance à cette clé, ce qui signifie que les certifications effectuées par celle-ci seront acceptées comme valides. Le marquage de cette clé comme valide sans faire confiance est plus difficile et nécessite soit une signature, soit le passage du modèle de confiance à direct. Si vous êtes sûr de n'importer que des clés valides, vous pouvez simplement marquer toutes les clés comme valides en ajoutant trust-model always. Dans ce dernier cas, veillez à désactiver la récupération automatique de la clé (non activée par défaut).

5
Helmut Grohne

Cela a fonctionné pour moi:

Essayer de chiffrer un fichier répond par ceci:

gpg -e --yes -r <uid> <filename>

It is NOT certain that the key belongs to the person named
in the user ID.  If you *really* know what you are doing,
you may answer the next question with yes.

Use this key anyway? (y/N)

That causes my Shell script to fail.

Donc je:

$gpg --edit-key <uid>

gpg> trust

Please decide how far you trust this user to correctly verify other 
users' keys (by looking at passports, checking fingerprints from 
different sources, etc.)

  1 = I don't know or won't say
  2 = I do NOT trust
  3 = I trust marginally
  4 = I trust fully
  5 = I trust ultimately
  m = back to the main menu

Your decision? 5
Do you really want to set this key to ultimate trust? (y/N) y

Please note that the shown key validity is not necessarily correct
unless you restart the program.

gpg> quit

Maintenant, le cryptage fonctionne correctement. 

4
eurokous

Sur la base de l'article de @ tersmitten et de quelques essais et erreurs, la ligne de commande suivante m'a permis de faire confiance à toutes les clés d'un trousseau donné sans interaction de l'utilisateur. Je l'utilise pour les clés utilisées avec StackEschange Blackbox et hiera-eyaml-gpg :

# The "-E" makes this work with both GNU sed and OS X sed
gpg --list-keys --fingerprint --with-colons |
  sed -E -n -e 's/^fpr:::::::::([0-9A-F]+):$/\1:6:/p' |
  gpg --import-ownertrust

Personnellement, je préfère une solution qui stocke les résultats dans le fichier trustdb lui-même plutôt que de dépendre de l'environnement utilisateur en dehors du référentiel Git partagé.

2
Amos Shapira

Voici une astuce que j'ai mise au point pour automatiser la gestion des clés GnuPG: hint heredoc + --command-fd 0 est comme par magie. Vous trouverez ci-dessous une version abrégée de l'un des scripts qui ont été écrits pour faciliter l'automatisation avec GnuPG.

#!/usr/bin/env bash
## First argument should be a file path or key id
Var_gnupg_import_key="${1}"
## Second argument should be an integer
Var_gnupg_import_key_trust="${2:-1}"
## Point to preferred default key server
Var_gnupg_key_server="${3:-hkp://keys.gnupg.net}"
Func_import_gnupg_key_edit_trust(){
    _gnupg_import_key="${1:-${Var_gnupg_import_key}}"
    gpg --no-tty --command-fd 0 --edit-key ${_gnupg_import_key} <<EOF
trust
${Var_gnupg_import_key_trust}
quit
EOF
}
Func_import_gnupg_key(){
    _gnupg_import_key="${1:-${Var_gnupg_import_key}}"
    if [ -f "${_gnupg_import_key}" ]; then
        echo "# ${0##*/} reports: importing key file [${_gnupg_import_key}]"
        gpg --no-tty --command-fd 0 --import ${_gnupg_import_key} <<EOF
trust
${Var_gnupg_import_key_trust}
quit
EOF
    else
        _grep_string='not found on keyserver'
        gpg --dry-run --batch --search-keys ${_gnupg_import_key} --keyserver ${Var_gnupg_key_server} | grep -qE "${_grep_string}"
        _exit_status=$?
        if [ "${_exit_status}" != "0" ]; then
            _key_fingerprint="$(gpg --no-tty --batch --dry-run --search-keys ${_gnupg_import_key} | awk '/key /{print $5}' | tail -n1)"
            _key_fingerprint="${_key_fingerprint//,/}"
            if [ "${#_key_fingerprint}" != "0" ]; then
                echo "# ${0##*/} reports: importing key [${_key_fingerprint}] from keyserver [${Var_gnupg_key_server}]"
                gpg --keyserver ${Var_gnupg_key_server} --recv-keys ${_key_fingerprint}
                Func_import_gnupg_key_edit_trust "${_gnupg_import_key}"
            else
                echo "# ${0##*/} reports: error no public key [${_gnupg_import_key}] as file or on key server [${Var_gnupg_key_server}]"
            fi
        else
            echo "# ${0##*/} reports: error no public key [${_gnupg_import_key}] as file or on key server [${Var_gnupg_key_server}]"
        fi
    fi
}
if [ "${#Var_gnupg_import_key}" != "0" ]; then
    Func_import_gnupg_key "${Var_gnupg_import_key}"
else
    echo "# ${0##*/} needs a key to import."
    exit 1
fi

Exécuter avec script_name.sh 'path/to/key' '1' ou script_name.sh 'key-id' '1' pour importer une clé et affecter une valeur de confiance de 1 ou éditer toutes les valeurs avec script_name.sh 'path/to/key' '1' 'hkp://preferred.key.server'

Le chiffrement devrait maintenant se faire sans réclamation, mais même si cela est le cas, l'option --always-trust suivante devrait permettre le chiffrement même avec réclamation.

gpg --no-tty --batch --always-trust -e some_file -r some_recipient -o some_file.gpg

Si vous souhaitez voir cela en action, vérifiez les journaux Travis-CI build et comment le script d'assistance GnuPG_Gen_Key.sh est utilisé pour générer et importer des clés dans la même opération ... Ce script d'aide sera beaucoup plus propre et modifiable, mais c'est un bon point de départ.

2
S0AndS0

Il existe un moyen plus simple de dire à GPG de faire confiance à toutes ses clés en utilisant l'option --trust-model :

    gpg -a --encrypt -r <recipient key name> --trust-model always

De la page de manuel:

  --trust-model pgp|classic|direct|always|auto

    Set what trust model GnuPG should follow. The models are:

      always Skip  key  validation  and assume that used 
             keys are always fully trusted. You generally 
             won't use this unless you are using some 
             external validation scheme. This option also 
             suppresses the "[uncertain]" tag printed 
             with signature checks when there is no evidence 
             that the user ID is bound to the key.  Note that 
             this trust model still does  not  allow  the use 
             of expired, revoked, or disabled keys.
1
Johnny

Je pense que j’ai trouvé le moyen de le faire ... J'ai utilisé «gpg --import-ownertrust» pour exporter ma base de données de confiance dans un fichier texte, puis j’en ai retiré toutes mes clés, à l’exception de la clé publique dont j'avais besoin pour Push. Et puis importé ma clé publique et édité le fichier de confiance du propriétaire sur le serveur. Cela semble fonctionner . Maintenant, j'ai du mal à mettre en oeuvre ces étapes dans le fichier Kickstart :-(

1
user1366786

Avec powershell, voici comment faire confiance à [email protected] (adapté du blog de @tersmitten):

(gpg --fingerprint [email protected] | out-string)  -match 'fingerprint = (.+)'
$fingerprint = $Matches[1] -replace '\s'
"${fingerprint}:6:" | gpg --import-ownertrust

Remarque: en utilisant cinst gpg4win-Vanilla

0
majkinetor

Il existe un moyen d'autotrust key en utilisant --edit-key, mais sans entrer dans un shell interactif (peut donc être automatisé en script). Vous trouverez ci-dessous un exemple pour Windows:

(echo trust &echo 5 &echo y &echo quit) | gpg --command-fd 0 --edit-key [email protected]
0
Mike Twc
echo "$( gpg --list-keys --fingerprint | grep "your-key-name-here" -B 1 | head -1 | tr -d '[:space:]'|awk 'BEGIN { FS = "=" } ; { print $2 }' ):6:" | gpg --import-ownertrust;

Ce one-liner est tiré de this Gist

Il suffit de remplacer "your-key-name-here" par le nom de votre clé.

0
genegc