Criptografar e Descriptografar Arquivos com GPG no Linux

CompTIABeginner
Pratique Agora

Introdução

Neste laboratório, você adquirirá as habilidades essenciais para criptografar e descriptografar arquivos em um ambiente Linux usando o GPG (GNU Privacy Guard). Você começará gerando seu próprio par de chaves pública/privada, que é a base do modelo de segurança do GPG. Após a geração das chaves, você praticará as operações fundamentais de criptografar um arquivo para si mesmo e, em seguida, descriptografá-lo usando sua chave secreta e frase de senha (passphrase).

Com base nesses fundamentos, você explorará como trocar informações de forma segura com outras pessoas. Isso inclui exportar sua chave pública para compartilhamento e importar a chave pública de outro usuário. Você também aprenderá a assinar uma chave pública para verificar sua autenticidade e a realizar tarefas cruciais de manutenção, como fazer o backup de sua chave secreta e criar um certificado de revogação, caso sua chave seja comprometida em algum momento.

Este é um Laboratório Guiado, que fornece instruções passo a passo para ajudá-lo a aprender e praticar. Siga as instruções cuidadosamente para concluir cada etapa e ganhar experiência prática. Dados históricos mostram que este é um laboratório de nível iniciante com uma taxa de conclusão de 93%. Ele recebeu uma taxa de avaliação positiva de 94% dos alunos.

Gerar seu Par de Chaves GPG com gpg --gen-key

Nesta etapa, você gerará seu par de chaves pessoal do GPG (GNU Privacy Guard). Um par de chaves GPG consiste em duas chaves distintas, porém relacionadas: uma chave pública e uma chave privada. Você pode compartilhar sua chave pública com outras pessoas para que elas criptografem arquivos para você. Você deve manter sua chave privada em segredo, pois ela é a única capaz de descriptografar arquivos protegidos com sua chave pública.

Primeiro, vamos garantir que o pacote gnupg, que fornece as funcionalidades do GPG, esteja instalado em seu sistema.

sudo apt-get update && sudo apt-get install -y gnupg

Agora, você está pronto para gerar seu par de chaves. O comando gpg --gen-key o guiará por um processo interativo.

Execute o seguinte comando no seu terminal:

gpg --gen-key

Você verá uma nota informando que este comando utiliza uma geração de chave simplificada. Para opções mais avançadas, você poderia usar gpg --full-generate-key, mas as opções padrão são adequadas para este laboratório.

Serão solicitadas as seguintes informações:

  1. Real name: Digite labex
  2. Email address: Digite labex@example.com
  3. Confirm User ID: Revise seus dados. Quando solicitado Change (N)ame, (E)mail, or (O)kay/(Q)uit?, digite O e pressione Enter.

O sistema usará automaticamente padrões seguros:

  • Tipo de chave: RSA e RSA (padrão)
  • Tamanho da chave: 3072 bits (padrão seguro)
  • Validade da chave: 2 anos (expiração automática para segurança)

Nota: Diferente de versões mais antigas, o GPG moderno pode não solicitar uma frase de senha durante a geração de chave via --gen-key. Se você desejar adicionar uma frase de senha à sua chave para segurança adicional, poderá fazer isso mais tarde usando:

gpg --edit-key labex

Em seguida, digite passwd no prompt do GPG para definir uma senha e depois save para sair.

O sistema agora gerará seu par de chaves. Este processo requer dados aleatórios (entropia) e pode levar alguns instantes.

Uma vez concluído, você verá uma mensagem de confirmação semelhante a esta:

gpg: key <KEY_ID> marked as ultimately trusted
gpg: revocation certificate stored as '/home/labex/.gnupg/openpgp-revocs.d/<FINGERPRINT>.rev'
public and secret key created and signed.

pub   rsa3072 2025-07-01 [SC] [expires: 2027-07-01]
      <FINGERPRINT>
uid                      labex <labex@example.com>
sub   rsa3072 2025-07-01 [E] [expires: 2027-07-01]

