7.- Almacenamiento Seguro de Secretos con Vaul y Hvac

Usando Vault de Hashicorp y hvac para guardar secretos usando Python

Introducción

Los secretos deben almacenarse de forma segura para proteger datos privados y evitar que las personas obtengan acceso no autorizado a tus aplicaciones. Vault es una solución de almacenamiento basada en tokens para gestionar secretos. Hay cuatro etapas de seguridad para Vault:

1. Autenticación
2. Validación
3. Autorización
4. Acceso

Vamos a examinar más de cerca cómo Vault autentica a los usuarios y gestiona secretos usando Python.

Instalar Vault

A lo largo de este laboratorio, utilizarás una herramienta llamada Vault de Hashicorp. Antes de poder usar Vault en cualquier sistema, debes instalarlo.

Tu Tarea

Ejecuta los siguientes comandos en la terminal para instalar Vault:

wget -O- https://apt.releases.hashicorp.com/gpg | gpg — dearmor | sudo tee /usr/share/keyrings/hashicorp-archive-keyring.gpg >/dev/null
echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] https://apt.releases.hashicorp.com $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/hashicorp.list
sudo apt update
sudo apt install vault

Puedes verificar que se instaló correctamente ejecutando el comando vault en una terminal:

vault

Esto debería mostrar una lista de comandos que puedes utilizar con la herramienta.

Configuración del Servidor de Desarrollo

Ahora, iniciarás el servidor de desarrollo de Vault solo para tener una idea de cómo son las funcionalidades. En realidad, esto no es muy seguro, pero es útil para explorar la herramienta localmente. No obstante, todos los datos están cifrados y se almacenan en memoria para el servidor de desarrollo.

Tu Tarea

Usa el comando `vault server` con la bandera `-dev` para ejecutar el servidor de Vault en modo de desarrollo:

vault server -dev

Al final de la salida, deberías ver un mensaje de advertencia que nos proporciona más información.

En primer lugar, nos informa que la variable de entorno debe ser configurada. Esta es la dirección a través de la cual puedes acceder a Vault localmente:

Set environment variable

export VAULT_ADDR=’http://127.0.0.1:8200'

La clave de desbloqueo (unseal key) y el token de raíz (root token) (resaltados a continuación) también se proporcionan en el mensaje de salida:
Se utilizan para autenticar al usuario, siendo el primer paso de seguridad en Vault. El token de raíz se regenera cada vez que inicias el servidor, así que asegúrate de editar y ejecutar la declaración a continuación de acuerdo con el token de raíz más actualizado que se muestra en tu terminal:

```export VAULT_TOKEN=”TU TOKEN DE RAÍZ AQUÍ”

Verificar el Estado del Servidor:
Es importante saber si el servidor se está ejecutando correctamente, así que en este paso usarás el comando `vault status` para verificar el estado del servidor.

Usa el comando `vault status` para verificar que el servidor esté en funcionamiento:

```shell
vault status
```

No necesitas entender todo esto por ahora, solo comprende que muestra que tenemos un servidor de Vault en funcionamiento para gestionar tus secretos.

Acceder a la Interfaz de Usuario de Vault:
Hay varias formas de acceder a Vault. Una forma fácil de usar es lanzar la Interfaz de Usuario web (UI) en tu localhost.

Iniciar la Interfaz de Usuario de Vault:
Esto abrirá una nueva pestaña en este entorno de desarrollo para la aplicación. Se te presentará una página de inicio de sesión. Desde aquí, puedes ingresar el token de raíz que copiaste en la variable de entorno `VAULT_TOKEN` para iniciar sesión.

Puedes mostrar tu token desde una terminal con:
```shell
echo $VAULT_TOKEN
```

Una vez que hayas iniciado sesión, puedes acceder a los secretos almacenados en secret/ haciendo clic en el enlace:
http://localhost:8200

O alternativamente, si haces clic en el botón en la esquina superior derecha (resaltado por el recuadro amarillo a continuación), puedes abrir la página en una nueva ventana del navegador:

Instalación de HVAC:
Por defecto, el servidor de desarrollo de Vault incluye motores de secretos KV v2 en la ruta `secret/`, almacenando secretos en su almacenamiento físico configurado. Los secretos se cifran antes de escribirse en el almacenamiento de backend, por lo que Vault nunca puede descifrar estos valores sin Vault.

Aprenderás a leer y escribir secretos en el servidor utilizando Python con la ayuda de la biblioteca `hvac`. Antes de hacer esto, debemos instalar el paquete Python `hvac` utilizando el Administrador de paquetes de Python (pip).
Usa el comando `pip` para instalar el paquete `hvac` con el siguiente comando:

python3 -m pip install hvac

Nota: También puedes usar la línea de comandos de Vault en lugar de la API de Python para gestionar secretos.

Escribir Secreto en Vault:
Ahora estás listo para comenzar a usar Vault escribiendo secretos en él.

Antes de empezar, primero debes obtener el archivo Python que se utilizará para escribir, leer y eliminar secretos de Vault:
Usa el siguiente comando `wget` para obtener el programa `read_write_vault.py`:

``` wget https://path/to/read_write_vault.py

