Mostrando entradas con la etiqueta script. Mostrar todas las entradas
Mostrando entradas con la etiqueta script. Mostrar todas las entradas

19 de enero de 2013

Python Script: QosCalc.py

Feliz año, merry christmas y esas cosas que se dicen... Ya se que es un poco tarde pero es mi primera entrada del año y tenía que decirlo en algún momento. Tengo varias entradas entre manos y algunas de ellas dedicadas a scripts Python que estoy realizando.

En esta entrada voy a mostrar la actualización que he realizado del script TosCalc.py, descrito en esta entrada. En primer lugar le he cambiado el nombre porque el anterior no me convencía, he utilizado la variable self para almacenar todos los valores que se van calculando y un pequeño control de excepciones que controla los errores el script.

El script acepta solamente un argumento y éste debe ser un número entero (de tipo int), en caso de no pasar un número fallará salvo algunas excepciones siempre y cuando los valores estén comprendidos entre el 1 y el 7.


Sintaxis: ./QosCalc.py value

Código fuente:
#!/usr/bin/env python
#
# Name: QoSCalc.py
# Description: Calculate any QoS values through a IP Precedence or Class Selector
# Author: Brixton Cat
# Date: 19 Ene 2013
# Version: 1.0
# Sintax: ./QoSCalc.py value
#
 
### Dependencies
import sys
 
### tosCalc class
class qosCalc:
  """ Class to calc any QoS values through a IP Precedence or
      Class Selector """
  
  def __init__(self, value):
    """ Initializing qosCalc class """
    self.value = value                            # Creating value variable
    
    # Check value introduced
    if value < 1 or value > 7:
      print "[!] Error: Allow values it's from 1 to 7"
      sys.exit(3)                                 # Exit code: 3

  def eightBits(self):
    """ This function add 0s to right side of binary variable and calc their
        decimal value """

    self.tosb = self.dscpb + str(0) * 2           # Type of Service binary value
    self.tosd = int(self.tosb, 2)                 # Type of Service decimal value

  def main(self):
    """ Main function """
    
    calc.threeBits()
    calc.sixBits()
    calc.eightBits()

  def results(self):
    """ Prints values of the IP Precedence or Class Selectors argument """
  
    # Header of table
    print "Value  3bits   DSCP Bin  DSCP   ToS Bin   ToS"
    print "-----  -----   --------  ----   -------   ---"
    # Values
    print "  %d\t%s\t%s\t  %d\t%s  %d" % \
      (self.value, self.binary, self.dscpb, self.dscpd, self.tosb, self.tosd)

    return sys.exit(0)

  def sixBits(self):
    """ This function add 0s to right side of binary variable and calculate
        their decimal value """
  
      self.dscpb = self.binary + str(0) * 3       # DSCP binary value
      self.dscpd = int(self.dscpb, 2)             # DSCP decimal value

  def threeBits(self):
    """ This function convert decimal argument to 3 bits value and check
        correct lenght of this """

    # If less of 3 bits, add 0s to left of binary variable
    bina = bin(self.value).split('b')             # Array ['0', 'value']
    if bina[1] < "3":
        rest = 3 - len(bina[1])
        self.binary = str(0) * rest + bina[1]
    else:
        self.binary = bina[1]

### Script
if __name__ == "__main__":
  try:
    value = int(sys.argv[1])                      # Check first argument
    
    calc = qosCalc(value)                         # Initializing qosCalc class
    calc.main()                                   # Run main() function
    calc.results()                                # Prints results
    
  except IndexError:                              # Error: No argument
    print "[!] Error: Any value defined"
    sys.exit(1)                                   # Exit code: 1
    
  except ValueError:                              # Error: Bad arguments
    print "[!] Error: Not valid Class Selector or IP Precedence value"
    sys.exit(2)                                   # Exit code: 2

#EOF
##FVE

Un saludo, Brixton Cat

27 de marzo de 2012

Bash Script: Transferencias de zonas públicas

Hoy traigo un post sobre DNS y transferencias de zonas, tanto de forma teórica como práctica, pero también he de decir que en esta entrada no voy a descubrir nada nuevo sobre el protocolo o las maneras de explotarlo. Entremos en materia...

Introducción