Agora que suas chaves foram geradas, você pode visualizá-las. Para ver sua nova chave pública, execute:

gpg --list-keys

A saída listará todas as chaves públicas em seu chaveiro, incluindo a que você acabou de criar:

/home/labex/.gnupg/pubring.kbx
------------------------------
pub   rsa3072 2025-07-01 [SC] [expires: 2027-07-01]
      <FINGERPRINT>
uid           [ultimate] labex <labex@example.com>
sub   rsa3072 2025-07-01 [E] [expires: 2027-07-01]

Para visualizar sua chave privada, execute:

gpg --list-secret-keys

A saída será semelhante, mas indicará uma chave secreta (sec) em vez de uma chave pública (pub):

/home/labex/.gnupg/pubring.kbx
------------------------------
sec   rsa3072 2025-07-01 [SC] [expires: 2027-07-01]
      <FINGERPRINT>
uid           [ultimate] labex <labex@example.com>
ssb   rsa3072 2025-07-01 [E] [expires: 2027-07-01]

Você criou e verificou com sucesso seu par de chaves GPG.

Criptografar e Descriptografar um Arquivo Local com gpg -e e gpg --decrypt

Nesta etapa, você usará o par de chaves GPG que gerou para criptografar e, em seguida, descriptografar um arquivo. Este é um caso de uso fundamental do GPG, permitindo proteger a confidencialidade dos seus dados. A criptografia transforma seus dados legíveis em um formato ilegível, e apenas alguém com a chave privada correta pode descriptografá-los de volta ao formato original.

Primeiro, vamos criar um arquivo de texto simples para trabalhar. Todas as operações serão realizadas no seu diretório atual, ~/project.

echo "This is a secret message for the lab." > mytestfile.txt

Agora, você pode criptografar este arquivo usando sua chave pública. O comando gpg -e é usado para criptografia. Você também precisa especificar o destinatário da mensagem criptografada com a flag -r, que deve ser o nome associado à sua chave GPG (labex).

gpg -e -r labex mytestfile.txt

O GPG usará sua chave pública para criptografar o arquivo. Você não será solicitado a inserir sua frase de senha porque a criptografia é feita com a chave pública, que não é secreta.

Após a conclusão do comando, use o comando ls para ver o novo arquivo criptografado.

ls

Você deve ver mytestfile.txt.gpg na saída, ao lado do arquivo original.

mytestfile.txt  mytestfile.txt.gpg

O arquivo mytestfile.txt.gpg contém os dados criptografados. Se você tentar visualizar seu conteúdo, verá dados binários ilegíveis.

Agora, vamos descriptografar o arquivo. Para fazer isso, você usará o comando gpg --decrypt. Como você está descriptografando, o GPG usará sua chave privada.

Usaremos a flag --output para especificar um novo arquivo para o conteúdo descriptografado, mytestfile.txt.decrypted. Isso evita sobrescrever o arquivo original e deixa claro qual arquivo é qual.

gpg --output mytestfile.txt.decrypted --decrypt mytestfile.txt.gpg

Se sua chave tiver uma frase de senha, você será solicitado a inseri-la. Se nenhuma frase de senha foi definida durante a geração da chave, a descriptografia prosseguirá automaticamente. Você deverá ver uma saída semelhante a:

gpg: encrypted with 3072-bit RSA key, ID <KEY_ID>, created 2025-07-01
      "labex <labex@example.com>"

Uma vez descriptografado, você pode visualizar o conteúdo do novo arquivo para confirmar que ele corresponde à mensagem original.

cat mytestfile.txt.decrypted

A saída deve ser o texto original que você criou:

This is a secret message for the lab.

Você criptografou com sucesso um arquivo para si mesmo e o descriptografou usando seu par de chaves GPG.

Trocar Chaves Públicas com gpg --export e gpg --import

