docs: update vpn/openvpn/servidor

This commit is contained in:
José Antonio Yáñez Jiménez 2022-06-02 08:46:07 +00:00 committed by José Antonio Yáñez Jiménez
parent 19d9c9fe28
commit 66dc90be0a

View File

@ -2,29 +2,28 @@
title: OpenVPN - Servidor
description: Tutorial de instalación del Servidor OpenVPN
published: true
date: 2022-06-01T00:14:53.817Z
date: 2022-06-02T08:46:03.887Z
tags: vpn, servidor, debian
editor: markdown
dateCreated: 2022-05-18T16:48:57.246Z
---
# OpenVPN
![openvpn_logo.svg](/assets/images/openvpn_logo.svg)
## Requisitos
# Requisitos
* **[Debian 11 “bullseye”](https://www.debian.org/releases/bullseye/)**
* **Usuario con privilegios `sudo`**
## EasyRSA
# EasyRSA
### Instalación de EasyRSA (en CA, Signer y oVPN)
## Instalación de EasyRSA (en CA, Signer y oVPN)
* Primero descargamos la última versión disponible de EasyRSA en nuestra CA y nuestro Signer
* Primero descargamos la última versión disponible de EasyRSA en nuestra CA, Signer oVPN.
```bash
wget -P ~/ https://github.com/OpenVPN/easy-rsa/releases/download/v3.1.0/EasyRSA-3.1.0.tgz
```
* Luego descomprimimos y dejamos un nombre sencillo
* Luego descomprimimos y dejamos un nombre sencillo.
```bash
cd ~
@ -33,9 +32,9 @@ mv EasyRSA-3.1.0 EasyRSA
cd EasyRSA
```
### Configuración de EasyRSA (en CA, Signer y oVPN)
## Configuración de EasyRSA (en CA, Signer y oVPN)
* Inicialmente tendremos un fichero `vars.example` que utilizaremos como base
* Crearemos nuestro fichero vars desde cero utilizando este [Fichero de referencia](https://github.com/OpenVPN/easy-rsa/blob/v3.1.0/easyrsa3/vars.example).
```bash
cp vars.example vars
@ -64,7 +63,7 @@ set_var EASYRSA_REQ_OU "Community"
set_var EASYRSA_ALGO ed
```
* La especificación de curva elíptica que utilizaremos será la [Curva 25519](https://es.wikipedia.org/wiki/Curve25519), definida como una curva segura segçun [SafeCurves](https://safecurves.cr.yp.to/)
* La especificación de curva elíptica que utilizaremos será la [Curva 25519](https://es.wikipedia.org/wiki/Curve25519), definida como una curva segura según [SafeCurves](https://safecurves.cr.yp.to/)
```bash
set_var EASYRSA_CURVE ed25519
@ -84,54 +83,54 @@ set_var EASYRSA_CERT_RENEW 20 # Los certificados se pueden renova
* [Referencia de variables de EasyRSA](/assets/files/openvpn-server/easyrsa-vars)
### Creación de CA
## Creación de CA
* Inicializamos nuestra Infraestructura de Clave Pública en la CA
* Inicializamos nuestra Infraestructura de Clave Pública en la CA.
```bash
./easyrsa init-pki
```
* Como se nos informa de que el fichero `vars` se ha movido a la PKI procedemos a mover nuestro fichero personalizado
* Como se nos informa de que el fichero `vars` se ha movido a la PKI procedemos a mover nuestro fichero personalizado.
```bash
mv vars pki/vars
```
* Generamos nuestra CA
* Generamos nuestra CA.
```bash
./easyrsa build-ca # Podríamos añadir 'nopass' para no establecer una Passphrase
```
### Creación de SubCA en Signer
## Creación de SubCA en Signer
* Inicializamos nuestra Infraestructura de Clave Pública en la SubCA
* Inicializamos nuestra Infraestructura de Clave Pública en la SubCA.
```bash
./easyrsa init-pki
```
* Como se nos informa de que el fichero `vars` se ha movido a la PKI procedemos a mover nuestro fichero personalizado
* Como se nos informa de que el fichero `vars` se ha movido a la PKI procedemos a mover nuestro fichero personalizado.
```bash
mv vars pki/vars
```
* Generamos la solicitud de nuestra SubCA
* Generamos la solicitud de nuestra SubCA.
```bash
./easyrsa build-ca subca
```
* Enviamos la solicitud de nuestra SubCA a la CA para validarla
* Enviamos la solicitud de nuestra SubCA a la CA para validarla.
```bash
scp ~/EasyRSA/pki/reqs/ca.req ca@ca.bastionado.es:/tmp
```
* Nos situamos sobre la CA e importamos y firmamos la solicitud
* Nos situamos sobre la CA e importamos y firmamos la solicitud.
```bash
./easyrsa import-req /tmp/ca.req signer
@ -139,7 +138,7 @@ scp ~/EasyRSA/pki/reqs/ca.req ca@ca.bastionado.es:/tmp
./easyrsa sign-req ca signer
```
* Devolvemos el certificado encadenado de la CA con la SubCA válido a nuestra SubCA
* Devolvemos el certificado encadenado de la CA con la SubCA válido a nuestra SubCA.
```bash
cat pki/issued/signer.crt \
@ -151,39 +150,39 @@ scp /tmp/signer.crt signer@signer.bastionado.es:/tmp
rm -rf /tmp/signer.crt
```
* Volvemos a la SubCA y movemos el certificado a la ruta de puesto PKI
* Volvemos a la SubCA y movemos el certificado a la ruta de puesto PKI.
```bash
mv /tmp/signer.crt ~/EasyRSA/pki/ca.crt
```
### Creación de Certificado en oVPN
## Creación de Certificado en oVPN
* Inicializamos nuestra Infraestructura de Clave Pública en oVPN
* Inicializamos nuestra Infraestructura de Clave Pública en oVPN.
```bash
./easyrsa init-pki
```
* Como se nos informa de que el fichero `vars` se ha movido a la PKI procedemos a mover nuestro fichero personalizado
* Como se nos informa de que el fichero `vars` se ha movido a la PKI procedemos a mover nuestro fichero personalizado.
```bash
mv vars pki/vars
```
* Generamos la solicitud de nuestra VPN
* Generamos la solicitud de nuestra VPN.
```bash
./easyrsa gen-req ovpn nopass # Aquí no establecemos Passphrase
```
* Enviamos la solicitud de nuestra VPN a la SubCA para validarla
* Enviamos la solicitud de nuestra VPN a la SubCA para validarla.
```bash
scp ~/EasyRSA/pki/reqs/ovpn.req signer@signer.bastionado.es:/tmp
```
* Nos situamos sobre la SubCA e importamos y firmamos la solicitud
* Nos situamos sobre la SubCA e importamos y firmamos la solicitud.
```bash
./easyrsa import-req /tmp/ovpn.req ovpn
@ -191,51 +190,68 @@ scp ~/EasyRSA/pki/reqs/ovpn.req signer@signer.bastionado.es:/tmp
./easyrsa sign-req server ovpn
```
* Devolvemos el certificado válido a nuestra oVPN junto con el certificado de la SubCA
* Devolvemos el certificado válido a nuestra oVPN junto con el certificado de la SubCA.
```bash
scp pki/ca.crt ovpn@ovpn.bastionado.es:/tmp
scp pki/issued/ovpn.crt ovpn@ovpn.bastionado.es:/tmp
```
## OpenVPN
# OpenVPN
### Instalación de dependencias OpenVPN
## Instalación de dependencias OpenVPN
* Comenzaremos actualizando nuestro repositorio `apt`
* Comenzaremos actualizando nuestro repositorio `apt`.
```bash
sudo apt update
```
* Después realizaremos una instalación de dependencias previas
* Después realizaremos una instalación de dependencias previas.
```bash
sudo apt -y install ca-certificates wget net-tools gnupg
```
* Ahora añadiremos las claves PGP del repositorio de OpenVPN
* Ahora añadiremos las claves GPG del repositorio de OpenVPN para utilizar un Keyring ya que APT KEY está [obsoleto](https://www.linuxuprising.com/2021/01/apt-key-is-deprecated-how-to-add.html).
```bash
wget -qO- https://swupdate.openvpn.net/repos/repo-public.gpg | gpg --dearmor | sudo tee /usr/share/keyrings/openvpn-archive-keyring.gpg > /dev/null
```
* Y añadiremos el repositorio de OpenVPN a nuestro listado de repositorios
* Y añadiremos el repositorio de OpenVPN a nuestro listado de repositorios.
```bash
echo "deb [signed-by=/usr/share/keyrings/openvpn-archive-keyring.gpg] http://build.openvpn.net/debian/openvpn/stable bullseye main" | sudo tee /etc/apt/sources.list.d/openvpn-repo.list > /dev/null
```
* Es turno de volver a actualizar nuestro listado de repositorios
* Es turno de volver a actualizar nuestro listado de repositorios.
```bash
sudo apt update
```
* Y ya podemos proceder con la instalación de OpenVPN
* Y ya podemos proceder con la instalación de OpenVPN.
```bash
sudo apt -y install openvpn
```
### Configuración de certificados y seguridad TLS
## Explicación de certificados, claves y encriptado
* Copiamos los certificados que dejamos en /tmp y la clave privada
> Como iremos viendo ahora, existen mútiples certificados y claves a los que haremos referencia en OpenVPN.
>
> Por un lado tenemos los certificados de **CA (y SubCA), Servidor y Cliente**. Todos estos certificados, que no son más que claves asimétricas públicas y privadas, son utilizados para la **autenticación mutua**, es decir, para que el servidor demuestre quién es y los clientes puedan hacer lo propio.
>
> Por otra parte tenemos **Diffie-Hellman**, un [protocolo de intercambio de claves desarrollado en 1976](https://ee.stanford.edu/~hellman/publications/24.pdf), que, en resumidas cuentas, sirve para **establecer un secreto compartido** entre el cliente y el servidor con el que poder encriptar después los datos de comunicación que se enviarán a través de la VPN. Este secreto será utilizado únicamente durante la sesión activa, si reiniciamos la conexión se volverá a hacer uso de este protocolo, generando un nuevo secreto. Utilizar este protocolo para el encriptado de datos nos protege de ataques MITM ya que no se utiliza para la autenticación, que está cubierto por el punto anterior.
>
> También tenemos el combinado de claves de **TLS-AUTH**, que se utiliza para **firmar todos los paquetes** que circularán por la cxonexión, utilizando un código de autenticación de mensaje basado en hash, de tal forma que se puedan descartar automáticamente los paquetes que no estén firmados con este código de autenticación, actuando como una especie de Firewall ante diversos ataques.
>
> Para finalizar, una vez se ha hecho uso de todas estas tecnologías ya podemos enviar y recibir datos a través de la VPN utilizando un cifrado simétrico, como es AES-256-CBC, aunque, como veremos más adelante, este cifrado puede verse reemplazado por otras opciones más modernas si tanto cliente como servidor lo permiten.
## Configuración de certificados y seguridad TLS
* Copiamos los certificados que dejamos en /tmp y la clave privada.
```bash
sudo cp ~/EasyRSA/pki/private/ovpn.key /etc/openvpn/
@ -244,7 +260,7 @@ sudo mv /tmp/{ovpn.crt,ca.crt} /etc/openvpn/
```
> Diffie-Hellman es un algoritmo que permite crear una clave secreta entre dos equipos que nunca han tenido contacto previo, a través de un canal inseguro, y mediante el envío de solo dos mensajes. Aunque es algo lento, es recomendable crear una clave de 4096 bits.
* Volvemos a la ruta de EasyRSA para generar la clave Diffie-Hellman
* Volvemos a la ruta de EasyRSA para generar la clave Diffie-Hellman.
```bash
cd ~/EasyRSA/
@ -255,24 +271,24 @@ cd ~/EasyRSA/
> En el modo de clave estática, se genera una clave precompartida que se comparte entre ambos pares de OpenVPN antes de iniciar el túnel. Esta clave estática contiene 4 claves independientes: HMAC de envío, HMAC de recepción, cifrado y descifrado. Por defecto, en el modo de clave estática, ambos hosts utilizarán la misma clave HMAC y la misma clave de cifrado/descifrado. Sin embargo, utilizando el parámetro `--secret`, es posible utilizar las 4 claves de forma independiente.
* Generamos la firma HMAC para reforzar las capacidades de verificación de integridad TLS
* Generamos la firma HMAC para reforzar las capacidades de verificación de integridad TLS.
```bash
sudo openvpn --genkey secret ta.key
```
* Movemos los ficheros generados a nuestro directorio de OpenVPN
* Movemos los ficheros generados a nuestro directorio de OpenVPN.
```bash
sudo mv ~/EasyRSA/ta.key /etc/openvpn/
sudo mv ~/EasyRSA/pki/dh.pem /etc/openvpn/
```
### Certificados Cliente
## Certificados Cliente
Con la estructura propuesta las solicitudes de certificados cliente serán generadas desde el servidor de OpenVPN `oVPN` y firmadas desde la SubCA `Signer`, de tal modo que, posteriormente, el cliente simplemente recibirá un fichero de configuración para conectar a la VPN junto con sus certificados sin tener que estar intercambiando certificados inicialmente si fuera el propio cliente el que realizara la solicitud de creación de certificado.
> Con la estructura propuesta las solicitudes de certificados cliente serán generadas desde el servidor de OpenVPN `oVPN` y firmadas desde la SubCA `Signer`, de tal modo que, posteriormente, el cliente simplemente recibirá un fichero de configuración para conectar a la VPN junto con sus certificados sin tener que estar intercambiando certificados inicialmente si fuera el propio cliente el que realizara la solicitud de creación de certificado.
* Crearemos un directorio en nuestra VPN para almacenar las configuraciones de cliente y restringiremos los permisos
* Crearemos un directorio en nuestra VPN para almacenar las configuraciones de cliente y restringiremos los permisos.
```bash
mkdir -p ~/client-configs/keys
@ -280,7 +296,7 @@ mkdir -p ~/client-configs/keys
chmod -R 700 ~/client-configs
```
* Volvemos a la ruta de EasyRSA para generar la solicitud de certificado cliente
* Volvemos a la ruta de EasyRSA para generar la solicitud de certificado cliente.
```bash
cd ~/EasyRSA/
@ -291,19 +307,19 @@ cd ~/EasyRSA/
./easyrsa gen-req client4 nopass
```
* Copiamos la clave privada generada a nuestro directorio de configuraciones Cliente
* Copiamos la clave privada generada a nuestro directorio de configuraciones Cliente.
```bash
cp pki/private/{client1.key,client2.key,client3.key,client4.key} ~/client-configs/keys/
```
* Enviamos las solicitudes de nuestra VPN a la SubCA para validarlas
* Enviamos las solicitudes de nuestra VPN a la SubCA para validarlas.
```bash
scp ~/EasyRSA/pki/reqs/{client1.req,client2.req,client3.req,client4.req} signer@signer.bastionado.es:/tmp
```
* Nos situamos sobre la SubCA e importamos y firmamos las solicitudes
* Nos situamos sobre la SubCA e importamos y firmamos las solicitudes.
```bash
./easyrsa import-req /tmp/client1.req client1
@ -317,20 +333,20 @@ scp ~/EasyRSA/pki/reqs/{client1.req,client2.req,client3.req,client4.req} signer@
./easyrsa sign-req client client4
```
* Devolvemos los certificados válidos a nuestra oVPN
* Devolvemos los certificados válidos a nuestra oVPN.
```bash
scp pki/issued/{client1.crt,client2.crt,client3.crt,client4.crt} ovpn@ovpn.bastionado.es:/tmp
```
* Volvemos a la VPN y copiamos el certificado a nuestro directorio de configuraciones Cliente
* Volvemos a la VPN y copiamos el certificado a nuestro directorio de configuraciones Cliente.
```bash
cp /tmp/{client1.crt,client2.crt,client3.crt,client4.crt} ~/client-configs/keys/
```
* Ahora copiamos el certificado de la SubCA y la Firma HMAC a nuestro directorio de configuraciones Cliente
* Ahora copiamos el certificado de la SubCA y la Firma HMAC a nuestro directorio de configuraciones Cliente.
```bash
exit
@ -338,30 +354,32 @@ exit
sudo cp /etc/openvpn/{ca.crt,ta.key} ~/client-configs/keys/
```
### Configuración de OpenVPN
## Configuración de OpenVPN
Ahora que ya hemos terminado completamente con la Infraestructura de Clave Pública es el momento de configurar el servicio OpenVPN.
> Ahora que ya hemos terminado completamente con la Infraestructura de Clave Pública es el momento de configurar el servicio OpenVPN.
* Comenzamos copiando la configuración de ejemplo y lo editamos
* Comenzamos creando la configuración del servidor desde cero [tomando esta referencia](https://github.com/OpenVPN/openvpn/blob/v2.5.7/sample/sample-config-files/server.conf).
```bash
sudo nano /etc/openvpn/server.conf # sudo vim /etc/openvpn/server.conf
```
* Modificamos el puerto por defecto y mantenemos el uso del protocolo UDP, más rápido y resistente frente a ataques de denegación de servicio
* Modificamos el puerto por defecto y mantenemos el uso del protocolo UDP, más rápido y resistente frente a ataques de denegación de servicio.
```bash
port 6174
proto udp
```
* Especificamos la interfaz de red que se creará de forma explícita como `tun0`
> Trabajaremos con una interfaz tipo `tun`. OpenVPN puede trabajar con interfaces tipo `tun` a nivel de red (Capa 3 OSI) y tipo `tap`, a nivel de enlace (Capa 2 OSI). Si utilizarámos una interfaz de tipo `tap` tendríamos acceso automáticamente a la subred completa del servidor, ya que la interfaz estaría actuando como un `switch`, pero también generaríamos grandes problemas de enrutamiento. Utilizando `tun` estaremos realizando un enlace punto a punto, por lo que, si queremos tener visibilidad de otras redes deberemos añadir otras opciones. Hablaremos más adelante de ellas.
* Especificamos la interfaz de red que se creará de forma explícita como `tun0`.
```bash
dev tun0
```
* Apuntaremos a nuestros certificados generados anteriormente
* Apuntaremos a nuestros certificados generados anteriormente.
```bash
ca ca.crt
@ -369,24 +387,26 @@ cert ovpn.crt
key ovpn.key
```
* Establecemos la directiva `dh` con nuestra clave generada anteriormente
* Establecemos la directiva Diffie-Hellman con nuestra clave generada anteriormente.
```bash
dh dh.pem
```
* Establecemos la subred que se establecerá en las conexiones. El servidor tendrá automáticamente la IP `10.10.10.1`
* Establecemos la subred que se establecerá en las conexiones. El servidor tendrá automáticamente la IP `10.10.10.1`.
```bash
server 10.10.10.0 255.255.255.0
```
* Establecemos un fichero de persistencia para que los clientes vuelvan a tener la misma asignación de IP en caso de una caida del servicio
* Establecemos un fichero de persistencia para que los clientes vuelvan a tener la misma asignación de IP en caso de una caida del servicio.
```bash
ifconfig-pool-persist /var/log/openvpn/ipp.txt
```
> Como comentamos anteriormente, al utilizar `tun`, si queremos que los clientes puedan ver algo más que al servidor deberemos habilitar enrutamientos. Supongamos que oVPN se encuentra conectado a una sub red tipo `192.168.128.0/24` y queremos que los clientes tengan conectvidad. En este caso deberíamos añadir la siguiente directiva: `push "route 192.168.128.0 255.255.255.0"`. Además, si nuestro servidor VPN no es la puerta de enlace de esta subred deberemos añadir un enrutamiento (con nftables, por ejemplo) en ésta para que redirija el tráfico de `10.10.10.0/24` hacia la IP de oVPN
> `def1` Modifica la tabla de enrutamiento de los clientes para redirigir todo el tráfico hacia la intrerfaz VPN.
> `bypass-dhcp` Añade una ruta directa al servidor DHCP de OpenVPN
@ -403,7 +423,7 @@ push "dhcp-option DNS 1.1.1.1"
push "dhcp-option DNS 1.0.0.1"
```
* Establecemos una directiva para consultar que los clientes siguen conectados cada 10 segundos y se consideran desconectados si no responden en 2 minutros.
* Establecemos una directiva para consultar que los clientes siguen conectados cada 10 segundos y se consideran desconectados si no responden en 2 minutos.
```bash
keepalive 10 120
@ -411,29 +431,29 @@ keepalive 10 120
> La directiva `tls-auth` añade una capa adicional de autenticación HMAC sobre el canal de control TLS para mitigar los ataques DoS y los ataques a la pila TLS. En pocas palabras, --tls-auth habilita una especie de "cortafuegos HMAC" en el puerto TCP/UDP de OpenVPN, donde los paquetes del canal de control TLS que lleven una firma HMAC incorrecta pueden ser descartados inmediatamente sin respuesta.
* Nos aseguramos de que `tls-auth` está habilitado (debemos eliminar el `;` inicial si existe)
* Nos aseguramos de que `tls-auth` está habilitado .
```bash
tls-auth ta.key 0 # This file is secret
```
> La directiva `cipher` cifra los paquetes del canal de datos con el algoritmo de cifrado `alg`.El valor por defecto es `BF-CBC`, una abreviatura de [Blowfish en modo Cipher Block Chaining](https://cryptopp.com/wiki/Blowfish). Ya no se recomienda el uso de BF-CBC, debido a su tamaño de bloque de 64 bits. Este pequeño tamaño de bloque permite realizar ataques basados en colisiones, como ha demostrado [SWEET32](https://sweet32.info/#CBC). Nos pasaremos al cifrado [AES en modo Cipher Block Chaining](https://cryptopp.com/wiki/Advanced_Encryption_Standard) con bloques de 256 bits.
> La directiva `cipher` cifra los paquetes del canal de datos con el algoritmo de cifrado `alg`.El valor por defecto es `BF-CBC`, una abreviatura de [Blowfish en modo Cipher Block Chaining](https://cryptopp.com/wiki/Blowfish). Ya no se recomienda el uso de BF-CBC, debido a su tamaño de bloque de 64 bits. Este pequeño tamaño de bloque permite realizar ataques basados en colisiones, como ha demostrado [SWEET32](https://sweet32.info/#CBC). Nos pasaremos al cifrado [AES en modo Cipher Block Chaining](https://cryptopp.com/wiki/Advanced_Encryption_Standard) con bloques de 256 bits. En cualquier caso, este será el cifrado de referencia, si tanto el cliente como el servidor soportan métodos más rápidos y modernos cambiarán automáticamente a éstos, por ejemplo `AES-256-GCM`.
* Escogemos el cifrado `AES-256-CBC` que ofrece un buen nivel de seguridad
* Escogemos el cifrado `AES-256-CBC` que ofrece un buen nivel de seguridad.
```bash
cipher AES-256-CBC
```
> La directiva `auth` Autentica los paquetes del canal de datos y (si está habilitado) los paquetes del canal de control `tls-auth` con HMAC utilizando el algoritmo de resumen de mensajes alg. (El valor predeterminado es `SHA1` ). HMAC es un algoritmo de autenticación de mensajes (MAC) de uso común que utiliza una cadena de datos, un algoritmo hash seguro y una clave, para producir una firma digital.El protocolo de canal de datos de OpenVPN utiliza encrypt-then-mac (es decir, primero encripta un paquete y luego HMAC el texto cifrado resultante), lo que evita los ataques de oráculo de relleno.
> La directiva `auth` Autentica los paquetes del canal de datos y (si está habilitado) los paquetes del canal de control `tls-auth` con HMAC utilizando el algoritmo de resumen de mensajes `alg`. (El valor predeterminado es `SHA1` ). HMAC es un algoritmo de autenticación de mensajes (MAC) de uso común que utiliza una cadena de datos, un algoritmo hash seguro y una clave, para producir una firma digital.El protocolo de canal de datos de OpenVPN utiliza encrypt-then-mac (es decir, primero encripta un paquete y luego HMAC el texto cifrado resultante), lo que evita los ataques padding oracle.
* Justo debajo añadimos la directiva `auth`
* Justo debajo añadimos la directiva `auth`.
```bash
auth SHA512
```
* Haremos que el servicio OpenVPN se ejecute con el usuario `nobody` y grupo `nogroup` descomentando estos valores
* Haremos que el servicio OpenVPN se ejecute con el usuario `nobody` y grupo `nogroup` descomentando estos valores.
```bash
user nobody
@ -447,35 +467,37 @@ persist-key
persist-tun
```
* Escribimos el estado (un resumen de las conexiones) cada minuto en un fichero
* Escribimos el estado (un resumen de las conexiones) cada minuto en un fichero.
```bash
status /var/log/openvpn/openvpn-status.log
```
* También escribimos un fichero de registro que se mantendrá entre sesiones
* También escribimos un fichero de registro que se mantendrá entre sesiones.
```bash
log-append /var/log/openvpn/openvpn.log
```
* Establecemos el nivel de detalle que va desde 0 (nada) a 9 (ultra detallado)
* Establecemos el nivel de detalle que va desde 0 (nada) a 9 (ultra detallado).
```bash
verb 3
```
* Informamos a los clientes ante un reinio del servidor para que puedan reconectar posterirmente
* Informamos a los clientes ante un reinio del servidor para que puedan reconectar posterirmente.
```bash
explicit-exit-notify 1
```
* [Referencia de configuración de OpenVPN servidor](/assets/files/openvpn-server/server.conf)
* [Referencia de configuración de OpenVPN servidor](/assets/files/openvpn-server/server.conf).
### Directivas adicionales
## Directivas adicionales
* Habilitar la redirección de tráfico
> Tanto si habilitamos el enrutamiento de subredes como si hacemos que todo el tráfico de los clientes pase a través de la VPN deberemos permitir que nuestro servidor VPN realice redirección de tráfico.
* Habilitar la redirección de tráfico.
```bash
sudo nano /etc/sysctl.conf # sudo vim /etc/sysctl.conf
@ -485,45 +507,45 @@ net.ipv4.ip_forward=1 # Descomentar esta línea
sudo sysctl -w net.ipv4.ip_forward=1
```
### Puesta en funcionamiento del servicio
## Puesta en funcionamiento del servicio
* Arrancar y comprobar el estado del servicio OpenVPN
* Arrancar y comprobar el estado del servicio OpenVPN.
```bash
sudo systemctl restart openvpn@server && sudo systemctl status openvpn@server
```
* Comprobar la existencia de la intefaz virtual de OpenVPN
* Comprobar la existencia de la intefaz virtual de OpenVPN.
```bash
ip addr show tun0
```
* Habilitar el arranque automático de OpenVPN
* Habilitar el arranque automático de OpenVPN.
```bash
sudo systemctl enable openvpn@server
```
## Configuración para el cliente
# Configuración para el cliente
### Plantilla de cliente
## Plantilla de cliente
Ahora que ya tenemos nuestra VPN funcionando es el momento de generar la configuración que los clientes importarán para poder conectar a nuestra VPN.
> Ahora que ya tenemos nuestra VPN funcionando es el momento de generar la configuración que los clientes importarán para poder conectar a nuestra VPN.
* Comenzamos creando en nuestro directorio de configuración de clientes un directorio donde almacenar la configuración individual
* Comenzamos creando en nuestro directorio de configuración de clientes un directorio donde almacenar la configuración individual.
```bash
mkdir -p ~/client-configs/files
```
* Copiamos la plantilla de configuración de cliente por defecto y procedemos a editarla
* Creamos la plantilla de configuración de cliente por defecto utilizando [esta referencia](https://github.com/OpenVPN/openvpn/blob/v2.5.7/sample/sample-config-files/client.conf).
```bash
nano ~/client-configs/base.conf # vim ~/client-configs/base.conf
```
* Especificamos que estamos ante un fichero cliente
* Especificamos que estamos ante un fichero cliente.
```bash
client
@ -579,23 +601,23 @@ persist-tun
remote-cert-tls server
```
* Establecemos las mismas directivas `cipher` y `auth` que establecimos en el servidor
* Establecemos las mismas directivas `cipher` y `auth` que establecimos en el servidor.
```bash
cipher AES-256-CBC
auth SHA512
```
* Establecemos el nivel de detalle que va desde 0 (nada) a 9 (ultra detallado)
* Establecemos el nivel de detalle que va desde 0 (nada) a 9 (ultra detallado).
```bash
verb 3
```
> La directiva `key-direction` establece una forma alternativa de especificar el parámetro opcional de dirección para las opciones `tls-auth` y `secret`, Es útil cuando se utilizan ficheros incrustados.
> La directiva `key-direction` establece una forma alternativa de especificar el parámetro opcional de dirección para las opciones `tls-auth` y `secret`, Es útil cuando se utilizan ficheros incrustados, como será nuestro caso.
* Establecemos la directiva `key-direction`
* Establecemos la directiva `key-direction`.
```bash
key-direction 1
@ -603,17 +625,17 @@ key-direction 1
* [Referencia de configuración de OpenVPN cliente](/assets/files/openvpn-server/client.conf)
### Script de configuración de clientes
## Script de configuración de clientes
Generaremos un script que se encargará de crear un fichero incrustado con la configuración de conexión plantilla y los certificados apropiados para cada cliente.
> Generaremos un script que se encargará de crear un fichero incrustado con la configuración de conexión plantilla y los certificados apropiados para cada cliente.
* Creamos el script
* Creamos el script.
```bash
nano ~/client-configs/make_config.sh # vim ~/client-configs/make_config.sh
```
* Añadimos el siguiente código al script
* Añadimos el siguiente código al script.
```bash
#!/bin/bash
@ -637,13 +659,13 @@ cat ${BASE_CONFIG} \
> ${OUTPUT_DIR}/bastionado-${1}.ovpn
```
* Establecemos los permisos de ejecución
* Establecemos los permisos de ejecución.
```bash
chmod 700 ~/client-configs/make_config.sh
```
* Y ahora ya podemos generar el fichero de configuración para nuestros clientes
* Y ahora ya podemos generar el fichero de configuración para nuestros clientes.
```bash
cd ~/client-configs
@ -656,12 +678,18 @@ sudo ./make_config.sh client4
* Los fichero resultantes, `bastionado-client{1,2,3}.ovpn` deberán entregarse a los clientes para que éstos puedan conectar a la VPN.
## Habilitando el forwarding en nftables
# Habilitando el forwarding en nftables
> Como hemos visto, nuestra VPN recibirá todo el tráfico de los clientes, por lo que si queremos que éstos puedan tener salida a internet debemos redirigir su tráfico desde la interfaz `tun` hacia la interfaz de salida de nuestro servidor. Para ello, haremos uso de `NetFilter Tables`.
* Editamos el fichero de configuración de Net Filter Tables.
```bash
sudo vim /etc/nftables.conf
```
* Aparte de unas reglas básicas de seguridad, en esta configuración encontramos la aceptación del tráfico entrante por el puerto que hemos configurado para el servidor de OpenVPN y el enrutamiento del tráfico de OpenVPN hacia la interfaz de salida en la cadena de post enrutamiento.
```bash
#!/usr/sbin/nft -f
@ -718,15 +746,19 @@ table ip nat {
}
```
* Ahora solo nos queda reiniciar el servicio, comprobar que ha levantado correctamente y habilitar su inicio automático.
```bash
sudo systemctl restart nftables.service && sudo systemctl status nftables.service
sudo systemctl enable nftables.service
```
### Revocación de clientes
# Revocación de clientes
* Desde la SubCA
> El sistema de autenticación que hemos establecido utiliza certificados que deben ser renovados para los clientes cada dos meses, pero, ¿qué ocurre si queremos que un cliente deje de poder conectar a los 15 días de expedir su certificado? Para este escensario deberemos generar una Lista de revocación de certificados.
* Vayamos, por tanto, a nuestra SubCA y revoquemos uno de los clientes.
```bash
cd ~/EasyRSA
@ -734,6 +766,8 @@ cd ~/EasyRSA
./easyrsa revoke client4
```
* Con el certificado ya revocado es el momento de generar nuestra lista de revocación, que posteriormente copiaremos al servidor oVPN.
```bash
./easyrsa gen-crl
```
@ -742,6 +776,8 @@ cd ~/EasyRSA
scp ~/EasyRSA/pki/crl.pem ovpn@ovpn.bastionado.es:/tmp
```
* Ahora moveremos la CRL a la instalación de OpenVPN y añadiremos la directiva `crl-verify` apuntando a nuestra lista.
```bash
sudo mv /tmp/crl.pem /etc/openvpn