17 de febrero de 2012

Bash Script: domain2nmap.sh

domain2nmap.sh

En esta entrada se muestra el código fuente del script domain2nmap.sh que recibe un nombre de dominio y utiliza el comando wget, el buscador Bing y/o Shodan para conseguir un listado relacionado con el mismo. Posteriormente realiza un escaneo con Nmap de las IPs que resuelven dichos dominios.

Sintaxis: ./domain2nmap.sh [OPTIONS] URL

Entre las opciones que podemos utilizar se incluye la posibilidad de elegir el motor de búsqueda: wget, Bing, Shoda o All. También podemos elegir entre realizar un escaneo de tipo SYN, ACK, UDP o Ping y guardar el reporte en formato XML, grepeable o normal.

En caso de lanzar el script sin opciones, utilizará todos los métodos de búsqueda para realizar un escaneo ping y guardar el resultado en formato XML.

Código fuente:
#!/bin/bash
#
# Name:         domain2nmap.sh
# Description:  This script receive a web domain name and obtain a list 
#               of associated domains and their IPs to make differents
#               scans with nmap.
# Author:       BrixtonC
# Date:         15 Feb 2012
# Version:      0.4
# Example:     ./domain2nmap.sh --help
#              ./domain2nmap.sh www.cnn.com
#              ./domain2nmap.sh -r shodan www.cnn.com
#              ./domain2nmap.sh -s A -o normal www.sun.com
#

### FUNCTIONS

function Usage {
# This function show the sintax of script and some examples. This function
# is call by Arguments function or errors.
#

 echo -e " Sintax:\t$0 [OPTIONS] URL\n"
 echo -e " Options:\t* Search methods (-r)"
 echo -e " \t\t   all:  Search with all methods (default**)"
 echo -e " \t\t   bing: Bing search with IP operator"
 echo -e " \t\t   shodan: Shodan search with hostname operator"
 echo -e " \t\t   wget: Search with wget command"
 echo -e " \t\t* Scan types (-s)"
 echo -e " \t\t   A: ACK scan"
 echo -e " \t\t   P: Ping scan (default**)"
 echo -e " \t\t   S: SYN scan"
 echo -e " \t\t   U: UDP scan"
 echo -e " \t\t* Out types (-o)"
 echo -e " \t\t   grep: Save scan in grepable format"
 echo -e " \t\t   normal: Save scan in normal format"
 echo -e " \t\t   xml: Save scan in xml format (default**)\n"
 echo -e " \t\t** Without options the script it's call with default options\n"
 echo -e " Examples:\t$0 www.cnn.com\n\t\t$0 -s A -o normal www.sun.com"
 echo -e "\t\t$0 -r shodan www.microsoft.com\n\t\t$0 -r wget -s U www.cnn.com\n"
 exit 0

}

function Arguments() {
# This function check the number of arguments, print error if don't pass
# any argument and define the domain name objetive for Resolv function.
#

 if [ "$#" == "0" ]; then
   echo -e "[*] ERROR: Valid domain name is required\n"
   Usage
 else

   if [ "$1" == "--help" ] || [ "$1" == "-h" ]; then
     Usage
   else
     local NAME="`echo $@ | awk '{print $NF;}' | sed 's/www\.//'`"
     CheckDomain $NAME
   fi

 fi

}

function CheckDomain() {
# This function run ping test to evaluate if the last argument's of script
# is a valid domain name and declarate the variable $DOMAIN. In wrong case,
# show error and exit.
#

 resolveip $1 > /dev/null

 [ "$?" != "0" ] && echo -e "[*] ERROR: '$1' not is a valid" \
   "domain name" && exit 1 || DOMAIN="`echo $1`"

 echo -e "[+] Domain name: $DOMAIN"

}

