GPG (GNU Privacy Guard) te permite proteger archivos, firmar documentos, verificar la autenticidad de software y demostrar tu identidad en commits de Git, todo mediante criptografía de clave pública que no requiere compartir ninguna contraseña secreta. Cuando envías un archivo cifrado, solo el destinatario con su clave privada puede descifrarlo. Cuando firmas un commit de Git, cualquiera puede verificar que fuiste tú quien lo escribió y que el código no ha sido manipulado. Esta guía cubre el uso práctico de GPG desde la generación de claves hasta los flujos de trabajo cotidianos para cifrado de archivos, firmas digitales e integración con Git.

Requisitos Previos

  • Un sistema Linux, macOS o Windows
  • GnuPG 2.2 o posterior instalado (compruébalo con gpg --version)
  • Una terminal o símbolo del sistema
  • Una dirección de correo electrónico para la identidad de tu clave

Instalación de GnuPG

# Debian / Ubuntu (generalmente preinstalado)
sudo apt install gnupg

# RHEL / Fedora
sudo dnf install gnupg2

# macOS
brew install gnupg

# Verificar la instalación
gpg --version
# gpg (GnuPG) 2.4.x

Generación de tu Par de Claves

# Generación interactiva de claves con todas las opciones
gpg --full-generate-key

Cuando se te solicite:

  1. Tipo de clave: Elige ECC (sign and encrypt) o RSA and RSA para la mayor compatibilidad
  2. Tamaño de clave: 4096 para RSA, o Curve 25519 para ECC
  3. Expiración: Establece 1-2 años (puedes ampliarla más adelante). Nunca crees claves sin fecha de expiración
  4. Nombre y correo: Usa el mismo correo que tu cuenta de Git y GitHub
  5. Frase de paso: Usa una frase de paso robusta — protege tu clave privada si el archivo es robado
# Listar tus claves
gpg --list-keys
gpg --list-secret-keys --keyid-format long

# Ejemplo de salida:
# sec   ed25519/ABC123DEF456 2025-12-12 [SC] [expires: 2027-12-12]
#       ABCDEF1234567890ABCDEF1234567890ABC123DE
# uid           [ultimate] Your Name <you@example.com>
# ssb   cv25519/789GHI012JKL 2025-12-12 [E] [expires: 2027-12-12]

El ID de clave (ABC123DEF456 en este ejemplo) es lo que usas para referenciar tu clave en los comandos.

Generar un Certificado de Revocación

Hazlo inmediatamente después de crear tu clave — antes de que lo necesites:

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

Guarda este archivo de forma segura en un lugar offline (un USB, papel impreso). Si tu clave se ve comprometida, publicas este certificado para revocarla.

Cifrado y Descifrado de Archivos

Cifrar para un Destinatario (Asimétrico)

# Primero, importa la clave pública del destinatario
gpg --import colleague-pubkey.asc

# Cifrar un archivo para un destinatario específico
gpg --encrypt --recipient colleague@example.com secret-report.pdf
# Crea: secret-report.pdf.gpg

# Cifrar para múltiples destinatarios
gpg --encrypt --recipient alice@example.com --recipient bob@example.com data.tar.gz

# Cifrar y firmar (recomendado — prueba quién lo envió)
gpg --encrypt --sign --recipient colleague@example.com secret-report.pdf

# Cifrar con ASCII armor (salida segura para texto en email)
gpg --encrypt --armor --recipient colleague@example.com message.txt
# Crea: message.txt.asc (codificado en base64, apto para email)

Descifrar un Archivo

# Descifrar (GPG usa automáticamente tu clave privada)
gpg --decrypt secret-report.pdf.gpg > secret-report.pdf

# Descifrar y verificar la firma
gpg --decrypt signed-encrypted-file.gpg
# La salida incluye: "Good signature from ..."

Cifrado Simétrico (Basado en Contraseña)

Cuando no tienes la clave pública del destinatario, usa una contraseña compartida:

# Cifrar con una frase de paso (sin necesidad de claves)
gpg --symmetric --cipher-algo AES256 backup.tar.gz
# Solicita una frase de paso
# Crea: backup.tar.gz.gpg

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

Firma de Archivos y Mensajes

Las firmas digitales prueban la autenticidad (quién lo firmó) y la integridad (que el contenido no ha cambiado).

# Crear una firma separada (archivo .sig independiente)
gpg --detach-sign release-v1.0.tar.gz
# Crea: release-v1.0.tar.gz.sig

# Verificar una firma separada
gpg --verify release-v1.0.tar.gz.sig release-v1.0.tar.gz
# Good signature from "Your Name <you@example.com>"

# Crear una firma en texto claro (legible por humanos)
gpg --clearsign announcement.txt
# Crea: announcement.txt.asc (texto con firma embebida)

# Verificar una firma en texto claro
gpg --verify announcement.txt.asc

Firma de Commits en Git

Los commits firmados muestran una insignia de “Verified” en GitHub y GitLab, demostrando que fuiste tú quien realizó el commit.

Configuración

# Encontrar tu ID de clave GPG
gpg --list-secret-keys --keyid-format long
# sec   ed25519/ABC123DEF456 2025-12-12 [SC]

# Configurar Git para usar tu clave
git config --global user.signingkey ABC123DEF456

# Activar la firma automática para todos los commits
git config --global commit.gpgsign true

# También firmar etiquetas
git config --global tag.gpgsign true

# Si los prompts de GPG fallan, establece el TTY
export GPG_TTY=$(tty)
echo 'export GPG_TTY=$(tty)' >> ~/.bashrc

Exportar tu Clave Pública a GitHub/GitLab

# Exportar tu clave pública en formato ASCII
gpg --export --armor ABC123DEF456

# Copia la salida (incluyendo -----BEGIN PGP PUBLIC KEY BLOCK-----)
# Pégala en GitHub: Settings > SSH and GPG keys > New GPG key

Firma en la Práctica

# Firmar un commit individual
git commit -S -m "Fix authentication bug"

# Verificar firmas en el historial
git log --show-signature -3

# Firmar una etiqueta
git tag -s v1.0 -m "Release 1.0"

# Verificar una etiqueta firmada
git tag -v v1.0

Comparación de Herramientas de Cifrado

CaracterísticaGPG (GnuPG)ageOpenSSLSignal Protocol
Caso de usoArchivos, email, GitCifrado de archivosTLS, certificados, archivosMensajería
Gestión de clavesKeyring, servidores de clavesArchivos de clave simplesCertificados, CAsAutomática
ComplejidadAlta (muchas opciones)Muy bajaModeradaIntegrada en la app
Cifrado asimétricoSí (RSA, ECC)Sí (X25519)SíSí
Firmas digitalesSíNoSíSí
Integración con GitNativaNoNoNo
Mejor paraEmail, Git, firma de paquetesCifrado simple de archivosSeguridad TLS/servidorAplicaciones de chat

Usa GPG para firmar commits de Git, cifrar emails y verificar paquetes de software. Usa age cuando necesites cifrado de archivos simple sin la complejidad de la gestión de claves. Usa OpenSSL para certificados TLS y cifrado en el lado del servidor.

Buenas Prácticas de Gestión de Claves

# Exportar tu clave privada para copia de seguridad (¡guárdala offline!)
gpg --export-secret-keys --armor ABC123DEF456 > private-key-backup.asc

# Exportar tu clave pública
gpg --export --armor ABC123DEF456 > public-key.asc

# Importar una clave desde un archivo
gpg --import someone-public-key.asc

# Importar desde un servidor de claves
gpg --keyserver keyserver.ubuntu.com --recv-keys THEIR_KEY_ID

# Subir tu clave a un servidor de claves
gpg --keyserver keyserver.ubuntu.com --send-keys ABC123DEF456

