martes, 2 de junio de 2020

Script colector de eventos McAfee Mvision ePO Cloud

portada_mcafee_mvision_epo_cloud


¡Hola compañeros!

En esta entrada os quiero enseñar uno de mis primeros scripts en Python3 para extraer los eventos de la solución McAfee Mvision ePO Cloud.


Colector de eventos McAfee Mvision ePO Cloud


Trabajando como analistas o en ámbitos dedicados a blueteam,  en algunas situaciones nos vemos en la necesidad de tener que extraer los eventos de las soluciones que gestionamos y añadirlos al SIEM que tengamos para poder realizar la integración, correlación y generación de alertas según umbrales, etc, y de esta forma aportar mayor proactividad al entorno ante situaciones de seguridad.

En este caso, el script ha sido desarrollado para poder extraer los eventos según el cliente que configuremos, permitiéndonos configuraciones individuales de extración de eventos de la solución Cloud.

El script es el siguiente:

Antes de empezar, hay que modificar la variable "self.path" del archivo "Mvision_epo.py" con la ruta donde se encuentre el directorio del script.

Este script consta de varios archivos y directorios que pasaré a detallar:

  • setup.py: Es el primer archivo que debemos ejecutar, ya que se encarga de configurar el cliente y crear un archivo "CFG" donde almacenará la información de este.
  • mvision_epo.py: Es el archivo que se debe ejecutar en segundo lugar, este se encarga de la autenticación y obtención del token access para poder extraer los eventos y almacenarlos en un archivo.log
  • general.cfg: Este archivo contiene los ID de eventos que NO queremos extraer de la ePO de Mvision.
  • Directorio CONF: En este directorio se encuentran los archivos de configuración de los clientes, creados a partir del setup.py. Se crea una vez finalizado el setup.py
  • Archivo CONF: Este archivo contiene las credenciales de autenticación, el client_ID de Mvision, marca de tiempo para control de eventos, numero de eventos extraídos hasta la fecha, etc.


1 - Ejecución de Setup.py


En primer lugar como he comentado, ejecutamos el archivo "setup.py" para configurar el cliente, nos irá pidiendo los datos uno a uno:

ejecucion_script_setup


Una vez configurado el cliente, pasamos a mostrar el archivo creado, en este caso "Prueba1.cfg":

visualizar_archivo_creado

  • client: Nombre de cliente configurado
  • client_ID: Este es el identificador de cliente, lo podemos obtener a través del siguiente enlace una vez estemos logueados: https://auth.ui.mcafee.com/support.html. Se codifica en base64.
  • epo_user: Usuario de acceso a Mvision (podemos crear uno de solo lectura). Se codifica en base64.
  • epo_pass: Contraseña de acceso. Se codifica en base64
  • epo_scope: Alcance de módulos para extraer eventos. Es decir, de que módulos se extraeran, por defecto se han configurado todos.
  • dir_events: Directorio donde se almacenarán los eventos extraídos en un archivo ".log". Unicamente se debe definir el directorio con ruta absoluta.
  • state: Contador del cual nos permite identificar los eventos con un campo numérico (numevent).
  • last_since: Control de tiempo para poder extraer los eventos desde la ultima ejecución, evitando tener que extraer todos cada vez que se ejecuta.


2 - Ejecución de Mvision_epo.py


Como segundo paso, se debe ejecutar el script "Mvision_epo.py" con el argumento cliente, como se muestra en la siguiente imagen:

ejecucion_script_mvision

Nos indica que el script se ha ejecutado correctamente y los eventos han sido recolectados.

Ahora si echamos un ojo al archivo "CFG" del cliente en cuestión, veremos que la variable state y last_since, han sido definidas con otros valores.


3 - Revisión de logs

Una vez se haya ejecutado el script anterior, pasamos a visualizar los eventos recolectados. En este caso voy a mostrar una parte de los logs, ya que no he podido crear un tenant de prueba para la solución:

visualizacion_logs_recolectados

Opcional - Automatización con CRON