function Options() {
# This function receive all arguments to obtain the scan and output options
# to run nmap command with respective options. In default case, without
# options, run the script with ping scan and xml output format.
#

 while getopts "r:s:o:" OPTION; do

   case $OPTION in

       r)
  if [ "$OPTARG" == "bing" ]; then
    RESOLVTYPE="bing" && RESOLVNAME="Bing search"
  elif [ "$OPTARG" == "wget" ]; then
    RESOLVTYPE="wget" && RESOLVNAME="Wget search"
  elif [ "$OPTARG" == "shodan" ]; then
    RESOLVTYPE="shodan" && RESOLVNAME="Shodan search"
  elif [ "$OPTARG" == "all" ]; then
    RESOLVTYPE="all" && RESOLVNAME="All methods"
  fi
  ;;
       s)
  if [ "$OPTARG" == "P" ]; then
    SCANTYPE="-sn" && SCANNAME="Ping scan"
  elif [ "$OPTARG" == "S" ]; then
    SCANTYPE="-sS" && SCANNAME="SYN scan"
  elif [ "$OPTARG" == "A" ]; then
    SCANTYPE="-sA" && SCANNAME="ACK scan"
  elif [ "$OPTARG" == "U" ]; then
    SCANTYPE="-sU" && SCANNAME="UDP scan"
  fi
  ;;

       o)
  if [ "$OPTARG" == "xml" ]; then
    OUTTYPE="-oX" && OUTNAME="XML" && OUTEXT="xml"
  elif [ "$OPTARG" == "normal" ]; then
    OUTTYPE="-oN" && OUTNAME="Normal" && OUTEXT="txt"
  elif [ "$OPTARG" == "grep" ]; then
    OUTTYPE="-oG" && OUTNAME="Grep" && OUTEXT="log"
  fi
  ;;

   esac

 done

 [ -z "$SCANTYPE" ] && SCANTYPE="-sn" && SCANNAME="Ping scan (default)"
 [ -z "$OUTTYPE" ] && OUTTYPE="-oX" && OUTNAME="XML (default)" && \
   OUTEXT="xml"
 [ -z "$RESOLVTYPE" ] && RESOLVTYPE="all" && RESOLVNAME="All methods (default)"
 
 echo -e "[+] Search type: $RESOLVNAME"
 echo -e "[+] Scan type: $SCANNAME"
 echo -e "[+] Output type: $OUTNAME"

}

function Resolv {
# This function decide watch kind of search use: Wget, Bing, Shodan or All.
#

 if [ "$RESOLVTYPE" == "wget" ]; then
   WgetSearch
 elif [ "$RESOLVTYPE" == "bing" ]; then
   BingSearch
 elif [ "$RESOLVTYPE" == "shodan" ]; then
   ShodanSearch
 else
   WgetSearch
   BingSearch
   ShodanSearch
 fi
 
 grep -v "[0-9]f*" tmp | sort | uniq > domains.lst
 rm -rf tmp

}

function WgetSearch {
# This function save index Web page of the domain and obtain a list
# of domains relationated with domain target.
#

 echo -e "[+] Wget search domain: $DOMAIN"

 wget -q $DOMAIN > /dev/null

 grep -oE "http://[a-z0-9\-\.]*\.$DOMAIN" index.html | \
   cut -d "/" -f 3 >> tmp

 rm -rf index.html

}

function BingSearch {
# This function call Bing IP search to obtain a list of domains
# relationated with domain target.
#
# This functions is a modification of bing-ip2host script with
# GPLv3 license:
#
# http://www.morningstarsecurity.com/research/bing-ip2hosts
#

 local IP="`resolveip -s $DOMAIN`"
 local PAGE="0"

 echo -e "[+] Bing search IP: $IP"

 while (( "$PAGE" <= "10")); do

     local URL="http://m.bing.com/search/search.aspx?A=webresults&Q=ip%3a$IP&D=Web&SI=$PAGE"

     wget -q -O $IP-$PAGE.html $URL

     grep -oE "[a-z0-9\-\.]*\.$DOMAIN" $IP-$PAGE.html >> tmp
     rm -rf $IP-$PAGE.html

     PAGE="$(($PAGE + 1))"

 done

}

function ShodanSearch {
# This function run a Shodan hostname search to obtain a list of domains
# relationated with domain target.
#

 local URL="http://www.shodanhq.com/search?q=hostname%3A$DOMAIN"

 echo -e "[+] Shodan search domain: $DOMAIN"

 wget -q -O index.html $URL > /dev/null

 grep -E "class='hostname'" index.html  | \
          grep -oE "http://[0-9a-z\.\-]*\.$DOMAIN" | \
            cut -d "/" -f 3 >> tmp

 rm -rf index.html

}

function ResolvDomain {
# This function receive obtained domains names of domain target
# and translate it to their IP address.
#

 echo -e "[+] Resolving domains"

 for NAMES in $(cat domains.lst); do

   dig $DOMAIN | grep -oE "[0-9]{1,3}(\.[0-9]{1,3}){3}$" >> tmp

 done

 sort tmp | uniq > ipaddress.lst
 rm -rf tmp

}

