En anteriores entregas:

Presentación | Parte 1 | Parte 2 | Parte 3 | Parte4 | Parte 5 | Parte 6 | Parte 7 | Parte 8

Afterglow, InetVis, TNV, Argus, INAV.

 

Dejamos atrás Wireshark, visto en la parte 8 de esta serie, para ver otras herramientas que nos facilitan, cada una con sus propiedades y ventajas, la interpretación de nuestras captura y la obtención de datos y, en resumen, el análisis del tráfico de red.

En esta ocasión veremos una serie de herramientas que nos proporcionarán una visión gráfica de nuestras capturas.  Son las siguientes:

• Afterglow
• TNV
• InetVis
• INAV
• NetGrok

Esta parte (9/10) la dividiremos a su vez en 2 o 3 más. En esta primera veremos AfterGlow:

AfterGlow

 

AfterGlow es una herramienta formada por una serie de scripts de Perl que nos facilita la generación de gráficas a partir de, por ejemplo, un fichero de captura .pcap. Para ello necesitamos tener instalado GraphViz.

Descargamos Afterglow desde aquí: http://sourceforge.net/projects/afterglow/files/AfterGlow%201.x/1.6.2/. No necesita instalación.

Su funcionamiento es de lo más sencillo. Y para ello, como siempre, que mejor que explicarlo mediante ejemplos. Usaremos también Tshark que ya lo hemos visto en otros capítulos.

Tenemos una captura, por ejemplo: captura_ejemplo.pcap tomada desde nuestra máquina.  Un ejemplo muy sencillo aunque poco práctico porque en nuestra red switcheada solo “veremos” nuestro tráfico y el Broadcast. Pero nos servirá para empezar.

~/afterglow/src/perl/graph# tshark -r captura_ejemplo.pcap -T fields -E separator=, -e ip.dst -e ip.src | perl afterglow.pl -c color.properties -t > grafica.dot

Tenemos lo siguiente:

• Estamos usando Tshark como sniffer.
• -r leemos el fichero .pcap
• Tal como vimos en el artículo dedicado a Tshark, vamos a usar -T fields para el formateo de datos por campos, -e para especificar los campos que deseamos mostrar y -E separators para establecer un separador entre campos.

• | pasamos los datos al script afterglow.pl
• -c color.properties usamos un esquema de color por defecto para nuestra gráfica resultante. Más a delante vermos que son los esquemas de color.
• -t opción para modo dos nodos.
• > pasamos los datos al un archivo grafica.dot (ahora veremos para que)

Una vez que hemos generado el fichero .dot, invocamos a neato (por eso necesitamos GraphViz) para convertir los datos .dot en un fichero gráfico para poder visualizar:

~/afterglow/src/perl/graph# neato -Tgif -o grafica0.gif ./grafica.dot

El resultado:

Hemos usado Tshark, pero podríamos usar cualquier otro. Vamos a usar un fichero .pcap que incuye SIP/RTP y usaremos tcpdump:

~/afterglow/src/perl/graph# tcpdump -vttttnnel -r sip-rtp-g711.cap | perl tcpdump2csv.pl “sip rtp dport” > captura.csv

En este caso el fichero de salida es un .CSV (apto para visualizar en Excel en Windows por ejemplo) que hemos convertido mediante el script tcpdump2csv.pl incluído en el paquete Afterglow:

~/afterglow/src/perl/graph# cat captura.csv | perl afterglow.pl – c color.properties > captura.dot

Pasamos, arriba, los datos .csv a afterglow.pl para generar el fichero .dot

Abajo convertimos el .dot a captura.gif:

~/afterglow/src/perl/graph# neato -Tgif -ocaptura.gif captura.dot

El resultado:

Respecto al uso del tipo de gráfico Graphviz, no solo podemos usar neato, tenemos algunas opciones más:

• circo
• dot
• twopi
• fdp

 

Los esquemas de color. El archivo color.properties

 

La forma en que se representarán los nodos de las gráficas, color, aspecto, etc se definen en un archivo de configuración que se llama color.properties (por defecto). A este archivo lo llamamos de la forma -c color.properties. Para cada caso necesitaremos un archivo de propiedades diferentes.

Este archivo tiene este aspecto por defecto:

color.source=»yellow» if ($fields[0]=~/^192\.168\..*/);
color.source=»greenyellow» if ($fields[0]=~/^10\..*/);
color.source=»lightyellow4″ if ($fields[0]=~/^172\.16\..*/);
color.source=»red»
color.event=»yellow» if ($fields[1]=~/^192\.168\..*/)
color.event=»greenyellow» if ($fields[1]=~/^10\..*/)
color.event=»lightyellow4″ if ($fields[1]=~/^172\.16\..*/)
color.event=»red»
color.target=»blue» if ($fields[2]<1024)
color.target=»lightblue»

Los nodos pueden ser, básicamente, ya veremos más a delante que hay más:

• source nodo de origen
• target nodo de destino
• event nodo de evento

Si queremos representar gráficamente una captura que incluye los siguientes campos de representación: ip origen -> ip destino ->  puerto tcp destino ,en este orden, entonces quedaría: source -> target -> event.

Un ejemplo atendiendo al o expuesto en el párrafo anterior seria:

• tshark -r captura_ejemplo.pcap -T fields -E separator=, -e ip.scr -e ip.dst, tcp.dstport | perl afterglow.pl -c color.properties -t > grafica.dot 
  

Con esto crearíamos un fichero separado por comas que es interpretado por AfterGlow para la creación de la gráfica.

Campos.

$fields[0]  para el primer campo de .dot o .csv
$fields[1]  para el segundo campo de .dot o .csv
$fields[2]  para el tercer campo de .dot o .csv

Colores

color.source=”yellow” para nodos origen
color.target=”blue” para nodos destino
color.event=”red” para nodos eventos

color.=”invisible” para que no parezcan determinados datos.

Las formas

shape.source=”forma“
shape.target=”forma“
shape.event=”forma“

que pueden ser ellipse, box, triangle, circle.

Condicionando…

Podemos usar if para condicionar la representación de eventos, source y target usando, además, expresiones perl y/o regulares.

Y como siempre, para entenderlo mejor, los ejemplos.

Ejemplo 1

Queremos representar gráficamente la actividad FTP entre cliente y servidor. Como evento queremos representar los ftp.requests.

Lo primero es leer con tshark el archivo de captura, extraer lo datos necesarios y volcarlos, por ejemplo, a un archivo .csv:

> tshark -nn -r ftp_actividad.pcap -T fields -E separator=, -e ip.src -e ftp.request.command -e ip.dst | sort -u > grafica0.csv

> tshark -nn -r ftp_actividad.pcap -T fields -E separator=, -e ip.src -e ftp.request.command -e ip.dst | sort -u > grafica0.csv

Como véis extraemos:

• ip.scr  ip origen   source
• ftp.request.command comandos ftp request  event
• ip.dst  ip destino  target

Ahora creamos nuestro fichero de propiedades de color que quedará de esta forma:

color.source=”yellow” if ($fields[0]=~/^192\.168\..*/);
color.source=”lightblue” if ($fields[0]=!~/^192\.168\..*/);
color.source=”invisible”
shape.source=”ellipse”;

color.event=”green” if ($fields[1] =~ /PASS/);
color.event=”palegreen”;
shape.event=”box”;

color.target=”red” if ($fields[2]=~/^192\.168\..*/);
color.target=”red”;
shape.target=”circle”;

color.edge=”blue”;

Todo esto de arriba lo guardamos en un archivo que llamamos color.ftp

El significado es el siguiente:

color.source para nodos origen:

• indicamos amarillo para la expresión, del campo 1, del archivo .csv para toda IP 192.168.xxx.xxx
• indicamos azul claro para las que sean distintas a la anterior
• para el resto que no aparezca
• la forma de la etiqueta será un elipse.

color.event para nodos origen:

• indicamos verde para el segundo campo del archivo .csv si cumple la condición de que el comando ftp request sea PASS (password)
• para el resto, otra variedad de verde.
• la forma de la etiqueta será una caja.

color.target para nodos de destino:

• indicamos rojo para la condición y mismo color para el resto.
• la forma de la etiqueta será un cículo.

color.edge. para las líneas y flechas.

• serán de color azul. color.edge=”blue”;

Ahora pasamos los datos del archivo .csv al script de perl AfterGlow para «parsear» y crear el archivo .dot:

> cat grafica0.csv | perl afterglow.pl -c color.ftp > grafica.dot

Creamos el archivo de la gráfica tipo dot en formato .png:

> dot -Tpng -o grafica0.png ./grafica.dot

El resultado:

como veis queda marcado el comando ftp request PASS. Tenemos el origen cliente en amarillo, los comandos en verdes y destino o servidor ftp en rojo en forma de círculo.

Ejemplo 2

Queremos representar ahora la actividad http para etiquetar los request http: http.request.uri. Es decir; la petición URI (Identificador Uniforme de Recursos). Lo vimos aquí: Wireshark / Tshark. Filtros HTTP. Parte 2

Seguimos los mismo pasos que con el ejemplo anterior pero modificando según lo que necesitamos:

> tshark -nn -r actividad_http1.pcap -R “http” -T fields -E separator=, –e ip.src -e http.request.uri –e ip.dst > grafica_http.csv

Aquí el source sería ip.src, http.request.uri y target ip.dst.

Seguimos con el resto. el archivo de propiedades de color color.http1:

color.source=”yellow” if ($fields[0]=~/^192\.168\..*/);
color.source=”lightblue” if ($fields[0]=!~/^192\.168\..*/);
color.source=”invisible”;
shape.source=”ellipse”;

color.event=”green” if ($fields[1] =~ /dabo/);
color.event=”palegreen”;
shape.event=”box”;

color.target=”red”;
shape.target=”circle”;

color.edge=”blue”;

En este caso las propiedades con parecidas, solo cambia una condición. Cambia de color si la URI contiene la palabra dabo.

Seguimos con el resto:

cat grafica_http.csv | perl afterglow.pl -c color.http1 > grafica_http.dot

usaremos aquí un tipo de gráfico neato

neato -Tpng -o grafica_http.png ./grafica_http.dot

Las etiquetas que represntan los valores de http.request.uri son, en algunos casos bastante largas. En tal caso se pueden recortar. En este ejemplo no lo hago para qe veáis como queda en “bruto”:

Ejemplo 3

Queremos visualizar de forma gráfica la actividad http respecto a:

• http.host
• http.user_agent
• ip.dst

Vamos ya de seguido….:

Archivo color.http2:

color.source=”yellow”;
shape.source=”box”;

color.event=”green”;
shape.event=”box”;

color.target=”salmon”;
shape.target=”circle”;

color.edge=”blue”;

Extraemos, parseamos y generamos gráfica:

> tshark -nn -r actividad_http1.pcap -R “http” -T fields -E separator=, -e http.host -e http.user_agent -e ip.dst > grafica_http_1.csv

>cat grafica_http_1.csv | perl afterglow.pl -c color.http2 > grafica_http_1.dot

> neato -Tpng -o grafica_http_1.png ./grafica_http_1.dot

El resultado en gráfica grafica_http_1.png con zoom:

En verde el user_agent. En amarillo el http.host.

Variables.

 

Todo muy práctico. Tenemos un archivo de alertas Snort con una serie de alertas del tipo, por ejemplo:

• WEB-CGI redirect access
• WEB-CGI calendar access

y queremos crear una variable que contenga estas dos posiblidades. La varable la llamaremos @eventoswcgi.
como ya hemos comentado en el anterior artículo dedicado a  Visualización gráfica de alertas Snort con Aferglow.  las alertas irán en el campo name para los eventos. Recordad que dijimos:

• color.source es el color para las IP origen o sip.
• color.event será las descripciones de las alertas. Enmarcadas en una caja para name.
• color.target las Ip destino en color salmón para dip.
• color.edge son las flechas.

Pues bien la configuración de nuestra variable para estos eventos quedaría:

variable=@eventoswcgi=(“WEB-CGI redirect access”,”WEB-CGI calendar access”);

Ya tenemos nuestra variable almacenada. Ahora queremos crear una etiqueta para las coincidencias de esta bariable con las alertas.

Etiquetas.

 

Es posible que los eventos mostrados con AfterGlow en las gráficas seán muy largos, de difícil visualización o simplemente queramos mostrarlos de una foma más inteligible. Para ellos podemos recortar la salida .csv para el primer caso o etiquetas de forma personalizada para los otros dos.

Para ellos usaremos, en nuestro ejemplo con variable, label.event de la siguiente forma:

label.event=”Eventos.WEB-CGI” if (grep(/$fields[1]/,@eventoswcgi));

sin variable quedaría por ejemplo:

label.event=”Scan puertos” if ($fields[1] =~ /portscan/);

Vamos ahora con los ejemplos.

Ejemplo 1.