Como estaréis pensando, este script sería conveniente que se fuese ejecutando cada X tiempo para ir recolectandos los eventos que van sucediendo en la solución. Acordarse que en la ejecución del archivo, este debe tener el argumento "cliente" para que se ejecute con el archivo "CFG" en cuestión.

Añadimos la ejecución a CRON y de esta forma automatizamos. Unicamente nos quedaría la opción de indicarle al SIEM de donde debe leer los eventos, que en este caso sería de un archivo local.

Para finalizar, indicar como he comentado al principio que ha sido el primer script que he realizado en Python3. por lo que el código podrá ser optimizado de mejor forma, soís libres de ello.

Espero que os pueda servir de ayuda y como digo siempre, cualquier duda, sugerencia, etc, la podéis dejar en los comentarios.

Nos vemos en el próximo artículo.

Saludos!

rekaktz


miércoles, 25 de marzo de 2020

Obtener MD5 con Bash Script a través de Virustotal API



Obtener_MD5_con_BashScript_a_traves_de_API_Virustotal

¡Hola compañeros! 

Este va a ser un artículo rapido y conciso. 

En una solución Cloud de Endpoint necesitaba añadir 500 IOC's en formato hash para bloquear, esta consola solo permitía añadir el hash en formato MD5 y el cliente nos había proporcionado una lista con 500 hashes en varios formatos (MD5, SHA-1 y SHA-256). 

Podemos tomar varias opciones...indicar al cliente que nos pase los 500 hashes en formato MD5 o pensar la forma en la cual podemos tomar esos hashes ¿?... bingo, API Virustotal

La API gratuita nos permite realizar 4 peticiones/minuto y un máximo de 1000/día, por lo tanto en el código le he metido un sleep de 15 segundos entre cada petición para completar el minuto.

Código del Script 


#!/bin/bash

FILE=$1
API="---API---"
count=0

touch ./result_hash.txt
echo "Number,SourceHash,VTHits,MD5hash" > ./result_hash.txt

echo "Processing..."

while IFS= read -r line || [ -n "$line" ]; do

    let count=count+1
    var=$(curl -s -X POST 'https://www.virustotal.com/vtapi/v2/file/report' --form apikey="$API" --form resource="$line" | awk -F'positives\":' '{print $2}' | awk -F' ' '{print $1$5}' | sed 's/["}]//g')

    if [ -z "$var" ]; then
        echo "$count,$line,NULL,NULL" >> ./result_hash.txt
        echo "Hash $count - Not Found!"
    else
        echo "$count,$line,$var" >> ./result_hash.txt
        echo "Hash $count - OK!"
    fi

    sleep 15
done < $FILE



El script en si es sencillo y puede que tenga algún error que otro, pero el resultado es el esperado.

Metemos el archivo que contiene los hashes como argumento, separando cada hash por línea.

ejecucion_script_virustotal

Sintaxis de ejecución:
  • $ ./vthash.sh <file_hashes>
  • $ ./vthash.sh hashes.txt

Output del Script

 


Se creará un archivo result_hash.txt en el mismo directorio, este contiene el resultado.

Como podéis ver, los hashes que no se encuentren en la BBDD de Virustotal no saldrán...lógica, por lo tanto he añadido NULL en el caso de que la variable VAR se encuentre vacía.

Este código no solo sirve para obtener los hashes en formato MD5, si modificás los AWK podéis obtener una lista de cualquier cadena del resultado de la petición a VT con el comando CURL.


Resultado final

 



Para resumir y finalizar, el caso es que tuve que pedirle al cliente 49 hashes que no fueron encontrados en la BBDD, pero 49 de 509 no está mal ¿no?.

Dejo mi github con el script por si lo necesitáis.
Espero que os pueda servir de ayuda y como digo siempre, cualquier duda, sugerencia, etc, la podéis dejar en los comentarios.

Nos vemos en el próximo artículo.

Saludos!

rekaktz

lunes, 3 de febrero de 2020

Script Tools para Fortigate 3/3




¡Hola compañeros!

En esta tercera y última entrada, quiero mostrar el último script realizado para firewalls Fortigate. Esta vez el objetivo del script será la de realizar backups del firewall a través de línea de comandos, como podréis ver no es nada del otro mundo.