function ScanIP {
# This function scan each host obtained with Resolv function throuth
# ipaddress.lst file and save the result in a file with IP and date
# as name.

 echo -e "[+] Scaning address"
 local NAME="${DOMAIN}_$(date +'%Y-%m-%d')"

 nmap $SCANTYPE $OUTTYPE $NAME.$OUTEXT -iL ipaddress.lst > /dev/null

 echo -e "[+] Filename: $NAME.$OUTEXT"

}

### SCRIPT

# Run Arguments function with all arguments separated to whitespaces to check
# the number of options and domain value.
#
Arguments $@

# Run Options function with all arguments to obtain the scan and output options
# to run the script
#
Options $@

# Run Resolv function with domain name as argument to obtain a list of
# related domains names.
#
Resolv

# Now check if exist domain.lst and ipaddress.lst file by use it in
# ResolvDomain and ScanIP functions. In wrong case show a error and run
# function Usage.
#
# FILE: domains.lst
[ ! -r domains.lst ] && echo "[*] ERROR: Can't read domains.lst file or" \
  "don't exist" && exit 2 || ResolvDomain
#
# FILE: ipaddress.lst
[ ! -r ipaddress.lst ] && echo -e "[*] ERROR: Can't read ipaddress.lst" \
  "file or don't exist" exit 3 || ScanIP

### NORMAL EXIT

# Show some exit messages.
#
echo -e "[+] Exit of script"

# Exit codes.
# 0 -> Succefull exit and function Usage()
# 1 -> No valid domain
# 2 -> Error file domains.lst
# 3 -> Error file ipaddress.lst
#
exit 0

#EOF
##FVE

En el siguiente enlace puedes ver una explicación del mismo así como las pruebas realizadas. Falla cuando Nmap recibe el archivo ipaddress.lst vacío y habría que retocarlo para controlar los fallos. Los comentarios están escritos en Inglés, o Spanglish mejor dicho. Puede haber errores idiomaticos, sintacticos y todos los que encuentres...

La función SearchBing es una modificación del script bing-ip2host de Andrew Horton que se licencia bajo GPLv3 al igual que los contenidos publicados en el blog. Sientete libre de reutilizar o modificar el mismo siempre tengas en cuenta el licenciamiento ; ).

Un saludo, Brixton Cat.

Bash Script: Automatizando el escaneo de dominios

Como comentaba en uno de los últmos post, o si me siges en Twitter lo puedes comprobar, últimamente ando leyendo todo lo que encuentro sobre programación y sobre todo en Python. En esta ocasión les traigo un pequeño script Bash que realicé como práctica del curso Introduction to Pentest Scripting y que con el permiso de mi querido amigo Roberto Martinez paso a comentar.

Manos a la masa

Introducción

El script básicamente toma un nombre de dominio y lo utiliza para obtener un listado de nombres relacionados con nuestro objetivo para realizar un escaneo con la herramienta Nmap. Sencillo no? En la siguiente imagen teneis un pequeño esquema del funcionamiento.


Como se puede apreciar, tenemos varias opciones a la hora de recopilar los nombres relacionados con nuestro dominio objetivo. El script utiliza el comando wget, Bing con el operador IP y el buscador Shodan utilizando hostname como parámetro de búsqueda. Comentar en este punto que la búsqueda de Bing es una modificación del script bing-ip2host que se licencia bajo GPL versión 3.

Una vez tenemos el listado de nombres de dominio, utilizamos la herramienta dig para resolver la dirección IP de éstos y pasarlos a Nmap para que nos realice el escaneo. El script no contempla todas las opciones que Nmap nos permite, pero sí las más básicas e importantes. Podemos realizar varios tipos de escaneo: SYN (-sS), ACK (-sA), UDP (-sU) y por Ping (-sn) y la salida generada la podremos guardar en formato normal (-oN), grepeable (-oG) o XML (-oX).


Como se puede ver en la ayuda del script, en caso de lanzarse el comando sin opciónes utilizará los valores por defecto para cada una. Utilizará todos los métodos para obtener los nombres de dominios relacionados, realizará un escaneo de pines y guardará la salida en formato XML.


Si lanzamos el script sin argumentos nos saca un error por pantalla indicando que es necesario un nombre de dominio válido y nos muestra la aydua del mismo.


El script generará dos archivos de texto uno para los nombres de dominio obtenidos, domains.lst, y otro con las IPs que los resuelven, ipaddress.lst.


