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

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.

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 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.