GPG - vérifier les signatures sans créer de chaîne de confiance?

Est-il possible de demander à gpg (ou gpg4win) de simplement vérifier si un fichier a été signé par un fichier de clé publique particulier, sans avoir à importer, signer et approuver cette clé?

c'est à dire quelque chose comme

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

au lieu d'avoir à créer votre propre clé privée, puis faire

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
source

Essayez de voir si la commande gpg --status-fd 1 --verify (thefile)donne dans sa sortie comme première chaîne l'empreinte de la clé qui a fait la signature.

— harrymc

Un peu de contexte ici: nous avons un système qui signe les choses. Nous donnons sa clé publique aux personnes susceptibles de recevoir des messages de ce système, afin qu'elles puissent vérifier que les messages n'ont pas été falsifiés. Cependant, nous ne voulons pas dire aux destinataires de "faire confiance à tout ce qui est signé par cette clé", car cela pourrait être utilisé pour authentifier les messages d'autres systèmes (par exemple, les courriels de leurs amis).

— OJW

Nous voulons donc donner à quelqu'un un fichier de commandes / batch qui vérifie "est-ce que gpg dit que ce message a été envoyé par cette clé?" sans interférer avec leur utilisation quotidienne de gpg pour communiquer avec d'autres personnes. La clé ne doit être approuvée que parce que la ligne de commande le demande, pas parce que GPG a été invité à toujours lui faire confiance.

— OJW

Réponses:

Vous devez avoir la clé publique pour vérifier une signature faite avec la clé privée correspondante, mais vous n'avez pas besoin de signer ou même de signer localement la clé. Dans ce cas, vous recevrez un avertissement de GPG indiquant que la clé n'est pas approuvée.

Voici un test que j'ai fait avec un fichier signé par ma propre clé, mais sur un système où la clé n'avait pas été importée:

[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]$

Malheureusement, la suggestion de Harry ne fonctionne pas, elle extrait un peu plus d'informations, mais pas assez pour être utile.

Comme vous pouvez le voir, le plus d'informations obtenues est l'ID de clé de la sous-clé utilisée pour effectuer la signature et l'heure à laquelle la signature a été effectuée. Cela correspond aux données disponibles pour pgpdump (ou --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$

Comme vous pouvez le voir, il fournit l'algorithme de hachage, les détails du type de clé (ma clé de signature est une sous-clé RSA 3072 bits et l'ID de clé de la sous-clé, mais il n'y a rien pour identifier la clé principale. Ces informations ne sont que révélé lorsque vous avez la clé publique et vérifiez la signature.

J'ai ensuite importé ma clé publique sur ce système et réessayé:

[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]$

Maintenant, il est capable d'identifier la clé et de la faire correspondre à la clé primaire. Il est cependant possible de réduire la nature de ces avertissements comme ceci:

[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]$

Il y a toujours un avertissement qu'il s'agit d'une clé non fiable, mais pas massivement et la suppression de la verbosité ne la réduit qu'à ceci:

[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 clé publique est requise pour l'étape de vérification car elle est utilisée pour faire correspondre les données générées par le signataire avec sa clé privée. Il peut être considéré, en termes simples, comme le complément du cryptage où la clé privée est nécessaire pour décrypter les données cryptées vers la clé publique.

Remarque: J'ai légèrement modifié les UID dans cet exemple, mais tous ceux qui obtiennent cette clé verront ce qu'ils sont vraiment. Sinon, la sortie est un simple copier-coller.

EDIT: Vous pouvez appeler le fichier de clé publique directement comme un trousseau si vous l'avez au format armé non ASCII (c'est-à-dire un fichier .gpg au lieu d'un fichier .asc). Même ainsi, vous avez toujours besoin de la clé publique. Pour ce faire, la commande est la suivante:

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

En regardant votre sortie, je suis arrivé à la conclusion exactement opposée. J'ai utilisé votre résultat dans ma réponse, mais je vous en ai rendu hommage.

— harrymc

La partie à laquelle vous faites référence qui est la forme longue de l'ID de clé de la sous-clé (techniquement l'ID de clé complet est l'empreinte digitale) est la seule partie identifiable. Sans possession de la clé publique, cependant, vous ne pouvez pas identifier la clé principale ou vérifier la signature. Les détails à ce sujet se trouvent dans la section 5.2 de la RFC 4880 (avec un peu dans la section 2.2, mais la version 5.2 est là où les choses sont utiles). Si je me trompe, prouver la vérification sans une copie de la clé (indice: vous ne pouvez pas le faire avec mes exemples).

— Ben

De plus, sur votre conclusion concernant --verify, cela ne fonctionne que lorsque la clé est disponible, sinon revenez au premier exemple de ma réponse où l'ID de la clé et l'heure de la signature sont vérifiés, mais la clé n'est pas trouvée.

— Ben

Oui, une identification complète n'est bien sûr pas possible uniquement à partir de l'identifiant de la clé. J'ai modifié ma réponse pour indiquer clairement qu'il ne s'agit que d'une heuristique. Votre conclusion est que ce que l'affiche demande est impossible, mais c'est probablement parce que l'affiche a utilisé le mot «vérifier» qui est trop fort.

— harrymc

C'est vrai, l'OP n'utilise probablement pas les termes correctement et je les ai peut-être truqués à quelques endroits également (j'éternuais beaucoup la nuit dernière). Si sa question portait sur la validation d'une signature sans importer de clé, l'exemple de ma modification montre comment cela peut être fait, mais uniquement si cette clé est au format OpenPGP (pubkey.gpg). Cela ne fonctionne pas si la clé exportée est au format blindé ASCII (pubkey.asc).

