gpg chiede la password anche con --passphrase

Mi aspetto che il seguente comando estragga il file gpg senza chiedere la password:

  gpg --passphrase 1234 file.gpg

Ma chiede la password. Perché?

Anche questo ha lo stesso comportamento:

  gpg --passphrase-file passfile.txt file.gpg

Uso Ubuntu con gnome 3 e ricordo che funzionava in Fedora

Sono nella tua stessa barca (ha funzionato su Fedora ma non su Ubuntu). Ecco un apparente lavoro in giro che ho scoperto:

echo your_password | gpg --batch --yes --passphrase-fd 0 your_file.gpg

Spiegazione: Il passaggio 0causa la --passphrase-fdlettura da STDIN anziché da un file. Pertanto, il piping della passphrase --passphrase-fdaccetterà la stringa di password specificata.

Aggiornato il 04/12/2017. (Aggiunta di --batch per impedire il prompt passphrase)

Potrebbe essere necessario aggiungere --batchun'opzione:

Dalla versione 2 di GPG, l'opzione --batchè necessaria per garantire nessun prompt ... Ok, guardando che:

$ gpg --version
gpg (GnuPG) 2.1.18
libgcrypt 1.7.6-beta
Copyright (C) 2017 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <https://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

Home: /home/user /.gnupg
Supported algorithms:
Pubkey: RSA, ELG, DSA, ECDH, ECDSA, EDDSA
Cipher: IDEA, 3DES, CAST5, BLOWFISH, AES, AES192, AES256, TWOFISH,
        CAMELLIA128, CAMELLIA192, CAMELLIA256
Hash: SHA1, RIPEMD160, SHA256, SHA384, SHA512, SHA224
Compression: Uncompressed, ZIP, ZLIB, BZIP2

Provando:

