Garantir Integridade e Autenticidade de Dados com Criptografia

Introdução

No mundo digital, garantir que os dados não foram adulterados (integridade) e que provêm de uma fonte confiável (autenticidade) é crucial. A criptografia fornece as ferramentas para alcançar estes objetivos.

Este laboratório irá introduzi-lo às práticas criptográficas fundamentais num sistema Linux. Aprenderá sobre:

• Hashing: Criação de uma "impressão digital" única e de tamanho fixo de um ficheiro. Se o ficheiro for alterado, mesmo que por um único bit, o hash será completamente alterado. Utilizaremos os algoritmos MD5 e SHA256.
• Assinaturas Digitais: Utilização de uma chave privada para "assinar" um ficheiro, o que permite a qualquer pessoa com a chave pública correspondente verificar que o ficheiro é autêntico e não foi modificado.
• Criptografia: Embaralhar o conteúdo de um ficheiro de modo a que só possa ser lido por alguém que possua a chave correta para o descriptografar, garantindo a confidencialidade.

Utilizaremos ferramentas padrão da linha de comandos do Linux, incluindo md5sum, sha256sum e GnuPG (gpg), a implementação GNU do padrão Pretty Good Privacy (PGP). No final deste laboratório, será capaz de fazer hash, assinar, verificar, criptografar e descriptografar ficheiros com confiança.

Calcular Hashes de Ficheiros (MD5 e SHA256)

Nesta etapa, aprenderá a calcular hashes criptográficos para um ficheiro. Uma função de hash recebe uma entrada (como um ficheiro) e retorna uma string de bytes de tamanho fixo, conhecida como valor de hash ou digest. Este valor funciona como uma impressão digital digital.

Primeiro, utilizaremos o comando md5sum para calcular o hash MD5 do ficheiro important_data.txt que foi pré-criado no seu diretório ~/project.

Execute o seguinte comando no seu terminal:

md5sum important_data.txt

Verá uma saída composta pelo valor do hash seguido pelo nome do ficheiro:

d9e21981521545759153147864347199  important_data.txt

Embora o MD5 seja rápido, é agora considerado inseguro para fins criptográficos devido a vulnerabilidades. Uma alternativa mais segura e comummente utilizada é a família SHA-2, especificamente SHA256.

Agora, vamos calcular o hash SHA256 utilizando o comando sha256sum:

sha256sum important_data.txt

A saída será um hash mais longo e mais seguro:

a39b2c414f234246a2535321238863141b1a4849443b9992994b4189317e8591  important_data.txt

Se alterasse algo em important_data.txt, tanto o hash MD5 como o SHA256 mudariam completamente, permitindo-lhe detetar facilmente quaisquer modificações não autorizadas.

Instalar e Configurar GnuPG (GPG)

Nesta etapa, irá instalar o GnuPG (GPG), a ferramenta que utilizaremos para assinaturas digitais e encriptação. Embora o GPG seja frequentemente pré-instalado em distribuições Linux modernas, é uma boa prática garantir que está presente e atualizado.

Primeiro, atualize a sua lista de pacotes utilizando apt-get update. Precisa de usar sudo porque a gestão de pacotes requer privilégios administrativos.

sudo apt-get update

Em seguida, instale o pacote gnupg. A flag -y responde automaticamente "sim" a quaisquer pedidos, tornando a instalação não interativa.

sudo apt-get install -y gnupg

Após a conclusão da instalação, pode verificar se o GPG está instalado corretamente verificando a sua versão.

gpg --version

Deverá ver uma saída semelhante à seguinte, confirmando a instalação. Os números de versão e os detalhes podem variar ligeiramente.

gpg (GnuPG) 2.2.27
libgcrypt 1.9.4
Copyright (C) 2021 Free Software Foundation, Inc.
License GNU GPL-3.0-or-later <https://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

Home: /home/labex/.gnupg
Supported algorithms:
Pubkey: RSA, ELG, DSA, ECDH, ECDSA, EDDSA
Cipher: IDEA, 3DES, CAST5, BLOWFISH, AES, AES192, AES256, TWOFISH,
        CAMELLIA128, CAMELLIA192, CAMELLIA256
Hash: SHA1, RIPEMD160, SHA256, SHA384, SHA512, SHA224
Compression: Uncompressed, ZIP, ZLIB, BZIP2

Agora que o GPG está pronto, podemos prosseguir para a criação das nossas próprias chaves criptográficas.

Gerar um Par de Chaves GPG para Assinaturas Digitais

Nesta etapa, irá gerar o seu próprio par de chaves GPG, que consiste numa chave privada e numa chave pública.

• Chave Privada: Deve ser mantida em segredo. É utilizada para desencriptar mensagens e criar assinaturas digitais.
• Chave Pública: Pode ser partilhada livremente. É utilizada para encriptar mensagens destinadas a si e para verificar as suas assinaturas digitais.

Normalmente, gpg --full-generate-key executa uma configuração interativa. Para tornar este processo mais simples e não interativo para o laboratório, utilizaremos o modo batch do GPG. Primeiro, crie um ficheiro de parâmetros que especifica os detalhes para a nossa chave.

Utilize o seguinte comando cat com um "here document" para criar o ficheiro gen-key-params instantaneamente:

cat << EOF > gen-key-params
%echo Generating a basic key
Key-Type: RSA
Key-Length: 2048
Subkey-Type: RSA
Subkey-Length: 2048
Name-Real: LabEx User
Name-Email: user@labex.io
Expire-Date: 0
%no-protection
%commit
%echo done
EOF

