domingo, 19 de octubre de 2014

PYTHON: CREANDO NUESTRA HERRAMIENTA DE WEB SCRAPING [IV]

Regresando a nuestro script para extracción de datos, veremos como obtener las IP´s que se encuentren en una pagina objetivo.

EXTRAYENDO IP'S.

Para esto usaremos el siguiente regex:

1
REGEX_IP    = re.compile('[0-9]+(?:\.[0-9]+){3}')

Y añadiremos la siguiente función al script:

1
2
3
4
5
6
7
def Extraer_IP(HTML):
    try:
        IPs = re.findall(REGEX_IP, HTML)
        return IPs
    except Exception, e:
        print "[ERROR: Extraer_IP(HTML)] - ",e
        sys.exit(1)

Si observamos las funciones anteriores todas son prácticamente lo mismo y lo único que estamos cambiando aquí es el regex que enviamos, por lo que igual podríamos deshacernos de todas las anteriores y forma una función que englobe todas las anteriores y enviemos como parámetro el tipo de dato que queremos extraer... esa, ya es otra historia, pero les dejo la idea. Realizando una prueba sobre  el sitio www.us-proxy.org, que se presta perfecto para el ejemplo, nos percatamos que funciona sin problema:




Cabe mencionar que el regex en si no valida una IP correcta... es decir... bien podría tomar un string como el siguiente 987.654.321.987 y sabemos que no es un IP valida. Aun así, es un buen comienzo. 

BEAUTIFULSOUP

Hasta ahora las expresiones regulares han dominado y, pese a que se dio un breve -demasiado breve quizá- ejemplo en la entrada anterior - sobre el uso de Beautifulsoup (si no se ha leído la entrada anterior la librería puede descargarse aquí), aquí mostraremos uno mas. Una de las magias de esta librería consiste en que, si la pagina a analizar contiene una tabla (HTML) o datos en formato XML, realizar el barrido y extracción de datos es mucho mas sencillo. Realizaremos una prueba de esto sobre la pagina www.us-proxy.org debido a que contiene una tabla y es ideal para extraer de ella un par de proxys y su respectivo puerto:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
<table border="0" cellpadding="0" cellspacing="0" class="display fpltable" id="proxylisttable">
<thead>
   <tr>
      <th>IP Address</th>
      <th>Port</th>
      <th>Code</th>
      <th>Country</th>
      <th>Anonymity</th>
      <th>Google</th>
      <th>Https</th>
      <th>Last Checked</th>
   </tr>
</thead>

Para lo cual fabricamos la siguiente función:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
def ExtraerBS_IP(HTML):
    try:
        BS_HTML=BeautifulSoup(HTML)
        Max_Registros = 0
        Max_Registros = len(BS_HTML.findAll('tr'))-2
        while Max_Registros!=0:
            print BS_HTML('table')[0].findAll('tr')[Max_Registros].findAll('td')[0].string+':'+BS_HTML('table')[0].findAll('tr')[Max_Registros].findAll('td')[1].string
            Max_Registros=Max_Registros-1

    except Exception, e:
        print "[ERROR: ExtraerBS_IP(HTML)] - ",e
        sys.exit(1)

Probamos sobre el sitio:

URL='http://www.us-proxy.org/'
HTML=Extraer_HTML(URL)
ExtraerBS_IP(HTML)

Y nos retorna el resultado de la siguiente forma:



Esto nos puede servir para tener a la mano y de forma actual una lista de proxys a usar en otras herramientas - o en esta... ¬¬ ya que lo haga funcionar. Ya que andamos por aquí y recordando que nuestra lista de User_Agent no esta muy actualizada podemos hacer una función usando Beautifulsoap para extraer una lista mas amplia y quizá mas actualizada de estos. Procederemos a realizar la prueba en el sitio www.useragentstring.com/pages/Browserlist/Antes de ponernos a trabajar en la función debemos analizar- como en el caso anterior- la estructura de la pagina y en base a ello proceder a su diseño:



