Introducción
En este laboratorio, aprenderá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 es 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.
Basándote en estos fundamentos, explorarás cómo intercambiar información de forma segura con otros. 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 realizar tareas cruciales de mantenimiento de claves, como realizar copias 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 para ti. Debes mantener tu clave privada en secreto, ya que es la única clave que puede descifrar los archivos cifrados con tu clave pública.
Primero, asegurémonos de que el paquete gnupg, que proporciona la funcionalidad de 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 que indica que este comando utiliza una generación de claves simplificada. Para opciones más avanzadas, puedes usar gpg --full-generate-key, pero las opciones predeterminadas son adecuadas para este laboratorio.
Se te solicitará la siguiente información:
- Real name (Nombre real): Escribe
labex - Email address (Dirección de correo electrónico): Escribe
labex@example.com - Confirm User ID (Confirmar ID de usuario): Revisa tus detalles. Cuando se te pregunte
Change (N)ame, (E)mail, or (O)kay/(Q)uit?, escribeOy presionaEnter.
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 versiones anteriores, el GPG moderno puede no solicitar una frase de contraseña durante la generación de claves usando --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 frase de 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 verlas. Para ver tu nueva clave pública, ejecuta:
gpg --list-keys
La salida mostrará todas las claves públicas en tu llavero, incluida 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]
Ahora 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 para 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 a su forma original.
Primero, creemos un archivo de texto simple con el que 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 usando tu clave pública. El comando gpg -e se utiliza para el cifrado. También debes especificar el destinatario del mensaje cifrado con la bandera -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 solicitará tu frase de contraseña porque el cifrado se realiza con la clave pública, que no es secreta.
Después de que el comando se complete, 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, descifremos el archivo. Para hacer esto, usarás el comando gpg --decrypt. Dado que estás descifrando, GPG utilizará tu clave privada.
Usaremos la bandera --output para especificar un nuevo archivo para el contenido descifrado, mytestfile.txt.decrypted. Esto evita sobrescribir el archivo original y deja claro qué archivo es cuál.
gpg --output mytestfile.txt.decrypted --decrypt mytestfile.txt.gpg
Si tu clave tiene una frase de contraseña, se te pedirá que la ingreses. Si no se estableció ninguna frase de 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 cómo intercambiar claves públicas con otros. 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 recibes de otros a tu llavero GPG.
Primero, exportemos tu propia clave pública. Utilizarás el comando gpg --export. Es una buena práctica utilizar la opción --armor, que crea una versión de la clave basada en 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. Reemplaza labex con 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 creó usando 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 recibir una clave pública de otro usuario e importarla 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 la clave pública de Alice para simular este proceso.
Primero, generemos temporalmente un par de claves para Alice. Usaremos un modo por lotes (batch mode) para automatizar este proceso sin prompts 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 usando el archivo de parámetros:
gpg --batch --generate-key alice-key-params
Deberías ver una salida confirmando 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 Alice:
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 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
Nuevamente, 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 usando el comando gpg --import.
gpg --import alice.pub
Deberías ver una salida confirmando que la clave fue 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 todas tus claves públicas nuevamente.
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 cómo 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 cómo establecer confianza en una clave pública que has recibido y luego usarla 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 "Web 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 deseas 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 ingreses. Esto se debe a que una firma es una operación criptográfica que solo puede realizarse con tu clave secreta. Ingresa tu frase de contraseña si se te solicita y presiona Enter.
Una vez hecho esto, puedes verificar la firma enumerando las claves nuevamente.
gpg --list-keys
Observa el cambio en la entrada de la clave de Alice. Después de firmar la clave importada, GPG ya no la muestra como [unknown]. Dependiendo del estado de tu llavero local, la clave puede aparecer con un marcador de validez más fuerte, como [full] o [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]
Si deseas confirmar la firma directamente, ejecuta:
gpg --list-sigs alice@example.com
Deberías ver una línea de firma para labex <labex@example.com>, lo que confirma que tu clave firmó la clave pública importada de Alice.
Ahora que tienes una clave pública confiable 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 usando el comando gpg -e. Esta vez, especifica a Alice como destinataria con la bandera -r.
gpg -e -r alice@example.com message-for-alice.txt
GPG utilizará la clave pública de Alice para realizar el cifrado. Usa 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 ahora está 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 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 irremplazable; si la pierdes, pierdes el acceso a todos los datos cifrados con la clave pública correspondiente. Un certificado de revocación es tu red de seguridad, permitiéndote invalidar tu clave pública si tu clave secreta se pierde o se ve comprometida.
Primero, creemos 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 propósito. Usaremos la bandera --armor para crear un archivo de texto ASCII, que es fácil de almacenar y transportar. Debes especificar qué clave exportar por su ID de usuario.
gpg --export-secret-keys --armor -o gpgkey.asc labex
Este comando exporta la clave secreta para el usuario labex a un archivo llamado gpgkey.asc. Este archivo es extremadamente sensible. En un escenario del mundo real, almacenarías este archivo en una ubicación fuera de línea muy segura, como una unidad USB cifrada o una caja fuerte.
A continuación, crearás un certificado de revocación. Esto debe hacerse inmediatamente después de la generación de la clave y almacenarse de forma segura, separado de la copia de seguridad de tu clave secreta. Si pierdes tu clave secreta o es robada, puedes publicar este certificado para informar a otros que la clave ya no debe usarse ni ser confiable.
Usa el comando gpg --gen-revoke. Guardaremos el certificado en un archivo llamado revoke.asc usando la bandera --output.
gpg --output revoke.asc --gen-revoke labex
Serás guiado a través de un proceso interactivo:
- Cuando se te pregunte
Create a revocation certificate for this key? (y/N), escribeyy presionaEnter. - Se te pedirá que selecciones un motivo para la revocación. Para este laboratorio, presiona
Enterpara aceptar el valor predeterminado0 = No reason specified. - Puedes añadir una descripción opcional. Por ahora, simplemente presiona
Enterpara dejarla en blanco. - Finalmente, confirma los detalles escribiendo
yy presionandoEntercuando se te pregunteIs this okay? (y/N). - Si tu clave tiene una frase de contraseña, GPG la solicitará para autorizar la creación de este certificado. Ingresa tu frase de 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.
Usa el comando ls para verificar que ambos archivos nuevos se hayan 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 claves.
Resumen
En este laboratorio, aprendiste las operaciones fundamentales de GNU Privacy Guard (GPG) en un entorno Linux. Comenzaste generando un par de claves GPG personal, que consiste en una clave pública y una privada, utilizando el comando gpg --gen-key. Este proceso implicó seleccionar las especificaciones de la clave y crear un ID de usuario protegido por una frase de contraseña segura. Tras la generación de la clave, practicaste la función principal de GPG cifrando un archivo local para ti mismo con gpg -e y posteriormente descifrándolo utilizando tu clave privada y el comando gpg --decrypt, demostrando los principios básicos del cifrado asimétrico.
Basándote en estos conceptos básicos, exploraste cómo comunicarte de forma segura con otros. Aprendiste a intercambiar claves públicas usando 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 firmando una clave pública importada y luego usándola para cifrar un archivo específicamente para ese usuario. Finalmente, realizaste tareas esenciales de mantenimiento de claves, incluyendo la copia de seguridad de tu clave secreta con gpg --export-secret-keys y la creación de un certificado de revocación usando gpg --gen-revoke para invalidar tu par de claves si se ve comprometido.