Importante: Para poder realizar backups a través de linea de comandos, necesitaremos habilitar en fortigate la opción de SCP para la transferencia del archivo CONF.

Fortigate # config system global
Fortigate # set admin-scp enable
Fortigate # end


Código del Script

#!/usr/bin/expect -f

# Variables definidas
set PATH [lindex $argv 0];
set DATE [exec date +%d%m%Y_%H%M];
set CONFIG "sys_config"
set timeout 2;

# Log file
log_file <PATH_SAVE_LOG>
log_user 0

# Execution command to client Fortigate CLI
spawn scp -o "StrictHostKeyChecking=no" -o "UserKnownHostsFile=~/.ssh/known_hosts" -P 22 <USER@IP>:$CONFIG $PATH/
backup\_$DATE.conf
expect "password: "
send "password\r"
puts "#####################################"
puts "# Realizando Backup a través de SCP #"
puts "#####################################"
log_user 1
expect eof
puts "\r"

Sintaxis del comando a ejecutar:
  • ./4-backup_conf.sh <PathSave> 

Output del comando:

Output_Comando
Output del comando

lista_ficheros
Lista de backups en ruta

Pues bueno, este ha sido el último "script", por llamarlo de alguno forma, ya que simplemente le he añadido algunas variables y código adicional, pero la esencia está en el SCP.

Se pueden añadir variables nuevas y demás si tenéis una ruta por defecto para guardar los backups, de esta forma no haría falta añadirla como argumento en la ejecución del comando.

Si queréis automatizar la ejecución y llevar un control de los backups, podéis añadirlo a CRON especificando el tiempo.

Bueno, espero que os haya servido de ayuda, si quereís añadir alguna opinión, crítica, etc, podéis dejarlo abajo en los comentarios.

Nos vemos en el próximo artículo.

Saludos,
rekkatz.

viernes, 17 de enero de 2020

Script Tools para Fortigate 2/3




¡Hola compañeros!

Segunda entrada dedicada a herramientas creadas para firewalls Fortigate.

Esta entrada y la que viene serán cortas, ya que los scripts creados para tal son muy sencillos.

En este caso mostráre un script creado en Expect para realizar consultas por CLI al firewall, con destino de búsqueda el grupo de BLACKLIST creado en el post anterior.

De esta forma podremos consultar si una determinada dirección IP se encuentra como referencia dentro de este grupo o no.


Consultar direcciones IP 


Con la ejecución de este script, no introducimos ningún comando de configuración, simplemente realizamos consultas.

Como el output de este comando en crudo suele ser un tanto "simplón", he tenido que añadir la opción "-c" en el comando grep (grep -c), que de esta forma nos mostrará en cuantas líneas ha realizado match la dirección IP, por la tanto siempre deberá ser únicamente en 1, ya que no puede existir la dirección IP duplicada. En el caso de que no exista la dirección IP, obviamente no será matcheada en ninguna, por lo tanto el output será 0:

Así se muestra el output del comando normalmente:

output_show_fortigate_found
Dirección IP encontrada en el grupo Blacklist

output_show_fortigate_notfound
Dirección IP NO encontrada en el grupo Blacklist


Y así se muestra con la opción "-c" de GREP:

output2_show_fortigate_found
Dirección IP encontrada en el grupo Blacklist = 1

output2_show_fortigate_notfound
Dirección IP NO encontrada en el grupo Blacklist = 0

Código del Script:

#!/usr/bin/expect -f

# Variables
set IP [lindex $argv 0];
set timeout 2;

# Log file
log_user 0
log_file <PATH_SAVE_LOG>

# Execution command to client Fortigate CLI
spawn ssh -o "StrictHostKeyChecking=no" -o "UserKnownHostsFile=~/.ssh/known_hosts" <USER@IP> -p 22
expect "password: "
send "password\r"
expect "#"
send "show firewall addrgrp BLACKLIST | grep -c BL_$IP\r"
expect {
    "0" { puts "\n-- NOT FOUND - La dirección IP $IP NO se encuentra en el grupo BLACKLIST\n" }
    "1" { puts "\n++ FOUND - La dirección IP $IP se encuentra en el grupo BLACKLIST\n" }
}
send "exit\r"
expect "closed"

