---
title: OpenVPN - Servidor
description: Tutorial de instalación del Servidor OpenVPN
published: true
date: 2022-06-02T10:21:20.220Z
tags: vpn, servidor, debian
editor: markdown
dateCreated: 2022-05-18T16:48:57.246Z
---
# Requisitos
* **[Debian 11 “bullseye”](https://www.debian.org/releases/bullseye/)**
* **Usuario con privilegios `sudo`**
# EasyRSA
## Instalación de EasyRSA (en CA, Signer y oVPN)
* 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.
```bash
cd ~
tar xvf EasyRSA-3.1.0.tgz
mv EasyRSA-3.1.0 EasyRSA
cd EasyRSA
```
## Configuración de EasyRSA (en CA, Signer y oVPN)
* 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
```
* Editaremos este fichero para dejar nuestras propiedades personalizadas
```bash
nano vars # o vim vars
```
* Establecemos unos valores apropiados de la organización
```bash
set_var EASYRSA_REQ_COUNTRY "ES"
set_var EASYRSA_REQ_PROVINCE "Valladolid"
set_var EASYRSA_REQ_CITY "Valladolid"
set_var EASYRSA_REQ_ORG "Bastionado"
set_var EASYRSA_REQ_EMAIL "admin@bastionado.es"
set_var EASYRSA_REQ_OU "Community"
```
* Utilizaremos criptografía de curva elíptica para el cifrado, concretamente una [Curva Edwards](https://en.wikipedia.org/wiki/Edwards_curve)
```bash
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ún [SafeCurves](https://safecurves.cr.yp.to/)
```bash
set_var EASYRSA_CURVE ed25519
```
* Establecemos tiempos de expiración
```bash
set_var EASYRSA_CA_EXPIRE 7090 # La CA durará 20 años
set_var EASYRSA_CERT_EXPIRE 180 # Los certificados cliente caducan cada 6 meses
set_var EASYRSA_CRL_DAYS 90 # La lista de revocaciones se actualiza aproximadamente cada 3 meses
set_var EASYRSA_CERT_RENEW 20 # Los certificados se pueden renovar con 20 días de antelación
```
* [Referencia de variables de EasyRSA](/assets/files/openvpn-server/easyrsa-vars)
## Creación de 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.
```bash
mv vars pki/vars
```
* Generamos nuestra CA.
```bash
./easyrsa build-ca # Podríamos añadir 'nopass' para no establecer una Passphrase
```
## Creación de SubCA en Signer
* 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.
```bash
mv vars pki/vars
```
* Generamos la solicitud de nuestra SubCA.
```bash
./easyrsa build-ca subca
```
* 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.
```bash
./easyrsa import-req /tmp/ca.req signer
./easyrsa sign-req ca signer
```
* Devolvemos el certificado encadenado de la CA con la SubCA válido a nuestra SubCA.
```bash
cat pki/issued/signer.crt \
pki/ca.crt \
> /tmp/signer.crt
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.
```bash
mv /tmp/signer.crt ~/EasyRSA/pki/ca.crt
```
## Creación de Certificado 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.
```bash
mv vars pki/vars
```
* 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.
```bash
scp ~/EasyRSA/pki/reqs/ovpn.req signer@signer.bastionado.es:/tmp
```
* Nos situamos sobre la SubCA e importamos y firmamos la solicitud.
```bash
./easyrsa import-req /tmp/ovpn.req ovpn
./easyrsa sign-req server ovpn
```
* 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
## Instalación de dependencias OpenVPN
* Comenzaremos actualizando nuestro repositorio `apt`.
```bash
sudo apt update
```
* 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 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.
```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.
```bash
sudo apt update
```
* Y ya podemos proceder con la instalación de OpenVPN.
```bash
sudo apt -y install openvpn
```
## Explicación de certificados, claves y encriptado
> 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/
sudo cp /tmp/ovpn.crt ~/EasyRSA/pki/ovpn.crt
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.
```bash
cd ~/EasyRSA/
./easyrsa --keysize=4096 gen-dh
```
> 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.
```bash
sudo openvpn --genkey secret ta.key
```
* 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
> 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.
```bash
mkdir -p ~/client-configs/keys
chmod -R 700 ~/client-configs
```
* Volvemos a la ruta de EasyRSA para generar la solicitud de certificado cliente.
```bash
cd ~/EasyRSA/
./easyrsa gen-req client1 nopass
./easyrsa gen-req client2 nopass
./easyrsa gen-req client3 nopass
./easyrsa gen-req client4 nopass
```
* 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.
```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.
```bash
./easyrsa import-req /tmp/client1.req client1
./easyrsa import-req /tmp/client2.req client2
./easyrsa import-req /tmp/client3.req client3
./easyrsa import-req /tmp/client4.req client4
./easyrsa sign-req client client1
./easyrsa sign-req client client2
./easyrsa sign-req client client3
./easyrsa sign-req client client4
```
* 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.
```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.
```bash
exit
sudo cp /etc/openvpn/{ca.crt,ta.key} ~/client-configs/keys/
```
## 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.
* 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.
```bash
port 6174
proto udp
```
> 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.
```bash
ca ca.crt
cert ovpn.crt
key ovpn.key
```
* 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`.
```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.
```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
* Forzaremos que todo el tráfico de los clientes sea redirigido por la VPN.
```bash
push "redirect-gateway def1 bypass-dhcp"
```
* Establecemos los servidores DNS.
```bash
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 minutos.
```bash
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 .
```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. 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.
```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 padding oracle.
* 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.
```bash
user nobody
group nogroup
```
* Las opciones de persistencia tratarán de evitar el acceso a ciertos recursos en el reinicio que pueden dejar de ser accesibles debido a la reducción de privilegios.
```bash
persist-key
persist-tun
```
* 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.
```bash
log-append /var/log/openvpn/openvpn.log
```
* 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.
```bash
explicit-exit-notify 1
```
* [Referencia de configuración de OpenVPN servidor](/assets/files/openvpn-server/server.conf).
## Directivas adicionales
> 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
net.ipv4.ip_forward=1 # Descomentar esta línea
sudo sysctl -w net.ipv4.ip_forward=1
```
## Puesta en funcionamiento del servicio
* 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.
```bash
ip addr show tun0
```
* Habilitar el arranque automático de OpenVPN.
```bash
sudo systemctl enable openvpn@server
```
# Configuración para el 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.
* Comenzamos creando en nuestro directorio de configuración de clientes un directorio donde almacenar la configuración individual.
```bash
mkdir -p ~/client-configs/files
```
* 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.
```bash
client
```
* Configuramos el modo de interfaz igual que en el servidor.
```bash
dev tun
```
* Hacemos lo mismo con el protocolo.
```bash
proto udp
```
* Establecemos la IP y puerto de nuestro servidor VPN.
```bash
remote ovpn.bastionado.es 6174
```
* Intentamos que el intento de resolución de nombre del servidor VPN sea infinita, útil para equipos que no están permanentemente conectados a internet.
```bash
resolv-retry infinite
```
* Con la siguiente directiva hacemos que el puerto local de salida sea dinámico.
```bash
nobind
```
* Realizamos un descenso de privilegios después de inicializar en sistemas que no son Windows.
```bash
user nobody
group nogroup
```
* Intentamos persistir los siguientes valores entre reinicios.
```bash
persist-key
persist-tun
```
* Realizamos verificación del certificado del servidor y sus usos extendidos.
```bash
remote-cert-tls server
```
* 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).
```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, como será nuestro caso.
* Establecemos la directiva `key-direction`.
```bash
key-direction 1
```
* [Referencia de configuración de OpenVPN cliente](/assets/files/openvpn-server/client.conf)
## 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.
* Creamos el script.
```bash
nano ~/client-configs/make_config.sh # vim ~/client-configs/make_config.sh
```
* Añadimos el siguiente código al script.
```bash
#!/bin/bash
# First argument: Client identifier
KEY_DIR=/home/ovpn/client-configs/keys
OUTPUT_DIR=/home/ovpn/client-configs/files
BASE_CONFIG=/home/ovpn/client-configs/base.conf
cat ${BASE_CONFIG} \
<(echo -e '') \
${KEY_DIR}/ca.crt \
<(echo -e '\n') \
${KEY_DIR}/${1}.crt \
<(echo -e '\n') \
${KEY_DIR}/${1}.key \
<(echo -e '\n') \
${KEY_DIR}/ta.key \
<(echo -e '') \
> ${OUTPUT_DIR}/bastionado-${1}.ovpn
```
* 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.
```bash
cd ~/client-configs
sudo ./make_config.sh client1
sudo ./make_config.sh client2
sudo ./make_config.sh client3
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
> 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
flush ruleset
define vpn_port=6174
define vpn_if=tun0
define outside_if=enp0s17
define vpn_subnet=10.10.10.0/24
table inet filter {
chain input {
# allow OpenVPN VPN connections to the Server
udp dport $vpn_port accept
}
chain forward {
#Drop forwarded packets if they are not matched
type filter hook forward priority 0; policy drop;
# allow existing connections
ct state related,established accept
# allow packets from vpn interface
iifname $vpn_if oifname $outside_if accept
}
chain output {
# Security drops
ct state invalid counter drop
oifname != "lo" ip saddr != 127.0.0.1 ip daddr != 127.0.0.1 tcp flags & (fin|ack) == fin|ack counter drop
oifname != "lo" ip saddr != 127.0.0.1 ip daddr != 127.0.0.1 tcp flags & (rst|ack) == rst|ack counter drop
}
}
# create a ipv4 table only for NAT entries (you need both chains even if they're empty)
table ip nat {
chain postrouting {
type nat hook postrouting priority 100;
# enable NAT for VPN
iifname $vpn_if oifname $outside_if ip saddr $vpn_subnet masquerade
}
chain prerouting {
type nat hook prerouting priority 0;
}
}
```
* [Referencia de configuración de Net Filter Tables](/assets/files/openvpn-server/nftables.conf).
* 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
> 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
./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
```
```bash
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
sudo vim /etc/openvpn/server.conf
crl-verify crl.pem
```
[Referencia de configuración de OpenVPN servidor con CRL](/assets/files/openvpn-server/server-crl.conf)
* Arrancar y comprobar el estado del servicio OpenVPN.
```bash
sudo systemctl restart openvpn@server && sudo systemctl status openvpn@server
```
* Revisar el registro para comprobar que se está aplicando la CRL cuando un cliente intenta conectar.
```bash
sudo tail -f /var/log/openvpn/openvpn.log
```
# OpenVPN + TOR
> Ya que todo el tráfico de los clientes se enruta a través de la VPN, ¿Y si les damos la posibilidad de que puedan conectar a una VPN que además enrute todo su tráfico a través de nodos TOR? Sus comunicaciones quederán ocultas y podremos escoger el nodo de salida, haciendo que tanto la dirección de los clientes como del servidor queden ocultas.
## Configuración de OpenVPN
* Copiaremos nuestra configuración de servidor OpenVPN.
```bash
sudo cp /etc/openvpn/server.conf /etc/openvpn/tor.conf
```
* La editamos.
```bash
sudo vim /etc/openvpn/tor.conf
```
* Modificamos algunos valores para poder establecer el servicio VPN alternativo.
```bash
port 6175
dev tun1
server 10.10.20.0 255.255.255.0
ifconfig-pool-persist /var/log/openvpn/ipp-tor.txt
push "dhcp-option DNS 10.10.20.1"
push "dhcp-option DNS 1.1.1.1"
status /var/log/openvpn/openvpn-status-tor.log
log-append /var/log/openvpn/openvpn-tor.log
```
[Referencia de configuración de OpenVPN TOR](/assets/files/openvpn-server/tor.conf)
## Puesta en funcionamiento del servicio OpenVPN TOR
* Arrancar y comprobar el estado del servicio OpenVPN
```bash
sudo systemctl restart openvpn@tor && sudo systemctl status openvpn@tor
```
* Comprobar la existencia de la intefaz virtual de OpenVPN
```bash
ip addr show tun1
```
* Habilitar el arranque automático de OpenVPN
```bash
sudo systemctl enable openvpn@tor
```
## Habilitando TOR
* Instalamos TOR.
```bash
sudo apt install tor -y
```
* Editamos su fichero de configuración.
```bash
sudo vim /etc/tor/torrc
```
> Configuraremos la resolución de dominios `onion` y `exit` y la resolución DNS y HTTP a la dirección IP que tiene nuestra interfaz `tun1`.
>
> Por otra parte, solicitaremos que el nodo de salida de TOR sea a través de un servidor de los Estados Unidos.
```bash
VirtualAddrNetwork 10.192.0.0/10
AutomapHostsOnResolve 1
AutomapHostsSuffixes .onion,.exit
DNSPort 10.10.20.1:53530
TransPort 10.10.20.1:9040
ExitNodes {us} StrictNodes 1
```
* Levantamos nuestro servicio TOR y comprobamos que todo funciona correctamente.
```bash
sudo systemctl restart tor.service && sudo systemctl status tor.service
sudo netstat -tulpen | grep tor
```
* Habilitamos el inicio automático del servicio.
```bash
sudo systemctl enable tor.service
```
## Nftables con TOR
> Ahora deberemos modificar nuestras Net Filter Tables para que en la cadena de pre enrutamiento el tráfico de nuestra segunda VPN se redirija hacia los nodos TOR, estableciendo así un proxy transparente que redirigirá todo el tráfico de los clientes que conecten en esta modalidad.
* Limpiamos la configuración de nftables para pegar la nueva.
```bash
sudo dd if=/dev/null of=/etc/nftables.conf && sudo vim /etc/nftables.conf
```
```bash
#!/usr/sbin/nft -f
flush ruleset
define vpn_port=6174
define vpn_if=tun0
define outside_if=enp0s17
define vpn_subnet=10.10.10.0/24
define vpn_port_tor=6175
define vpn_if_tor=tun1
define vpn_subnet_tor=10.10.20.0/24
table inet filter {
chain input {
# allow OpenVPN connections to the Server
udp dport $vpn_port accept
# allow OpenVPN TOR connections to the Server
udp dport $vpn_port_tor accept
}
chain forward {
#Drop forwarded packets if they are not matched
type filter hook forward priority 0; policy drop;
# allow existing connections
ct state related,established accept
# allow packets from vpn interface
iifname $vpn_if oifname $outside_if accept
# allow packets from vpn interface
iifname $vpn_if_tor oifname $outside_if accept
}
chain output {
## Transproxy leak blocked:
# https://trac.torproject.org/projects/tor/wiki/doc/TransparentProxy#WARNING
ct state invalid counter drop
oifname != "lo" ip saddr != 127.0.0.1 ip daddr != 127.0.0.1 tcp flags & (fin|ack) == fin|ack counter drop
oifname != "lo" ip saddr != 127.0.0.1 ip daddr != 127.0.0.1 tcp flags & (rst|ack) == rst|ack counter drop
}
}
# create a ipv4 table only for NAT entries (you need both chains even if they're empty)
table ip nat {
chain postrouting {
type nat hook postrouting priority 100;
# enable NAT for VPN
iifname $vpn_if oifname $outside_if ip saddr $vpn_subnet masquerade
# enable NAT for TOR VPN
iifname $vpn_if_tor oifname $outside_if ip saddr $vpn_subnet_tor masquerade
}
chain prerouting {
# Transparent proxy to TOR
type nat hook prerouting priority 0;
iifname $vpn_if_tor ip saddr $vpn_subnet_tor udp dport 53 counter dnat to 10.10.20.1:53530
iifname $vpn_if_tor ip protocol tcp ip saddr $vpn_subnet_tor counter dnat to 10.10.20.1:9040
iifname $vpn_if_tor ip protocol udp ip saddr $vpn_subnet_tor counter dnat to 10.10.20.1:9040
}
}
```
* [Referencia de configuración de Net Filter Tables con TOR](/assets/files/openvpn-server/nftables-tor.conf).
* Reiniciamos nuestro servicio y comprobamos que todo funciona correctamente.
```bash
sudo systemctl restart nftables.service && sudo systemctl status nftables.service
```
## Configuración de script de cliente
* Copiamos la configuración y script de clientes base para personalizarlos para TOR.
```bash
cp ~/client-configs/base.conf ~/client-configs/base-tor.conf
cp ~/client-configs/make_config.sh ~/client-configs/make_config_tor.sh
```
* Modificamos la configuración y script de generación de configuraciones cliente para la variante TOR.
```bash
nano ~/client-configs/base-tor.conf # vim ~/client-configs/base-tor.conf
```
* En base-tor solo cambiaremos el puerto de destino.
```bash
remote ovpn.bastionado.es 6175
```
* Ahora modificamos el script de generación de clientes.
```bash
nano ~/client-configs/make_config_tor.sh # vim ~/client-configs/make_config_tor.sh
```
```bash
#!/bin/bash
# First argument: Client identifier
KEY_DIR=/home/ovpn/client-configs/keys
OUTPUT_DIR=/home/ovpn/client-configs/files
BASE_CONFIG=/home/ovpn/client-configs/base-tor.conf
cat ${BASE_CONFIG} \
<(echo -e '') \
${KEY_DIR}/ca.crt \
<(echo -e '\n') \
${KEY_DIR}/${1}.crt \
<(echo -e '\n') \
${KEY_DIR}/${1}.key \
<(echo -e '\n') \
${KEY_DIR}/ta.key \
<(echo -e '') \
> ${OUTPUT_DIR}/bastionado-tor-${1}.ovpn
```
* Y ahora ya podemos generar nuestros ficheros `ovpn` TOR para nuestros clientes.
```bash
cd ~/client-configs
sudo ./make_config_tor.sh client1
sudo ./make_config_tor.sh client2
sudo ./make_config_tor.sh client3
sudo ./make_config_tor.sh client4
```
# Landing Page para clientes
> Nuestra PKI y nuestro servidor VPN están listos para recibir a clientes, sin embargo, para que esto ocurra los clientes deberían recibir sus ficheros de configuración.
>
> Para esto, levantaremos un pequeño servidor Web que ponga a disposición de los clientes, mediante una autenticación básica, los ficheros de configuración.
## Instalación de NginX
* Utilizamos el repositorio del desarrollador de Debian Ondřej Surý para tener una versión más actualizada y compatible de NginX que la que incorpora Debian por defecto.
```bash
curl -sSL https://packages.sury.org/nginx/README.txt | sudo bash -x
```
* Ahora ya podemos actualizar la información de repositorios.
```bash
sudo apt update
```
* Y proceder a instalar todos los paquetes de NginX. Instalaremos adicionalmente `apache2-utils` para poder generar ficheros de autenticación básica `htpasswd`.
```bash
sudo apt install nginx-core nginx-common nginx nginx-full apache2-utils
```
## Configuración de NginX
* Generaremos ahora los ficheros de autenticación básica `htpasswd`. Cada cliente dispondrá de un usuario y clave únicos.
```bash
cd /var/www
sudo htpasswd -c .htpasswd1 client1
sudo htpasswd -c .htpasswd2 client2
sudo htpasswd -c .htpasswd3 client3
sudo htpasswd -c .htpasswd4 client4
```
* Es el momento de configurar NginX. Modificamos el fichero de configuración vaciándolo primero.
```bash
sudo dd if=/dev/null of=/etc/nginx/nginx.conf && sudo vim /etc/nginx/nginx.conf
```
* Establecemos unas opciones de configuración básicas, ocultando la información de versión de NginX.
```bash
user www-data;
worker_processes auto;
pid /run/nginx.pid;
include /etc/nginx/modules-enabled/*.conf;
events {
worker_connections 768;
}
http {
sendfile on;
tcp_nopush on;
types_hash_max_size 2048;
server_tokens off;
include /etc/nginx/mime.types;
default_type application/octet-stream;
access_log /var/log/nginx/access.log;
error_log /var/log/nginx/error.log;
gzip on;
include /etc/nginx/conf.d/*.conf;
include /etc/nginx/sites-enabled/*;
}
```
* [Referencia de configuración de NginX](/assets/files/openvpn-server/nginx.conf)
* Ahora configuraremos la aplicación web. Modificamos el servidor por defecto vaciándolo primero.
```bash
sudo dd if=/dev/null of=/etc/nginx/sites-available/default && sudo vim /etc/nginx/sites-available/default
```
* Utilizaremos una configuración básica escuchando por HTTP ya que, en realidad, este NginX no recibirá las solicitudes directas de internet, si no que éstas vendrán redireccionadas desde otro NginX que proporciona balanceo de carga y la seguridad necesaria para poder servir una aplicación web con garantías. Aquí es donde estableceremos la autenticación básica en las rutas de descarga de certificados de los diferentes clientes.
```bash
server {
listen 80 default_server;
listen [::]:80 default_server;
root /var/www/html;
index index.html;
server_name _;
location /download/client1 {
try_files $uri $uri/ =404;
auth_basic "Client Area";
auth_basic_user_file /var/www/.htpasswd1;
}
location /download/client2 {
try_files $uri $uri/ =404;
auth_basic "Client Area";
auth_basic_user_file /var/www/.htpasswd2;
}
location /download/client3 {
try_files $uri $uri/ =404;
auth_basic "Client Area";
auth_basic_user_file /var/www/.htpasswd2;
}
location /download/client4 {
try_files $uri $uri/ =404;
auth_basic "Client Area";
auth_basic_user_file /var/www/.htpasswd4;
}
}
```
* [Referencia de sitio web de NginX](/assets/files/openvpn-server/default-site-nginx.conf)
## Instalación de Sitio Web
* Con la configuración de NginX ya preparada tenemos que desplegar los ficheros de nuestra aplicación web. Para ello, primero descargaremos estos ficheros.
```bash
sudo wget -P /tmp https://wiki.bastionado.es/assets/files/openvpn-server/bastionado-vpn.tar
```
[Sitio web](/assets/files/openvpn-server/bastionado-vpn.tar)
* Descomprimimos los ficheros de la aplicación en el directorio desde el que la serviremos.
```bash
sudo tar -xvf /tmp/bastionado-vpn.tar -C /var/www/html
```
* Y ahora copiaremos todas las configuraciones cliente a las diferentes rutas de servicio.
```bash
sudo cp /home/ovpn/client-configs/files/bastionado-client1.ovpn /var/www/html/download/client1
sudo cp /home/ovpn/client-configs/files/bastionado-client2.ovpn /var/www/html/download/client2
sudo cp /home/ovpn/client-configs/files/bastionado-client3.ovpn /var/www/html/download/client3
sudo cp /home/ovpn/client-configs/files/bastionado-client4.ovpn /var/www/html/download/client4
sudo cp /home/ovpn/client-configs/files/bastionado-tor-client1.ovpn /var/www/html/download/client1
sudo cp /home/ovpn/client-configs/files/bastionado-tor-client2.ovpn /var/www/html/download/client2
sudo cp /home/ovpn/client-configs/files/bastionado-tor-client3.ovpn /var/www/html/download/client3
sudo cp /home/ovpn/client-configs/files/bastionado-tor-client4.ovpn /var/www/html/download/client4
```
* Lo siguiente que debemos hacer es otorgar la posesión de los ficheros al usuario y grupo que utilizará NginX y establecer los permisos correctos.
```bash
sudo chown -R www-data:www-data /var/www
sudo find /var/www -type f -print0|sudo xargs -0 chmod 660
sudo find /var/www -type d -print0|sudo xargs -0 chmod 770
```
* Comprobaremos que toda la configuración de NginX es correcta y después arrancaremos y habilitaremos el inicio automático del servicio.
```bash
sudo nginx -T
sudo systemctl restart nginx.service && sudo systemctl status nginx.service
sudo systemctl enable nginx.service
```