En base a lo anterior y revisando que el dato importante para nosotros se encuentra en la etiqueta 'li', fabricamos la siguiente función:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
def ExtraerBS_UserAgent(HTML):
    try:
        BS_HTML=BeautifulSoup(HTML)
        Max_Registros = 0
        Max_Registros = len(BS_HTML.find_all('li'))-2
        while Max_Registros!=0:
            print BS_HTML.find_all('li')[Max_Registros].string
            Max_Registros=Max_Registros-1

    except Exception, e:
        print "[ERROR: ExtraerBS_UserAgent(HTML)] - ",e
        sys.exit(1)

Usando la misma practica anterior:

URL='http://www.useragentstring.com/pages/Browserlist/'
HTML=Extraer_HTML(URL)
ExtraerBS_UserAgent(HTML)

Extraemos poco más de 2K registros:


Esta función puede ser aprovechada para extraer solo un numero limitado como  muestra y sobre escribir nuestro archivo de agent_user.txt (recuerde la primera entrada) de forma que siempre garanticemos el azar. Observando en base a los últimos dos ejemplos Beatifulsoap puede ser un auxiliar potente para el Web Scraping, pero, desafortunadamente sus funciones no son tan universales como el uso de regex para la extracción de información. Sin embargo, esto no tiene por que representar un punto del todo negativo ya que las estructura de las paginas no cambia de forma frecuente por lo que aunque tengamos que diseñar las funciones para un escenario particular estas pueden ser validas, más sencillas de elaborar y practicas por un largo periodo de tiempo.

A esta altura nuestro script ya puede extraer lo siguiente:

-Codigo HTML.
-E-mail.
-URL.
-IP.
-IP+Puerto (de una pagina en especifico).
-User_Agent (de una pagina en especifico).


Lo que ya representa un buen avance. Este sera el alcance de esta serie dejando a los interesados la tarea de explorar y explotar tanto el uso de regex como de Beautifulsoap. Espero les resulte de utilidad.

CONCLUSIÓN.


-Python es una lenguaje de programación flexible, poderoso y con una sencillez increíble. 
-Web Scraping, como han podido ver en una forma algo resumida puede ser una técnica poderosa orientada a la creación de herramientas OSINT mucho mas poderosas.
-Tanto el uso de regex como de Beautifulsoap son perfectamente validos y no excluyentes, depende mucho el escenario y lo que buscamos extraer. Es necesario sin embargo profundizar en ambos para un diseño optimo de una herramienta con esta orientación (Web Scraping).

REFERENCIAS.

-http://www.regular-expressions.info/python.html
-http://www.briancarpio.com/2012/12/02/website-scraping-with-python-and-beautiful-soup/
-http://www.nyu.edu/projects/politicsdatalab/workshops/BeautifulSoup.pdf
-https://pypi.python.org/pypi/beautifulsoup4
-http://www.pythoncentral.io/python-beautiful-soup-example-yahoo-finance-scraper/
-http://kochi-coders.com/2011/05/30/lets-scrape-the-page-using-python-beautifulsoup/

viernes, 17 de octubre de 2014

PYTHON: CREANDO NUESTRA HERRAMIENTA DE WEB SCRAPING [III]

Lo prometido - aunque bueno.. técnicamente no prometí nada - es deuda. Procederemos ahora con la extracción de links en una pagina dada.

EXTRAYENDO LINKS.

Continuando con la base del primer script, añadiremos el siguiente regex y su respectiva función para extraer los links de una pagina web (Si... cambie la definición de PATRON_ por REGEX_... me pareció mas apropiada):

1
REGEX_URL   = re.compile('https?://[^\s<>"]+|www\.[^\s<>"]+')

1
2
3
4
5
6
7
def Extraer_URL(HTML):
    try:
        Url = re.findall(REGEX_URL, HTML)
        return Url
    except Exception, e:
        print "[ERROR: Extractor(HTML)] - ",e
        sys.exit(1)

Anexado esto y acomodado en nuestro script principal procederemos a realizar la prueba tomando como base bueno, la propia sección de links de esta pagina (link) ejecutándolo al menos en mi caso (dependerá de como quieran manejar los argumentos) de la siguiente manera:

python WebScraping.py -url -lnk <URL>

Y observando que funciona adecuadamente:




El resultado no esta precisamente ordenado, pero basta para nuestro propósito. De forma separada tiendo a manejar un script aparte para ir probando las funciones por separado - me ayuda a no perderme en el código si el script es muy grande - por lo que para sus propias pruebas les comparto la función usando Beautifulsoup (comente el proxy debido a que después de cierto numero de intentos las paginas simplemente ya no responden igual... imagino que lo ven sospechoso y simplemente bloquean la respuesta):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#!/usr/bin/python -u
# -*- coding: utf-8 -*-
import mechanize
import cookielib
import re
import sys
from random import choice
from bs4 import BeautifulSoup

#VARIABLES GLOBALES
USER_AGENT  = {'User-Agent':(choice(open("user_agent.txt",'r').readlines()))}
REGEX_URL   = re.compile('https?://[^\s<>"]+|www\.[^\s<>"]+')

#FUNCIONES
def Extraer_HTML(URL):
    try:
        navegador = mechanize.Browser()                         # Inicializar Navegador
        #navegador.set_proxies({"http": "162.208.49.45:7808"})  # Establecer Proxy
        ncookie = cookielib.LWPCookieJar()                      # Cookie
        navegador.set_cookiejar(ncookie)
        navegador.set_handle_robots(False)                      # Ignorar Robots
        navegador.set_handle_refresh(mechanize._http.HTTPRefreshProcessor(), max_time=1)
        navegador.addheaders = [('User-agent', USER_AGENT)]     # Establecer User-Agent
        respuesta = navegador.open(URL)                         # Abrir URL
        return  respuesta.read()                                # Regresar codigo fuente de la pagina
    except Exception, e:
        print "[ERROR: Extraer_HTML(URL)] - ",e
        sys.exit(1)

def ExtraerBS_URL(HTML):
    try:
        BS_HTML=BeautifulSoup(HTML)
        for link in BS_HTML.find_all('a'):
            print(link.get('href'))
    except Exception, e:
        print "[ERROR: ExtraerBS_URL(HTML)] - ",e
        sys.exit(1)

URL='http://p01n7l355.blogspot.mx/p/online-tools-links-de-interes.html'
HTML=Extraer_HTML(URL)
ExtraerBS_URL(HTML)


Usando Beautifulsoup el resultado es un poco diferente y muestra un par de falsos positivos, aunque, esto quizá se deba a mi falta de experiencia con la librería; aun no juego lo suficiente con ella... francamente me siento mas cómodo usando regex. Cuestion de gustos:




NOTAS:


-Experimentando, hay sutiles diferencias entre la extracción de links entre paginas Web y un archivo de texto plano, pese a que en realidad esta entrada no contempla la idea de extraer esto desde un archivo - a fin de cuentas WebScraping se refiere exclusivamente a .. bueno.. eso... web... - considere importante como detalle mencionarlo. Es una cuestión de refinamiento en el regex - o esa es mi teoría- o contemplar un regex exclusivo para este escenario.
-En lo personal prefiero la idea de manejar regex que Beautifulsoup. Aunque en algunos enlaces leyendo por ahi escuche que no era lo mas optimo... igual es un debate habría que profundizar en el uso de ambos y realizar algunas pruebas para ver cual da mejor performance.
-En nuestra próxima entrada probaremos la extracción de IP y... a ver que mas se nos ocurre.

REFERENCIAS.

-http://www.pythonforbeginners.com/python-on-the-web/web-scraping-with-beautifulsoup/
-https://pypi.python.org/pypi/beautifulsoup4
-https://cloud.github.com/downloads/tartley/python-regex-cheatsheet/cheatsheet.pdf

miércoles, 15 de octubre de 2014

PYTHON: CREANDO NUESTRA HERRAMIENTA DE WEB SCRAPING [II]

Continuando con nuestra tarea para la construcción de nuestro script. Añadiremos en esta entrada la extracción de e-mails usando expresiones regulares.

EXTRAYENDO E-MAILS.

En esta ocasión anexaremos a nuestros script una función para extraer los e-mails que se encuentren en una pagina dada. La función a anexar es la siguiente:

1
2
3
4
5
6
7
def Extraer_Emails(HTML):
    try:
        emails = re.findall(PATRON_EMAIL, HTML)
        return emails
    except Exception, e:
        print "[ERROR: Extraer_Emails(HTML)] - ",e
        sys.exit(1)