Nesta etapa, você aprenderá como trocar chaves públicas com outras pessoas. Para criptografar um arquivo para outra pessoa, você precisa da chave pública dela. Da mesma forma, se alguém quiser enviar um arquivo criptografado para você, precisará da sua chave pública. Este processo envolve exportar sua chave pública para um arquivo e importar as chaves públicas que você recebe de terceiros para o seu chaveiro GPG.

Primeiro, vamos exportar sua própria chave pública. Você usará o comando gpg --export. É uma boa prática usar a opção --armor, que cria uma versão em texto (ASCII) da chave, facilitando a cópia e colagem em e-mails ou outros canais de comunicação baseados em texto. Vamos salvá-la em um arquivo chamado labex.pub.

No seu terminal, execute o seguinte comando. Substitua labex pelo ID de usuário que você usou durante a geração da chave.

gpg --export --armor -o labex.pub labex

Você pode verificar se o arquivo foi criado usando ls:

ls

Você deve ver labex.pub na lista de arquivos. Você também pode visualizar seu conteúdo:

cat labex.pub

A saída será um bloco de texto começando com -----BEGIN PGP PUBLIC KEY BLOCK-----. Esta é a sua chave pública, que agora você pode compartilhar com outras pessoas.

Em seguida, você simulará o recebimento de uma chave pública de outro usuário e a importação para o seu chaveiro. Em um cenário real, você receberia a chave pública de outra pessoa através de um canal seguro. Para este laboratório, criaremos um par de chaves temporário para a Alice e exportaremos a chave pública dela para simular esse processo.

Primeiro, vamos gerar temporariamente um par de chaves para a Alice. Usaremos o modo em lote (batch) para automatizar este processo sem prompts interativos:

cat > alice-key-params << 'EOF'
Key-Type: RSA
Key-Length: 2048
Subkey-Type: RSA
Subkey-Length: 2048
Name-Real: Alice
Name-Email: alice@example.com
Expire-Date: 2y
%no-protection
%commit
EOF

Agora gere o par de chaves da Alice usando o arquivo de parâmetros:

gpg --batch --generate-key alice-key-params

Você deve ver uma saída confirmando a geração da chave:

gpg: key <KEY_ID> marked as ultimately trusted
public and secret key created and signed.

Agora exporte a chave pública da Alice para um arquivo, simulando como você a receberia dela:

gpg --export --armor -o alice.pub alice@example.com

Para esta demonstração, também removeremos a chave secreta da Alice do chaveiro, já que, na realidade, você teria apenas a chave pública dela:

gpg --delete-secret-keys alice@example.com

Quando solicitado, confirme a exclusão digitando y e pressionando Enter.

gpg --delete-keys alice@example.com

Novamente, confirme a exclusão digitando y e pressionando Enter.

Agora você tem a chave pública da Alice no arquivo alice.pub, simulando o recebimento de outro usuário.

Limpe o arquivo temporário de geração de chave:

rm alice-key-params

Agora que você tem a chave pública da Alice em um arquivo, importe-a para o seu chaveiro GPG usando o comando gpg --import.

gpg --import alice.pub

Você verá uma saída confirmando que a chave foi importada:

gpg: key <KEY_ID>: public key "Alice <alice@example.com>" imported
gpg: Total number processed: 1
gpg:               imported: 1

Para confirmar que a chave da Alice está agora no seu chaveiro, liste todas as suas chaves públicas novamente.

gpg --list-keys

A saída mostrará agora tanto a sua chave (labex) quanto a chave recém-importada (Alice).

/home/labex/.gnupg/pubring.kbx
------------------------------
pub   rsa3072 2025-07-01 [SC] [expires: 2027-07-01]
      <FINGERPRINT_LABEX>
uid           [ultimate] labex <labex@example.com>
sub   rsa3072 2025-07-01 [E] [expires: 2027-07-01]

pub   rsa2048 2025-07-01 [SC] [expires: 2027-07-01]
      <FINGERPRINT_ALICE>
uid           [ unknown] Alice <alice@example.com>
sub   rsa2048 2025-07-01 [E] [expires: 2027-07-01]

