Análisis de Malware
Reading time: 10 minutes
tip
Aprende y practica Hacking en AWS:HackTricks Training AWS Red Team Expert (ARTE)
Aprende y practica Hacking en GCP: HackTricks Training GCP Red Team Expert (GRTE)
Aprende y practica Hacking en Azure:
HackTricks Training Azure Red Team Expert (AzRTE)
Apoya a HackTricks
- Revisa los planes de suscripción!
- Únete al 💬 grupo de Discord o al grupo de telegram o síguenos en Twitter 🐦 @hacktricks_live.
- Comparte trucos de hacking enviando PRs a los HackTricks y HackTricks Cloud repositorios de github.
Hojas de referencia forense
https://www.jaiminton.com/cheatsheet/DFIR/#
Servicios en línea
Herramientas antivirus y de detección sin conexión
Yara
Instalación
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
Crea el directorio rules y ejecútalo. Esto creará un archivo llamado malware_rules.yar que contiene todas las reglas yara para malware.
wget https://gist.githubusercontent.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9/raw/4ec711d37f1b428b63bed1f786b26a0654aa2f31/malware_yara_rules.py
mkdir rules
python malware_yara_rules.py
Escaneo
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 para generar yara rules a partir de un binario. Consulta estos tutoriales: Part 1, Part 2, Part 3
python3 yarGen.py --update
python3.exe yarGen.py --excludegood -m ../../mals/
ClamAV
Instalación
sudo apt-get install -y clamav
Escaneo
sudo freshclam #Update rules
clamscan filepath #Scan 1 file
clamscan folderpath #Scan the whole folder
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.
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.
Puedes usar herramientas como Redline para buscar IOCs definidos en un dispositivo.
Loki
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) 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 pueden usarse para revisar el sistema de archivos en busca de posibles rootkits y malware.
sudo ./rkhunter --check -r / -l /tmp/rkhunter.log [--report-warnings-only] [--skip-keypress]
FLOSS
FLOSS es una herramienta que intentará encontrar cadenas ofuscadas dentro de ejecutables usando diferentes técnicas.
PEpper
PEpper comprueba algunas cosas básicas dentro del ejecutable (datos binarios, entropía, URLs e IPs, algunas yara rules).
PEstudio
PEstudio 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 es una herramienta para detectar si un archivo está cifrado y también encontrar packers.
NeoPI
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 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.
#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:
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
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
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
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
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('<I', disp))
Después de parchear, fuerza a IDA a volver a analizar la función para que se restaure el CFG completo y la salida de Hex-Rays:
import ida_auto, idaapi
idaapi.reanalyze_function(idc.get_func_attr(ea, idc.FUNCATTR_START))
5. Etiquetar llamadas API indirectas
Una vez que se conoce el destino real de cada call rax
, puedes indicarle a IDA cuál es para que los tipos de parámetros y los nombres de variables se recuperen automáticamente:
idc.set_callee_name(call_ea, resolved_addr, 0) # IDA 8.3+
Beneficios prácticos
- Restaura el CFG real → la decompilación pasa de 10 líneas a miles.
- Habilita string-cross-reference & xrefs, haciendo la reconstrucción del comportamiento trivial.
- Los scripts son reutilizables: colócalos en cualquier loader protegido por el mismo truco.
References
- Unit42 – Evolving Tactics of SLOW#TEMPEST: A Deep Dive Into Advanced Malware Techniques
- SoTap: Lightweight in-app JNI (.so) behavior logger – github.com/RezaArbabBot/SoTap
tip
Aprende y practica Hacking en AWS:HackTricks Training AWS Red Team Expert (ARTE)
Aprende y practica Hacking en GCP: HackTricks Training GCP Red Team Expert (GRTE)
Aprende y practica Hacking en Azure:
HackTricks Training Azure Red Team Expert (AzRTE)
Apoya a HackTricks
- Revisa los planes de suscripción!
- Únete al 💬 grupo de Discord o al grupo de telegram o síguenos en Twitter 🐦 @hacktricks_live.
- Comparte trucos de hacking enviando PRs a los HackTricks y HackTricks Cloud repositorios de github.