Para su correcto funcionamiento debemos agregar la expresión regular correspondiente:

1
PATRON_EMAIL= re.compile("[-a-zA-Z0-9._]+@[-a-zA-Z0-9_]+.[a-zA-Z0-9_.]+")

En el script anterior dejamos preparado el escenario para anexar el texto de ayuda en la función Mostrar_Ayuda(). No creo que eso tenga mucha complicación, lo menciono como recordatorio encaso de que se quiera ir modificando para tenerlo todo en un solo script. Y claro, tendremos que modificar nuestro manejo de argumentos según como queramos usarlo. En mi caso particular lo acomode para que la ejecución sea de la siguiente forma:

python WebScraping.py -url -e <URL>

Esto por que se me ocurre que a futuro pueda anexar una función para ademas de extraer datos de paginas, pueda también extraerla de archivos de texto plano, excel, etc., y pueda mandarlo llamar de la siguiente manera:

python WebScraping.py -archivo -e <RUTA DE ARCHIVO>

Eso claro, pensando muy a futuro. Queda a consideración de cada quien. Una vez anexada la función al script procederemos a probar buscando alguna URL que contenga correos, ejecutando el siguiente Google Dork:


Una vez obtenidos los resultados tomaremos la versión en cache de alguno de los resultados para poder tomar los datos desde URL y procederemos a ejecutar el script:



Observando que efectivamente se extrajeron los correos de la pagina. La lista en este caso es un poco larga pero muestra correos repetidos debido a que, bueno, se mostraban repetidos en la pagina. En un futuro trabajaremos sobre este detalle para que nos muestra solo un correo e ignore las repeticiones.

NOTAS:

-Es importante prestarle algo de tiempo al estudio de las expresiones regulares ya que serán la llave para la creación de  patrones que nos permitan extraer lo que necesitemos.
-En la próxima entrada analizaremos la extracción de links y el uso de la librería Beautiful Soup como alternativa.

REFERENCIAS.

-https://docs.python.org/2/howto/regex.html
-http://whatis.techtarget.com/definition/Google-dork-query


martes, 14 de octubre de 2014

PYTHON: CREANDO NUESTRA HERRAMIENTA DE WEB SCRAPING [I]

INTRODUCCIÓN

Este articulo esta diseñado para formar parte de una serie de entradas mas bien cortas en las que se irán incluyendo poco a poco funciones para ir ensamblando la herramienta.

Asumiré antes que nada que se tiene los conceptos básicos de Python y que ya se ha jugado un poco con el lenguaje, en caso de no ser así recomiendo ampliamente pasarse un par de minutos a learnpythonthehardway.org para aprender las bases y de forma adicional recomiendo revisar este link para los mensajes de error mas habituales. En lo personal me gusto mucho la guía aunque no fue precisamente el primer material sobre Python que cayo en mis manos. Establecido esto, podemos empezar.

¿QUE ES WEB SCRAPING ?

Web Scraping es básicamente recolectar información de paginas web, extrayendo lo que consideremos útil desde e-mails, links, recopilación de datos personales como nombre, teléfono, dirección etc. El proceso puede ser usado para la creación de herramientas OSINT y/o como complemento para tareas más... em... intrusivas y elaboradas - probablemente ilegales... es mas bien una área un tanto gris... tendría que investigarse bien la pagina a la que se esta sometiendo- como el pujado automático en sitios de subastas. Entre otras cosas.

EXTRAYENDO LA PAGINA.

De entrada, requeriremos extraer todo el código HTML de la pagina (o paginas) de las que queremos extraer o minar información. Para esto recurriremos a la siguiente función usando la librería de mechanize- se pueden lograr resultados similares usando urllib2:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
def Extraer_HTML(URL):
    try:
        navegador = mechanize.Browser()                     # Inicializar Navegador
        navegador.set_proxies({"http": "97.77.104.22:80"})  # Establecer Proxy
        ncookie = cookielib.LWPCookieJar()                  # Cookie
        navegador.set_cookiejar(ncookie)
        navegador.set_handle_robots(False)                      # Ignorar Robots
        navegador.set_handle_refresh(mechanize._http.HTTPRefreshProcessor(), max_time=1)
        navegador.addheaders = [('User-agent', USER_AGENT)]     # Establecer User-Agent
        respuesta = navegador.open(URL)                         # Abrir URL
        return  respuesta.read()                                # Regresar codigo fuente de la pagina
    except Exception, e:
        print "[ERROR: Extraer_HTML(URL)] - ",e
        sys.exit(1)