Comprobaciones

Para esta primera prueba voy a explayarme un poco y utilizaremos todos los métodos de búsqueda para comprobar que obtenemos un listado único de nombres de dominio así como de las IPs que los resuelven. El resto de opciones las mantendremos por defecto.

* Opción wget: Básicamente descargamos y recorreremos el index del dominio objetivo en búsca de enlaces que apunten a otros subdominios.
./domain2nmap.sh -r wget www.cnn.com

* Opción bing: En este caso utilizamos el buscador Bing con el operador hostname para obtener un listado de dominios asociados a la IP que buscamos.
./domain2nmap.sh -r bing www.cnn.com

* Opción shodan: Vamos a lanzar una consulta por hostname al buscador Shodan y nuevamente a generar un listado con los dominios obtenidos.
./domain2nmap.sh -r shodan www.cnn.com

* Opción all: Esta es la opción por defecto y utiliza los métodos anteriores para generar la lista de dominios.
./domain2nmap.sh [-r all] www.cnn.com

Como podeis observar en las siguientes capturas, si juntamos los archivos obtenidos anteriormente, ordenamos y quitamos los repetidos. Obtenemos el mismo número de elementos que utilizando la búsqueda por defecto. Parece que no funciona mal al fin y al cabo : )



Pruebas varias

* Dominio: www.abc.com
* Busqueda: Bing
* Escaneo: Syn
* Salida: Grepeable

Vamos a generar un reporte en formato grepeable (filtrable) de un escaneo SYN realizado a las IPs que resolvamos de los dominios relacionados utilizando el buscador Bing.
./domain2nmap.sh -r bing -s S -o grep www.abc.com

* Dominio: www.hoy.es
* Busqueda: All (Default)
* Escaneo: Ping (Default)
* Salida: XML (Default)

En este caso vamos a lanzar el script sin opciones para que utilice los valores por defecto. Va a guardarnos un archivo XML de un escaneo de pines a todas las IPs de los nombres de dominios obtenidos a partir de todos los métodos de búsqueda: wget, Bing y Shodan.
./domain2nmap.sh www.hoy.es

Conclusiones

Éste script es un ejemplo de cómo obtener información acerca de un dominio tanto pasiva como activa dentro de la fase de information gathering, en la que descubrir la máxima información posible sobre el objetivo. Las consultas al buscador Bing se basan en el trabajo de Andrew Horton con su script bing-ip2host que se licencia bajo GPLv3 al igual que los contenidos del blog, salvo sea contrario a lo dicho en el artículo.

El código completo del script lo puedes encontrar en el siguiente enlace (domain2nmap.sh), sientete libre de reutilizarlo o mejorarlo, añadirle más opciones, nuevas funciones, etc.

Algunas [posibles/futuras] mejoras serían:

- Buscar también los nombres que utilicen otro TLD (Top Level Domain).
- Pasar a Bing todas las IPs de resolveip.
- Shodan logeado para obtener todas las funciones?
- Wget: búsquedas relacionadas con el dominio (sin TLD).

En algunas pruebas realizadas no ha generado correctamente los archivos de dominios e IPs y falla al realizar el escaneo a objetivos inexitentes. Habría que depurarlo más a fondo y comprobar debidamente el fichero que utiliza Nmap para realizar las pruebas, ipaddress.lst.

No quiero despedirme sin dedicar el post y el script a mi buen maestro Roberto dado que éste se basa en las prácticas de su curso, solo que ampliado y corregido levemente ; ). Muchas gracias Master!

Un saludo, Brixton Cat.

10 de febrero de 2012

Python script: BssidFromPcap.py paso a paso

En este post quiero explicar paso a paso como crear un script en Python que nos guarde en un archivo de texto las direcciones MAC de los APs disponibles en un archivo de captura PCAP. En este enlace puedes encontrar una pequeña explicación del mismo así como el código fuente del script final.

Versión 0.0

Dado que vamos a utilizar Scapy para manipular los paquetes de red, en primer lugar deberemos importar todos los métodos que ésta libreria nos permite.
from scapy.all import *
Creamos el objeto outfile, con el que creamos y abrimos el archivo de salida para los datos.
outfile = open('./Out.lst', 'w')
Especificamos el archivo de captura, en este caso hardcodeado, y creamos un nuevo objeto (capture) con el método rdpcap para leer el archivo de captura.
capfile = '../out-01.cap' # Change this!
capture = rdpcap(capfile)
Python es un lenguaje altamente secuencial, por lo que un simple for nor permite iterar fácilmente entre los distintos paquetes que contiene nuestro objeto capture.
for pcks in caputre:
   [...]
