YARA 101

¿Qué es YARA?

Cuando se habla de detección de malware existen principalmente tres maneras de determinar si un fichero es dañino o no: firmas, heurística y string signatures.

La más extendida en los sistemas de detección antivirus es la detección en base a firmas, es decir, en base al resultado de calcular el HASH de un fichero, pasarlo por una base de datos de firmas y comprobar si este fichero ha sido detectado anteriormente como malware. Este tipo de firma es inútil para la detección de malware no conocido y para evadirlo basta con recompilar el código en un sistema diferente o cambiarle un solo bit.

Para tratar de parar estos métodos de evasión se utiliza el método heurístico. Este método se basa en el comportamiento del ejecutable y, de acuerdo a las acciones que realiza dentro del sistema, se decide si el fichero es malicioso o no. El principal problema de este método es que puede generar una gran cantidad de falsos positivos ya que muchos programas realizan acciones lícitas que pueden hacer saltar las alertas.

Por último, queda el método que atañe a este artículo, string signatures. Este método se basa en otro tipo de firmas diferente al comentado anteriormente. En lugar de usar firmas tipo HASH, utiliza cadenas de texto o binarias que identifican inequívocamente a un malware. De esta forma aunque se modifique el fichero, si este sigue conteniendo esas cadenas que conforman una firma, los analistas seguirán siendo capaces de detectar y clasificar ese malware.

YARA es una herramienta diseñada por Víctor Manuel Álvarez principalmente para la detección y clasificación de malware basándose en string signatures. Y digo “principalmente” porque también se le pueden dar otros usos, que no sólo de malware vive el hombre.

Usando una reglas relativamente simples, YARA recorre los ficheros que recibe en busca de las cadenas definidas en la regla y, si se cumplen ciertas condiciones, te indica qué regla o reglas se han cumplido para cada fichero. Esto es también aplicable a procesos que se están ejecutando en ese momento.

Es muy fácil de usar y para instalarlo no hay más que descargar el paquete correspondiente de la web del proyecto y seguir las instrucciones de instalación. En caso de usar Linux (el enlace es para Ubuntu, pero seguro que sois capaces de extrapolarlo a vuestra distro favorita); y en caso de usar Windows es todavía más fácil: el ejecutable de YARA solo hay que extraerlo de un zip y para instalar la librería de YARA: doble click, siguiente, siguiente, finalizar.

Una de las cosas que más me gustan de YARA: ¡tiene una librería para Python que permite integrarlo de una manera muy fácil en los proyectos!

Reglas YARA

Para ilustrar las reglas de YARA empezaremos con un ejemplo simple:

rule HelloWorld
{
	strings:
		$a = "Hello world"
	
	condition:
		$a
}

Diseccionemos la regla:

rule HelloWorld	//rule -> Palabra clave con la que empiezan todas las reglas
		//HelloWorld -> nombre de la regla
{
	strings:	//Sección strings -> En esta sección se definen las
			//cadenas que luego se usarán para comprobar si se
			//cumplen las condiciones
		$a = "Hello world"	//variable $a, contiene “Hello world”
	
	condition:	//Sección condition -> Se definen las condiciones 
		$a	//Si se encuentra $a true
}

Creamos tres ficheros de texto para probar la regla:

test1.txt:
SecurityArtWork

test2.txt:
Hello world

test3.txt:
Hello World

Vemos la salida al ejecutar YARA. El fichero rules.yar contiene la regla y la opción –s es para que la salida muestre la cadena que hace saltar la regla:

# yara –s rules.yar test1.txt 
# yara –s rules.yar test2.txt 
HelloWorld test2.txt
0x0:$a: Hello world
# yara –s rules.yar test3.txt

Se puede observar que al lanzar YARA contra el fichero test2.txt encuentra una coincidencia:

HelloWorld test2.txt	-> La regla que ha saltado
0x0:$a: Hello world 	-> Offset:variable: Cadena que coincide.

Aunque la documentación es muy buena, hay algunas cosas que no están documentadas, como las que comentó Julia Wolf (@foxgrrl) en la charla de BerlinSides titulada Classifying malware with YARA. No he podido encontrar la presentación publicada por ninguna parte, así que supongo que esos problemas os los encontraréis sólo pegándoos con las reglas.

YARA con binarios

Para probar YARA con binarios voy a crear un pequeño escenario. Supongamos que trabajamos para una corporación maligna llamada La Corporación. En La Corporación trabajan habitualmente con patentes y en el pasado ha sido objetivo de… ¡APTs! Nosotros, como parte del CSIRT de La Corporación, tenemos que prepararnos para defendernos ante posibles ataques. Los análisis de los ataques anteriores revelan que todos los ataques han sido a través del correo y que además siempre han incluido cuentas de administración en alguna parte del código.

Como toda buena organización, en La Corporación se sigue una nomenclatura a rajatabla y todas las cuentas de administración siguen uno de los dos siguientes esquemas: admin.<user> o corp.<user>. Además, en la zona que intentamos defender, sólo se utilizan sistemas Linux.

Para defender La Corporación ponemos en marcha un sniffer que captura todo el tráfico del correo, extrae los adjuntos y se los pasa a YARA. Creamos la siguiente regla para defender La Corporación:

rule APT_adm_corp : apt 	//apt es una etiqueta, no afecta a la
				//pero se usa para la clasificación.
{
        meta:			//Metadatos, no afectan a la regla
                author = "xgusix"

        strings:
                $adm = "adm."
                $corp = "corp."
                $elf = { 7f 45 4c 46 } //Magic numbers de ficheros ELF

        condition:
                $elf in (0..4) and ($adm or $corp)
		//Si $elf en los primero 4 bytes y se cumple $adm o se cumple $corp
}

Hay algunos campos que no habían aparecido antes y que están explicados en los comentarios. Para probarla, lo lanzamos contra una simulación de malware que no es más que el ejecutable resultante de la compilación del siguiente código:

//testbin.c
#include 

int main ()
{
	char *user = "adm.user";
	printf("%s\n",user);
	return 0;
}

Lo lanzamos contra nuestra regla con las opciones: –s para ver las cadenas, -g para ver los tags y –m para ver los metadatos:

# yara -s -m -g rules.yar testbin
APT_adm_corp [apt] [author="xgusix"] testbin
0x0:$elf: 7F 45 4C 46 
0x4c0:$adm: adm.

La regla se ha ejecutado con éxito y ha pillado a nuestro “malware”. Las aplicaciones de YARA son muchas y lo que he escrito es sólo un ejemplo de lo que se puede hacer con esta herramienta. Os animo a todos a darle una oportunidad y ver hasta dónde se puede llegar con YARA.