La función básicamente obtiene el código HTML y lo retorna para su posterior análisis y extracción de datos. Ese sera el alcance de esta entrada.  Nos permite cierto grado de anonimato estableciendo un proxy y mutando el user_agen al azar en cada consulta según la lista que tengamos agregada en un archivo llamado user_agent.txt que se encuentre ubicado en el mismo directorio donde ejecutemos el script que contenga la función - o podemos mapearlo de forma permanente según nos resulte mas cómodo. Se pueden encontrar algunas listas de  user_agent y proxys en los siguientes sitios:

User Agent:

Proxy:
-http://free-proxy.cz/en/

El script en general de momento solo tomara en cuenta la extracción del código de una pagina objetivo, sin separar nada de momento. Lo crearemos de tal forma que funcione con parámetros desde consola y dejaremos preparada la ayuda que se ira expandiendo conforme se anexen entradas relacionadas a este articulo:


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
#!/usr/bin/python -u
# -*- coding: utf-8 -*-
import mechanize
import cookielib
import sys
from random import choice

#VARIABLES GLOBALES
PROYECTO    = "WebScraping"
VERSION     = "v 0.1"
AUTOR       = "Rodrigo Anael Perez Castro"
TWITTER     = "@rapcx1981"

USER_AGENT  = {'User-Agent':(choice(open("user_agent.txt",'r').readlines()))}
PROXY       = (choice(open("proxy.txt",'r').readlines()))

#FUNCIONES
def Mostrar_Ayuda():
 try:
  print "\t[  -h --parametro] - Muestra detalle del parametro y ejemplos de uso."
  print "\t[-url --url      ] - Extrael el codigo fuente de la pagina indicada."
 except Exception, e:
  print "[Error: Mostrar_Ayuda()] - ", e
  sys.exit(1)

def Mostrar_Creditos():
        try:
            print "\t["+PROYECTO+"\t"+VERSION+"\t\t]"
            print "\t["+AUTOR+"\t]"
            print "\t["+TWITTER+"\t\t\t\t\t]\n"
        except Exception, e:
            print "[ERROR: Mostrar_Creditos()] - ", e
            sys.exit(1)

def Extraer_HTML(URL):
    try:
        navegador = mechanize.Browser()                     # Inicializar Navegador
        navegador.set_proxies({"http": "97.77.104.22:80"})  # Establecer Proxy
        ncookie = cookielib.LWPCookieJar()                  # Cookie
        navegador.set_cookiejar(ncookie)
        navegador.set_handle_robots(False)                      # Ignorar Robots
        navegador.set_handle_refresh(mechanize._http.HTTPRefreshProcessor(), max_time=1)
        navegador.addheaders = [('User-agent', USER_AGENT)]     # Establecer User-Agent
        respuesta = navegador.open(URL)                         # Abrir URL
        return  respuesta.read()                                # Regresar codigo fuente de la pagina
    except Exception, e:
        print "[ERROR: Extraer_HTML(URL)] - ",e
        sys.exit(1)

def main():
    try:
        if len(sys.argv)<=1:
            Mostrar_Creditos()
            Mostrar_Ayuda()

        if len(sys.argv)>1:
            if sys.argv[1]=="-url":
                URL = sys.argv[2]
                R = Extraer_HTML(URL)
                print R
            elif sys.argv[1]=="-h":
                print 'En Contruccion...'

    except Exception, e:
        print "[ERROR: main()] - ",e

if __name__ == '__main__':
    main()

Usaremos la pagina httpbin.org para probar los cambios de user_agent y la veracidad del proxy. Podemos usar también whatsmyuseragent.com que nos muestra igualmente user_agent e IP al mismo tiempo, pero el resultado esta mas cargado debido al código HTML, por lo que, por cuestiones de practicidad y acomodo en este post dejare esa prueba a ustedes. Aqui solo se mostrara una parte como parte de nuestra prueba de testeo del script.