Observe que a chave da Alice está marcada com confiança [ unknown]. Você aprenderá como gerenciar a confiança da chave na próxima etapa.

Assinar uma Chave Pública e Criptografar um Arquivo para Outro Usuário

Nesta etapa, você aprenderá como estabelecer confiança em uma chave pública recebida e, em seguida, usá-la para criptografar um arquivo para o proprietário dela. Quando você importa uma chave pública, o GPG não tem como saber se ela é autêntica. Ao "assinar" a chave com sua própria chave privada, você está criando um endosso criptográfico, essencialmente dizendo à sua configuração GPG: "Eu confio que esta chave pertence a esta pessoa". Este é um conceito fundamental no modelo "Web of Trust" (Rede de Confiança) do GPG.

Primeiro, você precisa assinar a chave pública da "Alice" que importou na etapa anterior. Você usará o comando gpg --sign-key, identificando a chave pelo seu endereço de e-mail (alice@example.com).

gpg --sign-key alice@example.com

O GPG exibirá os detalhes da chave da Alice e pedirá que você confirme se deseja assiná-la.

pub  rsa2048/XXXXXXXXXXXXXXXX 2025-07-01
     created: 2025-07-01  expires: 2027-07-01  usage: SC
     trust: unknown       validity: unknown
sub  rsa2048/YYYYYYYYYYYYYYYY 2025-07-01
     created: 2025-07-01  expires: 2027-07-01  usage: E
[ unknown] (1). Alice <alice@example.com>

Really sign? (y/N)

Digite y e pressione Enter. Se sua chave tiver uma frase de senha, você será solicitado a inseri-la. Isso ocorre porque uma assinatura é uma operação criptográfica que só pode ser realizada com sua chave secreta. Digite sua frase de senha se solicitado e pressione Enter.

Uma vez feito, você pode verificar a assinatura listando as chaves novamente.

gpg --list-keys

Observe a mudança na entrada da chave da Alice. O nível de confiança não é mais [unknown]. Agora mostra [ultimate] porque você confiou explicitamente nela ao assiná-la.

/home/labex/.gnupg/pubring.kbx
------------------------------
pub   rsa3072 2025-07-01 [SC] [expires: 2027-07-01]
      <FINGERPRINT_LABEX>
uid           [ultimate] labex <labex@example.com>
sub   rsa3072 2025-07-01 [E] [expires: 2027-07-01]

pub   rsa2048 2025-07-01 [SC] [expires: 2027-07-01]
      <FINGERPRINT_ALICE>
uid           [ultimate] Alice <alice@example.com>
sub   rsa2048 2025-07-01 [E] [expires: 2027-07-01]

Agora que você tem uma chave pública confiável para a Alice, pode criptografar um arquivo que somente ela poderá abrir. Primeiro, crie um novo arquivo para este propósito.

echo "This is a confidential message for Alice." > message-for-alice.txt

Em seguida, criptografe este arquivo usando o comando gpg -e. Desta vez, especifique a Alice como destinatária com a flag -r.

gpg -e -r alice@example.com message-for-alice.txt

O GPG usará a chave pública da Alice para realizar a criptografia. Use ls para ver o resultado.

ls

Você verá o novo arquivo criptografado, message-for-alice.txt.gpg, no seu diretório.

labex.pub                 mytestfile.txt
alice.pub                 mytestfile.txt.decrypted
message-for-alice.txt     mytestfile.txt.gpg
message-for-alice.txt.gpg

Este arquivo agora está criptografado com segurança. Somente alguém com acesso à chave privada da Alice (e sua frase de senha) poderá descriptografar e ler a mensagem.

Realizar Manutenção de Chaves com gpg --export-secret-keys e gpg --gen-revoke

Nesta etapa final, você realizará duas tarefas críticas de manutenção para sua chave GPG: criar um backup seguro de sua chave secreta e gerar um certificado de revogação. Sua chave secreta é insubstituível; se você a perder, perderá o acesso a todos os dados criptografados com a chave pública correspondente. Um certificado de revogação é sua rede de segurança, permitindo invalidar sua chave pública caso sua chave secreta seja perdida ou comprometida.