Abramos el archivo en el entorno de desarrollo para echarle un vistazo: Abre read_write_vault.py en el entorno de desarrollo

Examinemos el programa:
Hay cuatro funciones en este programa:

def init_server():
def write_secret(secret_path, key, value):
def read_secret(secret_path):
def delete_secret(secret_path):

Primero, usaremos más adelante `init_server()` (línea 4), que crea una nueva instancia del cliente `hvac` con la URL especificada. Si estuvieras ejecutando este laboratorio en tu propia computadora, esta URL sería `http://localhost:8200`, donde se encuentra tu servidor de Vault. En el entorno de IDE en la nube, usaremos la URL desde el lanzamiento de la aplicación en su lugar. Devolvemos la instancia del cliente a la función `Writing a secret`.

Ahora, intentemos escribir un secreto.

Usa `python3` para llamar al programa `read_write_vault.py` pasándole la función `write_secret` que se usará para escribir un par de clave/valor para el cliente en la ruta: con los parámetros `secret/path`.

```shell
python3 read_write_vault.py write_secret myapp alice mypassword
```

Esto establecerá la ruta como `secret/myapp` y escribirá el par clave/valor `alice=mypassword` allí.

Verificar el Secreto Escrito:

Después de escribir el par clave/valor, vamos a abrir la Interfaz de Usuario de Vault para asegurarnos de que el secreto se haya almacenado en el lugar correcto:
Vuelve a la interfaz de usuario de Vault.
Iniciar Interfaz de Usuario de Vault (http://localhost:8200)

Haz clic en el enlace `secret/`. Esto te mostrará todos los secretos.
Luego haz clic en el enlace `myapp/`. Esto te mostrará los secretos bajo `myapp`.
Deberías ver el secreto almacenado `alice=myapp` y cuando hagas clic en el icono del ojo, verás el valor `mypassword`.

Leer Secreto desde Vault:

En este paso, leerás el secreto nuevamente desde Vault. Para hacerlo programáticamente con Python, usarías la función `client.secrets.kv.v2.read_secret_version()`.

Esto se ha incluido en `read_secret()` (línea 21), que tomará el camino del secreto como argumento y mostrará los detalles del secreto leído.
Vas a usar la misma sintaxis en la terminal para leer un secreto desde la ruta `secret/myapp`.
Usa `python3` para ejecutar el programa `read_write_vault.py`, llamando a la función `read_secret` pasándole el parámetro `myapp`:

```shell
python3 read_write_vault.py read_secret myapp
```

Resultados:
La salida mostrará información sobre todos los datos almacenados bajo `secret/myapp`. Notarás el par clave/valor que acabas de escribir.

Nota: Si intentas leer desde una ruta no válida, `hvac` devolverá un error.

Eliminar Secreto de Vault:

Eliminar secretos de Vault también es posible con `client.secrets.kv.v2.delete_latest_version_of_secret()`, que eliminará la última versión del secreto en una cierta ruta que especifiques como parámetro para la función.
Usa `python3` para ejecutar el programa `read_write_vault.py`, llamando a la función `delete_secret` pasándole el parámetro `myapp`:

```shell
python3 read_write_vault.py delete_secret myapp
```

El programa no imprime ni devuelve nada para esta función, pero puedes volver a la Interfaz de Usuario de Vault para verificar que ha sido eliminado.

Verificar el Secreto Eliminado:

Siempre puedes verificar qué secretos existen usando la Interfaz de Usuario de Vault, pero lo haremos programáticamente utilizando un programa Python para comprobar si el secreto ha sido eliminado llamando nuevamente a `read_secret` para `myapp`.
Usa `python3` para ejecutar el programa `read_write_vault.py`, llamando a la función `read_secret` pasándole el parámetro `myapp`:

```shell
python3 read_write_vault.py read_secret myapp
```

Resultados:
Deberías ver un error por `InvalidPath`, junto con un diccionario que contiene una clave llamada “deletion_time” que muestra cuándo se eliminó el secreto.

Verificar en la Interfaz de Usuario de Vault:

Al volver a la Interfaz de Usuario de Vault, podrás ver este cambio reflejado también.

Segunda Parte: Tests de Seguridad y Estrategias de Mitigación

Lab 1: Usando Análisis Estático
Lab 2: Usando Análisis Dinámico
Lab 3: Evaluando el Análisis de Vulnerabilidades
Lab 4: Evaluando “Software Component Analysis (SCA)”

Tercera Parte: OWASP Top 10 vulnerabilidades

Lab 5: Comprendiendo SQL Injections
Lab 6: Cross Site Scripting XSS
Lab 7: Guardando Secretos de forma Segura

Cuarta Parte: Mejores Prácticas

Lab 8: Code Practices
Lab 9: Secure Development Environment