Ahora terminamos nuestro archivo de configuracion de propiedades color.snort para dejarlo de esta forma:

## color.snort.

# nodos de origen

color.source=”yellow” if ($fields[0]=~/^192\.168\..*/);
color.source=”lightblue”;
shape.source=”ellipse”;

# nodos de eventos

variable=@eventoswcgi=(“WEB-CGI redirect access”,”WEB-CGI calendar access”);

label.event=”Spoof…” if ($fields[1] =~ /SPOOF/);
color.event=”salmon” if ($fields[1] =~ /SPOOF/);

label.event=”Scan puertos” if ($fields[1] =~ /portscan/);
color.event=”red” if ($fields[1] =~ /portscan/);

label.event=”Eventos.WEB-CGI” if (grep(/$fields[1]/,@eventoswcgi));
color.event=”orange” if (grep(/$fields[1]/,@eventoswcgi));

color.event=”invisible”;
shape.event=”box”;

#nodos de destino

color.target=”green”;
shape.target=”ellipse”;

color.edge=”blue”;

Creamos la gráfica:

> type alert.ids | perl snortalert2csv.pl “sip name dip” > snort.csv

> type snort.csv | perl afterglow.pl -c color.snort | neato -Tpng -o snort.png

El resultado:

Seguimos con otro ejemplo donde aplicamos todo lo visto hasta ahora.

Visualización gráfica nmap scan con Afterglow.

 

Para ello vamos a tomar como referencia el campo tcp.flags. Como sabéis este campo toma valores para los flags TCP como pueden ser ACK/SYN/RST, etc y las combinaciones que se pueden dar, por ejemplo SYN-ACK.

Para un:

• SYN el valor de tcp.flags sería 0×02
• ACK el valor de tcp.flags sería 0×10
• para SYN-ACKtcp.flags tendría valor 0×12
• …….

Atendiendo a todo esto y con lo aprendido sobre propiedades del archivo configuración AfterGlow y usando label, solor.source, expresiones perl, etc, contruímos el siguiente archivo de propiedades que llamaremos color.nmap:

color.source=”salmon” if ($fields[1]=~/0×02/); # normal syn
color.source=”orange” if ($fields[1]=~/0×12/); # normal syn-ack
color.source=”lightcyan” if ($fields[1]=~/0×10/); # normal ack
color.source=”red” if ($fields[1] eq “0×14″); # rst-ack
color.source=”gray” if ($fields[1] eq “0×18″); # psh-ack.
color.source=”yellow” if ($fields[1] eq “0×04″); # rst
color.source=”gray20″;

label.event=”SYN” if ($fields[1] eq “0×02″); # normal syn
color.event=”salmon” if ($fields[1] eq “0×02″); # normal syn
label.event=”SYN-ACK” if ($fields[1] eq “0×12″); # normal syn-ack
color.event=”orange” if ($fields[1] eq “0×12″); # normal syn-ack
label.event=”ACK” if ($fields[1] eq “0×10″); # normal ack
color.event=”lightcyan” if ($fields[1] eq “0×10″); # normal ack
label.event=”RST-ACK” if ($fields[1] eq “0×14″); # rst-ack
color.event=”red” if ($fields[1] eq “0×14″); # rst-ack
label.event=”PSH-ACK” if ($fields[1] eq “0×18″); # psh-ack.
color.event=”gray” if ($fields[1] eq “0×18″); # psh-ack.
label.event=”RST” if ($fields[1] eq “0×04″); # rst
color.event=”yellow” if ($fields[1] eq “0×04″); # rst
color.event=”lightcoral”;
shape.event=”box”;

color.edge=”blue”;

Seguimos.

Para nmap, he usado -sS (TCP SYN Scan), que consiste en lo siguiente;  enviamos un paquete o varios con el flag SYN activado. Sería como simular un establecimiento de conexión. El host remoto puede responder con un paquete con SYN+ACK activado con lo que el puerto está abierto o con RST+ACK con lo que el puerto estára cerrado.

Quedaros con esto porque os servirá para interpretar la gráfica, tomando en cuenta que el host que realiza el scan es 192.168.1.106.

Además he usado la opción Decoys y -P0:

> nmap -sS -P0 -p -D192.168.1.10,192.168.1.11,192.168.1.29 80.XXX.XX.XXX

Mientras, con tcpdump, captura todos los segmentos TCP y los vuelco al archivo nmap001.pcap.

