---
title: OpenVPN - Servidor
description: Tutorial de instalación del Servidor OpenVPN
published: true
date: 2022-05-31T21:58:03.580Z
tags: vpn, servidor, debian
editor: markdown
dateCreated: 2022-05-18T16:48:57.246Z
---
# OpenVPN
## 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 y nuestro Signer
```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)
* Inicialmente tendremos un fichero `vars.example` que utilizaremos como base
```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çun [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 PGP del repositorio de OpenVPN
```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
```
### 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
Cona 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 copiando la configuración de ejemplo y lo editamos
```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
```
* 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 `dh` 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
```
> `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 minutros.
```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 (debemos eliminar el `;` inicial si existe)
```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.
* 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.
* 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
* 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
```
* Copiamos la plantilla de configuración de cliente por defecto y procedemos a editarla
```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 directa 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.
* 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 `client1`
```bash
cd ~/client-configs
sudo ./make_config.sh client1
sudo ./make_config.sh client2
sudo ./make_config.sh client3
sudo ./make_config.sh client3
```
* 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
```bash
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
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;
}
}
```
```bash
sudo systemctl restart nftables.service && sudo systemctl status nftables.service
sudo systemctl enable nftables.service
```
### Revocación de clientes
* Desde la SubCA
```bash
cd ~/EasyRSA
./easyrsa revoke client4
```
```bash
./easyrsa gen-crl
```
```bash
scp ~/EasyRSA/pki/crl.pem ovpn@ovpn.bastionado.es:/tmp
```
```bash
sudo mv /tmp/crl.pem /etc/openvpn
sudo vim /etc/openvpn/server.conf
```
```bash
sudo mv /tmp/crl.pem /etc/openvpn
sudo vim /etc/openvpn/server.conf
crl-verify crl.pem
```
* 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
### Configuración de OpenVPN
```bash
sudo cp /etc/openvpn/server.conf /etc/openvpn/tor.conf
```
```bash
sudo vim /etc/openvpn/tor.conf
```
```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
```
### Puesta en funcionamiento del servicio
* 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
```bash
sudo apt install tor -y
sudo vim /etc/tor/torrc
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
sudo systemctl restart tor.service
sudo netstat -tulpen | grep tor
```
```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
}
}
```
```bash
sudo systemctl restart nftables.service && sudo systemctl status nftables.service
```
### Configuración de script de cliente
```bash
cp ~/client-configs/base.conf ~/client-configs/base-tor.conf
cp ~/client-configs/make_config.sh ~/client-configs/make_config_tor.sh
```
## Landing Page para descarga de configuración cliente
```bash
curl -sSL https://packages.sury.org/nginx/README.txt | sudo bash -x
```
```bash
sudo apt update
```
```bash
sudo apt install nginx-core nginx-common nginx nginx-full apache2-utils
```
```bash
cd /var/www
sudo htpasswd -c .htpasswd1 client1
sudo htpasswd -c .htpasswd2 client2
sudo htpasswd -c .htpasswd3 client3
sudo htpasswd -c .htpasswd4 client4
```
```bash
sudo dd if=/dev/null of=/etc/nginx/nginx.conf && sudo vim /etc/nginx/nginx.conf
```
```bash
user www-data;
worker_processes auto;
pid /run/nginx.pid;
include /etc/nginx/modules-enabled/*.conf;
events {
worker_connections 768;
}
http {
brotli on;
brotli_comp_level 6;
brotli_static on;
brotli_types application/atom+xml application/javascript application/json application/rss+xml
application/vnd.ms-fontobject application/x-font-opentype application/x-font-truetype
application/x-font-ttf application/x-javascript application/xhtml+xml application/xml
font/eot font/opentype font/otf font/truetype image/svg+xml image/vnd.microsoft.icon
image/x-icon image/x-win-bitmap text/css text/javascript text/plain text/xml;
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/*;
}
```
```bash
sudo dd if=/dev/null of=/etc/nginx/sites-available/default && sudo vim /etc/nginx/sites-available/default
```
```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;
}
}
```
[bastionado-vpn.tar](/assets/files/openvpn-server/bastionado-vpn.tar)
```bash
scp -i .\.ssh\id_admin_bastionado .\bastionado-vpn.tar ovpn@ovpn.bastionado.es:/home/ovpn
sudo tar -xvf bastionado-vpn.tar -C /var/www/html
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
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
```