Tutorial para enmascarar y registrar nuestra IP pública (VPN/TOR) desde el inicio en Linux

Anonimizar y cambiar la IP periódicamente suele ser un requisito indispensable a la hora de realizar cualquier pentest, bien para mantener la privacidad (sobretodo si se están realizando pruebas digamos... no consentidas) o bien para evitar y/o evadir las listas negras de los IPS (sistemas de prevención de intrusiones). Por ello es buena idea crear un servicio que en el arranque de nuestra máquina inicie automáticamente TOR (o el cliente de otra red anónima) y la VPN que normalmente utilicemos. De esta manera lo más importante es que se evitarán las situaciones en las que, normalmente por olvido, se lanzan herramientas antes de enmascarar la IP real del atacante, exponiendo de forma inmediata su geolocalización.

A continuación veremos cómo crear un sencillo servicio en Linux (Kali en el ej.) que en el inicio del sistema levante tor, sobretodo para lanzar algunos comandos con proxychains y navegar a través de privoxy, y un cliente vpn (vpnbook en nuestro ejemplo) para no salir nunca directamente con la IP de nuestro ISP. Además, irá guardando cada cierto tiempo la IP en un fichero de log, algo muy útil por si nos lo piden para el informe o timeline del test de intrusión. Y por último, se comprobará que la IP con la que navegamos está enmascarada y, en caso de no estarlo, parará de inmediato los interfaces de red. Vamos a ello:

Primero descargamos los ficheros de configuración .ovpn en el directorio /etc/openvpn/profiles. Aquí, dependiendo de la VPN o VPNs utilizadas dejaremos tantos ficheros como configuraciones y peers disponga el proveedor, normalmente ubicados en diferentes países. En el ejemplo sólo usaremos cuatro de Europa, pero se pueden añadir muchos más incluso de distintos proveedores de VPN:

root@kali:/etc/openvpn/profiles# wget -qO- -O tmp.zip http://www.vpnbook.com/free-openvpn-account/VPNBook.com-OpenVPN-Euro1.zip && unzip tmp.zip && rm tmp.zip
Archive:  tmp.zip
  inflating: vpnbook-euro1-tcp80.ovpn 
  inflating: vpnbook-euro1-tcp443.ovpn 
  inflating: vpnbook-euro1-udp53.ovpn 
  inflating: vpnbook-euro1-udp25000.ovpn 

Después crearemos un fichero pass.txt que contenga el usuario y la contraseña de la VPN, en el caso de vpnbook está disponible y ni siquiera es necesario registrarse:

root@kali:/etc/openvpn/profiles# echo -e "vpnbook\nnu4uTEc" > pass.txt 

vpnbook (usuario)
nnu4uTEc (contraseña)

Actualización: este paso ya no es necesario ya que, gracias a un comentario anónimo en esta entrada, se ha añadido en el primer script los comandos para descargar las credenciales y guardarlas de forma automática en el fichero pass.txt.

El siguiente paso será reemplazar en todos los ficheros .ovpn la línea 'auth-user-pass' por 'auth-user-pass pass.txt' para que utilice el fichero recientemente creado:

root@kali:/etc/openvpn/profiles# sed -i -- 's/auth-user-pass/auth-user-pass pass.txt/g' *.ovpn

Posteriormente creamos un directorio /anonimato (directamente en el raíz) y dentro los scripts necesarios para el servicio. Primero el script de arranque/parada anon-init.sh que iniciará o parará los servicios de tor y vpn (para la vpn cargará un fichero .ovpn de forma aleatoria) y ejecutará el fichero específico para la creación de logs.

root@kali:/anonimato# vi anon-init.sh

#!/bin/bash
# Authors: vmotos & cantonini
CREDFILE="/etc/openvpn/profiles/pass.txt"

