# Análisis de Malware {{#include ../../banners/hacktricks-training.md}} ## Hojas de referencia forense [https://www.jaiminton.com/cheatsheet/DFIR/#](https://www.jaiminton.com/cheatsheet/DFIR/) ## Servicios en línea - [VirusTotal](https://www.virustotal.com/gui/home/upload) - [HybridAnalysis](https://www.hybrid-analysis.com) - [Koodous](https://koodous.com) - [Intezer](https://analyze.intezer.com) - [Any.Run](https://any.run/) ## Herramientas antivirus y de detección sin conexión ### Yara #### Instalación ```bash sudo apt-get install -y yara ``` #### Preparar reglas Usa este script para descargar y fusionar todas las reglas yara de malware desde github: [https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9](https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9)\ Crea el directorio _**rules**_ y ejecútalo. Esto creará un archivo llamado _**malware_rules.yar**_ que contiene todas las reglas yara para malware. ```bash wget https://gist.githubusercontent.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9/raw/4ec711d37f1b428b63bed1f786b26a0654aa2f31/malware_yara_rules.py mkdir rules python malware_yara_rules.py ``` #### Escaneo ```bash yara -w malware_rules.yar image #Scan 1 file yara -w malware_rules.yar folder #Scan the whole folder ``` #### YaraGen: Comprobar malware y crear reglas Puedes usar la herramienta [**YaraGen**](https://github.com/Neo23x0/yarGen) para generar yara rules a partir de un binario. Consulta estos tutoriales: [**Part 1**](https://www.nextron-systems.com/2015/02/16/write-simple-sound-yara-rules/), [**Part 2**](https://www.nextron-systems.com/2015/10/17/how-to-write-simple-but-sound-yara-rules-part-2/), [**Part 3**](https://www.nextron-systems.com/2016/04/15/how-to-write-simple-but-sound-yara-rules-part-3/) ```bash python3 yarGen.py --update python3.exe yarGen.py --excludegood -m ../../mals/ ``` ### ClamAV #### Instalación ``` sudo apt-get install -y clamav ``` #### Escaneo ```bash sudo freshclam #Update rules clamscan filepath #Scan 1 file clamscan folderpath #Scan the whole folder ``` ### [Capa](https://github.com/mandiant/capa) **Capa** detecta **capacidades** potencialmente maliciosas en ejecutables: PE, ELF, .NET. Por lo tanto encontrará cosas como Att\&ck tactics, o capacidades sospechosas como: - comprobar error de OutputDebugString - ejecutarse como un servicio - crear proceso Consíguelo en el [**Github repo**](https://github.com/mandiant/capa). ### IOCs IOC significa Indicator Of Compromise. Un IOC es un conjunto de **condiciones que identifican** algún software potencialmente no deseado o confirmado **malware**. Los Blue Teams usan este tipo de definiciones para **buscar este tipo de archivos maliciosos** en sus **sistemas** y **redes**.\ Compartir estas definiciones es muy útil, ya que cuando se identifica malware en un equipo y se crea un IOC para ese malware, otros Blue Teams pueden usarlo para identificar el malware más rápido. Una herramienta para crear o modificar IOCs es [**IOC Editor**](https://www.fireeye.com/services/freeware/ioc-editor.html)**.**\ Puedes usar herramientas como [**Redline**](https://www.fireeye.com/services/freeware/redline.html) para **buscar IOCs definidos en un dispositivo**. ### Loki [**Loki**](https://github.com/Neo23x0/Loki) es un scanner para Simple Indicators of Compromise.\ La detección se basa en cuatro métodos de detección: ``` 1. File Name IOC Regex match on full file path/name 2. Yara Rule Check Yara signature matches on file data and process memory 3. Hash Check Compares known malicious hashes (MD5, SHA1, SHA256) with scanned files 4. C2 Back Connect Check Compares process connection endpoints with C2 IOCs (new since version v.10) ``` ### Linux Malware Detect [**Linux Malware Detect (LMD)**](https://www.rfxn.com/projects/linux-malware-detect/) es un escáner de malware para Linux publicado bajo la licencia GNU GPLv2, diseñado en torno a las amenazas que se enfrentan en entornos de hosting compartido. Utiliza datos de amenazas procedentes de sistemas de detección de intrusiones en el perímetro de la red para extraer malware que se está usando activamente en ataques y genera firmas para su detección. Además, los datos de amenazas también provienen de envíos de usuarios mediante la función LMD checkout y de recursos de la comunidad de malware. ### rkhunter Herramientas como [**rkhunter**](http://rkhunter.sourceforge.net) pueden usarse para revisar el sistema de archivos en busca de posibles **rootkits** y malware. ```bash sudo ./rkhunter --check -r / -l /tmp/rkhunter.log [--report-warnings-only] [--skip-keypress] ``` ### FLOSS [**FLOSS**](https://github.com/mandiant/flare-floss) es una herramienta que intentará encontrar cadenas ofuscadas dentro de ejecutables usando diferentes técnicas. ### PEpper [PEpper ](https://github.com/Th3Hurrican3/PEpper) comprueba algunas cosas básicas dentro del ejecutable (datos binarios, entropía, URLs e IPs, algunas yara rules). ### PEstudio [PEstudio](https://www.winitor.com/download) es una herramienta que permite obtener información de ejecutables de Windows como imports, exports, headers, pero también consultará virus total y encontrará posibles técnicas Att\&ck. ### Detect It Easy(DiE) [**DiE**](https://github.com/horsicq/Detect-It-Easy/) es una herramienta para detectar si un archivo está **cifrado** y también encontrar **packers**. ### NeoPI [**NeoPI** ](https://github.com/CiscoCXSecurity/NeoPI) es un script Python que utiliza una variedad de **métodos estadísticos** para detectar contenido **ofuscado** y **cifrado** dentro de archivos de texto/script. El propósito previsto de NeoPI es ayudar en la **detección de código de web shell oculto**. ### **php-malware-finder** [**PHP-malware-finder**](https://github.com/nbs-system/php-malware-finder) hace todo lo posible por detectar **ofuscado**/**código sospechoso** así como archivos que usan funciones **PHP** frecuentemente usadas en **malwares**/webshells. ### Apple Binary Signatures Al analizar alguna **malware sample** siempre deberías **comprobar la firma** del binario, ya que el **desarrollador** que lo firmó puede ya estar **relacionado** con **malware.** ```bash #Get signer codesign -vv -d /bin/ls 2>&1 | grep -E "Authority|TeamIdentifier" #Check if the app’s contents have been modified codesign --verify --verbose /Applications/Safari.app #Check if the signature is valid spctl --assess --verbose /Applications/Safari.app ``` ## Técnicas de detección ### File Stacking Si sabes que alguna carpeta que contiene los **archivos** de un **servidor web** fue **actualizada por última vez en cierta fecha**, **comprueba** la **fecha** en la que todos los **archivos** en el **servidor web** fueron creados y modificados; si alguna fecha es **sospechosa**, revisa ese archivo. ### Baselines Si los archivos de una carpeta **no deberían haber sido modificados**, puedes calcular el **hash** de los **archivos originales** de la carpeta y **compararlos** con los **actuales**. Cualquier cosa modificada será **sospechosa**. ### Statistical Analysis Cuando la información se guarda en logs puedes **verificar estadísticas como cuántas veces se accedió a cada archivo del servidor web, ya que un web shell podría ser uno de los más**. --- ### Android: telemetría nativa dentro de la app (sin root) En Android, puedes instrumentar código nativo dentro del proceso de la app objetivo precargando una pequeña librería logger antes de que otras librerías JNI se inicialicen. Esto ofrece visibilidad temprana del comportamiento nativo sin hooks a nivel de sistema ni root. Un enfoque popular es SoTap: coloca libsotap.so para el ABI correcto dentro del APK e injerta una llamada System.loadLibrary("sotap") temprano (p. ej., en un static initializer o Application.onCreate), luego recoge logs desde rutas internas/externas o, como fallback, Logcat. See the Android native reversing page for setup details and log paths: {{#ref}} ../../mobile-pentesting/android-app-pentesting/reversing-native-libraries.md {{#endref}} --- ## Deobfuscating Dynamic Control-Flow (JMP/CALL RAX Dispatchers) Modern malware families heavily abuse Control-Flow Graph (CFG) obfuscation: instead of a direct jump/call they compute the destination at run-time and execute a `jmp rax` or `call rax`. A small *dispatcher* (typically nine instructions) sets the final target depending on the CPU `ZF`/`CF` flags, completely breaking static CFG recovery. The technique – showcased by the SLOW#TEMPEST loader – can be defeated with a three-step workflow that only relies on IDAPython and the Unicorn CPU emulator. ### 1. Localiza todos los saltos/llamadas indirectos ```python import idautils, idc for ea in idautils.FunctionItems(idc.here()): mnem = idc.print_insn_mnem(ea) if mnem in ("jmp", "call") and idc.print_operand(ea, 0) == "rax": print(f"[+] Dispatcher found @ {ea:X}") ``` ### 2. Extraer el dispatcher byte-code ```python import idc def get_dispatcher_start(jmp_ea, count=9): s = jmp_ea for _ in range(count): s = idc.prev_head(s, 0) return s start = get_dispatcher_start(jmp_ea) size = jmp_ea + idc.get_item_size(jmp_ea) - start code = idc.get_bytes(start, size) open(f"{start:X}.bin", "wb").write(code) ``` ### 3. Emularlo dos veces con Unicorn ```python from unicorn import * from unicorn.x86_const import * import struct def run(code, zf=0, cf=0): BASE = 0x1000 mu = Uc(UC_ARCH_X86, UC_MODE_64) mu.mem_map(BASE, 0x1000) mu.mem_write(BASE, code) mu.reg_write(UC_X86_REG_RFLAGS, (zf << 6) | cf) mu.reg_write(UC_X86_REG_RAX, 0) mu.emu_start(BASE, BASE+len(code)) return mu.reg_read(UC_X86_REG_RAX) ``` Ejecuta `run(code,0,0)` y `run(code,1,1)` para obtener los objetivos de las ramas *falsa* y *verdadera*. ### 4. Parchear de nuevo un salto/llamada directa ```python import struct, ida_bytes def patch_direct(ea, target, is_call=False): op = 0xE8 if is_call else 0xE9 # CALL rel32 or JMP rel32 disp = target - (ea + 5) & 0xFFFFFFFF ida_bytes.patch_bytes(ea, bytes([op]) + struct.pack('