GPG - verifica firme senza creare catena di fiducia?

È possibile chiedere a gpg (o gpg4win) di verificare semplicemente se un file è stato firmato da un determinato file di chiave pubblica, senza dover importare, firmare e fidarsi di quella chiave?

cioè qualcosa di simile

gpg --using-key pubkey.txt --verify message.txt

invece di dover creare la tua chiave privata e poi farlo

gpg --import pubkey.txt 
gpg --lsign-key [name within pubkey.txt]
# ... something to do with choosing trust levels
gpg --verify message.txt

gnupg digital-signature

— OJW
fonte

Prova a vedere se il comando gpg --status-fd 1 --verify (thefile)fornisce nel suo output come prima stringa l'impronta digitale della chiave che ha creato la firma.

— harrymc,

Qualche contesto qui: abbiamo un sistema che firma le cose. Forniamo la sua chiave pubblica alle persone che potrebbero ricevere messaggi da questo sistema, in modo che possano verificare che i messaggi non siano stati manomessi. Tuttavia, non vogliamo dire ai destinatari di "fidarsi di qualcosa firmato da questa chiave" perché potrebbe quindi essere utilizzato per autenticare i messaggi di altri sistemi (ad esempio le e-mail dei loro amici).

— GU

Quindi vogliamo dare a qualcuno un comando / file batch che controlli "gpg dice che questo messaggio è stato inviato da questa chiave?" senza interferire con l'uso quotidiano di gpg per comunicare con altre persone. La chiave dovrebbe essere attendibile solo perché la riga di comando lo richiede, non perché a GPG è stato detto di fidarsi sempre di essa.

— GU

Risposte:

È necessario disporre della chiave pubblica per verificare una firma effettuata con la chiave privata corrispondente, ma non è necessario firmare né firmare localmente la chiave. In questo caso riceverai un avviso da GPG che la chiave non è attendibile.

Ecco un test che ho fatto con un file firmato dalla mia chiave, ma su un sistema in cui la chiave non era stata importata:

[ben@seditious tmp]$ gpg -v --verify thing.txt.gpg 
gpg: original file name='thing.txt'
gpg: Signature made Thu 26 Sep 2013 06:51:39 AM EST using RSA key ID 35C7553C
gpg: Can't check signature: public key not found
[ben@seditious tmp]$ gpg -v --status-fd 1 --verify thing.txt.gpg 
gpg: original file name='thing.txt'
gpg: Signature made Thu 26 Sep 2013 06:51:39 AM EST using RSA key ID 35C7553C
[GNUPG:] ERRSIG 7FF2D37135C7553C 1 10 00 1380142299 9
[GNUPG:] NO_PUBKEY 7FF2D37135C7553C
gpg: Can't check signature: public key not found
[ben@seditious tmp]$

Sfortunatamente il suggerimento di Harry non funziona, estrae un po 'più di informazioni, ma non abbastanza per essere utili.

Come puoi vedere, la maggior parte delle informazioni ottenute è l'ID chiave della sottochiave utilizzata per creare la firma e l'ora della firma. Questo corrisponde ai dati disponibili per pgpdump (o --list-packets):

bash-3.2$ pgpdump thing.txt.gpg 
Old: Compressed Data Packet(tag 8)
    Comp alg - ZLIB <RFC1950>(comp 2)
Old: One-Pass Signature Packet(tag 4)(13 bytes)
    New version(3)
    Sig type - Signature of a binary document(0x00).
    Hash alg - SHA512(hash 10)
    Pub alg - RSA Encrypt or Sign(pub 1)
    Key ID - 0x7FF2D37135C7553C
    Next packet - other than one pass signature
Old: Literal Data Packet(tag 11)(24 bytes)
    Format - binary
    Filename - thing.txt
    File modified time - Thu Sep 26 06:51:39 EST 2013
    Literal - ...
