Buscar IPs maliciosas con Delphi y VirusTotal

 


En mi trabajo diario me he encontrado con la necesidad de hacer una comprobación de las conexiones que realiza mi PC, tanto las entrantes como salientes en busca de pistas que me permitan saber si mi equipo forma parte de una bot, si tengo un virus o si en background hay un troyano que espía mis datos y luego los envía otro PC en remoto.

Seguramente en Internet hay algún programa que hace lo mismo, pero he preferido hacerlo yo mismo desde cero, lo que me permite ampliarlo y modificarlo según lo necesite.

El modo de funcionamiento de este programa es el siguiente: 

Se pulsa el botón INICIAR y comienza una temporización en la que cada 5 segundos, desde la línea de comandos, se hace un netstat, después se parsea su resultado extrayendo la ip de origen y la ip de destino de cada conexión establecida almacenando ambas ips en dos listbox y por último  un proceso elimina las ips duplicadas.

 Tiene un botón para enviar cada IP de destino a VirusTotal, usando su API pública.


Hay que tener en cuenta que la APIKEY que incorpora el software, (que cada usuario puede obtener gratuitamente desde su página https://www.virustotal.com/gui/join-us) sólo permite comprobar 4 IPs por minuto y 500 al día.

La apiKey hay que indicarla en la línea 99 del archivo VirusTotal.pas

También incorpora un fichero con más de 1000000 de IPs maliciosas, que el usuario puede utilizar para comprobar cada una de las IPs de Destino pulsando el botón.

 Al final el resultado es el siguiente:

Algunas consideraciones previas:

Si al hacer una búsqueda en VirusTotal  aparece en cada IP: Result: 0/0 esto nos indica que no se ha hecho la búsqueda, bien sea porque se ha sobrepasado el límite de las 4 Ips por minuto o que la ApiKey no es correcta. Debería indicar p.ej: Result: 0/83, que quiere decir que de 83 antivirus consultados ninguno de ellos considera esa IP como maliciosa.

El programa hay que ejecutarlo como Administrador, y mi consejo es que se utilice cuando no se tenga abierto ningún navegador.

El fichero de IPs maliciosas lo he descargado desde  https://urlhaus.abuse.ch/api/ 

Si quieren profundizar más en el tema de la detección de malware les recomiendo consulten el proyecto firehol, que mantiene una amplia base de datos de malware de diferentes proveedores y  que gracias a "git pull" se pueden actualizar a la vez todas las listas que nos descarguemos.

He utilizado "Delphi superJSON", es un parser muy útil para archivos JSON escrito en Delphi, que lo pueden consultar y descargar desde su proyecto en Github

También he utilizado el archivo VirusTotal.pas, que utiliza su API de versión 2, que lo pueden descargar desde Github, accediendo al proyecto de halilhan badem

Este software está realizado con Rad Studio - Delphi - v 10.4.1 y a continuación les dejo el archivo ejecutable y el código fuente.

Espero que este programa les sea útil y que les ayude a prevenir y a detectar el malware.

Ejecutable

Código fuente

 

 


Analizar malware con reglas Yara utilizando Delphi



A continuación les presento un programa que he realizado para identificar y clasificar muestras de malware utilizando reglas Yara, ya que los antivirus tradicionales no suelen comprobar ciertos aspectos importantes que puede contener un fichero, dado que para conseguir una velocidad de análisis óptima utilizan hashes que cruzan contra una base de datos de hashes de archivos maliciosos.

Yara en este aspecto nos facilita mucho el trabajo, ya que principalmente analiza los strings de los ficheros, con lo que podemos detectar webshells, archivos utilizados en las APT, cryptomineros, macros de office maliciosas, exploits, troyanos, incluso el ransomware más actual como CobalStrike, Ryuk, etc.

En su forma mas básica, la estructura de una regla Yara es la siguiente:

rule Nombre_de_la_regla

{

              strings:

              $test_string1= ”Testing”

              $test_string2= {E1 D2 C3 B4}

              Conditions:

              $test_string1 or $test_string2

}

La regla se activará si las condiciones anteriores se cumplen.

Con Yara también podemos parsear archivos PE (Portable Executable), de la siguiente forma:

Import “PE”

Rule PE_Parse_Check

{

Strings:

$ string_pe=”abc” nocase

Condition:

pe.imports (“Kernel32.dll”,”CreateProcess”) and

pe.imports (“wininet.dll”,”httpsendrequest”) and

$ string_pe

}

 Esta regla buscará el string "abc" y se activará si existe una creación de un proceso y un "http send request"

En general las reglas son independientes de la extensión de los archivos a analizar, es decir si tenemos un documento HTML con una webshell al que se le ha cambiado la extensión por PDF para ocultarlo o dificultar su análisis, al ser examinado por Yara se descubrirá la webshell maliciosa. 

REQUISITOS PREVIOS

Descargar el archivo Yara64.exe desde aquí.

Tienen que guardar las reglas yara, que no son más que archivos de texto con la extensión ".yar" en la carpeta "reglasyar".

Existen en la red multitud de sitios desde donde descargarlas, sólo tienen que buscar en Google por "Yara rules download", para mí uno de los mejores es Yara Rules Project · GitHub

Los archivos que van a ser analizados hay que guardarlos en la carpeta "malware", aunque desde la red también se pueden descargar algunos archivos maliciosos de prueba desde aquí.

Al iniciar el programa se hace lo siguiente:

- Se comprueba que existen las carpetas "reglasyara" y "malware".

- Se leen las reglas y se muestran en pantalla.

Recomiendo ejecutar el programa como Administrador, para evitar problemas con los permisos en ficheros o carpetas. 

Después hay que pulsar el botón "Iniciar comprobación" y en caso de match con una regla se mostrará en la caja "Resultados", tal como muestro en la imagen:


En este caso ha detectado que varios emails tienen imágenes y un archivo adjunto y una webshell en el archivo JFolder.jsp

MEJORAS

Dentro del código fuente, en la línea:

 linea := 'yara64.exe -wf -p 20 ' + '.\reglasyar\' + regla + ' ' + DirSeleccionado;

se pueden añadir modificadores, p.ej.

-r  (buscar recursivamente en todas las carpetas y subcarpetas)

-S (muestra estadísticas)

-m (muestra metadatos)

-w (ignora los warnings)

 

SOURCES

- Programa.rar


ESTRUCTURA DEL PROGRAMA

- Project1.exe

- Yara64.exe 

- [CARPETA] reglasyar (carpeta donde se almacenan los ficheros *.yar)

- [CARPETA] malware  (esta es la carpeta donde se guardan los fichero que serán analizados)

 

La carpeta "reglasyara" almacenará todas las reglas que hayamos descargado de la red.


 





 

El análisis de ficheros con Yara debe ser un complemento al análisis con los antivirus tradicionales, sumando ambas técnicas se los pondremos más difícil a los actores maliciosos que andan por la red, al final esto de la ciberseguridad es como el juego del gato y el ratón, seguro que los creadores de malware ya estarán probando su software para evitar ser detectado por estas reglas, aunque si las estudian en profundidad y ven la potencia que tienen, la verdad es que lo tienen complicado.

Muchas gracias por seguir este blog y hasta la próxima.








Tips para programadores de apps

 

 

1) Revisar el consumo de memoria