El protocolo DNS es utilizado para la resolución de direcciones IP a nombres de hosts y dominios, de forma directa (nombre -> IP) e inversa (IP -> nombre). Tradicionalmente, utiliza el puerto 53 del protocolo de transporte UDP para el envio y recepción de consultas, aunque últimamente han surgido proyectos para la utilización de TCP para proteger dichas conexiones.

Cada dominio es considerado dentro del servidor como un ente independiente que recibe el nombre de zona y entre los registros que se pueden definir dentro de las zonas podemos encontrar:
* A. Resolución de nombre a IP.
* CNAME. Alias para un mismo host.
* PTR. Punteros para resolución inversa.
* MX. Servidores de correo electrónico.
* SRV. Localizador de servicios.
* TXT. Información en texto plano.
Dentro de la configuración de cada dominio, se define el campo SOA (Start of Authority) que se utiliza para realizar un control de cambios sobre dicha información. Puede ser configurado de manera manual o automática pero hay que tener en cuenta que a través de este valor, los servidores determinarán si la información es más reciente que la que tienen almacenada.

Debido a la estructura distribuida del protocolo, se utilizan las denominadas transferencias de zonas para retransmitir la información de servidores maestros hasta otros secundarios. Con ello se asegura la disponibilidad de los nombre de dominio consiguiendo una estructura jerarquizada de tipo árbol.


En caso que las zonas no estén correctamente configuradas, una tercera persona es capaz de obtener dicha información a través de los servidores maestros.

Consultas AXFR

Como comentaba anteriormente, las transferencias de zonas se utilizan para retransmitir los registros DNS entre servidores maestros y esclavos. Existen varias consultas que pueden ser realizadas a dichos servidores: completas (AXFR) e incrementales (IXFR).

Generalmente las transferencias de zonas se realizan utilizando el puerto 53 del protocolo TCP, aunque depende de la configuración del servidor así como de las herramientas que utilicemos.

Primero obtenemos la dirección IP del dominio


Se realiza una consulta SOA y queda a la espera de la respuesta, así se asegura que dispone de la última información sobre el dominio.


Posteriormente se realiza la propia consulta AXFR para obtener la información. En caso de visualizar la captura de red con Wireshark, nos muestra una petición y una respuesta para dicha consulta.


Podemos comprobar con más detalle que se establece la conexión


Se realiza la propia transferencia de zona, en la que se van añadiendo paquetes para formar la consulta.


Y se cierra la conexión


Herramientas

nsloouk

Nslookup es una de las herramientas que tradicionalmente se ha utilizado para la resolución de nombres DNS. Aunque se pueden añadir opciones al comando, su mayor potencial la obtenemos de forma interactiva:

Comandos: # nslookup
                    > set all
                    > dominio


Podemos realizar una consulta para obtener los DNS asociados al dominio

Comandos: > set q=NS
                    > dominio


O consultar cúal es el servidor maestro

Comandos: > set q=HINFO
                    > dominio


En este caso las transferencias de zonas no parecen funcionar, si lanzamos el comando ls o si visitamos el manual de la herramienta, vemos que no esta implementado.


Como comentaba anteriormente, también es posible realizar algunas consultas desde la línea de comandos


host 

La herramienta host también nos permite realizar consultas específicas sobre determinados registros, así como realizar transferencias de zonas.

Comando: host -t NS domain


Comando: host -l domain



En este caso, obtenemos un time out porque no ha conseguido conectar con el servidor, pero no significia que no puedan realizarse.

dig

Dig es un cliente en línea de comandos e interactivo para la resolución de nombres de dominios, viene incluida en la suite BIND y reemplaza a las herramientas anteriormente descritas. Debido al potencial y flexibilidad de la herramienta, es muy utilizado para la resolución de problemas relacionados con servidores DNS.

Para obtener los servidores de nombres asociados con el dominio objetivo, utilizaremos el comando:

Comando: dig NS domain


Para realizar la transferencia de zonas propiamente dicha utilizaremos:

Comando: dig axfr @NS domain


Automatización

Podemos utilizar las herramientas aqui descritas para crear scripts con los que automatizar y filtrar las consultas. En mi caso he creado un script en bash, ZoneTransfers.sh, que utiliza dig para obtener los servidores de nombres e intentar recopilar la información del dominio que pasemos como argumento del mismo.


