O GPG (GNU Privacy Guard) permite proteger arquivos, assinar documentos, verificar a autenticidade de softwares e comprovar sua identidade em commits Git — tudo usando criptografia de chave pública, sem precisar compartilhar uma senha secreta. Quando você envia um arquivo criptografado, apenas o destinatário com sua chave privada consegue abri-lo. Quando assina um commit Git, qualquer pessoa pode verificar que você foi o autor e que o código não foi alterado. Este guia aborda o uso prático do GPG, desde a geração de chaves até os fluxos de trabalho cotidianos de criptografia, assinaturas digitais e integração com Git.

Pré-requisitos

  • Um sistema Linux, macOS ou Windows
  • GnuPG 2.2 ou posterior instalado (verifique com gpg --version)
  • Um terminal ou prompt de comando
  • Um endereço de e-mail para a identidade da sua chave

Instalando o GnuPG

# Debian / Ubuntu (geralmente pré-instalado)
sudo apt install gnupg

# RHEL / Fedora
sudo dnf install gnupg2

# macOS
brew install gnupg

# Verificar a instalação
gpg --version
# gpg (GnuPG) 2.4.x

Gerando Seu Par de Chaves

# Geração interativa de chave com todas as opções
gpg --full-generate-key

Quando solicitado:

  1. Tipo de chave: Escolha ECC (sign and encrypt) ou RSA and RSA para máxima compatibilidade
  2. Tamanho da chave: 4096 para RSA, ou Curve 25519 para ECC
  3. Expiração: Defina 1 a 2 anos (você pode estender depois). Nunca crie chaves sem data de expiração
  4. Nome e e-mail: Use o mesmo e-mail da sua conta Git e GitHub
  5. Senha: Use uma senha forte — ela protege sua chave privada caso o arquivo seja roubado
# Listar suas chaves
gpg --list-keys
gpg --list-secret-keys --keyid-format long

# Exemplo de saída:
# sec   ed25519/ABC123DEF456 2025-12-12 [SC] [expires: 2027-12-12]
#       ABCDEF1234567890ABCDEF1234567890ABC123DE
# uid           [ultimate] Seu Nome <voce@exemplo.com>
# ssb   cv25519/789GHI012JKL 2025-12-12 [E] [expires: 2027-12-12]

O ID da chave (ABC123DEF456 neste exemplo) é o que você usa para referenciar sua chave nos comandos.

Gerar um Certificado de Revogação

Faça isso imediatamente após criar sua chave — antes de precisar dele:

gpg --gen-revoke --output revoke-cert.asc ABC123DEF456

Guarde este arquivo com segurança offline (pen drive, papel impresso). Se sua chave for comprometida, você publica este certificado para revogá-la.

Criptografando e Descriptografando Arquivos

Criptografar para um Destinatário (Assimétrico)

# Primeiro, importe a chave pública do destinatário
gpg --import colega-pubkey.asc

# Criptografar um arquivo para um destinatário específico
gpg --encrypt --recipient colega@exemplo.com relatorio-secreto.pdf
# Cria: relatorio-secreto.pdf.gpg

# Criptografar para múltiplos destinatários
gpg --encrypt --recipient alice@exemplo.com --recipient bob@exemplo.com dados.tar.gz

# Criptografar e assinar (recomendado — prova quem enviou)
gpg --encrypt --sign --recipient colega@exemplo.com relatorio-secreto.pdf

# Criptografar com ASCII armor (saída segura para e-mail em texto)
gpg --encrypt --armor --recipient colega@exemplo.com mensagem.txt
# Cria: mensagem.txt.asc (codificado em base64, seguro para e-mail)

Descriptografar um Arquivo

# Descriptografar (GPG usa automaticamente sua chave privada)
gpg --decrypt relatorio-secreto.pdf.gpg > relatorio-secreto.pdf

# Descriptografar e verificar assinatura
gpg --decrypt arquivo-assinado-criptografado.gpg
# A saída inclui: "Good signature from ..."

Criptografia Simétrica (Baseada em Senha)

