Assinaturas Digitais com RSA em Criptografia

Introdução

Bem-vindo ao laboratório sobre Assinaturas Digitais com RSA. Uma assinatura digital é um mecanismo criptográfico usado para verificar a autenticidade e a integridade de mensagens ou documentos digitais. Ela garante que a mensagem foi criada por um remetente conhecido (autenticidade) e que não foi alterada durante a transmissão (integridade).

Neste laboratório, você terá experiência prática com todo o ciclo de vida de uma assinatura digital. Utilizaremos a ferramenta de linha de comando openssl, uma utilidade robusta e versátil para tarefas criptográficas. Você aprenderá a gerar uma assinatura usando uma chave privada e a verificá-la usando a chave pública correspondente. Ao final, você terá uma compreensão prática de como as assinaturas digitais protegem nossas comunicações digitais.

Conceito de Assinatura Digital

Nesta etapa, começaremos a entender o conceito central de uma assinatura digital. Uma assinatura digital é criada pelo remetente usando sua chave privada (private key). Esta chave é mantida em segredo e é conhecida apenas pelo remetente. A assinatura pode então ser verificada por qualquer pessoa que possua a chave pública (public key) correspondente do remetente.

Este processo fornece duas garantias de segurança críticas:

• Autenticidade: Como apenas o remetente possui a chave privada, uma assinatura válida prova que a mensagem se originou dele.
• Integridade: A assinatura está matematicamente ligada ao conteúdo da mensagem. Se a mensagem for alterada de alguma forma, a assinatura não será mais válida.

Para facilitar este laboratório, o processo de configuração já gerou um par de chaves RSA para você: private.pem (sua chave secreta) e public.pem (sua chave compartilhável). Ele também criou um arquivo chamado message.txt. Vamos listar os arquivos em nosso diretório de projeto para visualizá-los.

Execute o seguinte comando no seu terminal:

ls -l

Você deverá ver os arquivos que foram preparados para você:

-rw-rw-r-- 1 labex labex   55 Oct 20 09:20 document.txt
-rw-rw-r-- 1 labex labex   26 Oct 20 09:20 message.txt
-rw------- 1 labex labex 1704 Oct 20 09:20 private.pem
-rw-rw-r-- 1 labex labex  451 Oct 20 09:20 public.pem

Agora que temos nossas chaves e uma mensagem, estamos prontos para criar nossa primeira assinatura digital.

Assinar Mensagem com Chave Privada

Nesta etapa, você criará uma assinatura digital para o arquivo message.txt. O processo envolve duas ações principais: primeiro, criar um hash criptográfico (uma string de bytes única de tamanho fixo) da mensagem e, segundo, criptografar esse hash com sua chave privada. O resultado é a assinatura digital.

Usaremos o comando openssl dgst para realizar esta operação. Vamos executar o comando para assinar message.txt.

openssl dgst -sha256 -sign private.pem -out signature.bin message.txt

Vamos detalhar este comando:

• openssl dgst: Invoca o comando de digest (resumo) do OpenSSL.
• -sha256: Especifica o algoritmo SHA-256 para criar o hash da mensagem.
• -sign private.pem: Informa ao OpenSSL para assinar o hash usando a chave privada especificada, private.pem.
• -out signature.bin: Especifica o arquivo de saída onde a assinatura binária resultante será armazenada.
• message.txt: É o arquivo de entrada que estamos assinando.

Após executar o comando, um novo arquivo chamado signature.bin será criado. Este arquivo contém a assinatura digital. Você pode verificar sua criação listando os arquivos novamente.

ls -l

Você verá agora signature.bin na lista de arquivos:

-rw-rw-r-- 1 labex labex   55 Oct 20 09:20 document.txt
-rw-rw-r-- 1 labex labex   26 Oct 20 09:20 message.txt
-rw------- 1 labex labex 1704 Oct 20 09:20 private.pem
-rw-rw-r-- 1 labex labex  451 Oct 20 09:20 public.pem
-rw-rw-r-- 1 labex labex  256 Oct 20 09:26 signature.bin

Verificar Assinatura com Chave Pública

Nesta etapa, desempenharemos o papel de um destinatário que deseja verificar a assinatura. Para fazer isso, o destinatário precisa de três coisas: a mensagem original (message.txt), a assinatura digital (signature.bin) e a chave pública do remetente (public.pem).

O processo de verificação reverte o processo de assinatura. O OpenSSL usará a chave pública para descriptografar a assinatura, revelando o hash original. Em seguida, ele calculará independentemente um novo hash da mensagem que recebeu. Se os dois hashes coincidirem, a assinatura é válida.