$ newdir=$(mktemp -d)
$ cd $newdir
$ seq 1 10 | gpg -c --batch --passphrase 1234 -o file.gpg -
$ ls -ltr
total 4
-rw-r--r-- 1 user  user  91 Dec  4 15:42 file.gpg
$ hd file.gpg 
00000000  8c 0d 04 07 03 02 ea fa  d0 d3 2b 9a ea 06 df d2  |..........+.....|
00000010  4a 01 ed 50 74 ff 27 45  0e 6c 94 74 db e9 8a a5  |J..Pt.'E.l.t....|
00000020  03 9f 67 a0 73 97 e9 15  6b 56 a0 f0 88 71 85 a8  |..g.s...kV...q..|
00000030  dc 41 71 9f fa 3b f9 9d  af ac 80 eb f4 f7 28 19  |.Aq..;........(.|
00000040  9f be 75 47 e6 d8 00 3e  f6 60 f1 00 5e 63 57 ef  |..uG...>.`..^cW.|
00000050  14 c3 4b 20 ff 94 03 03  c1 fc 98                 |..K .......|
0000005b

suona bene! Bene ora:

$ gpg -d --batch --passphrase 1234 file.gpg
gpg: AES encrypted data
gpg: encrypted with 1 passphrase
1
2
3
4
5
6
7
8
9
10

Sebbene non -dvenga fornito alcun parametro (stessa sintassi della domanda di SO), i dati decrittati da file.gpgverranno estratti in un nuovo file.

$ gpg --batch --passphrase 1234 file.gpg
gpg: WARNING: no command supplied.  Trying to guess what you mean ...
gpg: AES encrypted data
gpg: encrypted with 1 passphrase

$ ls -ltr
total 8
-rw-r--r-- 1 user  user  91 Dec  4 15:42 file.gpg
-rw-r--r-- 1 user  user  21 Dec  4 15:44 file

$ cat file
1
2
3
4
5
6
7
8
9
10

Questo funziona bene!

$ cd -
$ rm -fR $newdir
$ unset newdir

Per la versione 2.x di gpg non è necessario utilizzare --batch, solo

--pinentry-mode loopback  

funziona con --passphrase& --passphrase-filee ti consentirà di inserire nuove informazioni, ad esempio in caso di conflitti di nome file:

gpg --pinentry-mode loopback --passphrase-file=file encrypted.gpg

...
File 'encrypted' exists. Overwrite? (y/N)n
Enter new filename: f2

a differenza di --batchciò fallirà rapidamente, dicendo...failed: File exists

(testato su gpg Debian Stable / Stretch 2.1.18. Questo comportamento di ignorare --passphraseopzioni importanti dovrebbe davvero essere un bug, se non lo è già)

Sembra che tu stia usando gpg2. Devi anche inserire l' --batchopzione. (Se hai intenzione di aggiungere questo a uno script, ti consigliamo di aggiungere anche --no-ttye probabilmente --yes.)

per me, aggiungendo "--no-use-agent" risolto questo problema per "gpg (GnuPG) 1.4.16":

date > foo
echo pass > passphrase
# w/o --no-use-agent
> rm -f foo.gpg; gpg --cipher-algo aes256 --output foo.gpg --passphrase-file ./passphrase --batch --yes --symmetric foo
gpg: gpg-agent is not available in this session
gpg: can't query passphrase in batch mode
gpg: error creating passphrase: invalid passphrase
gpg: symmetric encryption of `foo' failed: invalid passphrase


> rm -f foo.gpg; gpg --cipher-algo aes256 --output foo.gpg --passphrase-file ./passphrase --batch --yes --no-use-agent --symmetric foo
> ls -al
total 20
drwxr-xr-x  2 root root 4096 Aug 22 13:59 .
drwx------ 18 root root 4096 Aug 22 13:58 ..
-rw-r--r--  1 root root   30 Aug 22 13:58 foo
-rw-r--r--  1 root root  103 Aug 22 13:59 foo.gpg
-rw-r--r--  1 root root    5 Aug 22 13:58 passphrase

Se si utilizza gpg (GnuPG) 2.2.7 Secondo la pagina man,

--passphrase-fd n

Leggi la passphrase dal descrittore di file n. Solo la prima riga verrà letta dal descrittore di file n. Se si utilizza 0 per n, la passphrase verrà letta da STDIN. Questo può essere usato solo se viene fornita una sola passphrase.

--passphrase-file file

Leggi la passphrase dal file file. Solo la prima riga verrà letta dal file file. Questo può essere usato solo se viene fornita una sola passphrase. Ovviamente, una passphrase memorizzata in un file è di dubbia sicurezza se altri utenti possono leggere questo file. Non utilizzare questa opzione se puoi evitarlo.

--passphrase string

Usa la stringa come passphrase. Questo può essere usato solo se viene fornita una sola passphrase. Ovviamente, si tratta di una sicurezza molto discutibile su un sistema multiutente. Non utilizzare questa opzione se puoi evitarlo.

aggiungere --pinentry-mode loopbackper funzionare

Si noti che dalla versione 2.0 questa passphrase viene utilizzata solo se è stata fornita anche l'opzione --batch. Dalla versione 2.1 anche la modalità --pinentry deve essere impostata su loopback.

Per esempio:

gpg --batch --yes --passphrase="pw" --pinentry-mode loopback -o out -d in

Per me ha funzionato come per magia:

echo "YOUR_PASS_PHRASE" | gpg --batch --yes  --passphrase-fd 0 /home/somewhere/your_file.pgp

read -sp "Enter passphrase: " pass
echo "${pass}" | gpg --batch --no-tty --yes --passphrase-fd 0 --symmetric -o /path/to/saved/file.jpg.gpg /path/to/file.jpg
echo "${pass}" | gpg --batch --no-tty --yes --passphrase-fd 0 --decrypt -o /path/to/decrypted/file.jpg /path/to/encrypted/file.jpg.gpg

hai provato a fare:

gpg --batch --passphrase-fd 0 --decrypt-files *.gpg
gpg --passphrase-fd 0 1234 file.gpg 

Fonte: qui

Penso che un metodo abbastanza sicuro per passare la password alla riga di comando sia questo:

gpg --passphrase-file <(echo password) --batch --output outfile -c file

Ciò che farà sarà generare il comando "echo" e passare un descrittore di file come nome di percorso a gpg (ad esempio / dev / fd / 63). gpg leggerà quindi la chiave da lì. Nel frattempo, il comando echo dovrebbe essere eseguito in parallelo e dovrebbe terminare all'istante, lasciando la chiave sul buffer di fd.

I vantaggi sono:

• Il comando gpg non avrà la password sulla sua riga di comando
• L'eco avrà vita breve. In effetti, dovrebbe essere quasi istantaneo
• La password non risiederà mai sul disco, non ci sarà un file da cancellare e se il comando viene interrotto non ci saranno residui

Non mi crederai quando ti dico che su Ubuntu gpg prova a chiedere la tua password se $ DISPLAY è impostato e lo prende dalla riga di comando - password se la disattivi. Funziona come previsto:

DISPLAY=    gpg --symmetric --passphrase pass --batch

Solo un altro esempio di ingegneria eccessiva credo.

Ecco un link a una risposta stackoverflow che forse di ulteriore assistenza; Ho un progetto che esegue la decrittografia / crittografia di massa e, dato che GnuPG è molto severo sulle passphrase, ho imparato a mie spese che --passphrasefunziona solo in rare occasioni. Invece considera l' --passphrase-fdopzione più affidabile.

Questo script fa un uso corretto--passphrase -fd dell'opzione ed è stato testato pubblicamente tramite Travis-CI, dove è possibile trovarne i log in azione.

Ora non ho intenzione di pubblicare link a una risposta senza fornire qui un codice di esempio, quindi ecco uno script "stand alone" aggiornato con cui puoi giocare:

#!/usr/bin/env bash
# Set some variables for easy modding
Var_fd='9'
Var_pass="/path/to/passphrase.file"
Var_gpg_opts="--passphrase-fd ${Var_fd} --decrypt"
Var_output_location="out.txt"
Arr_string=( "$@" )
# Open file descriptor and shove the passphrase file into it
if [ -f "${Var_pass}" ]; then
    exec ${Var_fd}<"${Var_pass}"
else
    exec ${Var_fd}<(echo "${Var_pass}")
fi
# Pipe input array though gpg and append to output file
cat <<<"${Arr_string[*]}" | $(which gpg) ${Var_gpg_opts} >> ${Var_output_location}
# Do not forget to close the file descriptor
exec ${Var_fd}>&-

Anche se quanto sopra non è elegante come la protezione collegata su GitHub, dovrebbe essere anche più funzionale della risposta collegata all'inizio di questo post.

Happy hacking.

Come menzionato in man gpg è possibile usare la seguente opzione

--pinentry-mode mode Imposta la modalità pinentry su mode. I valori consentiti per la modalità sono:

          default
                 Use the default of the agent, which is ask.

          ask    Force the use of the Pinentry.

          cancel Emulate use of Pinentry's cancel button.

          error  Return a Pinentry error (``No Pinentry'').

          loopback
                 Redirect Pinentry queries to the caller.  Note that in contrast to Pinentry the user is not prompted again if he enters a bad password.

Quindi, il comportamento predefinito di gpg è richiedere all'utente la passphrase, se cambia questa modalità agente utente in "--pinentry-mode loopback" Funziona perfettamente. comando completo

gpg --pinentry-mode loopback --passphrase <passphrase> -d <file to decrypt>

Un metodo semplice che ho trovato lavorando su una macchina linux è: 1) import key to gpg: => shell> gpg —import private_key.key