Apreciamos que el cambio aleatorio de user_agent funciona sin problemas:



También el proxy:



Y nos regresa sin problemas el código fuente de las pagina que consultamos:



Se pueden añadir algunas otras opciones y detalles, pero, para nuestro propósito y de momento esto bastara.

NOTAS:

-No he podido de momento hacer que el proxy se cambie al azar desde una lista en archivo de la misma manera que el user_agent... o, dicho de forma mas exacta, no que el objeto navegador lo tome... espero hacerlo funcionar en un futuro.
-El manejo de argumentos/parámetros en consola puede ser mejorado usando otra librería (argparse)... pero de momento no lo considero necesario y aun no la he explorado.
-Existen muchas formas de mejorar el script e incluso existen ya actualmente muchos que hacen lo mismo... En el libro de Violent Python ya viene incluida una clase para realizar esto de forma mas eficiente (Capitulo 6), sin embargo, considero básico realizar funciones propias y no simplemente acudir a un copy-paste. Ciertamente no hay mucha gracias en reinventar la rueda y tampoco mucho caso... pero para cuestiones de aprendizaje no hay nada mejor que ponerse a jugar y ver si podemos hacer lo que ya existe de manera diferente... es una simple consideración personal.

REFERENCIAS.

-http://es.wikipedia.org/wiki/Web_scraping
-http://www.osintinsight.com/shared.php?expand=&folderid=220&user=Mediaquest
-http://www.decalage.info/en/python/tutorial
-http://wwwsearch.sourceforge.net/mechanize/doc.html
-https://www.jetbrains.com/pycharm/
-Violent Python, TJ O'Connor
-http://www.pythonforbeginners.com/cheatsheet/python-mechanize-cheat-sheet
-http://stockrt.github.io/p/emulating-a-browser-in-python-with-mechanize/
-http://python.org.ar/MensajesExcepcionales
-http://stackoverflow.com/questions/10589620/syntaxerror-non-ascii-character-xa3-in-file-when-function-returns-%C2%A3



lunes, 6 de octubre de 2014

VOLCADOS DE MEMORIA Y VOLATILITY: UN [MUY]BREVE RECORRIDO.

¿VOLCADOS DE MEMORIA?, ¿VOLATILITY?

El volcado de memoria consiste básicamente en una fotografía de la información contenida en la memoria RAM en un momento dado descargada en un archivo.



Volatility, por otro lado, es un conjunto de herramientas desarrolladas en Python enfocadas para la extracción y análisis de información contenida en volcados de memoria RAM.

Para jugar con Volatility primero debemos tener un volcado de la memoria. Las herramientas para realizar esto pueden ser varias y un excelente resumen se encuentra aquí, una contribución de @hecky@bu5t3r5. Aun así, aprovecho el espacio para comentarles muy brevemente mi experiencia con tres de ellas; FTK Imager, DumpIt y Winpmem. Las tres son relativamente sencillas de usar, siendo muchísimo mas rápidas para generar el volcado DumpIt y Winpmem, ademas de no requerir instalación a diferencia de FTK Imager ya que funcionan desde consola. La gracia de esta ultima es que permite incluir en el volcado el archivo pagefile.sys que es básicamente el contenedor de la memoria virtual y puede usarse para leer los volcados de las anteriores (igual puede usarse WinHex o cualquier editor hexadecimal de su preferencia).


Para el volcado en dispositivos Android podemos acudir a LiME, aunque eso es algo que examinare en otra entrada.

En caso de que no se quiera hacer el volcado de memoria o simplemente se desee jugar con escenarios mas variados  e interesantes, el sitio de Volatility ofrece algunas "muestras gratis" para descargar y analizar ejemplos de volcados con malware aquí. Fuera del análisis de malware, el volcado permite también extraer contraseñas de correo y Truecrypt  entre otros datos.

INSTALANDO VOLATILITY.

La instalación con Python basta solo con descargar el archivo, descomprimir  e ingresar en consola:

python setup.py install

Si estamos ejecutando la versión de Python de Volatility sobre Windows 8 nos puede lanzar el siguiente error:


En Linux no ofreció ninguna resistencia:


En Windows 8 pese a que marque el error mostrado da la impresión de no da problemas mayores y aun así permite su ejecucion, como sea, prefiero no estar viendo ese error cada ves que lo lanzo por lo que podemos proceder a instalar distorm3 en nuestra PC descargando la versión que ser requiera aquí. Una vez instalado, podemos volver a ejecutarlo mostrándose libre de errores:



Si no tiene interés en manejarlo usando Python, siempre puede usarse el standalone para Windows que no dio ningún problema para ejecutarlo y cuya instalación basta con descomprimirlo y ejecutarlo:



Originalmente el ejecutable se llama volatility-2.4.standalone.exe, pero, por cuestiones practicas simplemente recorte el nombre. 

Antes de iniciar a jugar necesitamos sacar el perfil del SO de la memoria que descargamos usando el siguiente comando  nos arrojara ya sea el perfil o perfiles probables a usar, en este caso usare el volcado de memoria realizado a una NoteBook con Windows 7. Una vez obtenido el perfil  (Win7SP1x86 para este casopodemos empezar nuestro análisis con Volatility::

python vol.py -f "<ruta del volcado de memoria>" imageinfo


El siguiente ejemplo nos muestra la lista de procesos ejecutándose al momento de sacar el volcado:

python vol.py --profile=Win7SP1x86 pslist -f "<ruta del volcado de memoria>"



Podemos también visualizar la lista de credenciales para un posterior ataque de fuerza bruta (no se visualiza por razones obvias pero... prueben el comando :P):


python vol.py --profile=Win7SP1x86 -f "<ruta del volcado de memoria>"hashdump


Adicional a lo anterior Volatility ofrece muchas otras opciones, entre ellas visualizar:

- Puertos conectados
- DLLs cargadas por proceso
- Puertos abiertos
- Historial de Internet Explorer
- Ficheros cargados por procesos


RESUMEN.

El potencial de análisis de los volcados de memoria es bastante interesante. Estos ejemplos son meramente rudimentarios y lo que se observa aquí son ejemplos, ademas de pequeños, algo limitados en gran parte por que mi conocimiento en este campo es realmente escaso y aun no e experimentado con la parte mas interesante de esto, el estudio de malware- apenas estoy empezando a explorar el análisis de los volcados de memoria y el uso de Volatility. La pagina de Code Google tiene amplia documentación  al respecto por lo que aun tengo un largo camino por recorrer. Trate de concentrar en esta entrada el concepto básico y suficientes enlaces como para un buen inicio esperando sea tan útil para ustedes como lo sera para mi.

REFERENCIAS.

-https://code.google.com/p/volatility/
-https://github.com/volatilityfoundation/volatility
-https://code.google.com/p/volatility/downloads/detail?name=CheatSheet_v2.3.pdf
-http://volatility-labs.blogspot.mx/
-https://code.google.com/p/volatility/downloads/list
-https://code.google.com/p/volatility/wiki/CommandLineProcessing
-http://digital-forensics.sans.org/blog/2009/08/10/memory-forensics-a-practical-example/
-http://www.flu-project.com/2013/09/volatility-framework-obteniendo-el_103.html
-http://conexioninversa.blogspot.mx/2009/02/forensics-con-volatility.html
-http://www.seguridadx.com/volatility/
-http://www.sahw.com/wp/archivos/2011/11/02/analisis-avanzado-de-memoria-de-sistemas-microsoft-windows-con-volatility/
-https://code.google.com/p/volatility/wiki/VolatilityIntroduction
-http://code.google.com/p/distorm/downloads/list
-http://code.google.com/p/volatility/issues/detail?id=515
-https://code.google.com/p/volatility/wiki/CommandReference23
-https://code.google.com/p/volatility/wiki/CommandReference
-http://bugbu5t3r5.blogspot.mx/2014/10/herramientas-de-volcado-de-memoria.html?spref=tw
-http://www.securitybydefault.com/2012/07/volcado-de-memoria-en-linux-con-lime-11.html
-https://code.google.com/p/volatility/wiki/VolatilityDocumentationProject
-https://github.com/504ensicsLabs/LiME/blob/master/README.md
-http://www.hackplayers.com/2013/05/extrayendo-passwords-en-memoria-de-truecrypt.html