Como podéis ver, es bastante básico y me baso en el output 0 y 1 para determinar si la dirección IP se encuentra en el grupo indicado.

output_script_found
Output Script dirección IP encontrada
output_script_notfound
Output Script dirección IP NO encontrada

Dejo como siempre mi Github por si alguien lo quiere utilizar, modificar a su gusto, etc. Como ya sabéis, no es perfecto pero me sirve =P


Si alguno quiere dejar sus comentarios, ideas, opiniones, etc es libre de hacerlo y siempre son bienvenidos.

Gracias por leerme!

Saludos,
rekkatz.

martes, 14 de enero de 2020

Script Tools para Fortigate 1/3



script_tools_fortigate

¡Hola compañeros!

Quiero realizar un total de 3 entradas rápidas mostrando los scripts tools que realicé en su día cuando administraba firewalls Fortigate.

En nuestro día a día trabajando en ciberseguridad necesitamos respuestas rápidas para comportamientos extraños o sospechosos, para el caso de bloquear o banear direcciones IP en los perimetrales se prioriza el automatizar las acciones que conllevan tener que dar demasiados clics o movernos por la GUI de la plataforma que estemos administrando.

Estos scripts utilizan la shell interactiva EXPECT en sistemas GNU/Linux, la cual nos permite enviar comandos y esperar respuesta para nuevamente enviar comandos.

Instalación de "Expect":

  • # apt update && apt install expect

Para el que quiera saber un poquito más de Expect, dejo aquí el man page:

Para la creación de estos scripts, me basé en la entrada del Blog Inseguros de KinoMakino, la cual dejaré al final de esta entrada por si queréis echarle un ojo y poneros en contexto, aunque dudo que todavía no lo conozcáis =P

La intención que tenía en su día, era la de crear un panel de administración web en la cual mediante PHP y MySQL, realizar la llamada de estos scripts en función de los clientes, así como para tener un apartado threat intelligent donde quedasen recogidos todos los IOC's, en este caso con direcciones IP que fuesen añadiéndose en cada interacción.

Yo lo definía como un panel de herramientas adicional que sirviese de apoyo para los analistas: banear direcciones, consultar, escanear con API de Virustotal, de Spamhaus...vamos, ideas locas que se quedaron en el baúl.

Como veréis, son sencillos pero aún así explicaré las funciones de cada uno de ellos en sus respectivas entradas.

Dejo mi Github con los Scripts por aquí:

Banear direcciones IP


El primero de los scripts tiene como objetivo realizar un baneo rápido de una dirección IP la cual ha sido detectada intentando realizar conexiones o acciones sospechosas:

#!/usr/bin/expect -f

# Variables
set IP [lindex $argv 0];
set COM [lindex $argv 1];
set timeout 2;

# Logs
log_user 0
log_file -a <path_save_log>

# Execution command to client Fortigate CLI
puts "############################################"
puts "#### Añadiendo IP a grupo de Blacklist #####"
puts "############################################"
spawn ssh -o "StrictHostKeyChecking=no" -o "UserKnownHostsFile=~/.ssh/known_hosts" <USER@IP> -p 22
expect "password: "
send "<YOUR_PASSWORD>\r"
expect "#"
send "config firewall address\r"
expect "(address)"
send "edit BL_$IP\r"
expect "BL_$IP"
send "set subnet $IP/32\r"
expect {
    "invalid" {
        puts "\n++ ERROR - La dirección IP $IP no es correcta"
        puts "** Por favor, comprueba que ha sido introducida correctamente\n"
        exit
        }
}
send "set comment \"$COM\"\r"
expect "(BL_$IP)"
send "set color 6\r"
expect "(BL_$IP)"
send "end\r"
expect "#"
send "config firewall addrgrp\r"
expect "(addrgrp)"
send "edit BLACKLIST\r"
expect "(BLACKLIST)"
send "append member BL_$IP\r"
expect "(BLACKLIST)"
send "end\r"
expect "#"
send "exit\r"
expect "closed"
puts "\nOK - Dirección $IP añadida a grupo Blacklist\n"


