Cifrar y descifrar archivos con GPG en Linux | CompTIA Linux+

Introducción

En esta práctica de laboratorio, adquirirás las habilidades esenciales para cifrar y descifrar archivos en un entorno Linux utilizando GPG (GNU Privacy Guard). Comenzarás generando tu propio par de claves pública/privada, que constituye la base del modelo de seguridad de GPG. Tras la generación de las claves, practicarás las operaciones fundamentales de cifrar un archivo para ti mismo y luego descifrarlo utilizando tu clave secreta y tu frase de contraseña.

A partir de estos conceptos básicos, explorarás cómo intercambiar información de forma segura con otras personas. Esto incluye exportar tu clave pública para compartirla e importar la clave pública de otro usuario. También aprenderás a firmar una clave pública para verificar su autenticidad y a realizar tareas cruciales de mantenimiento, como realizar una copia de seguridad de tu clave secreta y crear un certificado de revocación en caso de que tu clave se vea comprometida.

Generar tu par de claves GPG con gpg --gen-key

En este paso, generarás tu par de claves personal de GPG (GNU Privacy Guard). Un par de claves GPG consta de dos claves distintas pero relacionadas: una clave pública y una clave privada. Puedes compartir tu clave pública con otros para que puedan cifrar archivos dirigidos a ti. Debes mantener tu clave privada en secreto, ya que es la única que puede descifrar los archivos cifrados con tu clave pública.

Primero, aseguremonos de que el paquete gnupg, que proporciona la funcionalidad GPG, esté instalado en tu sistema.

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

Ahora, estás listo para generar tu par de claves. El comando gpg --gen-key te guiará a través de un proceso interactivo.

Ejecuta el siguiente comando en tu terminal:

gpg --gen-key

Verás una nota indicando que este comando utiliza una generación de claves simplificada. Para opciones más avanzadas, podrías usar gpg --full-generate-key, pero las opciones predeterminadas son adecuadas para este laboratorio.

Se te solicitará la siguiente información:

Real name: Introduce labex
Email address: Introduce labex@example.com
Confirm User ID: Revisa tus datos. Cuando aparezca el mensaje Change (N)ame, (E)mail, or (O)kay/(Q)uit?, escribe O y presiona Enter.

El sistema utilizará automáticamente valores predeterminados seguros:

Tipo de clave: RSA y RSA (predeterminado)
Tamaño de clave: 3072 bits (predeterminado seguro)
Validez de la clave: 2 años (expiración automática por seguridad)

Nota: A diferencia de las versiones antiguas, el GPG moderno puede no solicitar una frase de contraseña durante la generación de claves mediante --gen-key. Si deseas añadir una frase de contraseña a tu clave para mayor seguridad, puedes hacerlo más tarde usando:

gpg --edit-key labex

Luego escribe passwd en el prompt de GPG para establecer una contraseña, seguido de save para salir.

El sistema generará ahora tu par de claves. Este proceso requiere datos aleatorios (entropía) y puede tardar unos instantes.

Una vez completado, verás un mensaje de confirmación similar a este:

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]

Ahora que tus claves han sido generadas, puedes visualizarlas. Para ver tu nueva clave pública, ejecuta:

gpg --list-keys

La salida enumerará todas las claves públicas en tu llavero, incluyendo la que acabas de crear:

/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 ver tu clave privada, ejecuta:

gpg --list-secret-keys

La salida será similar, pero indicará una clave secreta (sec) en lugar de una clave 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]

Has creado y verificado con éxito tu par de claves GPG.

Cifrar y descifrar un archivo local con gpg -e y gpg --decrypt

En este paso, utilizarás el par de claves GPG que generaste para cifrar y luego descifrar un archivo. Este es un caso de uso fundamental de GPG, que te permite proteger la confidencialidad de tus datos. El cifrado transforma tus datos legibles en un formato ilegible, y solo alguien con la clave privada correcta puede descifrarlos para devolverlos a su forma original.

Primero, vamos a crear un archivo de texto sencillo para trabajar. Todas las operaciones se realizarán en tu directorio actual, ~/project.

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

Ahora, puedes cifrar este archivo utilizando tu clave pública. El comando gpg -e se utiliza para el cifrado. También debes especificar el destinatario del mensaje cifrado con el indicador -r, que debe ser el nombre asociado a tu clave GPG (labex).

gpg -e -r labex mytestfile.txt

GPG utilizará tu clave pública para cifrar el archivo. No se te pedirá la frase de contraseña porque el cifrado se realiza con la clave pública, que no es secreta.

Una vez finalizado el comando, utiliza el comando ls para ver el nuevo archivo cifrado.

ls

Deberías ver mytestfile.txt.gpg en la salida, junto al archivo original.

mytestfile.txt  mytestfile.txt.gpg

El archivo mytestfile.txt.gpg contiene los datos cifrados. Si intentas ver su contenido, verás datos binarios ilegibles.

