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

Question

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

i.e. algo como

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

ao invés de ter que criar sua própria chave privada e então fazer

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

    

Answer 1

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 dizendo que a chave não é confiável.

Aqui está um teste que fiz com um arquivo assinado pela 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, ele extrai um pouco mais de informação, mas não o suficiente para ser útil.

Como você pode ver, a maior parte das informações obtidas é o ID da chave da subchave usada para fazer a assinatura e a hora em que a assinatura foi feita. Isto 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 da subchave, mas não há nada para identificar a chave mestre. as informações só são reveladas quando você tem a chave pública e verifica a assinatura.

Em seguida, 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, é capaz de identificar a chave e combiná-la com a chave primária. É, no entanto, possível reduzir a natureza dos 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 massiva, e a remoção do detalhamento só reduz 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, pois é usada para corresponder dados gerados pelo signatário com sua chave privada. Pode-se pensar, em termos simples, como o complemento da criptografia, em que a chave privada é necessária para decodificar os dados criptografados para a chave pública.

Nota: Eu modifiquei os UIDs neste exemplo um pouco, mas todos que recebem essa chave verão o que realmente são. Caso contrário, a saída é uma cópia direta e cole.

EDIT: Você pode chamar o arquivo de chave pública diretamente como um chaveiro, se você o tiver no formato blindado não-ASCII (ou seja, 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 ~]$ 

    

Answer 2

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

De acordo com os testes realizados por @Ben para confirmar meu comentário, existe a possibilidade de que o seguinte comando possa 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 nota são os valores de ERRSIG e NO_PUBKEY, e também o valor de "RSA key ID" que está parcialmente contido em ambos, como 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

Observe acima a string 7FF2D37135C7553C . Essa mesma string é encontrada dentro da impressão digital da chave que é relatada quando 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

Esta string é encontrada como a parte inferior da impressão digital (subchave acima), portanto, possivelmente ser usado para identificar a chave. A "impressão digital da chave primária" provavelmente deve ser verificada também, além da subchave.

A string "RSA key ID" é idêntica em ambas as saídas e também é encontrada como a última parte da impressão digital, Por isso, é possível que seja suficiente, por si só, identificar a assinatura. Se for esse o caso, usar apenas a saída de gpg --verify pode ser suficiente para identificar a assinatura de forma 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 de GPG não é suficiente para validar totalmente esse método, então você deve tentar em mais arquivos de exemplo. Se funcionar, você pode classificar os arquivos de acordo com o assinaturas, mas precisará importar a chave para encontrar a identidade do signatário.

Para indicar claramente: esse método não pode identificar totalmente uma assinatura. É apenas uma maneira de classificar heuristicamente os documentos assinados.

    

Answer 3

Se você estiver certo em enviar um chaveiro, em vez de um arquivo de chave pública, provavelmente desejará usar gpgv em vez de gpg :

gpgv --keyring key.ring somefile.txt