# Ampliar la expiración de la clave antes de que venza
gpg --edit-key ABC123DEF456
# gpg> expire
# (establecer nueva expiración)
# gpg> save

# Revocar una clave comprometida
gpg --import revoke-cert.asc
gpg --keyserver keyserver.ubuntu.com --send-keys ABC123DEF456

Casos Especiales y Problemas Comunes

Las claves expiradas no pueden cifrar ni firmar: Si tu clave caduca, no puedes crear nuevas firmas ni cifrar datos para destinatarios. Aun así puedes descifrar datos antiguos y ampliar la fecha de expiración desde la clave privada. Amplía siempre antes de que expire.

Confusión con el modelo de confianza: Importar la clave pública de alguien no significa que confíes en ella. GPG marca las claves no confiables con una advertencia. Usa gpg --edit-key THEIR_ID y trust para establecer el nivel de confianza, o firma su clave con lsign tras verificar su identidad.

Conflicto entre el agente SSH y el agente GPG: GPG tiene su propio agente (gpg-agent) que almacena en caché tu frase de paso. Si también usas un agente SSH, pueden entrar en conflicto. El GPG moderno puede actuar también como agente SSH: configúralo en ~/.gnupg/gpg-agent.conf con enable-ssh-support.

Prompts de frase de paso en sesiones sin entorno gráfico: Cuando ejecutas GPG por SSH o en scripts, el programa pinentry puede fallar porque no hay interfaz gráfica. Establece GPG_TTY=$(tty) y configura pinentry-curses en ~/.gnupg/gpg-agent.conf:

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

El cifrado de archivos grandes es lento: GPG no está diseñado para cifrar archivos de varios gigabytes. Para datos de gran tamaño, cifra con un cifrado simétrico (AES256) y protege la frase de paso con GPG, o usa herramientas como age que están optimizadas para el cifrado de archivos.

Solución de Problemas

”gpg: signing failed: No secret key"

# Comprueba que el ID de la clave de firma coincide con tu configuración de Git
git config --global user.signingkey
gpg --list-secret-keys --keyid-format long

# Asegúrate de que el correo en tu clave GPG coincide con el correo de Git
git config --global user.email

"gpg: decryption failed: No secret key”

# Necesitas la clave privada que corresponde al destinatario del cifrado
gpg --list-secret-keys

# Si la clave está en otra máquina, expórtala e impórtala
# En la máquina de origen:
gpg --export-secret-keys --armor KEYID > key.asc
# En la máquina de destino:
gpg --import key.asc

La firma de commits en Git se queda colgada

# El agente GPG no puede solicitar la frase de paso
export GPG_TTY=$(tty)

# Prueba la firma GPG directamente
echo "test" | gpg --clearsign

# Si usas VS Code u otro IDE, configura el TTY en el perfil de tu shell
echo 'export GPG_TTY=$(tty)' >> ~/.bashrc

Resumen

  • GPG usa criptografía de clave pública donde tu clave pública cifra los datos y tu clave privada los descifra — comparte las claves públicas libremente, protege las privadas de forma absoluta
  • Genera claves con gpg --full-generate-key y crea inmediatamente un certificado de revocación guardado offline para poder revocar la clave en caso de emergencia
  • Cifra archivos con gpg --encrypt --recipient para cifrado asimétrico, o usa gpg --symmetric cuando compartir una frase de paso es más sencillo
  • Firma commits de Git con git commit -S y configura commit.gpgsign true para firma automática — añade tu clave pública a GitHub para obtener la insignia de “Verified”
  • Establece fechas de expiración en tus claves y amplíalas antes de que venzan — una clave expirada bloquea el cifrado y la firma, pero sigue descifrando datos anteriores
  • Haz una copia de seguridad de tu clave privada en almacenamiento offline — perderla supone perder de forma permanente la capacidad de descifrar todos los datos cifrados con esa clave

Artículos Relacionados