encryption - para - ¿Cómo hacer auto confianza gpg clave pública?

gpg para linux

Question

Estoy tratando de agregar mi clave pública GPG como parte de nuestro proceso de instalación del dispositivo. El propósito de este es cifrar cualquier archivo importante como registros antes de que el administrador los lleve a su portal de administración local y luego los descifre mediante una clave privada. El plan es exportar la clave pública a un archivo y hacer que el proceso de instalación del dispositivo lo importe con el comando gpg --import. Pero me di cuenta de que la clave es necesaria para ser confiable / firmada antes de realizar cualquier cifrado. ¿Cómo hacer que esta clave sea confiable sin ninguna intervención humana en el momento de la instalación? Por cierto, nuestro sistema operativo es ubuntu vm y usamos kickstart para automatizar.

Avance gracias por toda la ayuda.

Answer 1

Agregue trusted-key 0x0123456789ABCDEF a su ~/.gnupg/gpg.conf reemplazando el keyid. Esto equivale a confiar finalmente en esta clave, lo que significa que las certificaciones realizadas por ella se aceptarán como válidas. Solo marcando esta clave como válida sin confiar en ella es más difícil y requiere una firma o cambiar el modelo de confianza a directo. Si está seguro de importar solo claves válidas, simplemente puede marcar todas las claves como válidas agregando trust-model always . En este último caso, asegúrese de deshabilitar la recuperación automática de claves (no habilitada de forma predeterminada).

Answer 2

Aquí hay un truco que he descubierto para la automatización de la gestión de claves de GnuPG, sugerencia heredoc + --command-fd 0 es como magia. A continuación se muestra una versión abreviada de uno de los scripts que se ha escrito para ayudar en la automatización con 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

Ejecute con script_name.sh ''path/to/key'' ''1'' o script_name.sh ''key-id'' ''1'' para importar una clave y asignar un valor de confianza de 1 o editar todos los valores con script_name.sh ''path/to/key'' ''1'' ''hkp://preferred.key.server''

El cifrado ahora debe estar sin quejas, pero incluso si lo hace, la siguiente --always-trust debería permitir el cifrado incluso con la queja.

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

Si desea ver esto en acción, luego verifique los registros de compilación de Travis-CI y cómo se usa la secuencia de comandos auxiliar GnuPG_Gen_Key.sh para generar e importar claves en la misma operación ... la versión dos de esta secuencia de comandos auxiliar será mucho más limpia Y modificable pero es un buen punto de partida.

Answer 3

Basándome en el artículo de @tersmitten y un poco de prueba y error, terminé con la siguiente línea de comandos para confiar en todas las claves de un conjunto de claves determinado sin la interacción del usuario. Lo uso para las teclas que se usan tanto con StackEschange Blackbox como con 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

Personalmente, prefiero una solución que almacene los resultados en el propio archivo trustdb en lugar de depender del entorno del usuario fuera del repositorio de Git compartido.

Answer 4

Casualmente, tengo una situación similar a la OP: estoy tratando de usar claves públicas / privadas para firmar y cifrar el firmware de diferentes dispositivos integrados. Como todavía no hay respuesta, se muestra cómo agregar confianza a una clave que ya ha importado, aquí está mi respuesta.

Después de crear y probar las claves en una máquina de prueba, las exporté como ascii:

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

Luego las copió e importó de forma segura al servidor de compilación:

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

Importante: agregar confianza

Ahora edita la clave para agregar confianza final:

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

En el indicador gpg> , escriba trust , luego escriba 5 para la máxima confianza, luego y para confirmar, luego quit .

Ahora probarlo con un archivo de prueba:

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

que informa

...
[GNUPG:] END_ENCRYPTION

sin agregar confianza, recibo varios errores (no limitados a lo siguiente):

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

Answer 5

Con powershell, aquí está cómo confiar en [email protected] (adaptado de la publicación del blog @tersmitten):

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

Nota: utilizando cinst gpg4win-vanilla

Answer 6

Creo, pensé la manera de hacer esto. Utilicé ''gpg --import-ownertrust'' para exportar mi base de datos de confianza a un archivo de texto y luego eliminé todas mis claves, excepto la clave pública que necesitaba insertar. Y luego importé mi clave pública y mi archivo de confianza de propietario editado al servidor. Esto parece funcionar. Ahora tengo problemas para implementar estos pasos en el archivo Kickstart :-(

Answer 7

Esto funcionó para mí:

Tratando de cifrar un archivo responde con esto:

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.

Asique:

$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

Ahora el cifrado funciona correctamente.

Answer 8

Hay una forma de autocrear la clave usando --edit-key, pero sin entrar en el shell interactivo (por lo que puede automatizarse en un script). A continuación se muestra una muestra para windows:

(echo trust &echo 5 &echo y &echo quit) | gpg --command-fd 0 --edit-key [email protected]

Answer 9

Hay una manera más fácil de decirle a GPG que confíe en todas sus claves usando la opción --trust-model :

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

De la página del manual:

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

Answer 10

Su pregunta es realmente: "¿Cómo puedo cifrar una clave sin rechazar gpg ante el hecho de que la clave no es confiable?"

Una respuesta es que puedes firmar la llave.

gpg --edit-key YOUR_RECIPIENT
sign
yes
save

La otra es que podrías decirle a gpg que siga adelante y confíe.

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

Answer 11

Ver este artículo que escribí recientemente al respecto. Dos posibles soluciones:

• Magia de concha
• Esperar

Answer 12

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;

Este one-liner se extrae de esta esencia.

Simplemente reemplace "su-clave-nombre-aquí" con el nombre de su clave.