• Marcos Pablo Russo

SpiderFoot


¿ Qué es ?

Es una herramienta de automatización de inteligencia de código abierto (OSINT). Se integra con casi todas las fuentes de datos disponibles y utiliza una variedad de métodos para el análisis de datos, lo que hace que esos datos sean fáciles de navegar.

A su vez tiene un servidor Web incorporado para proporcionar una interfaz intuitiva, pero también se puede usar completamente a través de la línea de comandos. Está herramienta se encuentra desarrollada en Python 3 con licencia GPL.

Características

Como comentamos podemos ejecutarla desde una terminal, como tambien mediante una interfaz web. La aplicación contiene:

  • Alrededor de 170 módulos.

  • Exportación de archivos en JSON/CSV/GEXF.

  • Contiene una API para importar/exportar.

  • Utiliza base de datos SQLite para realizar búsquedas.

  • Integración con TOR para realizar búsquedas en la dark web.

  • Nos permite generar un cointainer mediante Docker para ser utilizado.

  • Puede llamar a otras herramientas como DNSTwist, Whatweb y CMSeek.

  • Desde el año 2012 que se viene desarrollando activamente.

Dentro de los 170 módulos que dispone, permite extraer datos desde:

  • Enumeración de direcciones de e-mail como extracción.

  • Números telefónicos.

  • Zonas de transferencia de DNS.

  • Consultas y amenazas de listas negras.

  • API integración con SHODAN, HavelBeenPwned, Censys, AlienVault, SecurityTrails, etc.

  • Enumeración de cuentas sociales.

  • S3/Azure/Digitalocean enumeración.

  • Geolocalización de IP.

  • Web scraping, análisis de contenidos web.

  • Meta datos de archivos de imágenes y binarios.

  • Meta datos de archivos de documentos de office.

  • Búsqueda en la dark web.

  • Etc.

De donde lo bajamos

Lo bajamos mediante el repositorio de github en la dirección https://github.com/smicallef/spiderfoot



  # git clone https://github.com/smicallef/spiderfoot
 


Instalación

Como bien dijimos podemos utilizarlo desde la linea de comandos, mediante la web o bien armar un cointainer mediante Docker.

Pasame a ver como se arma el container, dependiendo de las distribución de GNU/Linux vamos a tener que instalar la aplicación de docker, por ejemplo para las siguientes distribuciones.

  • Debian

  • apt-get install docker.io

  • Ubuntu

  • apt-get install docker

