Todos sabemos qué es un antivirus, cuales son sus funciones y qué forma tienen de proteger nuestros equipos. Lo que explicaré en este y otros tres artículos es el funcionamiento interno de los mismos para que sepamos cómo funciona un antivirus, de que forma detectan las amenazas y por qué no son útiles frente ataques dirigidos. Además pondré casos prácticos con ejemplos de cómo burlarlos.

En esta parte comentaremos como funciona la detección de malware mediante firmas, la forma mas utilizada desde el nacimiento de los antivirus.

¿Cómo se diferencia un virus de un archivo que no lo es?

Como todos sabemos algo que diferencia unos antivirus de otros es la cantidad de firmas que contiene, es decir la cantidad de virus que tiene catalogados en su base de datos y es capaz de identificar. Pero ¿Qué son las firmas?

Como todos sabemos un archivo está formado por una cantidad de bytes los cuales en conjunto dicen qué hacer al sistema operativo, por tanto cada programa tiene una secuencia de bytes distinta al resto, no hay dos programas distintos que usen la misma secuencia de bytes.

Sabiendo todo esto es lógico pensar que si tenemos una base de datos donde figure una copia de los bytes de los diferentes virus luego podríamos comparar cada archivo con ella y determinar si es un virus en caso de que exista en la base de datos. Pero esto no es del todo así ya que una base de datos que contenga integramente todos los bytes de los miles y miles de virus que hay sería totalmente inviable por su tamaño.


Parte del código del virus Walker.

Lo que se hace en realidad es tomar fragmentos del código en lugar de todo el mismo y almacenarlo en la base de datos.

Cuando el programa antivirus empiece a analizar ficheros buscara en cada fichero coincidencias en su código con los almacenados en la base de datos si encuentra una coincidencia lo catalogará como una amenaza y cuanto mas coincidencias mas indudable para el será que es un virus.

El análisis mediante firmas a priori parece muy fiable pero si lo pensamos concienzudamente nos damos cuenta de lo frágil que es, pensemos que si logramos detectar  cuales son las partes (en adelante firmas)  modificarlos y que este continue funcionando el antivirus será incapaz de detectarlo.

Caso práctico: Burlando un antivirus con el virus Walker.

El virus Walker es uno de los virus de antaño mas conocidos que existen, originario de Estambul y creado en el año 1992, los efectos de este virus son graciosos y es que muestra un hombrecillo caminando por la pantalla cada cierto tiempo. Como todos podéis suponer este es un virus que deberían tener mas que trillado todos los antivirus.

Para el ejemplo que voy a poner voy a usar en todo momento el antivirus Microsoft Security Essentials, como veis detecta sin problemas la amenaza y es capaz de desinfectarla.

Paso uno: Averiguar qué partes del código está tomando el antivirus como firmas

Como hemos dicho antes el antivirus compara partes del código con su base de datos para decidir que es un virus o que no lo es, por tanto tenemos que detectar dichas partes, para ello dividiremos el virus en partes y las examinaremos con el antivirus para ver con cual (o cuales de ellas salta). En mi ejemplo usaré el programa HJSplit que permite definir el tamaño de cada parte.

En nuestro caso, puesto que el virus es pequeño (solo 6Kb) vamos a dividirlo en dos partes de 3Kb. Una vez dividido pasamos el antivirus a cada parte y obtenemos los resultados:

Como vemos en la imagen el antivirus está detectando la primera parte del archivo por lo cual el resto del código podemos dejarlo como está ya que no es detectado por nuestro antivirus, si quisieramos afinar mas dónde está la firma podriamos dividir la primera parte en otras y volver a analizarlas hasta tener un fragmento mínimo. Pero puesto que nuestro ejemplo es muy pequeño y la parte detectada es de solo 3Kb lo dejaremos así.

Paso 2: Modificando el código para hacer a Walker indetectable.

Esta es quizás la parte mas compleja de todo el ejemplo y puede variar dependiendo de muchos factores, en las próximas partes comentaremos otros modos de edición.

Lo primero es abrir la parte que detecta el antivirus con un editor hexadecimal, esto nos mostrará sus bytes en código hexadecimal y podremos identificar de una manera mas o menos sencilla las partes editables. Nosotros usaremos HxD pero podéis utilizar cualquier otro.

Una vez abierto lo mas fácil es ojear un poco el código en su parte derecha para buscar cadenas de texto

Lo que vamos a hacer es editar estas cadenas de texto que como vemos son dedicaciones, etc, por otro, en nuestro caso serán puntos dejandolo así, debemos buscar bien y cambiar la mayor parte posible del código, en nuestro caso tendremos otra cadena de texto similar un poco mas abajo la cual también sustituiremos con puntos.

