docs: update vpn/openvpn/servidor

assets/files/openvpn-server/default-site-nginx.conf

@@ -0,0 +1,35 @@
+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;
+        }
+        
+}

assets/files/openvpn-server/nftables-tor.conf

@@ -0,0 +1,68 @@
+#!/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
+        }
+
+}

assets/files/openvpn-server/nftables.conf

@@ -0,0 +1,53 @@
+#!/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;
+
+        }
+
+}

assets/files/openvpn-server/nginx.conf

@@ -0,0 +1,23 @@
+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/*;
+}

assets/files/openvpn-server/server-crl.conf

@@ -0,0 +1,43 @@
+port 6174
+
+proto udp
+
+dev tun0
+
+ca ca.crt
+cert ovpn.crt
+key ovpn.key
+
+dh dh.pem
+
+server 10.10.10.0 255.255.255.0
+
+ifconfig-pool-persist /var/log/openvpn/ipp.txt
+
+push "redirect-gateway def1 bypass-dhcp"
+
+push "dhcp-option DNS 1.1.1.1"
+push "dhcp-option DNS 1.0.0.1"
+
+keepalive 10 120
+
+tls-auth ta.key 0
+
+cipher AES-256-CBC
+auth SHA512
+
+user nobody
+group nogroup
+
+persist-key
+persist-tun
+
+status /var/log/openvpn/openvpn-status.log
+
+log-append  /var/log/openvpn/openvpn.log
+
+verb 3
+
+explicit-exit-notify 1
+
+crl-verify crl.pem

assets/files/openvpn-server/tor.conf

@@ -0,0 +1,43 @@
+port 6175
+
+proto udp
+
+dev tun1
+
+ca ca.crt
+cert ovpn.crt
+key ovpn.key
+
+dh dh.pem
+
+server 10.10.20.0 255.255.255.0
+
+ifconfig-pool-persist /var/log/openvpn/ipp-tor.txt
+
+push "redirect-gateway def1 bypass-dhcp"
+
+push "dhcp-option DNS 10.10.20.1"
+push "dhcp-option DNS 1.0.0.1"
+
+keepalive 10 120
+
+tls-auth ta.key 0
+
+cipher AES-256-CBC
+auth SHA512
+
+user nobody
+group nogroup
+
+persist-key
+persist-tun
+
+status /var/log/openvpn/openvpn-status-tor.log
+
+log-append  /var/log/openvpn/openvpn-tor.log
+
+verb 3
+
+explicit-exit-notify 1
+
+crl-verify crl.pem

vpn/openvpn/guide.md

@@ -2,7 +2,7 @@
 title: OpenVPN - Guía de instalación
 description: Guía de instalación utilizada durante la realización de la práctica
 published: true
-date: 2022-06-01T00:54:59.608Z
+date: 2022-06-02T10:11:26.934Z
 tags: vpn, servidor
 editor: markdown
 dateCreated: 2022-05-31T21:04:15.280Z
@@ -200,7 +200,7 @@ scp pki/ca.crt ovpn@ovpn.bastionado.es:/tmp
 scp pki/issued/ovpn.crt ovpn@ovpn.bastionado.es:/tmp
 ```
 
-# Fin día 1
+## Fin día 1
 ---
 
 # Panel Títulos (⌘1)
@@ -877,6 +877,9 @@ clear && cowsay -W 76 -f ovpn 'Solo nos queda reiniciar nuestro servidor y compr
 sudo systemctl restart openvpn@server && sudo systemctl status openvpn@server
 ```
 
+## Fin Día 2
+----
+
 # Panel Títulos (⌘1)
 
 ```bash
@@ -886,7 +889,66 @@ clear && echo "" && echo "" && echo "" && echo && echo "" && echo "" && echo ""
 # Panel oVPN (⌘4)
 
 ```bash
-clear && cowsay -W 76 -f ovpn '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. Para ello, comenzaremos instalando TOR.'
+clear && cowsay -W 76 -f ovpn '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.'
+```
+
+```bash
+clear && cowsay -W 76 -f ovpn 'Crearemos una copia de nuestra configuración base servidor.'
+```
+
+```bash
+sudo cp /etc/openvpn/server.conf /etc/openvpn/tor.conf
+```
+
+```bash
+clear && cowsay -W 76 -f ovpn 'Editamos el fichero de servidor OpenVPN TOR.'
+```
+
+```bash
+sudo nano /etc/openvpn/tor.conf # sudo vim /etc/openvpn/tor.conf
+```
+
+```bash
+clear && cowsay -W 76 -f ovpn 'Tenemos que modificar el puerto, el rango de IPs, los ficheros log y el DNS que utilizará. El resto de opciones las podemos mantener iguales.'
+```
+
+```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
+```
+
+```bash
+clear && cowsay -W 76 -f ovpn 'Con todo configurado, es el momento de levantar nuestro servicio, comprobando también que se ha creado la interfaz virtual `tun1`.'
+```
+
+```bash
+sudo systemctl restart openvpn@tor && sudo systemctl status openvpn@tor
+
+ip addr show tun1
+```
+
+```bash
+clear && cowsay -W 76 -f ovpn 'Si todo esto es correcto podemos habilitar el servicio en inicio automático.'
+```
+
+```bash
+sudo systemctl enable openvpn@tor
+```
+
+```bash
+clear && cowsay -W 76 -f ovpn 'Es el momento de instalar TOR.'
 ```
 
 ```bash
@@ -911,25 +973,96 @@ ExitNodes {us} StrictNodes 1
 ```
 
 ```bash
-clear && cowsay -W 76 -f ovpn 'Configuraremos la resolución de dominios `onion` y `exit` y la resolución DNS y HTTP a la dirección IP que tendrá nuestra futura interfaz `tun`. Por otra parte, solicitaremos que el nodo de salida de TOR sea a través de un servidor de los Estados Unidos.'
+clear && cowsay -W 76 -f ovpn '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
-clear && cowsay -W 76 -f ovpn 'Levantamos nuestro servicio, comprobamos que todo funciona correctamente y habilitamos el inicio automático.'
+clear && cowsay -W 76 -f ovpn '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
+```
 
+```bash
+clear && cowsay -W 76 -f ovpn 'Habilitamos el inicio automático del servicio.'
+```
+
+```bash
 sudo systemctl enable tor.service 
 ```
 
+```bash
+clear && cowsay -W 76 -f ovpn 'Crearemos copias de nuestra configuración base para clientes y del script de generación de configuración.'
+```
+
+```bash
+cp ~/client-configs/base.conf ~/client-configs/base-tor.conf
+
+cp ~/client-configs/make_config.sh ~/client-configs/make_config_tor.sh
+```
+
+```bash
+clear && cowsay -W 76 -f ovpn '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
+```
+
+```bash
+remote ovpn.bastionado.es 6175
+```
+
+```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 '<ca>') \
+    ${KEY_DIR}/ca.crt \
+    <(echo -e '</ca>\n<cert>') \
+    ${KEY_DIR}/${1}.crt \
+    <(echo -e '</cert>\n<key>') \
+    ${KEY_DIR}/${1}.key \
+    <(echo -e '</key>\n<tls-auth>') \
+    ${KEY_DIR}/ta.key \
+    <(echo -e '</tls-auth>') \
+    > ${OUTPUT_DIR}/bastionado-tor-${1}.ovpn
+```
+
+```bash
+clear && cowsay -W 76 -f 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
+```
+
 ```bash
 clear && cowsay -W 76 -f ovpn '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.'
 ```
 
+```bash
+clear && cowsay -W 76 -f ovpn '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
 ```
@@ -1013,102 +1146,270 @@ clear && cowsay -W 76 -f ovpn 'Reiniciamos nuestro servicio y comprobamos que to
 sudo systemctl restart nftables.service && sudo systemctl status nftables.service
 ```
 
+# Panel Títulos (⌘1)
+
 ```bash
-clear && cowsay -W 76 -f ovpn 'Crearemos copias de nuestra configuración base para clientes, servidor y del script de generación de configuración y alteraremos los valores para nuestra VPN alternativa.'
+clear && echo "" && echo "" && echo "" && echo && echo "" && echo "" && echo "" && echo "" && echo "" && echo "" && figlet -w 130 -f ansi-shadow 'SERVIDOR WEB' -c | lolcat && echo "" && echo "" && echo "" && figlet -w 240 -f ansi-shadow 'PARA ACCESO CLIENTE' -c | lolcat -a -d 1 && echo "" && echo "" && echo "" && sleep 10 && clear
 ```
 
 ```bash
-cp ~/client-configs/base.conf ~/client-configs/base-tor.conf
+clear && cowsay -W 240 -f ovpn '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. 
 
-cp ~/client-configs/make_config.sh ~/client-configs/make_config_tor.sh
-
-sudo cp /etc/openvpn/server.conf /etc/openvpn/tor.conf
+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.'
 ```
 
-```bash
-sudo nano /etc/openvpn/tor.conf # 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
-```
-
-```bash
-clear && cowsay -W 76 -f ovpn 'Con todo configurado, es el momento de levantar nuestro servicio, comprobando también que se ha creado la interfaz virtual `tun1`.'
-```
-
-```bash
-sudo systemctl restart openvpn@tor && sudo systemctl status openvpn@tor
-
-ip addr show tun1
-```
-
-```bash
-clear && cowsay -W 76 -f ovpn 'Si todo esto es correcto podemos habilitar el servicio en inicio automático.'
-```
-
-```bash
-sudo systemctl enable openvpn@tor
-```
-
-```bash
-nano ~/client-configs/base-tor.conf # vim ~/client-configs/base-tor.conf
-```
-
-```bash
-remote ovpn.bastionado.es 6175
-```
-
-```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 '<ca>') \
-    ${KEY_DIR}/ca.crt \
-    <(echo -e '</ca>\n<cert>') \
-    ${KEY_DIR}/${1}.crt \
-    <(echo -e '</cert>\n<key>') \
-    ${KEY_DIR}/${1}.key \
-    <(echo -e '</key>\n<tls-auth>') \
-    ${KEY_DIR}/ta.key \
-    <(echo -e '</tls-auth>') \
-    > ${OUTPUT_DIR}/bastionado-tor-${1}.ovpn
-```
+# Panel oVPN (⌘4)
 
 
 ```bash
-clear && cowsay -W 76 -f ovpn 'Y ahora ya podemos generar nuestros ficheros `ovpn` para nuestros clientes.'
+clear && cowsay -W 76 -f ovpn '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 
-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
+curl -sSL https://packages.sury.org/nginx/README.txt | sudo bash -x
 ```
 
+```bash
+clear && cowsay -W 76 -f ovpn 'Ahora ya podemos actualizar la información de repositorios.'
+```
+
+```bash 
+sudo apt update
+```
+
+```bash
+clear && cowsay -W 76 -f ovpn '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 -y nginx-core nginx-common nginx nginx-full apache2-utils
+```
+
+```bash
+clear && cowsay -W 76 -f ovpn '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
+```
+
+```bash
+clear && cowsay -W 76 -f ovpn '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
+```
+
+```bash
+clear && cowsay -W 76 -f ovpn '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/*;
+}
+```
+
+```bash
+clear && cowsay -W 76 -f ovpn '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
+```
+
+```bash
+clear && cowsay -W 76 -f ovpn '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;
+        }
+        
+}
+```
+
+```bash
+clear && cowsay -W 76 -f ovpn '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
+```
+
+```bash
+clear && cowsay -W 76 -f ovpn '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
+```
+
+```bash
+clear && cowsay -W 76 -f ovpn '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
+```
+
+```bash
+clear && cowsay -W 76 -f ovpn '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
+```
+
+```bash
+clear && cowsay -W 76 -f ovpn '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
+```
+
+# Panel Títulos (⌘1)
+
+## Cliente en Windows de Alberto
+
+```bash
+clear && echo "" && echo "" && echo "" && echo && echo "" && echo "" && echo "" && echo "" && echo "" && echo "" && figlet -w 130 -f ansi-shadow 'PROBANDO' -c | lolcat && echo "" && echo "" && echo "" && figlet -w 220 -f ansi-shadow 'OPEN VPN' -c | lolcat -a -d 1 && echo "" && echo "" && echo "" && sleep 10 && clear
+```
+
+```bash
+clear && cowsay -W 240 -f ovpn 'Ahora que hemos terminado completamente la configuración y que todo está operativo es el momento de ver si todo funciona correctamente. Para ello, veamos como un cliente Windows descarga su configuración conecta correctamente a la VPN.'
+```
+
+
+# Panel oVPN (⌘4)
+
+```bash
+clear && cowsay -W 76 -f ovpn 'Mientras el cliente está conectando a la VPN podemos monitorizar nuestro servicio.'
+```
+
+```bash 
+sudo tail -f /var/log/openvpn/openvpn.log
+```
+
+# Panel Títulos (⌘1)
+
+## Cliente Android
+
+```bash
+clear && cowsay -W 240 -f ovpn 'OpenVPN es multiplataforma, por lo que otros clientes, como por ejemplo Android, también pueden conectar. En este caso, además, utilizaremos la VPN TOR y comprobaremos como nuestra dirección IP de salida está en Estados Unidos y podemos acceder a dominios .onion.'
+```
+
+# Panel oVPN (⌘4)
+
+```bash
+clear && cowsay -W 76 -f ovpn 'De nuevo, mientras el cliente está conectando a la VPN podemos monitorizar nuestro servicio.'
+```
+
+```bash 
+sudo tail -f /var/log/openvpn/openvpn-tor.log
+```
+
+# Panel Títulos (⌘1)
+
+## Cliente MacOS
+
+```bash
+clear && cowsay -W 240 -f ovpn 'La VPN TOR también puede utilizarse sin problemas en plataformas de escritorio como MacOS.'
+```
+
+# Panel Títulos (⌘1)
+
+## Cliente iOS
+
+```bash
+clear && cowsay -W 240 -f ovpn 'Si recordamos nuestros pasos anteriores anulamos el certificado del cliente 4 metiéndolo en nuestra Lista de revocación de certificados. Veamos qué ocurre cuando el cliente intenta conectar al servicio.'
+```
+
+# Panel oVPN (⌘4)
+
+```bash
+clear && cowsay -W 76 -f ovpn 'En la monitorización de nuestro servicio podemos observar como se registra, durante el saludo entre servidor y cliente, que su certificado está en la CRL y por lo tanto el servidor OpenVPN rechaza la conexión, lo que se traduce en que el cliente se queda indefinidamente intentando conectar sin éxito.'
+```
+
+```bash 
+sudo tail -f /var/log/openvpn/openvpn-tor.log
+```
+
+# Panel Títulos (⌘1)
+
+```bash
+clear && echo "" && echo "" && echo "" && echo && echo "" && echo "" && echo "" && echo "" && echo "" && echo "" && figlet -w 190 -f ansi-shadow 'THE END' -c | lolcat -a -d 1 && echo "" && echo "" && echo "" && sleep 5 && unimatrix -f -n -s 96 -w && clear
+```

vpn/openvpn/servidor.md

@@ -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-02T10:21:20.220Z
 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
 
@@ -717,6 +745,9 @@ table ip nat {
 
 }
 ```
+* [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
@@ -724,9 +755,11 @@ sudo systemctl restart nftables.service && sudo systemctl status nftables.servic
 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 +767,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 +777,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
 
@@ -749,31 +786,40 @@ 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
+* 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
+* 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
+# OpenVPN + TOR
 
-### Configuración de OpenVPN
+> 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
 
@@ -790,8 +836,10 @@ 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
+
+## Puesta en funcionamiento del servicio OpenVPN TOR
 
 * Arrancar y comprobar el estado del servicio OpenVPN
 
@@ -811,25 +859,58 @@ ip addr show tun1
 sudo systemctl enable openvpn@tor
 ```
 
-## Habilitando 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
+```
 
-sudo systemctl restart tor.service
+* 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
 
@@ -900,12 +981,17 @@ table ip nat {
 
 }
 ```
+* [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
+## 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
@@ -913,21 +999,87 @@ 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.
 
-## Landing Page para descarga de configuración cliente
+```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 '<ca>') \
+    ${KEY_DIR}/ca.crt \
+    <(echo -e '</ca>\n<cert>') \
+    ${KEY_DIR}/${1}.crt \
+    <(echo -e '</cert>\n<key>') \
+    ${KEY_DIR}/${1}.key \
+    <(echo -e '</key>\n<tls-auth>') \
+    ${KEY_DIR}/ta.key \
+    <(echo -e '</tls-auth>') \
+    > ${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
 
@@ -937,10 +1089,14 @@ 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;
@@ -952,15 +1108,6 @@ events {
 }
 
 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;
@@ -975,11 +1122,17 @@ http {
         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;
@@ -1017,15 +1170,26 @@ server {
         
 }
 ```
+* [Referencia de sitio web de NginX](/assets/files/openvpn-server/default-site-nginx.conf)
 
+## Instalación de Sitio Web
 
-[bastionado-vpn.tar](/assets/files/openvpn-server/bastionado-vpn.tar)
+* 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
-scp -i .\.ssh\id_admin_bastionado .\bastionado-vpn.tar ovpn@ovpn.bastionado.es:/home/ovpn
+sudo wget -P /tmp https://wiki.bastionado.es/assets/files/openvpn-server/bastionado-vpn.tar
+```
+[Sitio web](/assets/files/openvpn-server/bastionado-vpn.tar)
 
-sudo tar -xvf bastionado-vpn.tar -C /var/www/html
+* 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
@@ -1035,9 +1199,24 @@ sudo cp /home/ovpn/client-configs/files/bastionado-tor-client1.ovpn /var/www/htm
 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
+```
+