start() {
ifconfig $(ls /sys/class/net/ | grep -E '^eth|^en|^wl' | head -1) up && sleep 5
#dhclient eth0

# Obtención de credenciales de vpnbook
curl -s http://www.vpnbook.com/freevpn -o results.html
username=$(cat results.html | grep "Username:" | cut -d' ' -f2 | cut -d'>' -f2 | cut -d'<' -f1)
password=$(cat results.html | grep "Password:" | cut -d' ' -f2 | cut -d'>' -f2 | cut -d'<' -f1 | uniq)
echo $username > $CREDFILE && echo $password >> $CREDFILE
rm results.html

IPREAL=$(curl icanhazip.com)
sed $A'1!b;/IPREAL/c\IPREAL\='$IPREAL'' -i start-logs.sh
cd /etc/openvpn/profiles ; nohup openvpn --config $(ls *.ovpn | shuf -n 1) &
systemctl start tor
cd /anonimato ; nohup sh start-logs.sh &
}

stop() {
systemctl stop tor
ps -uax | grep log- | awk '{print $2}' | xargs kill -9
ps -aux | grep openvpn | awk '{print $2}' | xargs kill -9
ifconfig $(ifconfig | egrep -io "tun\w") down 2> /dev/null
rm -f $CREDFILE
ifconfig $(ls /sys/class/net/ | grep -E '^eth|^en|^wl' | head -1) down
}

case $1 in
        start|stop) "$1" ;;
esac

Y segundo creamos el fichero start-logs.sh que comprobará que no usamos la IP real e irá insertando en el fichero de logs las IPs correspondientes durante el intervalo en segundos que especifiquemos.

root@kali:/anonimato# vi start-logs.sh

IPREAL=179.85.12.55
SECS=300
IPVPN=$(curl icanhazip.com)
IPTOR=$(proxychains curl icanhazip.com)

if [ $IPREAL == $IPVPN ] || [ $IPREAL == $IPTOR ];
        then
                ifconfig $(ifconfig | grep Ethernet -n3 | egrep -io "1-\w+" | awk -F'-' '{print $2}') down 2> /dev/null
                ifconfig $(ifconfig | egrep -io "tun\w") down 2> /dev/null
                echo "PRIVACY ALARM!" >> logs/log-vpn-`date +'%d-%m-%Y'`.log
                echo "PRIVACY ALARM!" >> logs/log-tor-`date +'%d-%m-%Y'`.log
                exit 1
        fi

while true;do echo $IPVPN = `date` >> logs/log-vpn-`date +'%d-%m-%Y'`.log && sleep $SECS ; done &
while true;do echo $IPTOR = `date` >> logs/log-tor-`date +'%d-%m-%Y'`.log && sleep $SECS ; done &

* No hay que olvidarse de dar permisos de ejecución a los dos scripts creados:

root@kali:/anonimato# chmod +x *.sh

A continuación creamos el fichero de configuración unit para systemd:

root@kali:/anonimato# vi /etc/systemd/system/anon.service

[Unit]
Description=Inicia VPN/TOR y log

[Service]
Type=oneshot
ExecStart=/anonimato/anon-init.sh start
ExecStop=/anonimato/anon-init.sh stop
RemainAfterExit=yes

[Install]
WantedBy=multi-user.target

Para finalmente activar e iniciar el servicio:

root@kali:/anonimato# chmod 664 /etc/systemd/system/anon.service

root@kali:/etc/systemd/system# systemctl enable anon.service

Created symlink from /etc/systemd/system/multi-user.target.wants/anon.service to /etc/systemd/system/anon.service

root@kali:/anonimato# systemctl start anon.service

Ahora bien, podríamos ir revisando regularmente los logs (tail -f) o comprobando manualmente cada cierto tiempo que efectivamente la IP con la que navegamos no es la "nuestra", pero sin duda es mucho mejor utilizar un monitor de sistema para nuestras X, que se integre en el escritorio y que podamos ir consultándolo de forma visual casi sin querer. Hablamos de Conky para el cual os dejo el fichero de configuración que sólo tenéis que ubicar en el home de vuestro usuario, en el ejemplo en /root/.conkyrc para la versión 1.10.3 que es la que trae Kali (la versión posterior 1.10.4 cambia ligeramente la sintaxis):