Old: Signature Packet(tag 2)(412 bytes)
    Ver 4 - new
    Sig type - Signature of a binary document(0x00).
    Pub alg - RSA Encrypt or Sign(pub 1)
    Hash alg - SHA512(hash 10)
    Hashed Sub: signature creation time(sub 2)(4 bytes)
        Time - Thu Sep 26 06:51:39 EST 2013
    Sub: issuer key ID(sub 16)(8 bytes)
        Key ID - 0x7FF2D37135C7553C
    Hash left 2 bytes - f0 97 
    RSA m^d mod n(3066 bits) - ...
        -> PKCS-1
bash-3.2$

Come puoi vedere fornisce l'algoritmo hash, i dettagli del tipo di chiave (la mia chiave di firma è una sottochiave RSA a 3072 bit e l'ID chiave della sottochiave, ma non c'è nulla per identificare la chiave principale. rivelato quando si possiede la chiave pubblica e si verifica la firma.

Quindi ho importato la mia chiave pubblica su quel sistema e ho riprovato:

[ben@seditious tmp]$ gpg -v --verify thing.txt.gpg 
gpg: original file name='thing.txt'
gpg: Signature made Thu 26 Sep 2013 06:51:39 AM EST using RSA key ID 35C7553C
gpg: using subkey 35C7553C instead of primary key 73590E5D
gpg: using PGP trust model
gpg: Good signature from "Ben M <ben@REDACTED>"
gpg:                 aka "Ben M <ben.m@REDACTED>"
gpg:                 aka "Ben M <ben.m@REDACTED>"
gpg:                 aka "Ben M (backup email address) <benm@REDACTED>"
gpg: WARNING: This key is not certified with a trusted signature!
gpg:          There is no indication that the signature belongs to the owner.
Primary key fingerprint: DB47 24E6 FA42 86C9 2B4E  55C4 321E 4E23 7359 0E5D
     Subkey fingerprint: B7F0 FE75 9387 430D D0C5  8BDB 7FF2 D371 35C7 553C
gpg: binary signature, digest algorithm SHA512
[ben@seditious tmp]$

Ora è in grado di identificare la chiave e abbinarla alla chiave primaria. È tuttavia possibile ridurre la natura di tali avvisi in questo modo:

[ben@seditious tmp]$ gpg -v --verify --trust-model always thing.txt.gpg 
gpg: original file name='thing.txt'
gpg: Signature made Thu 26 Sep 2013 06:51:39 AM EST using RSA key ID 35C7553C
gpg: using subkey 35C7553C instead of primary key 73590E5D
gpg: Good signature from "Ben M <ben@REDACTED>"
gpg:                 aka "Ben M <ben.m@REDACTED>"
gpg:                 aka "Ben M <ben.m@REDACTED>"
gpg:                 aka "Ben M (backup email address) <benm@REDACTED>"
gpg: WARNING: Using untrusted key!
gpg: binary signature, digest algorithm SHA512
[ben@seditious tmp]$

C'è ancora un avvertimento che si tratta di una chiave non attendibile, ma non così massiccia e la rimozione della verbosità la riduce solo a questo:

[ben@seditious tmp]$ gpg --verify --trust-model always thing.txt.gpg 
gpg: Signature made Thu 26 Sep 2013 06:51:39 AM EST using RSA key ID 35C7553C
gpg: Good signature from "Ben M <ben@REDACTED>"
gpg:                 aka "Ben M <ben.m@REDACTED>"
gpg:                 aka "Ben M <ben.m@REDACTED>"
gpg:                 aka "Ben M (backup email address) <benm@REDACTED>"
gpg: WARNING: Using untrusted key!
[ben@seditious tmp]$

La chiave pubblica è necessaria per la fase di verifica perché viene utilizzata per abbinare i dati generati dal firmatario con la loro chiave privata. Si può pensare, in termini semplici, come il complemento della crittografia in cui è necessaria la chiave privata per decodificare i dati crittografati nella chiave pubblica.

Nota: in questo esempio ho modificato un po 'gli UID, ma tutti quelli che ottengono quella chiave vedranno quello che sono realmente. Altrimenti l'output è una copia e incolla diretta.

EDIT: Puoi chiamare il file della chiave pubblica direttamente come un portachiavi se lo hai nel formato corazzato non ASCII (cioè un file .gpg invece di un file .asc). Anche così, hai ancora bisogno della chiave pubblica. Per fare questo il comando è così:

