Mostrando entradas con la etiqueta python. Mostrar todas las entradas
Mostrando entradas con la etiqueta python. 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

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.

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.