Hay que tener muy encuenta la identación, tabulaciónes, pues es un factor clave dentro del lenguaje y nos delimita las clases, funciones, estructuras de control, etc. dentro de nuestro código.

En una primera versión, vamos a registrar todas las direcciones físicas de los paquetes capturados en un nuevo objeto llamado bssid.
bssid = pcks.addr2
Realizamos un filtro para direcciones nulas, 00:00:00:00:00:00, a través del objeto blank para pasar a la siguiente iteración.
blank = '00:' * 5 + '00'
if bssid == blank:
    continue
En caso contrario, escribimos la MAC en el archivo de salida, outfile.
outfile.write(bssid + "\n")
Para finalizar, cerramos el archivo de salida.
outfile.close()
El código de esta primera versión sería:
#!/usr/bin/env python

from scapy.all import *

outfile = open('./Out.lst', 'w')
capfile = '../out-01.cap' # Change this!
capture = rdpcap(capfile)
blank = '00:' * 5 + '00'

for pcks in capture:

  bssid = pcks.addr2
  
  if bssid == blank:
    continue
  else:
    outfile.write(bssid + "\n")

outfile.close()
Y una primera prueba del mismo


Versión 0.1

Para mejorar el código anterior, vamos a eliminar los resultados repetidos. Para ello utilizamos un nuevo array, unique, con el que comprobar la existencia del objeto bssid. En caso incorrecto, añadimos dicho valor al array y lo escribimos al archivo de salida.
else:
  unique = []
  if unique.count(bssid) == 0:
    unique.append(bssid)
Si utilizamos el mismo archivo de captura obtenemos el siguiente resultado


Versión 0.2

Una mejora indispensable, es que podamos elegir el archivo de captura a analizar. Para ello deberemos importar el módulo sys que nos permite usar el método argv para acceder a los argumentos del script.
import sys

capfile = sys.argv[1]
Para finalizar, únicamente vamos a analizar los paquetes beacon frame exitentes en los archivos de captura y en caso contrario pasaremos al siguiente paquete.
if pcks.haslayer(Dot11Beacon):
  [...]
else:
  continue
El código final, sin comentar, es el siguiente. Para una versión completa del mismo, visita el siguiente enlace.
import sys
from scapy.all import *

outfile = open('./Out.lst', 'w')
capfile = sys.argv[1]
capture = rdpcap(capfile)
blank = '00:' * 5 + '00'
unique = []

for pcks in capture:

  if pcks.haslayer(Dot11Beacon):
    bssid = pcks.addr2
  
    if bssid == blank:
      continue
    else:
      if unique.count(bssid) == 0:
        unique.append(bssid)
        outfile.write(bssid + "\n")

  else:
    continue

outfile.close()
Realizando algunas pruebas

Utilizando el mismo archivo de captura, obtenemos el siguiente resultado.


Con otro archivo de captura


Si realizamos una captura de varios APs y lanzamos el script al archivo de captura, podemos comprobar que genera una lista con BSSIDs únicos presentes en la red.


Un saludo, Brixton Cat ; )

28 de enero de 2012

Simulando una red corporativa: Instalando la red VoIP

Continuando con la serie Simulando una red corporativa, en esta entrada voy a describir el proceso para instalar una red de telefonía utilizando Cisco Call Manager Express como centralita IP PBX para manejar las llamadas y contar con la posibilidad de interconectar la red de datos (IP) con la red telefónica tradicional (PSTN).

En nuestro caso, el más sencillo, crearemos un Dial Peer (1)(2) para enrutar las llamadas entre las sedes remotas. Además deberemos configurar un Pool DHCP, opción 150, que será utilizado para dar direccionamiento a los teléfonos IP así como a las aplicaciones de telefonía.


Los datos completos del direccionamiento del laboratorio los podeis encontrar en el siguiente documento.

Desplegando la red VoIP

En primer lugar deberemos configurar la VLAN de telefonía tanto en los routers como en los swtiches de cada sede, en nuestro caso VLAN 40, al igual que añadir la red a la configuración RIP para que nos la enrute.


Comprobamos que tenemos conexión:


Tendremos que configurar el direccionamiento para la VLAN así como el modo de acceso en los distintos puertos de los switches. Utilizaremos el comando switchport voice vlan 40 para permitir el tráfico de voz por los puertos access. Los puertos trunks deberemos resetearlos tras añadir la VLAN con el comando switchport trunk allowed vlan add 40.






Comprobamos la conexión entre las sedes remotas.


Cisco Call Manager Express

En Packet Tracer, el servicio CME está disponible en los dispositivos de la serie 2800 incluidos por defecto en la instalación. Deberemos por tanto migrar nuestra configuración a un equipo superior para poder continuar con la instalación del servicio.




Configuramos un pool de direcciones DHCP para cada sede con la opción 150, una puerta de enlace por defecto y las direcciones IP excluidas. Además configuraremos el número máximo de teléfonos (ephones) y extensiones (dn), la dirección donde se registrarán los terminales a través del protocolo SCCP (3) y la auto-asignación pero no funciona muy bien que digamos...


También debemos crear las distintas extensiones indicando la numeración que utilizarán


Una vez tenemos configurado todo, podemos empezar a conectar terminales y ver como se registrar y toman un extensión. El siguiente enlace muestra información sobre el registro de teléfonos SCCP y SIP en centralitas Cisco Call Manager.


Y si realizamos una llamada entre las extensiones de una misma sede, ésta se realizará correctamente


Conectando sedes

La gracia de todo esto no es que podamos solamente realizar llamadas locales, también podemos realizar llamadas entre distintas sedes estableciendo Dial Peers entre ellas. Deberemos especificar la numeración destino y la sesión a través de la que se enrutarán las llamadas para un dial peer dado.

Sede Central
Sede Externa
Si realizamos llamadas entre las sedes, igualmente se establecen correctamente.


Me gustaría seguir jugando con Packet Tracer y algunas otras opciones y características interesantes que incluyen las últimas versiones del programa, un resumen con los comandos realizados así como publicar los archivos pkt, etc.

Enlaces de referencia

1. http://www.cisco.com/en/US/tech/tk652/tk90/technologies_tech_note09186a008010ae1c.shtml
2. http://www.cisco.com/en/US/docs/ios/12_3/vvf_c/dial_peer/dp_plan.html
3. http://www.cisco.com/en/US/products/sw/voicesw/ps556/products_tech_note09186a00801a62b9.shtml

Un saludo, Brixton Cat.

24 de enero de 2012

Python Script: BssidFromPcap.py

BssidFromPcap.py

En esta entrada se presenta el código fuente del script BssidFromPcap.py desarrollado para obtener un listado de BSSIDs únicos contenidos en un archivo de captura PCAP que será pasado como argumento al script.

Sintaxis: ./BssidFromPcap.py archivo.pcap

Es necesario especificarle un archivo de captura PCAP como primer argumento del script donde leerá los paquetes secuencialmente para obtener la dirección MAC origen de los paquetes Beacon Frames que existan. El script no comprueba la existencia del fichero y tampoco existen un control de errores, try y execption, etc...

Código fuente:
#!/usr/bin/env python
#
# Name: BssidFromPcap.py
# Decription: List unique BSSIDs from pcap capture file.
# Date: 23 Jan 2012
# Author: Brixton Cat
# Version: 0.2
#

### Import modules

import sys
from scapy.all import *

### Declare variables and constants

# Open output file
outfile = open('./Out.txt', 'w')
# Obtain pcap capture file from first arguments
capfile = sys.argv[1]
# Open pcap capture file with scapy
capture = rdpcap(capfile)
# Filter for blank MAC address: 00:00:00:00:00:00
blank = '00:' * 5 + '00'
# Blank array for unique bssids
unique = []

### Script

# Read pcap capture file
for pcks in capture:

  # If pcks is Dot11 (802.11) package
  if pcks.haslayer(Dot11Beacon):
    # Obtain MAC address from package
    bssid = pcks.addr2
  
    # If bssid is blank go to next iteration
    if bssid == blank:
      continue
   
    # Check if exist bssid in unique array and append it
    else:
      if unique.count(bssid) == 0:
        unique.append(bssid)
        # Write bssid in outfile
        outfile.write(bssid + "\n")
 
  # Else go to next iteration
  else:
    continue

# Close output file
outfile.close()

#EOF
##FVE
En esta entrada puedes ver más información sobre el mismo así como unas imágenes con algunas pruebas realizadas.

Un saludo, Brixton Cat ; )