Me he inspirado en el siguiente script del amigo Zerial, para obtener un listado único de nombres de hosts así como de direcciones  relacionadas con el dominio objetivo.




Recientemente he estrenado un repositorio público en Github donde almacenar los distintos scripts que vaya desarrollando, en él podeis encontrar este último así como un pequeño archivo README con la descripción del mismo.

Tened en cuenta que la transferencia de zonas es un ataque activo dado que consultamos directamente los servidores DNS objetivos. Esta entrada se publica de modo informativo y para un uso educativo del protocolo y las herramientas disponibles. En ningún caso se incita a los lectores a realizar dichas consultas y no me responsabilizo del uso que terceras personas puedan dar de esta información, así como los daños que puedan provocar.

Un saludo, Brixton Cat.

11 de marzo de 2012

Python Script: ToSCalc.py

ToSCalc.py

En esta entrada se muestra el código fuente del script ToSCalc.py con el que calcular los distintos valores ToS y DSCP para configuraciones de calidades de servicio.

Sintaxis: ./TosCalc.py VALUE

VALUE corresponde a los posibles valores configurables dentro del campo IP Precedence o Class Selectors para la priorización de tráfico en las redes IP.

Código fuente:
#!/usr/bin/env python
#
# Name: ToSCalc.py
# Description: Calculate ToS and DSCP values for IP Precedence
# or Class Selector argument.
# Author: Brixton Cat
# Date: 10 Mar 2012
# Version: 0.1
# Sintax: ./ToSCalc.py VALUE
#

### Dependencies
import sys

### Functions
def Arguments(decimal):
    """ This function check the introduced argument and call ThreeBits
    function if the value is correct """

    # If not valid value, exit of script
    if decimal < 1 or decimal > 7:
        print "ERROR: %d not valid CS or IP Precedence value" % \
            decimal
        sys.exit(1)
    else:
        ThreeBits(decimal)

def ThreeBits(decimal):
    """ This function convert decimal argument to a 3 bits value and
    check correct lenght of this """

    # Array ['0', 'value']
    bina = bin(decimal).split('b')

    # If less of 3 bits, add 0s to left of binary variable
    if bina[1] < "3":
        rest = 3 - len(bina[1])
        binary = str(0) * rest + bina[1]
    else:
        binary = bina[1]
 
    # Run SixBits functions
    SixBits(decimal, binary)

def EightBits(decimal, binary, dscpb, dscpd):
    """ This function add 0s to right of tosb variable and run Results
    function with all prints values """

    # Rest of 8 and binary lenght
    rest = 8 - len(binary)
    # Type of Service binary value
    tosb = binary + str(0) * rest
    # Type of Service decimal value
    tosd = int(tosb, 2)

    # Call Results function with all values
    Results(decimal, binary, dscpb, dscpd, tosb, tosd)

def Main():
    """ Declare decimal variable and run Arguments function with
    this value """

    # Fisrt argument of the script
    decimal = int(sys.argv[1])
    # Run Arguments functions
    Arguments(decimal)

def Results(decimal, binary, dscpb, dscpd, tosb, tosd):
    """ Prints values relationated with IP Precedence or Class
    Selectors introduced argument"""

    # Header
    print "Value  3bits   DSCP Bin  DSCP   ToS Bin   ToS"
    print "-----  -----   --------  ----   -------   ---"
    # Values
    print "  %d\t%s\t%s\t  %d\t%s  %d" % \
        (decimal, binary, dscpb, dscpd, tosb, tosd)
 
def SixBits(decimal, binary):
    """ This function add 0s to right of dscpb variable and calculate
    their decimal value """

    # DSCP binary value
    dscpb = binary + str(0) * 3
    # DSCP decimal value
    dscpd = int(dscpb, 2)
 
    # Run EightBits function
    EightBits(decimal, binary, dscpb, dscpd)

### Script
Main()

### Exit
# Exit Codes
# 0 -> Normal exit
# 1 -> No valid argument
sys.exit(0)

#EOF
##FVE
En la siguiente entrada hay información sobre el mismo así como algunas pruebas multiplataforma.

Un saludo, Brixton Cat.

Python Script: Calculando calidades de servicio