Este ficheiro instrui o GPG a criar uma chave RSA de 2048 bits para um utilizador chamado "LabEx User" com o email "user@labex.io". A chave nunca expirará e utilizamos %no-protection para criar a chave sem uma passphrase por simplicidade (num cenário real, deve sempre usar uma passphrase forte).

Agora, gere a chave utilizando o ficheiro de parâmetros:

gpg --batch --gen-key gen-key-params

O GPG utilizará os parâmetros para gerar o par de chaves. Isto pode demorar alguns momentos. Assim que terminar, pode listar as suas chaves para confirmar que o par de chaves foi criado com sucesso.

gpg --list-keys

A saída deverá mostrar a sua chave pública recém-criada, semelhante a esta:

/home/labex/.gnupg/pubring.kbx
-------------------------------
pub   rsa2048 2023-10-27 [SC]
      XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
uid           [ultimate] LabEx User <user@labex.io>
sub   rsa2048 2023-10-27 [E]

Agora tem um par de chaves GPG pronto para assinar e encriptar ficheiros.

Assinar Digitalmente e Verificar um Arquivo com GPG

Nesta etapa, irá utilizar a sua chave privada para criar uma assinatura digital para um ficheiro. Esta assinatura prova que o ficheiro se originou consigo e não foi alterado desde que o assinou.

Criaremos uma assinatura "desanexada" (detached), que é armazenada num ficheiro separado. Isto é útil porque o ficheiro original permanece intocado.

Para assinar important_data.txt, execute o seguinte comando. O GPG utilizará automaticamente a chave privada padrão que acabou de gerar.

gpg --detach-sign important_data.txt

Como criámos a chave sem uma passphrase, não lhe será solicitada uma. Agora, liste os ficheiros no seu diretório para ver o novo ficheiro de assinatura.

ls

Verá o ficheiro original e a sua assinatura:

gen-key-params  important_data.txt  important_data.txt.sig

Agora, imagine que é um destinatário que recebeu tanto important_data.txt como important_data.txt.sig, juntamente com a sua chave pública. Para verificar a autenticidade e integridade do ficheiro, executariam o comando gpg --verify.

Vamos realizar a verificação você mesmo:

gpg --verify important_data.txt.sig important_data.txt

A saída confirmará que a assinatura é válida:

gpg: Signature made Mon Aug  4 16:39:30 2025 CST
gpg:                using RSA key 8765265B14E42532B9CBAE6DE2120C9784C69814
gpg: Good signature from "LabEx User <user@labex.io>" [ultimate]

A mensagem "Good signature" confirma que o ficheiro é autêntico e não foi modificado.

Criptografar e Descriptografar um Arquivo com GPG

Nesta etapa, irá aprender a encriptar um ficheiro para confidencialidade. Ao contrário da assinatura (que utiliza a sua chave privada), encriptar um ficheiro para alguém requer a chave pública dessa pessoa. O destinatário utiliza então a sua chave privada para o desencriptar.

Aqui, encriptaremos important_data.txt para nós mesmos, pelo que utilizaremos a nossa própria chave pública como chave do destinatário.

Utilize o seguinte comando para encriptar o ficheiro. A bandeira --recipient especifica qual a chave pública a utilizar para encriptação, e --output define o nome do ficheiro encriptado.

gpg --encrypt --recipient "user@labex.io" --output important_data.txt.gpg important_data.txt

Se tentar visualizar o conteúdo do novo ficheiro encriptado, important_data.txt.gpg, verá dados binários ilegíveis.

cat important_data.txt.gpg

Agora, vamos desencriptar o ficheiro. Esta ação requer a chave privada correspondente. Como possui a chave privada, pode desencriptar a mensagem. Guardaremos o conteúdo desencriptado num novo ficheiro chamado decrypted_data.txt.

gpg --decrypt --output decrypted_data.txt important_data.txt.gpg

O GPG utilizará a sua chave privada para desencriptar o ficheiro. Verá algumas informações do GPG no seu terminal, incluindo uma confirmação de que o ficheiro foi encriptado com a sua chave.

Finalmente, visualize o conteúdo do ficheiro desencriptado para confirmar que o processo foi bem-sucedido.

cat decrypted_data.txt

A saída deverá ser a mensagem original e legível:

This is a secret message that needs to be protected.

Encriptou com sucesso um ficheiro para proteger o seu conteúdo e depois desencriptou-o para recuperar a informação original.

Resumo

Neste laboratório, adquiriu experiência prática com ferramentas e conceitos criptográficos essenciais num sistema Linux. Realizou com sucesso as seguintes tarefas:

• Calculou hashes de ficheiros utilizando md5sum e sha256sum para garantir a integridade dos dados.
• Instalou e configurou o GnuPG (gpg), a ferramenta padrão para criptografia de código aberto.
• Gerou um par de chaves GPG pessoal (chaves pública e privada).
• Criou uma assinatura digital com gpg --detach-sign para fornecer autenticidade e integridade.
• Verificou uma assinatura digital com gpg --verify.
• Encriptou um ficheiro para confidencialidade utilizando gpg --encrypt.
• Desencriptou o ficheiro para aceder ao seu conteúdo original utilizando gpg --decrypt.

Estas competências são fundamentais para proteger dados, verificar downloads de software e proteger comunicações numa vasta gama de contextos profissionais e pessoais.