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.