[ben@seditious ~]$ gpg -v --no-default-keyring --keyring /tmp/mykey.gpg --verify /tmp/thing.txt.gpg 
gpg: original file name='thing.txt'
gpg: Signature made Thu 26 Sep 2013 06:51:39 AM EST using RSA key ID 35C7553C
gpg: using subkey 35C7553C instead of primary key 73590E5D
gpg: using PGP trust model
gpg: Good signature from "Ben M <ben@REDACTED>"
gpg:                 aka "Ben M (backup email address) <benm@REDACTED>"
gpg:                 aka "Ben M <ben.m@REDACTED>"
gpg:                 aka "Ben M <ben.m@REDACTED>"
gpg: WARNING: This key is not certified with a trusted signature!
gpg:          There is no indication that the signature belongs to the owner.
Primary key fingerprint: DB47 24E6 FA42 86C9 2B4E  55C4 321E 4E23 7359 0E5D
     Subkey fingerprint: B7F0 FE75 9387 430D D0C5  8BDB 7FF2 D371 35C7 553C
gpg: binary signature, digest algorithm SHA512
[ben@seditious ~]$

— Ben
fonte

Guardando il tuo risultato, ho raggiunto la conclusione esattamente opposta. Ho usato il tuo risultato nella mia risposta, ma ti ho dato credito.

— harrymc,

