Criptografar e Descriptografar Arquivos com GPG no Linux | CompTIA Linux+

Introdução

Neste laboratório, você aprenderá 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 da chave, você praticará as operações principais de criptografar um arquivo para si mesmo e, em seguida, descriptografá-lo usando sua chave secreta e senha.

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

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 possam criptografar arquivos para você. Você deve manter sua chave privada em segredo, pois ela é a única chave capaz de descriptografar arquivos criptografados com sua chave pública.

Primeiro, vamos garantir que o pacote gnupg, que fornece a funcionalidade 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 em seu terminal:

gpg --gen-key

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

Você será solicitado a fornecer as seguintes informações:

Real name: Digite labex
Email address: Digite labex@example.com
Confirm User ID: Revise seus detalhes. 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 por segurança)

Nota: Ao contrário de versões mais antigas, o GPG moderno pode não solicitar uma senha durante a geração da chave usando --gen-key. Se você quiser adicionar uma senha à sua chave para segurança adicional, poderá fazê-lo mais tarde usando:

gpg --edit-key labex

Em seguida, digite passwd no prompt do GPG para definir uma senha, seguido de 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 para o GPG, permitindo que você proteja a confidencialidade de 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 à sua forma original.

Primeiro, vamos criar um arquivo de texto simples para trabalhar. Todas as operações serão realizadas em 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 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ê deverá 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 senha, você será solicitado a inseri-la. Se nenhuma 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 se 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ê, essa pessoa precisará da sua chave pública. Este processo envolve exportar sua chave pública para um arquivo e importar chaves públicas que você recebe de outras pessoas 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 baseada 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.

Em 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ê deverá 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 é sua chave pública, que você agora 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 por meio de um canal seguro. Para este laboratório, criaremos um par de chaves temporário para a Alice e, em seguida, exportaremos a chave pública da Alice para simular este processo.

Primeiro, vamos gerar temporariamente um par de chaves para a Alice. Usaremos um modo de lote (batch mode) 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ê deverá 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 da Alice:

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

Para esta demonstração de laboratório, 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 como você a receberia de outro usuário.

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

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ê deverá 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 agora está em seu chaveiro, liste todas as suas chaves públicas novamente.

gpg --list-keys

A saída agora mostrará 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 de chaves 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 que recebeu 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: "Confio que esta chave pertence a esta pessoa". Este é um conceito fundamental no modelo de "Teia de Confiança" (Web of Trust) do GPG.

Primeiro, você precisa assinar a chave pública da "Alice" que você importou na etapa anterior. Você usará o comando gpg --sign-key, identificando a chave pelo endereço de e-mail dela (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 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. Insira sua senha, se solicitado, e pressione Enter.

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

gpg --list-keys

Observe a mudança na entrada da chave da Alice. Depois de assinar a chave importada, o GPG não a mostra mais como [unknown]. Dependendo do estado do seu chaveiro local, a chave pode aparecer com um marcador de validade mais forte, como [full] ou [ultimate].

/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           [full] Alice <alice@example.com>
sub   rsa2048 2025-07-01 [E] [expires: 2027-07-01]

Se você quiser confirmar a assinatura diretamente, execute:

gpg --list-sigs alice@example.com

Você deverá ver uma linha de assinatura para labex <labex@example.com>, o que confirma que sua chave assinou a chave pública importada da Alice.

Agora que você tem uma chave pública confiável para a Alice, pode criptografar um arquivo que apenas ela pode 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, em 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. Apenas alguém com acesso à chave privada da Alice (e sua senha) pode 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 que você invalide sua chave pública caso sua chave secreta seja perdida ou comprometida.

Primeiro, vamos criar um backup da sua chave secreta. Esta é uma das etapas 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 com armadura 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 para o usuário labex para um arquivo chamado gpgkey.asc. Este arquivo é extremamente sensível. Em um cenário do mundo real, você armazenaria este arquivo em um local offline muito seguro, como uma unidade USB criptografada ou um cofre seguro.

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, separado do backup da sua chave secreta. Se você perder sua chave secreta ou ela for roubada, poderá publicar este certificado para informar a outras pessoas 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:

Quando perguntado Create a revocation certificate for this key? (y/N), digite y e pressione Enter.
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.
Você pode adicionar uma descrição opcional. Por enquanto, apenas pressione Enter para deixá-la em branco.
Finalmente, confirme os detalhes digitando y e pressionando Enter quando perguntado Is this okay? (y/N).
Se sua chave tiver uma senha, o GPG a solicitará para autorizar a criação deste certificado. Insira sua 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 em seu diretório ~/project.

ls

Agora você deve ver gpgkey.asc e revoke.asc na listagem de arquivos. Você realizou com sucesso a manutenção essencial de 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 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 com segurança com outras pessoas. Você 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 cobriu a importância de estabelecer confiança assinando uma chave pública importada e, em seguida, usando-a para criptografar um arquivo especificamente para aquele usuário. Finalmente, você realizou tarefas essenciais de manutenção de chaves, incluindo fazer backup de sua chave secreta com gpg --export-secret-keys e criar um certificado de revogação usando gpg --gen-revoke para invalidar seu par de chaves caso ele seja comprometido.