— Ben

Si vous êtes prêt à expédier un trousseau de clés, plutôt qu'un fichier de clé publique, vous souhaitez probablement utiliser gpgvplutôt que gpg:

gpgv --keyring key.ring somefile.txt

— womble
source

Si votre mot "vérifier" dans la question signifie "absolument vérifier", alors bien sûr une clé publique doit être importée pour vérifier complètement un document signé. Cependant, si cela signifie «identifier», je décris ci-dessous une heuristique qui peut dire si un groupe de documents a tous été signé par la même signature.

Selon les tests effectués par @Ben pour vérifier mon commentaire, il est possible que la commande suivante puisse être utilisée pour indiquer heuristiquement la clé de signature:

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

Le test de Ben a donné le résultat ci-dessous. Il convient de noter les valeurs de ERRSIG et NO_PUBKEY, ainsi que la valeur de "RSA key ID" qui est partiellement contenue dans les deux, comme suit:

[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

Remarque au-dessus de la chaîne 7FF2D37135C7553C. Cette même chaîne se trouve à l'intérieur de l'empreinte digitale de la clé qui est signalée une fois la clé importée:

[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

Cette chaîne se trouve comme la partie inférieure de l'empreinte digitale (sous-clé ci-dessus), elle peut donc éventuellement être utilisée pour identifier la clé. L'empreinte digitale de la clé primaire devrait également être vérifiée, en plus de la sous-clé.

La chaîne "ID de clé RSA" est identique dans les deux sorties et se trouve également comme la dernière partie de l'empreinte digitale, il peut donc être possible qu'elle suffise à elle seule pour identifier la signature. Si tel est le cas, l'utilisation de la sortie de gpg --verifypeut suffire à identifier la signature de manière plus simple.

[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

Ma connaissance de GPG n'est pas suffisante pour valider complètement cette méthode, vous devriez donc l'essayer sur d'autres fichiers d'exemple. Si cela fonctionne, vous pouvez alors trier les fichiers en fonction de leurs signatures, mais vous devrez importer la clé pour trouver l'identité du signataire.

Pour énoncer clairement à nouveau: Cette méthode ne peut pas identifier complètement une signature. Ce n'est qu'un moyen de trier heuristiquement des documents signés.

— harrymc
source

Une signature contient suffisamment de données pour identifier la clé utilisée pour la créer et conjointement avec les serveurs de clés, elle peut être utilisée pour localiser la clé principale (en supposant qu'une sous-clé de signature a été utilisée comme dans mes exemples). Sans une copie de la clé publique au format OpenPGP (dans un trousseau de clés ou comme dans mon exemple final), la validation de la signature n'est pas possible car l'empreinte digitale / l'ID de la clé ne sont pas suffisamment de données pour le calculer.

— Ben

@Ben: Je répète qu'il ne s'agit que d'une heuristique, ce qui est le mieux qui puisse être fait pour répondre à la question de l'affiche de "vérifier si un fichier a été signé par un fichier de clé publique particulier, sans avoir à importer et signer et faire confiance à cette clé ".

— harrymc

cela clarifierait-il la question si je disais que nous faisons confiance à toutes les clés du fichier .pub (aux fins de vérification de ce fichier de données spécifique) et que les raisons pour lesquelles nous choisissons de faire confiance à ce fichier .pub n'entrent pas dans le cadre de une activité GPG?

— OJW

L'heuristique de lister les clés dans le fichier .pub et de comparer leur ID de clé RSA sera-t-elle utile? Je n'ai pas de gpg ici pour essayer, mais peut-être quelque chose comme "gpg --no-default-keyring --keyring <pub-file> --list-keys".

— harrymc