Quando você não tem a chave pública do destinatário, use uma senha compartilhada:

# Criptografar com uma senha (sem necessidade de chaves)
gpg --symmetric --cipher-algo AES256 backup.tar.gz
# Solicita uma senha
# Cria: backup.tar.gz.gpg

# Descriptografar
gpg --decrypt backup.tar.gz.gpg > backup.tar.gz

Assinando Arquivos e Mensagens

As assinaturas digitais provam autenticidade (quem assinou) e integridade (o conteúdo não foi alterado).

# Criar uma assinatura destacada (arquivo .sig separado)
gpg --detach-sign release-v1.0.tar.gz
# Cria: release-v1.0.tar.gz.sig

# Verificar uma assinatura destacada
gpg --verify release-v1.0.tar.gz.sig release-v1.0.tar.gz
# Good signature from "Seu Nome <voce@exemplo.com>"

# Criar uma assinatura em texto claro (legível por humanos)
gpg --clearsign anuncio.txt
# Cria: anuncio.txt.asc (texto com assinatura embutida)

# Verificar uma assinatura em texto claro
gpg --verify anuncio.txt.asc

Assinatura de Commits Git

Commits assinados exibem um selo “Verified” no GitHub e GitLab, comprovando que você foi o autor do commit.

Configuração

# Encontre o ID da sua chave GPG
gpg --list-secret-keys --keyid-format long
# sec   ed25519/ABC123DEF456 2025-12-12 [SC]

# Configure o Git para usar sua chave
git config --global user.signingkey ABC123DEF456

# Ativar assinatura automática em todos os commits
git config --global commit.gpgsign true

# Também assinar tags
git config --global tag.gpgsign true

# Se os prompts do GPG falharem, defina o TTY
export GPG_TTY=$(tty)
echo 'export GPG_TTY=$(tty)' >> ~/.bashrc

Exportar Sua Chave Pública para GitHub/GitLab

# Exportar sua chave pública em formato ASCII
gpg --export --armor ABC123DEF456

# Copie a saída (incluindo -----BEGIN PGP PUBLIC KEY BLOCK-----)
# Cole no GitHub: Settings > SSH and GPG keys > New GPG key

Assinando na Prática

# Assinar um único commit
git commit -S -m "Fix authentication bug"

# Verificar assinaturas no log
git log --show-signature -3

# Assinar uma tag
git tag -s v1.0 -m "Release 1.0"

# Verificar uma tag assinada
git tag -v v1.0

Comparando Ferramentas de Criptografia

RecursoGPG (GnuPG)ageOpenSSLSignal Protocol
Caso de usoArquivos, e-mail, GitCriptografia de arquivosTLS, certificados, arquivosMensagens
Gerenciamento de chavesChaveiro, servidores de chavesArquivos de chave simplesCertificados, CAsAutomático
ComplexidadeAlta (muitas opções)Muito baixaModeradaNativo nos apps
Criptografia assimétricaSim (RSA, ECC)Sim (X25519)SimSim
Assinaturas digitaisSimNãoSimSim
Integração com GitNativaNãoNãoNão
Melhor paraE-mail, Git, pacotesCriptografia simples de arquivosTLS/segurança de servidoresAplicativos de chat

Use GPG para assinatura de commits Git, criptografia de e-mail e verificação de pacotes de software. Use age quando precisar de criptografia de arquivos simples, sem a complexidade do gerenciamento de chaves. Use OpenSSL para certificados TLS e criptografia no lado do servidor.

Boas Práticas de Gerenciamento de Chaves

# Exportar sua chave privada para backup (guarde offline!)
gpg --export-secret-keys --armor ABC123DEF456 > backup-chave-privada.asc

# Exportar sua chave pública
gpg --export --armor ABC123DEF456 > chave-publica.asc

# Importar uma chave de um arquivo
gpg --import chave-publica-de-alguem.asc

# Importar de um servidor de chaves
gpg --keyserver keyserver.ubuntu.com --recv-keys ID_DA_CHAVE