Una vez hecho los cambios analizaremos de nuevo la parte para ver si ya no lo detecta, en caso deque lo detectase deberiamos seguir cambiando código.

Paso 3: Volver a montar los ficheros y probarlo.

Es una parte lógica, volver a montar los ficheros mediante el mismo programa que hemos usado para partirlos. Como vemos, tras analizarlo no se debería encontrar ninguna amenaza

Y a pesar de que nuestro antivirus ya no lo ve peligroso, veamos que ocurre si lo ejecuta una máquina.

Hace un tiempo vimos las diferentes formas en las que un antivirus detectan las amenazas, centrándonos en el análisis de firmas y vimos una forma básica de burlarlo. En esta entrada (2.1) y en la siguiente (2.2) nos centraremos en los análisis heurísticos que tratan de identificar el malware a través de su comportamiento. Por ejemplo, si un ejecutable se copia a los diferentes pendrives  y se conecta a un servidor , es muy probable que un antivirus lo detecte como una amenaza.

Generalmente los antivirus corren los ficheros en un sandbox donde analizan su comportamiento. Una vez sabemos básicamente como funcionan estos análisis vamos a ver cuatro ejemplos de cómo burlar este tipo de análisis, que van desde saturar el proceso dedicado al análisis a detectar si estamos siendo analizados por un antivirus para realizar unas acciones u otras. En nuestro ejemplo usaré un Keylogger programado para la ocasión y el antivirus AVG el cual tiene protección heurística y como podemos ver es identificado como una amenaza.

Excediendo el tiempo límite de análisis.

Este es el ejemplo mas básico de los que vamos a ver, se basa en la limitación de los antivirus a la hora de analizar un fichero y es que por razones de optimización no es capaz de mantener un análisis constante hacia un fichero pasado un tiempo sin actividad sospechosa lo toma como fiable, este método aunque puede sonar sencillo es tenido en cuenta por muchos antivirus que suprimen las “pausas” que tenga el proceso, así que lo correcto es que el malware realice acciones legítimas durante el tiempo que dura dicho análisis a fin de ser considerado un software no malicioso. Un ejemplo de esto es el siguiente código:

Para vurlarlo en este primer ejemplo lo que haremos es iniciar la función keylogger() pasado un determinado tiempo, sin realizar llamadas a Thread.sleep o demás formas “deducibles”, para ello iniciamos en un hilo a parte una funcion encargada de ver si ha pasado dicho tiempo

1234567double inicio; //Guarda el milisegundo en el que se inicia el programaprivate void Form1_Load(object sender, EventArgs e){inicio = new TimeSpan(DateTime.Now.Ticks).TotalMilliseconds;hilo_key = new Thread(startKeylogger);hilo_key.Start();}

Como podéis ver lo primero que hacemos es comprobar el momento en el que se ha iniciado la aplicación y guardarlo en la variable global inicio, a continuación llamamos al proceso startKeylogger la cual se encargará de ver si ha pasado el tiempo indicado como vemos a continuación

12345678910111213141516171819//Inicia el keylogger cuando hayan pasado 5 minutosprivate void startKeylogger(){ while (1==1){if (new TimeSpan(DateTime.Now.Ticks).TotalMilliseconds > inicio + 300000) //Si han pasado 5 minutos{while (1==1) //Bucle sin sentido, lo explicaremos mas abajo.{keylogger(); //Inicia el keylogger}}else{System.Threading.Thread.Sleep(1000); //Si no han pasado cinco minutos espera un segundo hasta volver a realizar la comprobación}}}

Si bien puede parecer algo enrevesada esta función lo único que hace es comprobar si el tiempo actual es inicio (el momento en el que arrancó el software) mas 30000 segundos, lo correspondiente a cinco minutos, en caso de que no sea así vuelve a ejecutarse la comprobación hasta que dicha condición se cumpla.

Además es importante jugar con diferentes formas de hacer este tipo de cosas aunque por que cuanto mas compliquemos el camino mas efectivo será contra un análisis heurísticos pesar de que no sea “lógico” en términos de programación, ya que a mas acciones “no perjudiciales” detecte el motor antivirus menos motivos hay para sospechar. De ahí podemos ver el segundo bucle infinito que es simplemente algo absurdo y que a razón de eficiencia podríamos suprimir dejando solo keylogger();

Si os fijáis hemos puesto algunos Sleeps, los cuales no son pensando en el análisis heurístico, ya que probablemente sean omitidos, si no que son pensados para reducir el consumo de recursos en el equipo ya que realizar las comprobaciones de forma infinita y sin control daría como resultado un alto uso de CPU.

En este caso, esta modificación es suficiente para que AVG no detecte mi software como malicioso, pero en cualquier caso en la próxima entrega explicaremos otros medios mas sofisticados a la par que efectivos para detectar si estamos siendo analizados.