Como hace poco he estado indagando sobre Quality of Service, Type of Service, Class Selectors y demás campos con los que priorizar el tráfico en las redes IP, he creado un script (ToSCalc.py) en Python que calcula los distintos valores decimales y binarios de estos.

El script recibe los posibles valores de nuestras configuraciones IP Precedence y Class Selectors, devolviendo los valores decimales y binarios para los campos Differentiated Services Code Points (DSCP) y Type of Service (ToS).


Como todavía estoy aprendiendo Python no he sido capaz de hacer una función ayuda, por lo que si se lanza el script sin argumentos falla.


Los posibles valores van del 0 al 7, por lo que en caso de introducir argumentos superiores o inferiores muestra un mesaje de error indicando que no es un valor válido.


Como el script necesita únicamente el módulo sys para recibir el argumento y para los código de salida, es compatible entre sistemas operativos sin necesidad de realizar ningún cambio.


Conclusiones

He de decir que estoy aprendiendo Python y el paradigma de la programación orientada a objetos.

El script funciona de manera secuencial dada la versatibilidad del lenguaje aunque utilizando la variable self propia de éste, sería mucho más simple e igual de funcional. Tal vez para versiones posteriores, alguien se apunta?

Un saludo, Brixton Cat.

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 ; )

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.

10 de diciembre de 2011

Bash Script: Comparando archivos

Bueno, bueno, bueno... Hace tiempo que tenía ganas de hacer una entrada con algo de programación de scripts en Bash pero no encontraba el momento ni el código apropiado para colgarlo. En el trabajo me pidieron que comparase unos archivos y completase uno de ellos con datos del segundo. Como no tenía ganas de hacerlo manualmente ni de crear una macro Excel, pensé en un pequeño script que lo hiciera por mi. Os pongo en situación...

Tenemos un archivo Excel con una serie de datos de unas sedes en los que tenemos instalados unos equipos. Pensemos que tenemos las siguientes columnas:
- Sede
- Hostname
- IP
- Marca
- Modelo
- S/N (Reservado para los datos que tenemos que añadir)
En el segundo archivo tenemos una serie de datos que hemos recopilado de los distintos equipos. Imaginemos:
- Hostname
- IP
- S/N
La idea es comparar ambos archivos a partir del hostname y añadir el S/N (Número de Serie) a los datos del archivo original. Lo primero que vamos a hacer es crear un archivo CSV a partir del Excel original, por lo que nos quedaría un archivo parecido a:
Sede;Hostname;IP;Marca;Modelo;S/N;;;;;;
Sede1;Sede1;10.10.10.10;Cisco;1841;;;;;;;
Sede2;Sede2;10.10.10.11;Cisco;2801;;;;;;;
Mientras que el segundo tendrá la siguiente estructura:
Sede1 10.10.10.10 1234567890
Sede2 10.10.10.11 2345678901
Leeremos línea a línea el archivo con los número de serie, llamémosle NumeroSerie, y filtraremos el archivo original, llamémosle Planta, a partir del hostname. Luego con otro bucle leeremos todos los campos de la fila seleccionada y los mandaremos separados por coma a un nuevo fichero para que nos genere un CSV final tal que así:
Sede;Hostname;IP;Marca;Modelo;S/N;;;;;;
Sede1;Sede1;10.10.10.10;Cisco;1841;1234567890;;;;;;
Sede2;Sede2;10.10.10.11;Cisco;2801;2345678901;;;;;;
El código del script es:
#!/bin/bash
#

### VARIABLES
FILEORIG="Planta"
SERIALSORIG="NumeroSerie"
FILETARGET="Nuevo.csv"
CSVCOLS="6"

### FUNCTIONS
function Errors() {
        [ "$#" != "2" ] && echo -e "Fallo de ejecucion" && exit 1

        if [ "$1"  == "name" ]; then
          PARAM="nemonico"
        elif [ "$1" == "serial" ]; then
          PARAM="numero de serie"
        fi

        echo -e "Falta $PARAM en la linea '$2'" >> Error.log
}

### SCRIPT
sort $SERIALSORIG | uniq > NewSerials

FILESERIALS="NewSerials"

TOTAL="`cat $FILESERIALS | wc -l`"

head -n 1 $FILEORIG >> $FILETARGET