2) decodifica fornendo il nome del file di output: => shell> gpg —output -d

2.1) Dare il comando sopra ti chiederà di inserire la parafrasi. Inserisci la parafrasi e decodificherà il file gpg.

gpg2 -se --passphrase yourpassword --batch --yes -r user@example.com filename

Metti alla fine di ~/.gnupg/gpg.conf:

use-agent
pinentry-mode loopback

Inserisci alla fine del file (forse nuovo) ~/.gnupg/gpg-agent.conf:

allow-loopback-pinentry

E quindi eseguire questo comando:

echo RELOADAGENT | gpg-connect-agent

Ora puoi eseguirlo senza chiedere la password:

echo "$1" | gpg2 --trust-model always --clearsign --batch --no-tty --quiet --no-verbose --yes -u $2 --digest-algo SHA512
--s2k-digest-algo SHA512 --passphrase "$3"

Dove $ 1 è il testo da crittografare, $ 2 è l'ID utente e $ 3 la password.

Nota: non ricordo perché funziona, ma funziona. Se conosci i dettagli, modifica e inserisci qui.

per Ubuntu 18.04 questo ha funzionato per me-

cifrare:

pass='123'

gpg -c --batch --passphrase "$pass" some-file.tgz

decifrare:

gpg some-file.tgz.gpg