Ahora, vamos a descifrar el archivo. Para ello, utilizarás el comando gpg --decrypt. Dado que estás descifrando, GPG utilizará tu clave privada.

Utilizaremos el indicador --output para especificar un nuevo archivo para el contenido descifrado, mytestfile.txt.decrypted. Esto evita sobrescribir el archivo original y permite distinguir claramente cada archivo.

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

Si tu clave tiene una frase de contraseña, se te pedirá que la introduzcas. Si no se estableció ninguna contraseña durante la generación de la clave, el descifrado procederá automáticamente. Deberías ver una salida similar a:

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

Una vez descifrado, puedes ver el contenido del nuevo archivo para confirmar que coincide con el mensaje original.

cat mytestfile.txt.decrypted

La salida debería ser el texto original que creaste:

This is a secret message for the lab.

Has cifrado con éxito un archivo para ti mismo y luego lo has descifrado utilizando tu par de claves GPG.

Intercambiar claves públicas con gpg --export y gpg --import

En este paso, aprenderás a intercambiar claves públicas con otras personas. Para cifrar un archivo para otra persona, necesitas su clave pública. Del mismo modo, si alguien quiere enviarte un archivo cifrado, necesita tu clave pública. Este proceso implica exportar tu clave pública a un archivo e importar las claves públicas que recibas de otros en tu llavero GPG.

Primero, exportemos tu propia clave pública. Utilizarás el comando gpg --export. Se recomienda utilizar la opción --armor, que crea una versión de la clave en formato de texto (ASCII), lo que facilita copiarla y pegarla en correos electrónicos u otros canales de comunicación basados en texto. La guardaremos en un archivo llamado labex.pub.

En tu terminal, ejecuta el siguiente comando. Sustituye labex por el ID de usuario que utilizaste durante la generación de la clave.

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

Puedes verificar que el archivo se ha creado utilizando ls:

ls

Deberías ver labex.pub en la lista de archivos. También puedes ver su contenido:

cat labex.pub

La salida será un bloque de texto que comienza con -----BEGIN PGP PUBLIC KEY BLOCK-----. Esta es tu clave pública, que ahora puedes compartir con otros.

A continuación, simularás la recepción de una clave pública de otro usuario y su importación a tu llavero. En un escenario real, recibirías la clave pública de otra persona a través de un canal seguro. Para este laboratorio, crearemos un par de claves temporal para Alice y luego exportaremos su clave pública para simular este proceso.

Primero, generemos temporalmente un par de claves para Alice. Utilizaremos un modo por lotes para automatizar este proceso sin avisos interactivos:

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

Ahora genera el par de claves de Alice utilizando el archivo de parámetros:

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

Deberías ver una salida que confirme la generación de la clave:

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

Ahora exporta la clave pública de Alice a un archivo, simulando cómo la recibirías de ella:

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

Para esta demostración de laboratorio, también eliminaremos la clave secreta de Alice del llavero, ya que en la realidad solo tendrías su clave pública:

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

Cuando se te solicite, confirma la eliminación escribiendo y y presionando Enter.

gpg --delete-keys alice@example.com

De nuevo, confirma la eliminación escribiendo y y presionando Enter.

Ahora tienes la clave pública de Alice en el archivo alice.pub, simulando cómo la recibirías de otro usuario.

Limpia el archivo temporal de generación de claves:

rm alice-key-params

Ahora que tienes la clave pública de Alice en un archivo, impórtala a tu llavero GPG utilizando el comando gpg --import.

gpg --import alice.pub

Deberías ver una salida confirmando que la clave ha sido importada:

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

Para confirmar que la clave de Alice está ahora en tu llavero, enumera de nuevo todas tus claves públicas.

gpg --list-keys

La salida mostrará ahora tanto tu clave (labex) como la clave recién 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]

Observa que la clave de Alice está marcada con confianza [ unknown]. Aprenderás a gestionar la confianza de las claves en el siguiente paso.

Firmar una clave pública y cifrar un archivo para otro usuario

En este paso, aprenderás a establecer confianza en una clave pública que has recibido y luego a utilizarla para cifrar un archivo para su propietario. Cuando importas una clave pública, GPG no tiene forma de saber si es auténtica. Al "firmar" la clave con tu propia clave privada, estás creando un respaldo criptográfico, diciéndole esencialmente a tu configuración de GPG: "Confío en que esta clave pertenece a esta persona". Este es un concepto fundamental en el modelo de "Red de Confianza" (Web of Trust) de GPG.

Primero, necesitas firmar la clave pública de "Alice" que importaste en el paso anterior. Utilizarás el comando gpg --sign-key, identificando la clave por su dirección de correo electrónico (alice@example.com).

gpg --sign-key alice@example.com

GPG mostrará los detalles de la clave de Alice y te pedirá que confirmes que quieres firmarla.

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)

Escribe y y presiona Enter. Si tu clave tiene una frase de contraseña, se te pedirá que la introduzcas. Esto se debe a que una firma es una operación criptográfica que solo puede realizarse con tu clave secreta. Introduce tu contraseña si se te solicita y presiona Enter.

Una vez hecho esto, puedes verificar la firma enumerando las claves de nuevo.

gpg --list-keys

Observa el cambio en la entrada de la clave de Alice. El nivel de confianza ya no es [unknown]. Ahora muestra [ultimate] porque has confiado explícitamente en ella al firmarla.

/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]

Ahora que tienes una clave pública de confianza para Alice, puedes cifrar un archivo que solo ella pueda abrir. Primero, crea un nuevo archivo para este propósito.

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

A continuación, cifra este archivo utilizando el comando gpg -e. Esta vez, especifica a Alice como destinataria con el indicador -r.

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

GPG utilizará la clave pública de Alice para realizar el cifrado. Utiliza ls para ver el resultado.

ls

Verás el nuevo archivo cifrado, message-for-alice.txt.gpg, en tu directorio.

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

Este archivo está ahora cifrado de forma segura. Solo alguien con acceso a la clave privada de Alice (y su frase de contraseña) puede descifrar y leer el mensaje.

Realizar el mantenimiento de claves con gpg --export-secret-keys y gpg --gen-revoke

En este paso final, realizarás dos tareas de mantenimiento críticas para tu clave GPG: crear una copia de seguridad segura de tu clave secreta y generar un certificado de revocación. Tu clave secreta es insustituible; si la pierdes, perderás el acceso a todos los datos cifrados con la clave pública correspondiente. Un certificado de revocación es tu red de seguridad, que te permite invalidar tu clave pública si tu clave secreta se pierde o se ve comprometida.

Primero, vamos a crear una copia de seguridad de tu clave secreta. Este es uno de los pasos más importantes en la gestión de una clave GPG.

El comando gpg --export-secret-keys se utiliza para este fin. Utilizaremos el indicador --armor para crear un archivo de texto con armadura ASCII, que es fácil de almacenar y transportar. Debes especificar qué clave exportar mediante su ID de usuario.

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

Este comando exporta la clave secreta del usuario labex a un archivo llamado gpgkey.asc. Este archivo es extremadamente sensible. En un escenario real, guardarías este archivo en una ubicación fuera de línea muy segura, como una unidad USB cifrada o una caja fuerte segura.

A continuación, crearás un certificado de revocación. Esto debe hacerse inmediatamente después de la generación de la clave y guardarse de forma segura, separado de la copia de seguridad de tu clave secreta. Si pierdes tu clave secreta o te la roban, puedes publicar este certificado para que otros sepan que la clave ya no debe usarse ni ser de confianza.

Utiliza el comando gpg --gen-revoke. Guardaremos el certificado en un archivo llamado revoke.asc utilizando el indicador --output.

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

Se te guiará a través de un proceso interactivo:

Cuando se te pregunte Create a revocation certificate for this key? (y/N), escribe y y presiona Enter.
Se te pedirá que selecciones un motivo para la revocación. Para este laboratorio, presiona Enter para aceptar el valor predeterminado 0 = No reason specified.
Puedes añadir una descripción opcional. Por ahora, simplemente presiona Enter para dejarla en blanco.
Por último, confirma los detalles escribiendo y y presionando Enter cuando se te pregunte Is this okay? (y/N).
Si tu clave tiene una frase de contraseña, GPG la solicitará para autorizar la creación de este certificado. Introduce tu contraseña si se te solicita y presiona Enter.

Verás una confirmación de que el certificado de revocación ha sido creado.

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.

Utiliza el comando ls para verificar que ambos archivos nuevos se han creado en tu directorio ~/project.

ls

Ahora deberías ver gpgkey.asc y revoke.asc en la lista de archivos. Has realizado con éxito el mantenimiento esencial de las claves.

Resumen

En esta práctica de laboratorio, has aprendido las operaciones fundamentales de GNU Privacy Guard (GPG) en un entorno Linux. Comenzaste generando un par de claves GPG personal, compuesto por una clave pública y una privada, utilizando el comando gpg --gen-key. Este proceso implicó la selección de especificaciones de clave y la creación de un ID de usuario protegido por una frase de contraseña segura. Tras la generación de las claves, practicaste la función principal de GPG cifrando un archivo local para ti mismo con gpg -e y descifrándolo posteriormente con tu clave privada y el comando gpg --decrypt, demostrando los principios básicos del cifrado asimétrico.

A partir de estos conceptos básicos, exploraste cómo comunicarte de forma segura con los demás. Aprendiste a intercambiar claves públicas utilizando gpg --export para compartir tu clave y gpg --import para recibir la clave de otro usuario. El laboratorio también cubrió la importancia de establecer confianza mediante la firma de una clave pública importada y su posterior uso para cifrar un archivo específicamente para ese usuario. Por último, realizaste tareas esenciales de mantenimiento de claves, como la copia de seguridad de tu clave secreta con gpg --export-secret-keys y la creación de un certificado de revocación con gpg --gen-revoke para invalidar tu par de claves si llegara a verse comprometido.