Vamos usar o openssl dgst novamente, mas desta vez com a opção -verify.

openssl dgst -sha256 -verify public.pem -signature signature.bin message.txt

Aqui está o detalhamento do comando de verificação:

• -verify public.pem: Informa ao OpenSSL para verificar uma assinatura usando a chave pública especificada, public.pem.
• -signature signature.bin: Especifica o arquivo de assinatura a ser verificado.
• message.txt: É o arquivo de mensagem original ao qual a assinatura deve corresponder.

Se a assinatura for válida, o OpenSSL exibirá a seguinte mensagem:

Verified OK

Esta confirmação significa duas coisas: a mensagem foi definitivamente assinada pelo proprietário da chave private.pem e o conteúdo de message.txt não foi alterado desde que foi assinado.

Assinar Arquivo com Chave Privada

Nesta etapa, reforçaremos o processo de assinatura aplicando-o a um arquivo diferente. Isso ajudará a solidificar sua compreensão de como um hash assinado é criado e usado. Temos outro arquivo em nosso diretório chamado document.txt. Agora criaremos uma assinatura digital para este documento.

O procedimento é idêntico ao que fizemos na Etapa 2. Geraremos um hash SHA-256 de document.txt e, em seguida, assinaremos esse hash com nossa chave private.pem.

Vamos criar a assinatura e salvá-la em um arquivo chamado document.sig.

openssl dgst -sha256 -sign private.pem -out document.sig document.txt

Este comando cria um novo arquivo de assinatura, document.sig, que é específico para o conteúdo atual de document.txt. Qualquer alteração no documento exigiria a geração de uma nova assinatura.

Vamos listar os arquivos para confirmar que document.sig foi criado.

ls

Você deverá ver o novo arquivo de assinatura na saída:

document.sig  document.txt  message.txt  private.pem  public.pem  signature.bin

Agora temos um documento assinado, que usaremos na próxima etapa para demonstrar o poder de verificação de integridade das assinaturas digitais.

Testar Adulteração da Assinatura

Nesta etapa final, demonstraremos o recurso mais crítico de uma assinatura digital: a proteção de integridade. Alteraremos intencionalmente o arquivo document.txt após ele ter sido assinado e, em seguida, tentaremos verificá-lo com a assinatura original. Isso mostrará como as assinaturas digitais impedem modificações não autorizadas.

Primeiro, vamos adicionar algum texto ao arquivo document.txt. Isso simula um invasor alterando o documento.

echo "This is an unauthorized change." >> document.txt

O conteúdo de document.txt foi alterado. A assinatura original, document.sig, foi criada com base no conteúdo anterior do arquivo.

Agora, vamos tentar verificar o arquivo document.txt modificado usando a assinatura original document.sig e a chave pública.

openssl dgst -sha256 -verify public.pem -signature document.sig document.txt

Desta vez, a verificação não será bem-sucedida. Em vez disso, você verá uma mensagem de erro semelhante a:

Verification failure
805BA484597F0000:error:02000068:rsa routines:ossl_rsa_verify:bad signature:../crypto/rsa/rsa_sign.c:430:
805BA484597F0000:error:1C880004:Provider routines:rsa_verify:RSA lib:../providers/implementations/signature/rsa_sig.c:774:

Esta falha é o resultado esperado. Ocorre porque o hash do document.txt modificado não corresponde mais ao hash que foi criptografado dentro de document.sig. Isso prova instantaneamente que o arquivo foi adulterado desde que foi assinado. Este mecanismo é fundamental para confiar em documentos e comunicações digitais.

Resumo

Neste laboratório, você aprendeu com sucesso a aplicação prática de assinaturas digitais usando RSA e OpenSSL.

Você percorreu todo o processo:

• Entendeu os conceitos centrais de autenticidade e integridade fornecidos pelas assinaturas digitais.
• Usou uma chave privada (private.pem) para assinar uma mensagem e criar um arquivo de assinatura.
• Usou a chave pública correspondente (public.pem) para verificar a assinatura e confirmar a autenticidade da mensagem.
• Testemunhou uma Verification failure (Falha na Verificação) após adulterar intencionalmente um arquivo assinado, demonstrando como as assinaturas digitais protegem a integridade dos dados.

Esta experiência prática fornece uma base sólida para entender como a confiança é estabelecida no mundo digital, um conceito crucial em segurança cibernética e computação moderna.