it-swarm.com.de

Wie kann man den automatischen Schlüssel für gpg als öffentlichen Schlüssel verwenden?

Ich versuche, meinen öffentlichen GPG-Schlüssel als Teil des Installationsprozesses der Appliance hinzuzufügen. Damit können wichtige Dateien wie Protokolle verschlüsselt werden, bevor der Administrator sie mithilfe des Admin-Portals in sein lokales Verzeichnis zieht und sie anschließend mit dem privaten Schlüssel entschlüsselt. Der öffentliche Schlüssel soll in eine Datei exportiert werden und der Appliance-Installationsprozess muss importiert werden mit dem Befehl gpg --import. Aber mir wurde klar, dass der Schlüssel vertrauenswürdig sein muss, bevor eine Verschlüsselung durchgeführt wird. Wie kann man diesen Schlüssel zum Zeitpunkt der Installation ohne menschliches Eingreifen als vertrauenswürdig erachten? Btw, unsere Appliance ist ubuntu vm und Wir verwenden Kickstart zur Automatisierung.

Vielen Dank für alle Hilfe.

20
user1366786

Ihre Frage ist wirklich "Wie verschlüssele ich mich zu einem Schlüssel, ohne dass gpg daran stört, dass der Schlüssel nicht vertrauenswürdig ist?"

Eine Antwort ist, Sie könnten den Schlüssel unterschreiben.

gpg --edit-key YOUR_RECIPIENT
sign
yes
save

Das andere ist, Sie könnten gpg sagen, dass Sie weitermachen und vertrauen sollen.

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

Zufällig habe ich eine ähnliche Situation wie das OP - ich versuche, öffentliche/private Schlüssel zum Signieren und Verschlüsseln von Firmware für verschiedene eingebettete Geräte zu verwenden. Da noch keine Antwort zeigt, wie man einem bereits importierten Schlüssel Vertrauen hinzufügen kann, hier meine Antwort.

Nachdem ich die Schlüssel auf einer Testmaschine erstellt und getestet hatte, exportierte ich sie als ASCII:

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

Dann sicher kopiert und auf den Build-Server importiert:

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

Wichtig: Vertrauen hinzufügen

Bearbeiten Sie nun den Schlüssel, um ultimatives Vertrauen hinzuzufügen:

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

Geben Sie an der gpg>-Eingabeaufforderung trust ein, geben Sie dann 5 für die endgültige Vertrauensstellung ein, dann y zur Bestätigung und dann quit.

Testen Sie es jetzt mit einer Testdatei:

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

welche berichtet

...
[GNUPG:] END_ENCRYPTION

ohne Vertrauen hinzuzufügen, erhalte ich verschiedene Fehler (nicht auf die folgenden beschränkt):

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

Fügen Sie trusted-key 0x0123456789ABCDEF zu Ihrem ~/.gnupg/gpg.conf hinzu und ersetzen Sie dabei die keyid. Dies ist gleichbedeutend mit dem endgültigen Vertrauen in diesen Schlüssel. Dies bedeutet, dass die von ihm durchgeführten Zertifizierungen als gültig akzeptiert werden. Wenn Sie diesen Schlüssel nur als gültig markieren, ohne ihm zu vertrauen, ist dies schwieriger und erfordert entweder eine Signatur oder das Umschalten des Vertrauensmodells auf direkt. Wenn Sie sicher sind, nur gültige Schlüssel zu importieren, können Sie einfach alle Schlüssel als gültig markieren, indem Sie trust-model always hinzufügen. Stellen Sie im letzteren Fall sicher, dass Sie den automatischen Schlüsselabruf deaktivieren (standardmäßig nicht aktiviert).

5
Helmut Grohne

Das hat für mich funktioniert:

Der Versuch, eine Datei zu verschlüsseln, antwortet folgendermaßen:

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.

Also ich:

$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

Nun funktioniert die Verschlüsselung einwandfrei. 

4
eurokous

Basierend auf dem Artikel von @ tersmitten und ein wenig Versuch und Irrtum erhielt ich die folgende Befehlszeile, um allen Schlüsseln in einem bestimmten Schlüsselring ohne Benutzerinteraktion zu vertrauen. Ich verwende es für Schlüssel, die sowohl mit StackEschange Blackbox als auch mit hiera-eyaml-gpg verwendet werden:

# 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

Ich persönlich bevorzuge eine Lösung, die die Ergebnisse in der trustdb-Datei selbst speichert und nicht von der Benutzerumgebung außerhalb des gemeinsam genutzten Git-Repos abhängt.

2
Amos Shapira

Hier ist ein Trick, den ich für die Automatisierung der GnuPG-Schlüsselverwaltung gefunden habe. Hinweis heredoc + --command-fd 0 ist wie Zauberei. Nachfolgend finden Sie eine gekürzte Version eines Skripts, das zur Unterstützung der Automatisierung mit GnuPG geschrieben wurde.

#!/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

Führen Sie mit script_name.sh 'path/to/key' '1' oder script_name.sh 'key-id' '1' aus, um einen Schlüssel zu importieren, und weisen Sie einen Vertrauenswert von 1 zu, oder bearbeiten Sie alle Werte mit script_name.sh 'path/to/key' '1' 'hkp://preferred.key.server'.

Die Verschlüsselung sollte jetzt ohne Beanstandung sein, aber selbst wenn die folgende Option --always-trust die Verschlüsselung zulässt, sollte die Verschlüsselung auch bei Beanstandung möglich sein.

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

Wenn Sie dies in Aktion sehen möchten, überprüfen Sie die Protokolle Travis-CI build und wie das Hilfsskript GnuPG_Gen_Key.sh zum Generieren und Importieren von Schlüsseln in derselben Operation verwendet wird Dieses Helfer-Skript wird viel sauberer und modifizierbar sein, aber es ist ein guter Ausgangspunkt.

2
S0AndS0

Es gibt einen einfacheren Weg, GPG mit der Option-trust-model zu sagen, dass es allen Schlüsseln vertraut.

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

Aus der Manpage:

  --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

Ich denke, ich habe einen Weg gefunden, dies zu tun ... Ich benutzte 'gpg --import-ownertrust', um meine Vertrauensdatenbank in eine Textdatei zu exportieren, und entfernte alle meine Schlüssel, außer dem öffentlichen Schlüssel, den ich drücken musste. Und importierte dann meinen öffentlichen Schlüssel und die bearbeitete Eigner-Trust-Datei auf den Server. Das scheint zu funktionieren. Nun habe ich Probleme beim Implementieren dieser Schritte in der Kickstart-Datei :-(

1
user1366786

Mit powershell können Sie [email protected] vertrauen (angepasst an @tersmitten-Blogpost):

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

Hinweis: mit cinst gpg4win-Vanilla

0
majkinetor

Es gibt eine Möglichkeit zum Autotrust-Schlüssel mit --edit-key, aber ohne in die interaktive Shell zu gelangen (kann also im Skript automatisiert werden). Unten ist ein Beispiel für 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;

Dieser One-Liner wird aus this Gist gezogen.

Ersetzen Sie einfach "your-key-name-here" durch den Namen Ihres Schlüssels.

0
genegc