Python Script: Obteniendo BSSIDs de un archivo pcap

Buenas a tod@s! Se que tengo varias series por terminar, como configurar el servidor MySQL y el CMS Drupal para nuestro cluster web de alta disponibilidad o la instalación de la red VoIP utilizando Cisco Call Manager Express de nuestra simulación de una red corporativa. Pero en el primer caso haciendo pruebas me carge la configuración de DRBD y en el segundo caso tengo que tomar las capturas para escribirlo. Todo a su tiempo, todo a su tiempo...

De todas maneras, no solo de administración podemos vivir y la programación es una tarea fundamental para cualquier geek/freak/nerd/hacker/hack0r, o como mejor querais llamaros... Aprovechando que hace poco he terminado el curso Introduction to PenTest Scripting impartido por Roberto Martinez, gran maestro y persona, que ha montado un programa de cursos de lo más interesante utilizando webinars para crear clases virtuales a través de Internet y una posible futura aula virtal donde se añadirá la modalidad E-learning.

http://commons.wikimedia.org/
Volviendo con la entrada... El script nos va a generar un archivo lista con BSSIDs únicos presentes en un archivo de captura PCAP que le pasaremos como argumento. Voy a hacer uso del modulo Scapy para Python que se incluye en la instalación de BackTrack 5, pero si es necesario añadirlo a vuestras librerias lo podeis encontrar en la Web del desarrollo.

En esta entrada voy a resumir los pasos fundamentales del script y las pruebas realizadas, podeis encontrar el código completo en la siguiente entrada (BssidFromPcap.py) y una descripción del proceso de creación para los novatos como yo (aqui).

Explicación

En primer lugar declaramos algunas variables y objetos que serán utilizados a lo largo del script, en este paso especificamos el archivo de captura y de salida al igual que los abrimos para asociarlos a sus respectivos objetos.
# Open output file
outfile = open('./Out.lst', 'w')
# Obtain pcap capture file from first arguments
capfile = sys.argv[1]
# Open pcap capture file with scapy
capture = rdpcap(capfile)
# Filter for blank MAC address: 00:00:00:00:00:00
blank = '00:' * 5 + '00'
# Blank array for unique bssids
unique = []
Recorremos el archivo de captura para comprobar que el paquete se trata de un  Beacon Frame (Dot11Beacon) del que obtenemos la dirección física origen, BSSID, y comprobamos que no es un valor nulo: 00:00:00:00:00:00.
# Read pcap capture file
for pcks in capture:

  # If pcks is Dot11 (802.11) package
  if pcks.haslayer(Dot11Beacon):
    # Obtain MAC address from package
    bssid = pcks.addr2
  
    # If bssid is blank go to next iteration
    if bssid == blank:
      continue
La explicación que he encontrado sobre esta dirección (1)(2)(3), es que se utiliza como dirección destino en algunos ARP Request y en paquetes ARP Gratuitous, pero en las capturas aparecen valores nulos como origen de algunos paquetes. En los paquetes Beacon no he encontrado ninguno pero manteniendo el filtro nos aseguramos que se obvien en caso que se cuele alguno.


Si no existe el BSSID en el array unique, se añade a la lista y se escribe en el archivo de salida. En caso que el condicional sea falso, no guardará el BSSID en el array ni en el archivo de salida asegurando así que no se repiten resultados.
    # Check if exist bssid in unique array and append it
    else:
      if unique.count(bssid) == 0:
        unique.append(bssid)
        # Write bssid in outfile
        outfile.write(bssid + "\n")
Para finalizar cerramos el archivo de salida antes de salir del script.
# Close output file
outfile.close()
Pruebas

Auditando una red

Este es el archivo con el que estuve realizando la creación del script, corresponde con una captura realizada con airodump-ng sobre un AP específico en el que hay conectado un cliente. En entradas posteriores intentaré detallar la creación del script donde se entenderá mejor.


Auditando varias redes

Este otro caso, correponde con una captura realizada también con airodump-ng pero sin filtrar por una red concreta. Obtendremos múltiples direcciones MAC que serán filtradas para evitar duplicados en el archivo de salida. Igualmente, en la explicación detallada se verá más en detalle este proceso y el resultado.


Comentario final

Ya para finalizar, solo quiero decir que el script ya estaba inventado... Para crearlo me he basado en información de blogs y páginas de Internet (4)(5) y únicamente lo he ordenado a mi manera así como he personalizado las variables y nombres de los objetos.