Sintaxis del comando:
  • $ ./ban.sh "IP_a_banear" "Comentario"
  • $ ./ban.sh 2.2.2.2 "IPS detect" 
El argumento "Comentario" es opcional. Pero es una buena práctica introducir la relación del bloqueo de la dirección IP para tenerla identificada.
Este script crea un grupo de direcciones como objeto llamado BLACKLIST en el cual introduce un objeto de dirección IP que queremos bloquear con un prefijo de BL_ y con color de objeto 6 (Rojo), también introducimos un comentario para llevar un control del por qué ha sido baneada. Cada vez que este script es ejecutado, se registra las acciones realizadas en un archivo log.

IP_baneadas
Dirección 2.2.2.2 añadida como Blacklist

Desbanear direcciones IP


Exactamente igual que el anterior script, pero permitiéndonos eliminar una dirección IP del grupo de BLACKLIST en el cual ha sido añadido.

Este script viene bien cuando se ha introducido una dirección IP errónea y queremos eliminarla del grupo:

#!/usr/bin/expect -f

# Variables arguments
set IP [lindex $argv 0];
set timeout 2;

# Log file threat intelligent
log_user 0
log_file <path_save_log>

# Execution command to client Fortigate CLI
puts "############################################"
puts "#### Eliminando IP del grupo Blacklist #####"
puts "############################################"
spawn ssh -o "StrictHostKeyChecking=no" -o "UserKnownHostsFile=~/.ssh/known_hosts" <USER@IP> -p 22
expect "password: "
send "<YOUR_PASSWORD>\r"
expect "\#"
send "config firewall addrgrp\r"
expect "(addrgrp)"
send "edit BLACKLIST\r"
expect "(BLACKLIST)"
send "unselect member BL_$IP\r"
expect {
    "entry not found" {
        puts "\n++ ERROR - La dirección IP $IP no se encuentra en el grupo BLACKLIST\n"
        exit
        }
}
send "end\r"
expect "#"
send "config firewall address\r"
expect "(address)"
send "delete BL_$IP\r"
expect "(address)"
send "end\r"
expect "#"
send "exit\r"
expect "closed"
puts "\n++ OK - Dirección IP $IP eliminada del grupo BLACKLIST\n"


Sintaxis del comando:
  • $ ./unban.sh "IP_a_eliminar"
  • $ ./unban.sh 2.2.2.2

No hay mucho que comentar, se conecta por SSH al firewall y a través de CLI eliminamos la dirección IP deseada pasándola como argumento. Se mantiene el grupo de BLACKLIST pero se elimina el objeto dirección IP.


direccion_IP_desbaneada
Dirección 2.2.2.2 eliminada de Blacklist

Estos son los scripts principales para banear y desbanear direcciones IP. Se puede mejorar de mil maneras, añadiendo nuevas variables o condicionales, cada uno en su día a día irá viendo que le hace falta o que no, modificándolo a su antojo.

Uno de los problemas que tiene, es que la password se  puede ver en texto plano directamente dentro del archivo, pero podemos utilizar private key sin problema, añadiendo la opción para SSH de utilizar private key (-i) con su respectiva localización de esta.

Para que esto funcione, lógicamente tienen que existir políticas IPv4 configuradas en el firewall que tengan con acción "Deny" el origen, destino o ambos con el objeto grupo de direcciones BLACKLIST como referencia.

Como podréis ver no soy ningún experto en programación xD simplemente he intentado añadir algo nuevo al script de KinoMakino que me servía en mi día a día. Es lo bonito de compartir, coges algo y lo modificas a tu gusto y lo vuelves a compartir para que otro intente añadir algo más.

Había pensando en la posibilidad de crear un "programa" en bash con un menú y las diferentes opciones llamando a los diferentes scripts, así como modificar el de bloquear para que pueda bloquear direcciones IP que contenga un archivo con X direcciones.

Bueno yo seguiré mutando estos códigos para que se vaya mejorando...

Muchas gracias por leerme!

Espero que les sirva de ayuda, cualquier duda podéis dejarla en los comentarios.

Referencias:

Saludos,
rekkatz.