La parte a cui ti riferisci è la forma lunga dell'ID chiave della sottochiave (tecnicamente l'ID chiave completo è l'impronta digitale) è l'unica parte identificabile. Senza il possesso della chiave pubblica, tuttavia, non è possibile identificare la chiave principale o verificare la firma. I dettagli di questo sono nella sezione 5.2 di RFC 4880 (con un po 'nella sezione 2.2, ma 5.2 è dove si trovano le cose utili). Se sbaglio prova la verifica senza una copia della chiave (suggerimento: non puoi farlo con i miei esempi).

— Ben,

Inoltre, in base alle tue conclusioni riguardo a --verify, funziona solo quando la chiave è disponibile, altrimenti torna al primo esempio nella mia risposta in cui l'ID chiave e l'ora della firma sono verificati, ma la chiave non viene trovata.

— Ben,

Sì, ovviamente l'identificazione completa non è possibile solo dall'ID chiave. Ho modificato la mia risposta per affermare chiaramente che si tratta solo di un'euristica. La tua conclusione è che ciò che il poster chiede è impossibile, ma probabilmente perché il poster ha usato la parola "verifica" che è troppo forte.

— harrymc,

È vero, l'OP probabilmente non sta usando correttamente i termini e potrei averli confusi anche in un paio di posti (stavo starnutendo molto ieri sera). Se la sua domanda riguardava solo la convalida di un sig senza importare una chiave, l'esempio nella mia modifica mostra come si può fare, ma solo se quella chiave è in formato OpenPGP (pubkey.gpg). Non funziona se la chiave esportata è in formato ASCII corazzato (pubkey.asc).

— Ben

Se stai bene con la spedizione di un portachiavi, piuttosto che un file di chiave pubblica, probabilmente vorrai utilizzare gpgvanziché gpg:

gpgv --keyring key.ring somefile.txt

— Womble
fonte

Se la tua parola "verifica" nella domanda significa "verifica assolutamente", ovviamente è necessario importare una chiave pubblica per verificare completamente un documento firmato. Tuttavia, se questo significa "identificare", descrivo di seguito un'euristica che può dire se un gruppo di documenti è stato firmato con la stessa firma.

In base ai test effettuati da @Ben per verificare il mio commento, esiste la possibilità che il seguente comando possa essere utilizzato per indicare euristicamente la chiave di firma:

gpg --status-fd 1 --verify thefile.gpg

Il test di Ben ha dato il risultato qui sotto. Da notare i valori di ERRSIG e NO_PUBKEY e anche il valore di "ID chiave RSA" che è parzialmente contenuto in entrambi, come segue:

[ben@seditious tmp]$ gpg -v --status-fd 1 --verify thing.txt.gpg 
gpg: original file name='thing.txt'
gpg: Signature made Thu 26 Sep 2013 06:51:39 AM EST using RSA key ID 35C7553C
[GNUPG:] ERRSIG 7FF2D37135C7553C 1 10 00 1380142299 9
[GNUPG:] NO_PUBKEY 7FF2D37135C7553C
gpg: Can't check signature: public key not found

Nota sopra la stringa 7FF2D37135C7553C. Questa stessa stringa si trova all'interno dell'impronta digitale della chiave che viene segnalata dopo l'importazione della chiave:

[ben@seditious ~]$ gpg -v --no-default-keyring --keyring /tmp/mykey.gpg --verify /tmp/thing.txt.gpg 
gpg: original file name='thing.txt'
gpg: Signature made Thu 26 Sep 2013 06:51:39 AM EST using RSA key ID 35C7553C
gpg: using subkey 35C7553C instead of primary key 73590E5D
gpg: using PGP trust model
gpg: Good signature from "Ben M <ben@REDACTED>"
gpg:                 aka "Ben M (backup email address) <benm@REDACTED>"
gpg:                 aka "Ben M <ben.m@REDACTED>"
gpg:                 aka "Ben M <ben.m@REDACTED>"
gpg: WARNING: This key is not certified with a trusted signature!
gpg:          There is no indication that the signature belongs to the owner.
Primary key fingerprint: DB47 24E6 FA42 86C9 2B4E  55C4 321E 4E23 7359 0E5D
     Subkey fingerprint: B7F0 FE75 9387 430D D0C5  8BDB 7FF2 D371 35C7 553C
gpg: binary signature, digest algorithm SHA512

Questa stringa si trova nella parte inferiore dell'impronta digitale (sottochiave sopra), quindi potrebbe essere utilizzata per identificare la chiave. Anche l'impronta digitale della chiave primaria dovrebbe essere verificata, oltre alla sottochiave.

La stringa "ID chiave RSA" è identica in entrambi gli output e si trova anche come ultima parte dell'impronta digitale, quindi potrebbe essere possibile da solo identificare la firma. In tal caso, utilizzare solo l'output di gpg --verifypotrebbe essere sufficiente per identificare la firma in modo più semplice.

[ben@seditious tmp]$ gpg -v --verify thing.txt.gpg 
gpg: original file name='thing.txt'
gpg: Signature made Thu 26 Sep 2013 06:51:39 AM EST using RSA key ID 35C7553C
gpg: Can't check signature: public key not found

La mia conoscenza del GPG non è sufficiente per convalidare completamente questo metodo, quindi dovresti provarlo su più file di esempio. Se funziona, puoi quindi ordinare i file in base alle loro firme, ma dovrai importare la chiave per trovare l'identità del firmatario.

Per dichiarare di nuovo chiaramente: questo metodo non è in grado di identificare completamente una firma. È solo un modo per ordinare euristicamente i documenti firmati.

— harrymc
fonte

Una firma contiene dati sufficienti per identificare la chiave utilizzata per crearla e in combinazione con i key server può essere utilizzata per individuare la chiave principale (supponendo che sia stata utilizzata una sottochiave di firma come nei miei esempi). Senza una copia della chiave pubblica in formato OpenPGP (o in un portachiavi o come nel mio esempio finale), la convalida della firma non è possibile perché l'ID impronta digitale / chiave non è sufficiente per calcolarlo.

— Ben,

@Ben: ripeto che questo è solo un euristico, che è il massimo che si può fare per rispondere alla domanda del poster di "verificare se un file è stato firmato da un determinato file di chiave pubblica, senza dover importare, firmare e fidarsi di quella chiave ".

— harrymc,

renderebbe la domanda più chiara se dicessi che ci fidiamo di qualsiasi chiave nel file .pub (ai fini della verifica di questo specifico file di dati) e che i motivi per cui scegliamo di fidarci di questo file .pub non rientrano nell'ambito di qualche attività GPG?

— GU

L'euristica di elencare le chiavi nel file .pub e confrontare il loro ID chiave RSA sarà utile? Non ho gpg qui da provare, ma forse qualcosa come "gpg --no-default-keyring --keyring <pub-file> --list-keys".

— harrymc,