La realización del script me ha resultado francamente simple dada la posibilidad que nos brinda Scapy para utilizar su nomenclatura y métodos, que junto a la facilidad de escriptura de Python nos permite crear herramientas complejas y altamente potentes. Sobra decir que esto solo es un pequeño programa que puede ser utilizado en un script más complejo o con más opciones a través de funciones, clases, etc.

En los enlaces anteriores podeis encontrar explicaciones en las que me he basado así como ejemplos y métodos de Python que podemos aplicar en nuestros desarrollos. Yo tengo alguna que otra idea en mente, aunque solo sea por enreadar y aprender el lenguaje...

Enlaces de referencia

1 - http://wiki.wireshark.org/Gratuitous_ARP
2 - http://cauew.blogspot.com/2008/08/arp-rarp-proxy-arp-gratuitous-arp-and.html
3 - http://www.certforums.co.uk/forums/networks/43139-help-wireshark-newbie.html
4 - http://www.packetstan.com/2011/03/extracting-ap-names-from-packet.html
5 - http://www.devx.com/security/Article/34741/1954

Un saludo, Brixton Cat.

7 de enero de 2012

Simulando una red corporativa: Host y otras opciones

Siguiendo con la serie Simulando una red corporativa vamos a ir añadiendo hosts a nuestro escenario, instalaremos varios servidores y comprobaremos desde los clientes que tenemos acceso a los servicios; tanto dentro de la sede como desde la sede externa. Después realizaremos algunas pruebas y otras configuraciones que nos permite Packet Tracer con las que jugar un poco con la red que estamos creando.

El escenario final a configurar será:


Iremos añadiendo equipos y en cada uno deberemos configurar varias cosas: Gateway, la velocidad y el modo de la interfaz, una dirección IP y una máscara de red.





En el caso de los servidores, desactivaremos los servicios que no utilizaremos para evitar tráfico innecesario de la red.


Configuraremos también en cada switch los puertos donde se conectarán los equipos, para ello deberemos especificar el modo de la VLAN y el ID con la que etiquetar los paquetes, el modo y la velocidad de la interfaz y una descripción con la que reconocer fácilmente la configuración.


Podemos comprobar la configuración con el comando show running-config 


Podemos realizar algunas pruebas de pines para comprobar que tenemos conexión desde los servidores hasta la sede externa.


Otras configuraciones

Servidor Syslog

Configuraremos los equipos para que envien los eventos del log a un servidor centralizado donde leer "comodamente" los registros. Para ello, utilizaremos los siguientes comandos para definir el servidor y el nivel de registro de los eventos.


Podemos comprobar que el servidor registra los eventos de los distintos equipos.


Backup Startup-Config

Con el comando copy startup-config tftp: y especificando la dirección IP del servidor TFTP podemos volvar la configuración de arranque del sistema (startup-config).


Actualizar IOS

Podemos actualizar la versión de la IOS de los dispositivos con el comando copy tftp: flash: e indicando la dirección IP del servidor y el nombre origen y destino del fichero.


Podemos especificar las IOS que serán cargadas durante el arranque del equipo con el comando boot system file1;file2;...


Y reiniciamos el equipo para que cargue la nueva IOS


Igualmente podemos actualizar la versión software de los routers que tenemos instalados y especificar la IOS que será cargada durante el arranque.


Cargar configuracion

En el caso que tengamos una avería en uno de los equipos y sea necesario cambiarlo, si tenemos un backup con la configuración podemos cargarla en el nuevo equipo. Primero deberemos configurar una dirección IP válida con la que comunicarnos con el servidor TFTP, en este caso será necesario configurar además una VLAN y un puerto que la utilice.


Le damos una puerta de enlace y comprobamos que tenemos conexión con el servidor TFTP.


Con el comando copy tftp: startup-config, especificando la dirección IP del servidor y el nombre del fichero origen nos guardará la nueva configuración de arranque para el equipo.


Nuevamente con el comando show running-config chequeamos la configuración recien cargada y comprobamos que tenemos conexión con el resto de redes.



Servidor Web

Creamos un servidor Web para realizar algunas pruebas y comprobamos que desde los clientes podemos acceder al mismo.


En siguientes entradas configuraremos los routers de las sedes con el servicio de telefonía e implementar una solución VoIP básica utilizando las configuraciones CME que Packet Tracer nos permite.

Un saludo, Brixton Cat.