---
# System prepended metadata

title: Como crear y mantener llaves GPG

---

# Como crear y mantener llaves GPG
Esto es una guía practica, vamos a concentrar en los pasos, si quieren aprender más del tema, vamos a ir mencionando las referencias.

Queremos generar llaves de una manera segura y con buenas practicas, si ya tienen llaves y estas no fueron generadas siguiendo buenas practicas, recomendamos crear un par nuevo, si se conoce una mejor y mas segura forma de ejecutar alguno de los pasos, les agradecemos si nos pueden dejar un comentario.

## ¿Que queremos hacer?

1. Crear un keypair usando el cifrado mas seguro en el momento.
1. Agregar una llave de firmado al par anterior.
1. Exportar nuestro par de llaves principales (llave privada y llave publica) junto con el certificado de revocación, **estos serán guardados en un lugar muy seguro, este lugar no debería ser la computadora**
1. Eliminar la sub-llave de firmado (signing subkey) **original**  del master keypair en el keyring de la computadora, esto va a transformar a los keys que tenemos en keys para la computadora.

Vamos a ir paso a paso explicando la razon de cada comando.

**Nota:** Si se va a utilizar un yubikey para almacenar las llaves, hay que consultar para la version del yubikey y el firmware que tiene cargado, que tipo de llaves puede almacenar, esto va a ser importante al tomar la descición de que algoritmo utilizar para generar las subkeys.

## Creando el master key
Lo primero es verificar la version de gpg
```bash=
gpg --version
```
Es importante verificar que se tenga una version bastante actualizada(esto va a depender del sistema operativo que se utilice) una vez que se conozca la version, vamos a listar las llaves disponibles en nuestro keyring.