Una vez que tenemos instalado docker, para armar el container, donde dentro de la aplicación vamos a tener un archivo llamado Dockerfile, que es el que utilizamos para armalo.

 # 		git clone https://github.com/smicallef/spiderfoot
 # 		cd spiderfoot
 # 		cat Dockerfile
 #
 #		Spiderfoot Dockerfile
 #
 #		http://www.spiderfoot.net
 #
 #		Written by: Michael Pellon <m@pellon.io>
 #		Updated by: Chandrapal 
 #   <bnchandrapal@protonmail.com>
 # 			Updated by: Steve Micallef 
 #   <steve@binarypool.com>
 # 	   -> Inspired by 			
 # https://github.com/combro2k/dockerfiles/tree/master/alpine-
 # spiderfoot
 #
 # 		Usage:
 #
 # 		  sudo docker build -t spiderfoot .
 # 		  sudo docker run -it -p 5001:5001 spiderfoot
  
 # 		Pull the base image.
 FROM 		alpine:latest
 COPY 		requirements.txt .
 
 
 # Run everything as one command so that only one
 # layer is created
 RUN apk --update add --no-cache --virtual build-dependencies \
      gcc git curl py3-pip swig tinyxml-dev python3-dev \
      musl-dev openssl-dev libffi-dev libxslt-dev && \
      apk --update --no-cache add python3 musl openssl \
      libxslt tinyxml jpeg-dev openjpeg-dev zlib-dev \
      && pip3 --no-cache-dir install wheel \
      && pip3 --no-cache-dir install -r requirements.txt \
      && addgroup spiderfoot \
      && adduser -G spiderfoot -h /home/spiderfoot -s 
         /sbin/nologin \
        -g "SpiderFoot User" -D spiderfoot \
      && rmdir /home/spiderfoot \
      && cd /home \
      && curl -sSL https://github.com/smicallef/spiderfoot  /archive/v3.0.tar.gz \
  | tar -v -C /home -xz \
  && mv /home/spiderfoot-3.0 /home/spiderfoot \
  && chown -R spiderfoot:spiderfoot /home/spiderfoot \
  && apk del --purge build-dependencies \
  && rm -rf /var/cache/apk/* \
  && rm -rf /root/.cache
  
 USER 	 spiderfoot
 WORKDIR /home/spiderfoot
  
 EXPOSE 5001
  
 # Run the application.
 ENTRYPOINT ["/usr/bin/python3"]  
 CMD ["./sf.py", "-l", "0.0.0.0:5001"]

Analizando este archivo podemos ver que utiliza la distribución de alpinelinux siendo una distribución muy sencilla y muy rápida.

 FROM 			alpine:latest

Copia desde donde bajamos la aplicación, el archivo de requirements.txt que es utilizado por python para instalar las librerías que va utilizar, este mismo archivo lo copia en el raíz del container (/).

 COPY 			requirements.txt .

Luego vemos que ejecuta el update del repositorio, instala los programas necesarios, crea el grupo spiderfoot como también el usuario spiderfoot, luego baja el software, lo instala y cambia los permisos.

 # Run everything as one command so that only one
 # layer is created
 RUN apk --update add --no-cache --virtual build-dependencies \
      gcc git curl py3-pip swig tinyxml-dev python3-dev \
      musl-dev openssl-dev libffi-dev libxslt-dev && \
      apk --update --no-cache add python3 musl openssl \
      libxslt tinyxml jpeg-dev openjpeg-dev zlib-dev \
      && pip3 --no-cache-dir install wheel \
      && pip3 --no-cache-dir install -r requirements.txt \
      && addgroup spiderfoot \
      && adduser -G spiderfoot -h /home/spiderfoot -s 
         /sbin/nologin \
        -g "SpiderFoot User" -D spiderfoot \
      && rmdir /home/spiderfoot \
      && cd /home \
      && curl -sSL https://github.com/smicallef/spiderfoot  /archive/v3.0.tar.gz \
  | tar -v -C /home -xz \
  && mv /home/spiderfoot-3.0 /home/spiderfoot \
  && chown -R spiderfoot:spiderfoot /home/spiderfoot \
  && apk del --purge build-dependencies \
  && rm -rf /var/cache/apk/* \
  && rm -rf /root/.cache

Indica cual es el usuario que se utilizara y el directorio.


 USER 		spiderfoot
 WORKDIR 	/home/spiderfoot

Indica en que puerto quedara a la escucha (5001).

 EXPOSE 			5001

Y por ultimo el comando que se ejecuta (python3) y la dirección ip que queda para la conexión.

 # 			Run the application.
 ENTRYPOINT 			["/usr/bin/python3"]  
 CMD 			["./sf.py", "-l", "0.0.0.0:5001"]

Para realizar el container vamos a ejecutar el siguiente comando:

 $ docker build -t spiderfoot .

Si ejecutamos el siguiente comando, veremos que el container esta bajado y es una imágen.

 $ docker images

Una vez creado, vamos a levantar el container:

 $ docker run -ti -p 5001:5001 spiderfoot

Si no queremos realizar el container y ejecutarlo directamente de nuestro equipo, tenemos que instalas las aplicaciones que necesita python para utilizarlo.

 #  pip3 install -r requirements.txt

Una vez que bajo las librerías que necesita, vamos a poder ejecutar la aplicación de la siguiente forma:

 # python3 ./sf.py", "-l", "0.0.0.0:5001

Como lo utilizamos

Vamos a empezar a utilizarlo por la web, para eso accedemos a un navegador web, y ingresamos http://127.0.0.1:5001.


Dentro de Settings vamos a poder configurar las distintas aplicaciones que podemos utilizar para acceder a la información, en muchas vamos a requerir la API Key para poder conectarse para el pedido de información, lo vamos a poder observar de una forma muy sencilla porque al lado del nombre de la aplicación, vamos a tener un candado, como puede ser para Google Map, entre otros.


Una vez terminado la configuración vamos a realizar una nuevo scaneo (New Scan).



Como podemos observar podes ingresar en el target no solamente una ip, si no también un dominio, subdominio, red, subred, email, número telefónico, nombre/apellido, un usuario, etc.

Vemos que existen cuatro tipo de casos:

  • All: todos los módulos de SpiderFoot son habilitados y con esto tendremos mayor cantidad de información, será un poco mas lento.

  • Footprint: se utiliza motores de búsqueda, donde se realiza el rastreo de una gran cantidad de información en la web.

  • Investigate: Es cuando sospechamos que el objetivo es malicioso pero necesita más información. Se realizarán algunas huellas básicas además de consultar listas negras y otras fuentes pueden tener información sobre la malicia de su objetivo.

  • Passive: Cunado no queremos que el objetivo sospeche que lo estamos investigando. Se recompila tanta información sin tocar el objetivo o sus afiliados, por lo tanto, solo se habilitaran los módulos que no toquen el objetivo.

Luego tenemos dos pestañas Datos requeridos (By Required Data) que son los datos que queremos obtener de información y la segunda pestaña que son los Módulos (By Module), los módulos que configuramos al principio de todo donde también algunos le indicamos el API, acá vamos a poder seleccionarlos o no.

En este ejemplo simplemente vamos a poner una cuenta de email, para ver los resultados que obtuvo, para esto le damos al botón Run Scan, que aparece en la primer pestaña.


Resultados

Veremos que tenemos cinco tabs con la información encontrada.

Status

El resultado obtenido es el siguiente.


Si nos pasamos el mouse por cada grafico de barra, vamos a poder obtener información de los elementos únicos y el total de elementos.

Podemos observar que nos da el estado de los distintos módulos que nos dieron error, entre otras cosas.



Browse

Nos da un resumen del estado, donde podemos desplegar cada tipo de información obtenida en forma mas detallada.


Graph

Nos muestra un grafico con los puntos relacionados al correo que ingresamos, un resumen en las distintas redes sociales que se encontró el correo.

Cada punto representa la red social relacionado con el correo, también podemos grabar la imagen, exportar la información, etc.

Scan Settings

No muestra la configuración que utilizo para la realización del scaneo.

Logs

Nos muestra el estado, lo mismo que nos apareció en Status.

Conclución

Gracias a esta herramienta OpenSource, podemos obtener información de una persona, correo electrónico, etc. Todo a través desde la web como también desde la terminal, de forma muy sencilla, ya que la herramienta tiene los distintos plugin para conectarse a las redes sociales, como buscadores.

Saludos a la comunidad #DFIR