Ahora voy a crear la gráfica:

> alfon@alfonubuntu:~/afterglow/src/perl/graph$ tshark -nn -r nmap001.pcap -R “tcp” -T fields -E separator=, -e  ip.src -e tcp.flags -e ip.dst | sort -u > nmap001.csv

> alfon@alfonubuntu:~/afterglow/src/perl/graph$ cat nmap001.csv | perl afterglow.pl -c color.nmap > nmap001.dot

> alfon@alfonubuntu:~/afterglow/src/perl/graph$ dot -Tpng -o nmap001.png ./nmap001.dot

El resultado es:

Como veis, 192.168.1.106 host que realiza el scan, envía segmentos mediante Nmap SYN usando los Decoys 192.168.1.10-11-29 a la víctima 80.xxx.xx.xxx. Esta responde con SYN-ACK para puertos abiertos y RST-ACK para puertos cerrados, segmentos que son enviados a 192.168.1.106 que responde con RST para terminar la conexión.

La gráfica es muy simple porque el scan nmap, entre otras cosas, también lo es. Se puede complicar todo lo que queramos mediante scapy scan range, scapy scan python, y con diversas opciones de nmap. Para tales casos las gráficas resultarán complejas con superposición de nodos.

Para solventar esta inconveniencia, podemos usar clustering y otros tipos de gráficas como fdp. Lo vemos.

Ordenando y clusterizando datos.

 

Tenemos un fichero de captura de red .pcap que nos dicen corresponde a un scan de puertos nmap detectado. Se quiere graficar dicho scan de puertos atendiendo a:

• ip origen
• puerto tdp destino
• ip destino

Como ya hemos estudiado, este esquema se corresponderá con:

• nodos source
• nodos event
• nodos target

Realizamos las operaciones oportunas como siempre (en este caso en windows):

> tshark -r captura_nmap_5.cap -R “tcp” -T fields -E separator=, -e ip.src -e tcp.dstport -e ip.dst > captura_nmap_5.csv

abajo usamos un fichero de propiedades  como el que viene por defecto con AfterGlow:

Usamos type proque este ejemplo está realizado en windows. Para Linux podemos unsar cat o similar.

> type captura_nmap_5.csv | perl afterglow.pl -c color.properties > captura_nmap_5.dot

> neato -Tpng -o captura_nmap_5.png ./captura_nmap_5.dot

El resultado es este:

 Como se puede apreciar, el resultado es bastante caótico. Vamos a limpiar y ordenar los datos para una gráfica más amigable y con mejor visibilidad.

Lo primero que vamos a hacer es ordenar los datos fuente .csv y eliminar líneas duplicadas. Para ello usaremos sort -u para UNIX/Linux y Windows (herramienta portada sort.exe ya que este ejemplo está realizado en windows):

> tshark -r captura_nmap_5.cap -R “tcp” -T fields -E separator=, -e ip.src -e tcp.dstport -e ip.dst | sort -u > captura_nmap_5.csv

Clustering.

Ahora para los nodos event vamos a realizar clustering.

¿ Qué es clustering ?.

Se trata de agrupar un determinado tipo de nodo etiquetándolo de una forma generíca. Es decir, para nuestro caso, me da igual los números de puertos menores de 1024. Los quiero agrupar todos en un solo nodo y ponerle una etiqueta que diga >1024. Para ello creamos un nuevo fichero de porpiedades (ejercicio.properties) y modificamos la parte de nodos event, dejando tal como están source y target:

color.event=”blue” if ($fields[1]<1024);
cluster.event=”<1024″ if ($fields[1]<1024);
color.event=”lightblue”;

Esto significa que creamos un cluster llamado “<1024 » que agrupe todos los nodos event (tcp.dstport) que serán menores que 1024.

Ahora parseamos los datos con estas propiedades (ejercicio.properties):

> type captura_nmap_5.csv | perl afterglow.pl -c ejercicio.properties > captura_nmap_5.dot 

Gráfica fdp.

Un tipo de gráfica que, para nuestro caso,  clarifica un poco más los resultados:

> fdp -Tpng -o captura_nmap_5.png ./captura_nmap_5.dot

El resultado:

Ahora todos los nodos azules que correspondian a los puertos destino <1024 se integran en un solo nodo azul. El nodo amaillo de abajo es el host que realiza el scan de puertos.

Otro Ejemplo.