for ((i=1;i<=$TOTAL;i++)); do

  ARCHIVO="`cat $FILESERIALS | grep -n . | grep -E "^$i:"`"
  NEMONICO="`echo $ARCHIVO | cut -d ' ' -f 1 | sed 's/[0-9]*://g'`"
  SERIAL="`echo $ARCHIVO | cut -d ' ' -f 3`"

  [ -z $NEMONICO ] && Errors name "$ARCHIVO" && continue
  [ -z $SERIAL ] && Errors serial "$ARCHIVO" && continue

  for ((j=1;j<=$CSVCOLS;j++));do

    CAMPO="`cat $FILEORIG | grep $NEMONICO | cut -d ';' -f $j`"

    [ "$j" == "$CSVCOLS" ] && CAMPO="$SERIAL;;;;;;;"

    echo -ne "$CAMPO;" >> $FILETARGET

  done

  echo -ne "\n" >> $FILETARGET

done

rm -rf NewSerials

exit 0

#EOF
##FVE
Lo primero que hacemos es ordenar y quitar los repetidos del archivo NumeroSerie, contamos el número de líneas y lo pasamos al bucle que nos leerá el archivo línea a línea. Filtraremos el archivo NumeroSerie para quedarnos con el hostname y con el S/N de cada línea, NEMONICO y SERIAL respectivamente.
ARCHIVO="`cat $FILESERIALS | grep -n . | grep -E "^$i:"`"
NEMONICO="`echo $ARCHIVO | cut -d ' ' -f 1 | sed 's/[0-9]*://g'`"
SERIAL="`echo $ARCHIVO | cut -d ' ' -f 3`"
En caso que no exista el hostname o el numero de serie, enviamos a la función Errors una palabra clave acompañada de la línea donde ha fallado con lo que generamos un archivo de log, Error.log. Además cortamos la ejecución del bucle para que pase a la siguiente iteración.
[ -z $NEMONICO ] && Errors name "$ARCHIVO" && continue
[ -z $SERIAL ] && Errors serial "$ARCHIVO" && continue
En el segundo bucle leeremos el archivo Planta y lo filtramos a partir del hostname para recorrer todos los campos de la línea y generar un archivo CSV nuevo. En este caso los S/N van en la sexta columna (Variable CSVCOLS), por lo que cuando se encuentre en dicho campo utilizaremos el valor almacenado en la variable SERIAL para mandarlo al archivo final:
[ "$j" == "$CSVCOLS" ] && CAMPO="$SERIAL;;;;;;;"
El script no es nada del otro mundo: hay un pequeño control de errores, no hay funciones que estructuren bien el código, no está documentado, etc; pero me parece que puede ser interesante publicarlo porque es bastante genérico y fácilmente adaptable a otros proyectos o necesidades que puedan surgir.

Un saludo, Brixton Cat.

6 de marzo de 2010

Script para comprobar la conexión lan

Hace algunos días tuve problemas para navegar por internet por era causa de los DNS que no respondian y se me ocurrió hacer un script que compruebe la conexión tanto del host, del router como de los DNS que tenga configurados. Esta información la recopila a patir de los comandos: ifconfig, route y del archivo de configuración "/etc/resolv.conf"; por lo que son necesarios permisos de root para poder ejecutarlo.

Una vez ha recuperado dicha información y la ha confirmado el usuario, se pasa a un bucle for que lanza un paquete ICMP (ping -c 1) a las direcciones que comprobar. Las respuestas se guardan en un archivo temporal con el que filtrar los resultados: parquetes enviados y recibidos, perdidos, etc... Se crea un segundo archivo temporal que muestra por pantalla los resultados obtenidos según la opción que se eliga.

Por último, prueba la resolución de nombres lanzando nuevamente un paquete ping al dominio www.google.es o al dominio que espeficiquemos nosotros.

Esto solamente es una idea, tengo en mente que se pueda especificar el direccionamiento del equipo para aplicarlo y hacer pruebas. También hacer una lista con los DNS de varios ISP para incorporarlo al bucle y que pruebe la conexión hasta dichos equipos; entre otras cosas mas: consola nslookup, dig, nmap¿?...