# Enviar sua chave para um servidor de chaves
gpg --keyserver keyserver.ubuntu.com --send-keys ABC123DEF456

# Estender a expiração da chave antes de vencer
gpg --edit-key ABC123DEF456
# gpg> expire
# (defina nova data de expiração)
# gpg> save

# Revogar uma chave comprometida
gpg --import revoke-cert.asc
gpg --keyserver keyserver.ubuntu.com --send-keys ABC123DEF456

Armadilhas e Casos Especiais

Chaves expiradas não podem criptografar nem assinar: Se sua chave expirar, você não poderá criar novas assinaturas nem criptografar dados para destinatários. Ainda é possível descriptografar dados antigos e estender a data de expiração a partir da chave privada. Sempre estenda antes da expiração.

Confusão com o modelo de confiança: Importar a chave pública de alguém não significa que você confia nela. O GPG marca chaves não confiáveis com um aviso. Use gpg --edit-key ID_DELES e o comando trust para definir o nível de confiança, ou assine a chave deles com lsign após verificar a identidade.

Agente SSH vs agente GPG: O GPG tem seu próprio agente (gpg-agent) que armazena em cache sua senha. Se você também usa um agente SSH, eles podem entrar em conflito. O GPG moderno pode funcionar como agente SSH também — configure isso em ~/.gnupg/gpg-agent.conf com enable-ssh-support.

Prompts de senha em sessões sem interface gráfica: Ao executar o GPG via SSH ou em scripts, o programa pinentry pode falhar por não haver GUI. Defina GPG_TTY=$(tty) e configure pinentry-curses em ~/.gnupg/gpg-agent.conf:

echo "pinentry-program /usr/bin/pinentry-curses" >> ~/.gnupg/gpg-agent.conf
gpgconf --kill gpg-agent

Criptografia de arquivos grandes é lenta: O GPG não foi projetado para criptografar arquivos de vários gigabytes. Para dados grandes, criptografe com cifra simétrica (AES256) e proteja a senha com GPG, ou use ferramentas como age, otimizadas para criptografia de arquivos.

Solução de Problemas

”gpg: signing failed: No secret key"

# Verifique se o ID da chave de assinatura corresponde à sua configuração Git
git config --global user.signingkey
gpg --list-secret-keys --keyid-format long

# Certifique-se de que o e-mail na chave GPG corresponde ao e-mail do Git
git config --global user.email

"gpg: decryption failed: No secret key”

# Você precisa da chave privada correspondente ao destinatário da criptografia
gpg --list-secret-keys

# Se a chave estiver em outra máquina, exporte e importe
# Na máquina de origem:
gpg --export-secret-keys --armor KEYID > chave.asc
# Na máquina de destino:
gpg --import chave.asc

Assinatura de commit Git trava

# O agente GPG não consegue solicitar a senha
export GPG_TTY=$(tty)

# Teste a assinatura GPG diretamente
echo "test" | gpg --clearsign

# Se estiver usando VS Code ou outra IDE, configure o TTY no perfil do shell
echo 'export GPG_TTY=$(tty)' >> ~/.bashrc

Resumo

  • O GPG usa criptografia de chave pública onde sua chave pública criptografa os dados e sua chave privada os descriptografa — compartilhe chaves públicas livremente, proteja chaves privadas absolutamente
  • Gere chaves com gpg --full-generate-key e crie imediatamente um certificado de revogação guardado offline para revogação de emergência
  • Criptografe arquivos com gpg --encrypt --recipient para criptografia assimétrica, ou gpg --symmetric quando compartilhar uma senha for mais simples
  • Assine commits Git com git commit -S e configure commit.gpgsign true para assinatura automática — adicione sua chave pública ao GitHub para obter o selo “Verified”
  • Defina datas de expiração nas chaves e as estenda antes de vencer — uma chave expirada bloqueia criptografia e assinatura, mas ainda descriptografa dados antigos
  • Faça backup da sua chave privada em armazenamento offline — perdê-la significa perda permanente da capacidade de descriptografar todos os dados cifrados com ela

Artigos Relacionados