Tenemos otra captura cuyo destino del scan de puertos es toda una red local 102.168.1.0/24. No sé ahora cuantos hosts tiene esa red pero si son muchos es posible que la gráfica resulte muy engorrosa. Ni lo intento. Directamente voy a realizar clustering con las IP destino. Para este ejemplo no me interesan los puertos mayores de 1024, lo reflejaré en un cluster si exiten, solo los menores que los dejaré  tal cual para saber cuales son. Vamos a tomar como base el anterior archivo de propiedades ejercicio.properties y realizamos la siguiente modificaciónes:

#para los nodos origen

color.source=”green” if ($fields[0]=~/^192\.168\..*/);
cluster.source=”Red Local origen” if ($fields[0]=~/^192\.168\..*/);
color.source=”red”

#para los nodos eventos

color.target=”yellow” if ($fields[2]=~/^192\.168\..*/);
cluster.target=”Red Local destino” if ($fields[2]=~/^192\.168\..*/);
color.target=”yellow”;
cluster.target=”Red Externa” if ($fields[2]!~/^192\.168\..*/);

#para los nodos destino

color.event=”lightcyan” if ($fields[1]<1024);
color.event=”lighsalmon” if ($fields[1]>1024);
cluster.event=”>1024” if ($fields[1]>1024);
shape.event=”box”

He marcado en negrita donde os tenéis que fijar.

He creado:

• un cluster para la red local de origen
• un cluster parala red local de destino
• cluster la Red Externa destino
• cluster para eventos de puerto destino mayor que 1024

Y usaré grafica fdp.

Empezamos:

> tshark -r captura_nmap_3.cap -R “tcp” -T fields -E separator=, -e ip.src -e tcp.dstport -e ip.dst | sort -u > captura_nmap_3.csv

> type captura_nmap_3.csv | perl afterglow.pl -c ejercicio.properties > captura_nmap_3.dot

> fdp -Tpng -o captura_nmap_5.png ./captura_nmap_3.dot

El resultado:

Según hemos configurado en ejercicio.properties, tenemos una serie de nodos rojos que son IPs externas de origen. Cuadros azul claro son puertos menores de 1024. No aparece el cluster para mayor de 1024, entonces es que no existen. Se realizó el scan en un rango de 1-1024. Tenemos un nodo amarillo con una etiqueta de “Red local destino”, así que el destino del escan fue toda la red local. El resto de cluster no aparecen luego no existen.

Por cierto, ¿ existe un solo puerto de origen o hay varios ?:

En el archivo de propiedades ejercicio.properties modificamos solo los nodos event. Nodo event con circulo para diferenciar algo más:

color.event=”lightcyan”
shape.event=”circle”

En la línea tshark el event lo cambiamos de tcp.dstport a tcp.srcport.

En la línea de fdp añado -s250 para dar más resolución a la imagende los  resultante.

El resultado, ampliado a una zona es:

El puerto de origen usado por los hosts externos es 56. Vemos el nodo red local amarillo. Una serie de conexiones entre cluster red local origen y destino, es decir entre hosts de la red local. Uno de estos puertos es 445.

Como curiosidad y aplicando lo aprendido.

¿ Cómo se relacionan los host de una red entre ellos y la red externa atendiendo al protocolo usado ?.

Creamos un archivo de propiedades color.proto:

color.source=”green” if ($fields[0]=~/^192\.168\..*/);
color.source=”invisible”; # solo me interesa la red local

color.target=”yellow” if ($fields[2]=~/^192\.168\..*/);

#crear cluster si la IP destino es distinta a la local

color.target=”greenyellow” if ($fields[2]!~/^192\.168\..*/);
cluster.target=”Red Externa” if ($fields[2]!~/^192\.168\..*/);
shape.target=”circle“;

label.event=”ICMP” if ($fields[1] eq “0×01“);
color.event=”salmon” if ($fields[1] eq “0×01“);
label.event=”TCP” if ($fields[1] eq “0×06“);
color.event=”orange” if ($fields[1] eq “0×06“);
label.event=”UDP” if ($fields[1] eq “0×11“);
color.event=”red” if ($fields[1] eq “0×11“);
color.event=”gray”;
shape.event=”box”;

color.edge=”lightblue”;

Generando los datos y gráfica:

Usamos un fichero de captura de un laboratorio de pruebas, algunos hosts son virtuales.