El código es:
#!/bin/bash
#
# SCRIPT TO CHECK YOURS CONECTIONS
#
function net {
        ipl=`ifconfig | grep -E "inet[^6]" | grep -v 127| awk '{print $2}' | sed s/[a-zA-Z:]*//`
        msk=`ifconfig | grep -E "inet[^6]" | grep -v 127 | awk '{print $4}' | sed s/[a-zA-Z:]*//`
        gtw=`route | grep default | awk '{print $2}'`
        int=`route | grep default | awk '{print $8}'`
        dns1=`cat /etc/resolv.conf | grep -v "#" | grep -n "" | grep "1:" | awk '{print $2}'`
        dns2=`cat /etc/resolv.conf | grep -v "#" | grep -n "" | grep "2:" | awk '{print $2}'`
}
#
function conect {
        for i in $ipr; do
         ping -c 1 $i > temp
         ip=`cat temp | grep -oE "PING [0-9.]+" | awk '{print $2}'`
         env=`cat temp | grep -oE "[0-9]+ packets transmitted" | awk '{print $1}'`
         rec=`cat temp | grep -oE "[0-9]+ received" | awk '{print $1}'`
         per=`cat temp | grep -oE "[0-9]+% packet loss" | awk '{print $1}'`
         los=`expr $env - $rec`
         echo -e "IP destino: $ip"
         echo -e "Paquetes enviados: $env"
         echo -e "Paquetes recibidos: $rec"
         echo -e "Paquetes perdidos: $los"
         echo -e "Perdidas: $per"
         if [[ `cat temp | grep -oE "[0-9]+% packet loss" | awk '{print $1}' | sed s/\%//` == 0 ]]; then
             echo -e OK
         else
             echo -e OPS!
         fi
         echo -e "-----------------------"
        done
}
#
net
echo -ne "Creo que esta es tu configuracion de red:\n\tInterfaz: $int\n\tIP: $ipl\n\tMascara: $msk\n\tGateway: $gtw\n\tDNS 1: $dns1\n\tDNS 2: $dns2\nEs correcto (s/n): "
read resp
if [[ $resp == s || $resp == S ]]; then
    ipr=`echo "$ipl $gtw $dns1 $dns2"`
elif [[ $resp == n || $resp == N ]]; then
    echo -e "Hasta otra..."
    exit 1
else
    echo -e "Debes responder si o no... vuelve a internarlo ;)"
    exit 1
fi
clear
echo -e "Probando conectividad..."
conect > temp2
echo -ne "RESULTADOS:\n-----------\n\t1) $int\n\t2) $gtw\n\t3) $dns1\n\t4) $dns2\n\t*) Cualquier otra tecla para verlos todos\nElige el numero asociado al resultado que quieras ver: "
read report
case $report in
    1)
      clear
      cat temp2 | grep -A 5 `echo $ipl`
      ;;
    2)
      clear
      cat temp2 | grep -A 5 `echo $gtw`
      ;;
    3)
      clear
      cat temp2 | grep -A 5 `echo $dns1`
      ;;
    4)
      clear
      cat temp2 | grep -A 5 `echo $dns2`
      ;;
    *)
      clear
      more temp2
      ;;
esac
echo -e "\nQuieres probar la resolucion de nombres?\nEscribe la pagina web con la que quieras comprobar los servidores DNS\n[www.google.es]"
read resp
if [ -z $resp ]; then
    ping -c 1 www.google.es > temp
elif [ $resp = `echo $resp | grep -oE "www\.[a-z.]+\.[a-z.][a-z.]+"` ]; then
    ping -c 1 $resp > temp
else
    ping -c 1 www.google.es > temp
fi
echo -e "Ping a: `cat temp | grep -oE "PING www\.[a-z.]+\.[a-z.][a-z.]+" | awk '{print $2}'`"
echo -e "Perdidas: `cat temp | grep -oE "[0-9]+% packet loss" | awk '{print $1}'`"
if [[ `cat temp | grep -oE "[0-9]+% packet loss" | awk '{print $1}' | sed s/\%//` == 0 ]]; then
    echo -e OK
else
    echo -e OPS!
fi
rm -rf temp*
exit 0
#
#Fve
El script como no, se licencia bajo GPLv3. Un saludo, Brixton Cat ;)

PD: Si alguien tiene algún problema con el script o porque no se entienda bien por el formato del blog, no duden en comentar o pedir una copia del mismo.