conky.config = {
background = true ,
use_xft = true ,
xftalpha = 0.8 ,
update_interval = 5.0 ,
total_run_times = 0 ,
own_window = true ,
own_window_type = "normal" ,
own_window_transparent = "50" ,
background = true,
own_window_argb_visual = true ,
own_window_argb_value = "100",
own_window_argb_value = 0,
own_window_hints = "undecorated,below,skip_taskbar,sticky,skip_pager" ,
double_buffer = true ,
draw_shades = true ,
draw_outline = false ,
draw_graph_borders = true ,
stippled_borders = 8 ,
border_width = 1 ,
maximum_width = 350 ,
minimum_width = 300,
default_color = "darkgrey" ,
default_shade_color = "black" ,
default_outline_color = "black" ,
alignment = "top_right" ,
gap_x = 4 ,
gap_y = 4 ,
no_buffers = true ,
uppercase = false ,
cpu_avg_samples = 2 ,
net_avg_samples = 2 ,
override_utf8_locale = false ,
use_spacer = "left"
}

conky.text = [[

$color
${color #ffffff}[SYSTEM] ${hr 2}$color
${color #ffffff}UPTIME: $color ${uptime}

${color #ffffff}[CPU] ${hr 2}$color
$cpu% ${color ffcf00} ${cpubar 6}$color

${color #ffffff}[MEMORY] ${hr 2}$color
${color #ffffff}RAM Used: $color${mem}
${color #ffffff}RAM Free: $color${memfree}/ ${memmax}
${color #ffffff}RAM:$color $memperc% ${color ffcf00} ${membar 6}$color

${color #ffffff}NAME PID CPU% MEM%$color
${font GE Inspira:size=10}${color #ffffff}${top name 1} ${top pid 1} ${top cpu 1} ${top mem 1}
${top name 2} ${top pid 2} ${top cpu 2} ${top mem 2}
${top name 3} ${top pid 3} ${top cpu 3} ${top mem 3}
${top name 4} ${top pid 4} ${top cpu 4} ${top mem 4}
${top name 5} ${top pid 5} ${top cpu 5} ${top mem 5}$color$font

${color #ffffff}[ETHERNET INTERFACE] ${hr 2}$color
${color #ffffff}ETH0 Down: $color${downspeed eth0}${alignr}${downspeedgraph eth0 15,110 ffffff CAF200 -t}
${color #ffffff}ETH0 Up: $color${upspeed eth0}${alignr}${upspeedgraph eth0 15,110 ffffff CAF200 -t}
${color #ffffff}IP: $color${addr eth0}${alignr}

${color #ffffff}[VPN INTERFACE] ${hr 2}$color
${color #ffffff}TUN Down: $color${downspeed tun1}${alignr}${downspeedgraph tun1 15,110 ffffff CAF200 -t}
${color #ffffff}TUN Up: $color${upspeed tun1}${alignr}${upspeedgraph tun1 15,110 ffffff CAF200 -t}
${color #ffffff}IP(internal): $color${addr tun1}${alignr}
${color #ffffff}IP(External): $color${execi 1 curl icanhazip.com 2> /dev/null '{print $1}'}${alignr}
${color #ffffff}Country: $color${execi 1 curl ipinfo.io 2> /dev/null | grep "country" | awk -F'"' '{print $4}'}${alignr}

${color #ffffff}[TOR CONNECTION] ${hr 2}$color
${color #ffffff}TOR IP: $color${color #CAF200}${execi 1 proxychains curl ipinfo.io 2> /dev/null | grep "ip" | awk -F '"' '{print $4}'}${alignr}$color
${color #ffffff}Country: $color${color #CAF200}${execi 1 proxychains curl ipinfo.io 2> /dev/null | grep "country" | awk -F'"' '{print $4}'}${alignr}$color
]]

El dock (a falta de embellecerlo) es bastante útil, ya que podremos ver las IPs asignadas y el tráfico de bajada/subida consumido en tiempo real: