GPG - verificar assinaturas sem criar uma cadeia de confiança?

É possível solicitar ao gpg (ou gpg4win) apenas para verificar se um arquivo foi assinado por um arquivo de chave pública específico, sem precisar importar, assinar e confiar nessa chave?

ou seja, algo como

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

em vez de ter que criar sua própria chave privada e depois

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

Tente ver se o comando gpg --status-fd 1 --verify (thefile)fornece na saída como primeira sequência a impressão digital da chave que fez a assinatura.

— harrymc

Algum contexto aqui: temos um sistema que assina as coisas. Damos sua chave pública a pessoas que possam receber mensagens desse sistema, para que possam verificar se as mensagens não foram adulteradas. No entanto, não queremos que os destinatários "confiem em qualquer coisa assinada por essa chave", pois ela pode ser usada para autenticar mensagens de outros sistemas (por exemplo, e-mails de seus amigos).

— OJW 27/09/13

Então, queremos fornecer a alguém um arquivo de comando / lote que verifique "o gpg diz que esta mensagem foi enviada por essa chave?" sem interferir no uso diário de gpg para se comunicar com outras pessoas. A chave só deve ser confiável porque a linha de comando solicita, não porque o GPG foi instruído a confiar sempre nela.

— OJW 27/09/13

Respostas:

Você deve ter a chave pública para verificar uma assinatura feita com a chave privada correspondente, mas não precisa assinar nem assinar localmente a chave. Nesse caso, você receberá um aviso do GPG de que a chave não é confiável.

Aqui está um teste que eu fiz com um arquivo assinado por minha própria chave, mas em um sistema em que a chave não foi importada:

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

Infelizmente, a sugestão de Harry não funciona, ela extrai um pouco mais de informação, mas não o suficiente para ser útil.

Como você pode ver, o máximo de informações obtidas é o ID da chave da subchave usada para fazer a assinatura e a hora em que a assinatura foi feita. Isso corresponde aos dados disponíveis para o 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$