> tshark -r 031110Vrt.cap -T fields -E separator=, -e ip.src -e ip.proto -e ip.dst | sort -u > protocolos.csv

> type protocolos.csv | perl afterglow.pl -c color.proto > protocolos.dot

> circo -Tpng -o protocolos.png protocolos.dot

El resultado:

Seguimos con algúnos ejemplos sencillos.

¿ Quién ha usado Skype en la red ?.

 

Tenemos un archivo diario de captura de red. La información que contiene, aún filtrada, es bastante abultada. Queremos saber de una forma rápida y sencilla quién usa skype en nuestra red (en negrita lo más importante):

> tshark -nn -r 02032011.pcap -R “dns” -T fields -E separator=, -e ip.src -e dns.qry.name -e ip.dst | sort -u > grafica_skype.csv

> cat grafica_skype.csv | perl afterglow.pl -c color.skype > grafica_skype.dot

> neato -Tpng -o grafica_skype.png ./grafica_skype.dot

El esquema de propiedades color.skype es el siguiente ( en negrita y color  lo más importante):

color.source=”yellow” if ($fields[0]=~/^192\.168\..*/);
color.source=”lightblue” if ($fields[0]=!~/^192\.168\..*/);
color.source=”invisible”;
shape.source=”ellipse”;

color.event=”red” if ($fields[1] =~ /ui.skype.com/);
color.event=”invisible“;
shape.event=”box”;

color.target=”green”;
shape.target=”ellipse”;

color.edge=”blue”;

El resultado:

Eventos SMB / Microsoft windows Browser Protocol.

 

Básicamente  registra los nombres SMB/CIFS/NetBIOS de una red, para almacena y compartir con los demás hosts de la red.

Nos centramos en

• Host Announcement para anuncio SMB (0×01).
• Request Announcement (0×02) para el request.
• browser.response_computer_name para respuesta de nombre de host.

> tshark -nn -r 02032011.pcap -T fields -E separator=, -e ip.src -e browser.command -e browser.response_computer_name | sort -u > grafica_smb.csv

> cat grafica_smb.csv | perl afterglow.pl -c color.smb > grafica_smb.dot

> neato -Tpng -o grafica_smb.png ./grafica_smb.dot

El esquema de propiedades color.smb es el siguiente ( en negrita y color  lo más importante):

color.source=”yellow” if ($fields[0]=~/^192\.168\..*/);
color.source=”lightblue” if ($fields[0]=!~/^192\.168\..*/);
color.source=”invisible”;
shape.source=”ellipse”;

color.event=”red” if ($fields[1] =~ /0×01/);
color.event=”salmon” if ($fields[1] =~ /0×02/);
color.event=”invisible“;
shape.event=”box”;

color.target=”green”;
shape.target=”ellipse”;

color.edge=”blue”;

El resultado:

• En rojo 0×01 Host Announcement
• Amarillo IPs de la red local
• Salmón 0×02 Request Announcement
  
• Verde Host Name en respuesta al Request Announcement

 

AfterGlow Para Windows.

 

En algún ejemplo os he indicado el uso de Afterglow, Tshark y GraphViz para Windows.

Para ello necesitamos:

• Active Perl: http://www.activestate.com/activeperl/downloads
• GraphViz para Windows: http://www.graphviz.org/Download_windows.php
• Se supone que tenemos o Tshark (línea de comandos para Wireshark) ó Windump, nuestro TCPDump para Windows.
• AfterGlow: http://afterglow.sourceforge.net/

La línea de comandos para generar el fichero .csv a partir de la cpatura .pcap :

C:\afterglow\src\perl\graph>windump -vttttnnel  -r captura1.pcap | perl tcpdump2csv.pl “sip dip sport dport” > captura.csv

Usamos el comandos MS-DOS type (en Linux usamos cat) para pasarlo al script afterglow.pl:

C:\afterglow\src\perl\graph>type captura.csv | perl afterglow.pl -c color.properties -p2 > captura.dot

Usamos neato, que está contenido en nuestro GraphViz que hemos instalado para Windows:

C:\afterglow\src\perl\graph>neato -Tpng -ografica.png captura.dot

Obtenemos la gráfica grafica.png que podemos visualizar con cualquier herramienta de Windows para tal propósito.

==

Y hasta aquí la primera parte de (9/10) Herramientas para la interpretación de capturas de red. Hasta la próxima.