Primeiro, vamos criar um backup de sua chave secreta. Este é um dos passos mais importantes no gerenciamento de uma chave GPG.

O comando gpg --export-secret-keys é usado para este propósito. Usaremos a flag --armor para criar um arquivo de texto ASCII, que é fácil de armazenar e transportar. Você deve especificar qual chave exportar pelo seu ID de usuário.

gpg --export-secret-keys --armor -o gpgkey.asc labex

Este comando exporta a chave secreta do usuário labex para um arquivo chamado gpgkey.asc. Este arquivo é extremamente sensível. Em um cenário real, você armazenaria este arquivo em um local offline muito seguro, como um pendrive criptografado ou um cofre digital.

Em seguida, você criará um certificado de revogação. Isso deve ser feito imediatamente após a geração da chave e armazenado com segurança, separadamente do backup da sua chave secreta. Se você perder sua chave secreta ou se ela for roubada, poderá publicar este certificado para informar aos outros que a chave não deve mais ser usada ou confiada.

Use o comando gpg --gen-revoke. Salvaremos o certificado em um arquivo chamado revoke.asc usando a flag --output.

gpg --output revoke.asc --gen-revoke labex

Você será guiado por um processo interativo:

  1. Quando perguntado Create a revocation certificate for this key? (y/N), digite y e pressione Enter.
  2. Você será solicitado a selecionar um motivo para a revogação. Para este laboratório, pressione Enter para aceitar o padrão 0 = No reason specified.
  3. Você pode adicionar uma descrição opcional. Por enquanto, apenas pressione Enter para deixá-la em branco.
  4. Finalmente, confirme os detalhes digitando y e pressionando Enter quando perguntado Is this okay? (y/N).
  5. Se sua chave tiver uma frase de senha, o GPG a solicitará para autorizar a criação deste certificado. Digite sua frase de senha se solicitado e pressione Enter.

Você verá uma confirmação de que o certificado de revogação foi criado.

Revocation certificate created.

Please move it to a medium which you can hide away; if Mallory gets
access to this certificate he can use it to make your key unusable.
It is smart to print this certificate and store it away, just in case
your media become unreadable.  But have some caution:  The printout
might be scanned and reconstructed by a determined attacker.

Use o comando ls para verificar se ambos os novos arquivos foram criados no seu diretório ~/project.

ls

Você deve agora ver gpgkey.asc e revoke.asc na listagem de arquivos. Você realizou com sucesso a manutenção essencial das chaves.

Resumo

Neste laboratório, você aprendeu as operações fundamentais do GNU Privacy Guard (GPG) em um ambiente Linux. Você começou gerando um par de chaves GPG pessoal, consistindo em uma chave pública e uma privada, usando o comando gpg --gen-key. Este processo envolveu a seleção de especificações de chave e a criação de um ID de usuário protegido por uma frase de senha segura. Após a geração da chave, você praticou a função principal do GPG criptografando um arquivo local para si mesmo com gpg -e e, posteriormente, descriptografando-o usando sua chave privada e o comando gpg --decrypt, demonstrando os princípios básicos da criptografia assimétrica.

Com base nesses fundamentos, você explorou como se comunicar de forma segura com outras pessoas. Aprendeu a trocar chaves públicas usando gpg --export para compartilhar sua chave e gpg --import para receber a chave de outro usuário. O laboratório também abordou a importância de estabelecer confiança ao assinar uma chave pública importada e, em seguida, usá-la para criptografar um arquivo especificamente para aquele usuário. Por fim, você realizou tarefas essenciais de manutenção de chaves, incluindo o backup de sua chave secreta com gpg --export-secret-keys e a criação de um certificado de revogação usando gpg --gen-revoke para invalidar seu par de chaves caso ele seja comprometido.