No es necesario estar en la ultima versión de gpg, pero si en alguna reciente, pueden verificar las ultimas versiones en los [release notes](https://gnupg.org/download/release_notes.html) del sitio de Gnupg.

```bash=
gpg --list-keys
```
Si nunca hemos generado llaves, la lista va a estar vacía, si la lista no esta vacía, es importante no confundir las nuevas llaves con las existentes.

Vamos a genererar una nueva llave, la cual va a ser nuestra llave principal y luego vamos a generar los subkeys.

Al generar la llave principal vamos a seleccionar el tipo de llave que deseamos, en nuestro caso vamos a usar curvas elipticas o ECC y vamos a seleccionar las capacidades ("set your own capabilities" o "permite elegir capacidades").

Nota: en una futura versión de la guía vamos a poner las opciones directas para no tener que usar el modo interactivo.

```bash=
gpg --expert --full-gen-key
```


Esta llave solo la vamos a usar para **certificar**, es importante leer la salida y verificar la sección y eliminar las acciones que no queremos.

Se debería ver de esta manera:

```
Possible actions for this ECC key: Sign Certify Authenticate
Current allowed actions: Certify

   (S) Toggle the sign capability
   (A) Toggle the authenticate capability
   (Q) Finished
```

Una vez que solo tenemos **certify**, seleccionamos finalizar, esto nos va a permitir seguir con la selección del tipo de curva eliptica, voy a seleccionar el default que es **25519**.

Luego nos va a preguntar sobre el tiempo de validez de la llave, vamos a seleccionar 1 año, esto con el fin de practicar los comandos.

**Nota no recomendada:** si no quieren hacer esto, pueden seleccionar `0` y no va a tener fecha de expiración.

Por ultimo tenemos que poner el nombre o pseudonimo, correo y un comentario.

## Creando los subkeys

En el caso de los subkeys, es bueno tener una llave dedicada para cada tarea.

Para crear cada subkey, vamos a tener que editar la llave creada anteriormente.

Necisitamos el identificador de la llave principal.

```bash=
gpg --list-keys
```
```
➜  gpg gpg --list-keys
/Users/asegura/.gnupg/pubring.kbx
---------------------------------
pub   ed25519 2021-12-18 [C] [expires: 2022-12-18]
      <ID del key>
uid           [ultimate] <Nombre ingresado> <yo@correo.com>
```
Ahora vamos a agregar la subkeys.

```bash=
gpg --expert --edit-key <ID del key>
```

Este comando nos va a colocar en una terminal de `gpg` para editar la llave.

El comando que se utiliza para agregar un key es `addkey`.
```bash=
addkey
```
No va a dar la opción seleccionar el tipo de subkey.

Queremo agregar una de `Sign`, una de `encrypt`y to otra de `authenticate`, vamos a seguir usando ECC para este ejemplo.
```
Please select what kind of key you want:
   (3) DSA (sign only)
   (4) RSA (sign only)
   (5) Elgamal (encrypt only)
   (6) RSA (encrypt only)
   (7) DSA (set your own capabilities)
   (8) RSA (set your own capabilities)
  (10) ECC (sign only)
  (11) ECC (set your own capabilities)
  (12) ECC (encrypt only)
  (13) Existing key
  (14) Existing key from card
Your selection?
```

**Nota**: La salida mostrada anteriormente es solo una referencia, hacer la selección en base a la salida.

En el primer caso vamos a seleccionar `sign only`, esto nos va a dar la opción del tipo de curva que eliptica a utilizar, seleccionamos el default de nuevo, damos el tiempo de expiración de 1 año (`1y`), es recomendable **no** hacer las subkeys sin ficha de expiración, contestamos que es correcto y que se cree, luego agregamos la clave.

Repetir el proceso para la de `encrypt` y la de `authenticate`, en el caso de la de autenticación, vamos a tener que seleccionar `ECC (set your own capabilities)` y dejar solo la opción y apagar las otras capacidades.

Al lado derecho de la salida, vamos a ver la palabra `usage`, S para sign, E para encrypt y A para authenticate.

Luego tenemos que salvar los cambios.

``` gpg
save
quit
```

## Certificado de revocación

Vamos a crear un certificado de revocación, este va quedar guardado en el directorio donde estemos.

```bash=
gpg --output <id-de-la-llave>.gpg-revocation-certificate --gen-revoke <id-de-la-llave>
```

## Exportar el master key

La llave maestra **no** debe ser utilizada, debe ser almacenada en un lugar seguro, sin conexión a internet.

``` bash
gpg --export-secret-keys --armor bilbo@shire.org > \<bilbo@shire.org\>.private.gpg-key
```

``` bash
gpg --export --armor bilbo@shire.org > \<bilbo@shire.org\>.public.gpg-key
```

Tomar el certificado de revocación, la llave publica y la llave privada y almacenarlos en un lugar seguro, estos archivos son la llave maestra.

## Transforming your master keypair into your laptop keypair

``` bash
gpg --export-secret-subkeys bilbo@shire.org > /tmp/gpg/subkeys
```

Delete the original signing subkey from the keypair in our keyring
```bash
gpg --delete-secret-key bilbo@shire.org
```

Re-import the keys we exported and clean up our temporary file
``` bash
gpg --import /tmp/gpg/subkeys
```

## Yubikey
Revisar link de linode en referencias
```
gpg --card-edit

gpg --edit-key 1234ABC
```





# Referencias
* https://alexcabal.com/creating-the-perfect-gpg-keypair
* https://blog.tinned-software.net/create-gnupg-key-with-sub-keys-to-sign-encrypt-authenticate/
* https://blog.eleven-labs.com/en/openpgp-almost-perfect-key-pair-part-1/
* https://riseup.net/en/security/message-security/openpgp/best-practices
* https://devhints.io/gnupg
*  https://gnupg.org/download/release_notes.html
*  https://gpgtools.tenderapp.com/kb/gpg-keychain-faq/how-to-revoke-a-key-or-user-id
*  https://support.yubico.com/hc/en-us/articles/4402836718866-Understanding-YubiKey-PINs
*  https://www.linode.com/docs/guides/gpg-key-for-ssh-authentication/