Uno de nuestros objetivos al programar una aplicación para dispositivos móviles es no desperdiciar el uso de la memoria utilizándola eficientemente y evitando los memory leaks, en mi caso cuando estoy ejecutando el software que he programado, utilizo la siguiente rutina en Android que me va comprobando la memoria disponible actual y la memoria total del dispositivo.

Este procedimiento lo asocio a un componente tTimer para que cada segundo me informe de la situación actual del consumo de memoria.

Después voy abriendo y cerrando Forms varias veces y compruebo antes y después la memoria disponible. Cuando la diferencia es considerable toca revisar el código. Hay que tener en cuenta que el sistema Android es dinámico y en background se van abriendo y cerrando programas que forman parte del sistema operativo que también modifican la memoria disponible del dispositivo.

La rutina que utilizo es la siguiente:

 
USES
Androidapi.JNI.App;

VAR
    MemLibre, MemTotal: STRING;
    Am: JActivityManager;
    Mi: JActivityManager_MemoryInfo;

...

    Am := GetActivityManager;
    Mi := TJActivityManager_MemoryInfo.Create;
    Am.GetMemoryInfo(Mi);
    // bajamemoria := mi.lowMemory;
    MemLibre := (Mi.AvailMem DIV 1048576).Tostring() + 'Mb';
    MemTotal := (Mi.TotalMem DIV 1048576).Tostring() + 'Mb';
    Label2.Text := MemLibre + ' / ' + MemTotal;

2) Evitar el uso de "Release" con el componnte tWebBrowser

Si inserta un componente tWebBrowser (con su propiedad Name: WebBrowser1) no escriba WebBrowser1.Release para liberar memoria al cerrar la app. Esta instrucción está desactualizada y no tiene ningún efecto.

3) Controlar el uso de Form.BringTofront, después del Form.Show

No es necesario poner

Form1.Show;

Form1.BringtoFront;

Con poner Form1.Show es suficiente, ahorra código y evitará problemas cuando tiene muchos forms en la app.

4) Añadir FireDAC.Phys.SQLiteWrapper.Stat

Si usa FireDac, no olvide añadir en el USES de la unit: FireDAC.Phys.SQLiteWrapper.Stat 

Esto se ha activado en la última versión de Rad Studio la 10.4

5) No use Application.Processmessages al programar apps para Android.

 No tiene ningún efecto en el código


6) Optimizar SQLite

6.1) Use el comando Sweep de Firedac para optimizar la base de datos SQLite.

Internamente llama al comando VACCUM de SQLite, haciendo lo siguiente:

Primero copia los datos dentro de un archivo de base de datos a una base de datos temporal. Esta operación desfragmenta los objetos de la base de datos, ignora los espacios libres y vuelve a empaquetar páginas individuales. Luego, SQLite copia el contenido del archivo de base de datos temporal al archivo de base de datos original. Se sobrescribe el archivo de base de datos original.

Esto se hace de la siguiente forma:

Añada un componente llamado tFDSQLiteValidate al form.


 

 

y después escriba:

FDSQLiteValidate1.Sweep;

Recordar que la base de datos sobre la que tengamos que hacer esta operación ha de estar cerrada, en caso contrario salta una excepción.

6.2)  Use LIMIT 1 Cuando sólo quiera obtener una única fila al hacer una consulta.

En estos casos, añadir LIMIT 1 al query puede mejorar significativamente la velocidad. De esta forma la base de datos dejará de escanear resultados en el momento que encuentre uno, en lugar de recorrer toda la tabla o un índice.

6.3)  Indexe los campos de búsqueda.

Si utiliza siempre las mismas columnas para realizar búsquedas, indéxelos para mejorar la velocidad.

6.4) Evite SELECT *

Siempre que se pueda, coloque a continuación del SELECT los nombres de las columnas que use. Si una tabla tiene 2000 columnas no es eficiente hacer un select de las 2000.