Python y VPN (2)
En la entrega anterior aprendimos a rotar nuestras IP con NordVPN. Ahora vamos a profundizar usando OpenVPN y contenedores LXC para trabajar en paralelo.
Este artículo es bastante antiguo. La API mencionada se retiró hace mucho tiempo, pero mantengo el artículo como archivo.
Por comodidad, subiré a GitHub tanto el código anterior como el de hoy, junto con cualquier otro material útil.
No tengo ninguna relación con la empresa. Probablemente no renueve la suscripción, pero mientras siga vigente, vamos a aprovecharla.
La primera entrega era específica para ese cliente, porque utilizábamos sus propios comandos. En esta vamos a profundizar un poco y empezar a usar OpenVPN.
Ya tenemos un script sencillo que recorre aleatoriamente todas las IP disponibles. ¿Y si queremos hacerlo en paralelo? Podemos tener hasta 5 clientes conectados simultáneamente a la VPN, así que ¿por qué no aprovecharlos para rotar 5 IP distintas en un mismo dispositivo? Esto reduciría considerablemente el tiempo necesario para algunas operaciones.
Contenedores LXC
Para esta virtualización vamos a utilizar LXC.
LXC es un método de virtualización a nivel del sistema operativo que permite ejecutar varios sistemas Linux aislados en un mismo anfitrión utilizando un único núcleo de Linux.
Tendremos máquinas Linux aisladas (contenedores) ejecutándose en un mismo anfitrión, cada una con su propia interfaz de red y con salida a través del anfitrión. Hay un inconveniente: el cliente de NordVPN no funciona en entornos virtualizados, una limitación de NordVPN. Por eso tenemos que conectarnos directamente mediante OpenVPN con las credenciales de NordVPN.
Empecemos creando nuestro contenedor LXC y después veremos cómo sortear esta limitación.
Crear nuestro contenedor LXC
Primero comprobamos que tenemos instalados lxc y lxd. Probablemente ya estén instalados; si no:
$ sudo apt-get install lxc
También comprobamos que tenemos lxd, una extensión de lxc que añade funciones y facilita la administración:
$ sudo snap install lxd
Una vez instalados ambos, iniciamos la configuración de los contenedores con:
$ lxd init
root@prueba:~# lxd init
Would you like to use LXD clustering? (yes/no) [default=no]:
Do you want to configure a new storage pool? (yes/no) [default=yes]:
Name of the new storage pool [default=default]:
Would you like to connect to a MAAS server? (yes/no) [default=no]:
Would you like to create a new local network bridge? (yes/no) [default=yes]:
What should the new bridge be called? [default=lxdbr0]:
What IPv4 address should be used? (CIDR subnet notation, “auto” or “none”) [default=auto]:
What IPv6 address should be used? (CIDR subnet notation, “auto” or “none”) [default=auto]:
Would you like the LXD server to be available over the network? (yes/no) [default=no]:
Would you like stale cached images to be updated automatically? (yes/no) [default=yes]
Would you like a YAML "lxd init" preseed to be printed? (yes/no) [default=no]:
root@prueba:~#
Ahora, con:
$ lxc list
Podemos ver la lista de contenedores, que estará vacía:
root@prueba:~# lxc list
+------+-------+------+------+------+-----------+
| NAME | STATE | IPV4 | IPV6 | TYPE | SNAPSHOTS |
+------+-------+------+------+------+-----------+
Creamos un contenedor:
$ lxc launch ubuntu:20.04 nombre_contenedor
Comprobamos que se ha creado correctamente el contenedor vpn1, que ya estará en ejecución y tendrá una interfaz de red operativa:
root@prueba:~# lxc launch ubuntu:20.04 vpn1
Creating vpn1
Starting vpn1
root@prueba:~# lxc list
+------+---------+----------------------+-----------------------------------------------+-----------+-----------+
| NAME | STATE | IPV4 | IPV6 | TYPE | SNAPSHOTS |
+------+---------+----------------------+-----------------------------------------------+-----------+-----------+
| vpn1 | RUNNING | 10.42.55.134 (eth0) | fd42:3ede:c779:2b4e:216:3eff:fe8b:b3e4 (eth0) | CONTAINER | 0 |
+------+---------+----------------------+-----------------------------------------------+-----------+-----------+
root@prueba:~#
Ahora entramos en ese contenedor:
$ lxc exec vpn1 /bin/bash/
root@prueba:~# lxc exec vpn1 /bin/bash
root@vpn1:~#
Perfecto, ya estamos dentro del contenedor. Veamos cómo conectarnos a la VPN.
Podemos conectarnos manualmente a los servidores de NordVPN mediante los archivos de configuración que publican en un .zip en su web.
El problema es que no están actualizados. Muchos no funcionan, se desconectan, etc. Entonces me acordé de la API de la primera entrega. Esta API devuelve una lista actualizada de los servidores activos. De hecho, descubrí muchos servidores nuevos que no aparecían en el archivo .zip.
Podemos tomar un archivo de configuración como plantilla, ya que incluye la clave TLZ que el cliente utiliza para verificarse ante el servidor, un paso obligatorio antes de utilizar el usuario y la contraseña. Después extraeremos las IP de los servidores de su API y accederemos a su VPN.
$ openvpn –config archivo_configuracion –remote ip_server –auth-user-pass/etc/openvpn/secret
También necesitaremos un archivo en /etc/openvpn/secret con nuestro usuario y contraseña separados por \n (salto de línea). No es el método más seguro; hay soluciones que intentan evitarlo, pero aquí lo mantendremos sencillo.
He combinado la extracción de datos de la API, la gestión mediante openvpn y el resto de las piezas, y lo he subido al repositorio de GitHub.
Una vez explicada esta parte, sigamos con el contenedor.
Uso del script
$ git clone https://github.com/b0n3sh/sh3llcon_2021.git
Solo tenemos que importar vpn.py en nuestro script o proyecto y ejecutar vpn.get_vpn(), que nos dará una nueva ip. Hay que ejecutar este script con privilegios elevados. Tras instalar las bibliotecas indicadas en requirements.ex, estará listo para usar.
Este código no funciona porque NordVPN retiró la API hace tiempo.