Como você pode ver, ele fornece o algoritmo de hash, os detalhes do tipo de chave (minha chave de assinatura é uma subchave RSA de 3072 bits e o ID da chave, mas não há nada para identificar a chave mestra. revelado quando você tem a chave pública e verifica a assinatura.

Importei minha chave pública nesse sistema e tentei novamente:

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

Agora ele pode identificar a chave e combiná-la com a chave primária. É, no entanto, possível reduzir a natureza desses avisos como este:

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

Ainda há um aviso de que é uma chave não confiável, mas não massivamente, e a remoção da verbosidade a reduz apenas a isso:

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

A chave pública é necessária para o estágio de verificação porque é usada para corresponder os dados gerados pelo assinante com sua chave privada. Isso pode ser pensado, em termos simples, como o complemento da criptografia onde a chave privada é necessária para decodificar os dados criptografados na chave pública.

Nota: Ajustamos um pouco os UIDs neste exemplo, mas todos que obtiverem essa chave verão o que realmente são. Caso contrário, a saída será uma cópia e colagem direta.

EDIT: Você pode chamar o arquivo de chave pública diretamente como um chaveiro, se o tiver no formato blindado não ASCII (por exemplo, um arquivo .gpg em vez de um arquivo .asc). Mesmo assim, você ainda precisa da chave pública. Para fazer isso, o comando é assim:

[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

Olhando para a sua saída, cheguei à conclusão exatamente oposta. Eu usei sua saída na minha resposta, mas lhe dei crédito por isso.

— harrymc

A parte a que você se refere, que é a forma longa do ID da chave da subchave (tecnicamente, o ID da chave completa é a impressão digital) é a única parte identificável. Porém, sem a posse da chave pública, você não pode identificar a chave mestra ou verificar a assinatura. Os detalhes disso estão na seção 5.2 do RFC 4880 (com um pouco na seção 2.2, mas 5.2 é onde estão as coisas úteis). Se eu estiver errado, prove a verificação sem uma cópia da chave (dica: você não pode fazer isso com meus exemplos).

— Ben

Além disso, na sua conclusão sobre --verify, ela só funciona quando a chave está disponível; caso contrário, volte ao primeiro exemplo da minha resposta em que o ID da chave e o horário da assinatura são verificados, mas a chave não foi encontrada.

— 22413 Ben

Sim, é claro que a identificação completa não é possível apenas com o ID da chave. Modifiquei minha resposta para afirmar claramente que isso é apenas uma heurística. Sua conclusão é que o que o pôster está pedindo é impossível, mas provavelmente porque o pôster usou a palavra "verificar", que é muito forte.

— precisa saber é

Isso é verdade, o OP provavelmente não está usando os termos corretamente e eu posso tê-los enganado em alguns lugares também (eu estava espirrando muito ontem à noite). Se a pergunta dele era sobre validar um sig sem importar uma chave, o exemplo na minha edição mostra como isso pode ser feito, mas apenas se essa chave estiver no formato OpenPGP (pubkey.gpg). Não funciona se a chave exportada estiver no formato blindado ASCII (pubkey.asc).

— Ben

Se você concorda em enviar um chaveiro, em vez de um arquivo de chave pública, provavelmente deseja usar, em gpgvvez de gpg:

gpgv --keyring key.ring somefile.txt

— womble
fonte

Se sua palavra "verificar" na pergunta significa "verificar absolutamente", é claro que uma chave pública deve ser importada para verificar completamente um documento assinado. No entanto, se isso significa "identificar", descrevo abaixo uma heurística que pode dizer se um grupo de documentos foi assinado pela mesma assinatura.

De acordo com os testes realizados pelo @Ben para verificar meu comentário, existe a possibilidade de o seguinte comando poder ser usado para indicar heuristicamente a chave de assinatura:

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

O teste de Ben deu o resultado abaixo. De notar os valores de ERRSIG e NO_PUBKEY e também o valor de "RSA key ID", que está parcialmente contido nos dois, da seguinte forma:

[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

Observe acima da string 7FF2D37135C7553C. Essa mesma sequência é encontrada dentro da impressão digital da chave que é relatada depois que a chave é importada:

[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

Essa sequência é encontrada como a parte inferior da impressão digital (subchave acima), portanto, pode ser usada para identificar a chave. Provavelmente, a "impressão digital da chave primária" também deve ser verificada, além da subchave.

A cadeia "RSA key ID" é idêntica nas duas saídas e também é encontrada como a última parte da impressão digital; portanto, é possível que seja suficiente por si só para identificar a assinatura. Se for esse o caso, usar apenas a saída de gpg --verifypode ser suficiente para identificar a assinatura de uma maneira mais simples.

[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

Meu conhecimento do GPG não é suficiente para validar completamente esse método; portanto, você deve experimentá-lo em mais arquivos de exemplo. Se funcionar, você poderá classificar os arquivos de acordo com as assinaturas, mas precisará importar a chave para encontrar a identidade do signatário.

Para declarar claramente novamente: Este método não pode identificar completamente uma assinatura. É apenas uma maneira de classificar heuristicamente os documentos assinados.

— harrymc
fonte

Uma assinatura contém dados suficientes para identificar a chave usada para criá-la e, em conjunto com os servidores de chaves, pode ser usada para localizar a chave mestra (assumindo que uma subchave de assinatura foi usada como nos meus exemplos). Sem uma cópia da chave pública no formato OpenPGP (em um chaveiro ou como no meu exemplo final), a validação da assinatura não é possível porque o ID da impressão digital / chave não possui dados suficientes para calcular isso.

— Ben

@ Ben: repito que isso é apenas uma heurística, que é o melhor que pode ser feito para responder à pergunta do pôster de "verificar se um arquivo foi assinado por um arquivo de chave pública específico, sem ter que importar, assinar e confiar nessa chave "

— precisa saber é

tornaria a pergunta mais clara se eu dissesse que confiamos em qualquer chave do arquivo .pub (para fins de verificação desse arquivo de dados específico) e que os motivos pelos quais escolhemos confiar nesse arquivo .pub estão fora do escopo de alguma atividade de GPG?

— OJW 27/09/13

A heurística de listar as chaves no arquivo .pub e comparar seu ID de chave RSA será útil? Não tenho gpg aqui para tentar, mas talvez algo como "gpg --no-default-keyring --keyring <pub-file> --list-keys".

— harrymc