¿Por qué es importante conocer las APIs de Windows usadas por malware?

Porque las APIs que un malware importa revelan sus capacidades sin necesidad de ejecutarlo. Ver CreateRemoteThread + VirtualAllocEx indica inyección de código. Ver CryptEncrypt + FindFirstFile indica posible ransomware. Las imports son la fuente más valiosa del análisis estático.

¿Qué pasa cuando el malware no muestra estas APIs en la Import Table?

Usa dynamic API resolution: carga las funciones en runtime con GetProcAddress o recorriendo el PEB manualmente. Herramientas como CAPA y FLOSS pueden detectar estos patrones. En análisis dinámico, un API monitor registra todas las llamadas independientemente de cómo se resolvieron.

¿Cuál es la diferencia entre APIs de kernel32 y ntdll?

kernel32.dll proporciona las APIs documentadas de Windows (CreateFile, ReadFile). ntdll.dll proporciona las APIs nativas no documentadas (NtCreateFile, NtReadFile) que son las que realmente hacen las system calls al kernel. El malware avanzado llama directamente a ntdll para evitar hooks de EDR en kernel32.

¿Qué es una syscall directa y por qué la usa el malware?

En vez de llamar a kernel32 o ntdll (donde el EDR tiene hooks), el malware ejecuta la instrucción syscall directamente con el número de syscall correspondiente. Esto bypasea completamente los hooks en user-mode. Técnicas como SysWhispers y HellsGate automatizan esto.

¿Qué herramientas monitorizan API calls en tiempo real?

API Monitor (rohitab.com), x64dbg con plugins de logging, Process Monitor (Sysinternals) para I/O y registro, y los EDRs que hookean ntdll. Para análisis automatizado: ANY.RUN, Joe Sandbox y CAPE Sandbox registran todas las API calls.

IntermedioWindowsAPIanálisis estáticobehavioral analysisreferenciacheat sheet

Windows API Calls Más Usadas por Malware: Guía de Referencia para Analistas

Catálogo completo de las Windows APIs más usadas por malware, organizadas por comportamiento: inyección de código, persistencia, evasión, exfiltración, cifrado, keylogging y comunicación C2. Cada API con su DLL, descripción y nivel de sospecha.

MalwareIntel Research·21 de mayo de 2026·10 min lectura

Serie: Malware en Windows — Parte 4

Las APIs como huella dactilar del malware

Cada acción que un programa realiza en Windows pasa por una API: abrir un archivo, crear un proceso, escribir en el registro, conectarse a Internet, cifrar datos. El malware no es diferente. Las APIs que utiliza son un mapa de sus capacidades.

Este artículo es una referencia organizada por comportamiento: qué APIs indican inyección de código, cuáles indican persistencia, cuáles indican evasión. Para cada API, la DLL que la exporta, una descripción de su uso legítimo vs malicioso, y el nivel de sospecha cuando aparece en un análisis.

Inyección de código y manipulación de procesos

APIs críticas de inyección

API	DLL	Uso malicioso	Sospecha
`OpenProcess`	kernel32	Obtener handle de otro proceso para inyección	Media (legítimo en debuggers, task managers)
`VirtualAllocEx`	kernel32	Reservar memoria en otro proceso	Alta (casi exclusivo de inyección)
`WriteProcessMemory`	kernel32	Escribir código/datos en otro proceso	Muy alta
`CreateRemoteThread`	kernel32	Crear hilo de ejecución en otro proceso	Muy alta
`NtUnmapViewOfSection`	ntdll	Vaciar la imagen de un proceso (hollowing)	Muy alta
`SetThreadContext`	kernel32	Modificar registros de un hilo (cambiar entry point)	Alta
`ResumeThread`	kernel32	Reanudar hilo suspendido tras inyección	Media (combinado con CreateProcess SUSPENDED = alta)
`QueueUserAPC`	kernel32	Encolar APC en otro hilo (APC injection)	Alta cuando es cross-process
`NtQueueApcThread`	ntdll	Versión nativa de QueueUserAPC	Alta
`RtlCreateUserThread`	ntdll	Alternativa a CreateRemoteThread	Alta

Patrón clásico de inyección

La secuencia OpenProcess + VirtualAllocEx + WriteProcessMemory + CreateRemoteThread es el patrón más reconocible de DLL injection / shellcode injection. Si estas cuatro APIs aparecen en las imports de un PE, la probabilidad de que sea malicioso es muy alta.

Persistencia

API	DLL	Mecanismo	ATT&CK
`RegSetValueExA/W`	advapi32	Escritura en claves de registro (Run keys, Services)	T1547.001
`RegCreateKeyExA/W`	advapi32	Creación de claves de registro	T1547.001
`CreateServiceA/W`	advapi32	Crear un servicio Windows	T1543.003
`ChangeServiceConfigA/W`	advapi32	Modificar servicio existente	T1543.003
`SchRpcRegisterTask`	taskschd (COM)	Crear scheduled task programáticamente	T1053.005
`CopyFileA/W`	kernel32	Copiar malware a ubicación de persistencia	Variable
`MoveFileExA/W` (MOVEFILE_DELAY_UNTIL_REBOOT)	kernel32	Mover archivo al reiniciar (evasión)	T1547
`SetWindowsHookExA/W`	user32	Hooking global (keylogger, inyección vía mensaje)	T1056.001
`SHGetFolderPathA/W`	shell32	Obtener rutas como Startup folder	T1547.001

Claves de registro usadas para persistencia

HKCU\Software\Microsoft\Windows\CurrentVersion\Run
HKLM\Software\Microsoft\Windows\CurrentVersion\Run
HKCU\Software\Microsoft\Windows\CurrentVersion\RunOnce
HKLM\SYSTEM\CurrentControlSet\Services\[nombre_servicio]
HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders
HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon\Shell

Evasión de defensas

API	DLL	Uso malicioso	ATT&CK
`IsDebuggerPresent`	kernel32	Detectar si se ejecuta en debugger	T1622
`CheckRemoteDebuggerPresent`	kernel32	Detectar debugger remoto	T1622
`NtQueryInformationProcess`	ntdll	Query ProcessDebugPort, ProcessDebugFlags	T1622
`GetTickCount` / `QueryPerformanceCounter`	kernel32	Timing checks anti-sandbox	T1497.003
`Sleep` / `NtDelayExecution`	kernel32/ntdll	Retrasar ejecución para evadir sandbox (time-based)	T1497.003
`VirtualProtect`	kernel32	Cambiar permisos de memoria (RW a RWX para execute)	T1055
`GetSystemInfo`	kernel32	Detectar número de CPUs (sandbox suele tener 1-2)	T1497.001
`GlobalMemoryStatusEx`	kernel32	Detectar RAM baja (sandbox)	T1497.001
`EnumProcesses`	psapi	Listar procesos (buscar herramientas de análisis)	T1057
`GetModuleHandleA("sbiedll.dll")`	kernel32	Detectar Sandboxie	T1497.001
`CreateToolhelp32Snapshot`	kernel32	Enumerar procesos/módulos (buscar AV/análisis)	T1057

Anti-debugging: patrón común

# Patron anti-debug tipico (pseudocodigo)
if IsDebuggerPresent():
    exit()

# Check mas avanzado via NtQueryInformationProcess
debug_port = NtQueryInformationProcess(
    GetCurrentProcess(), ProcessDebugPort, ...)
if debug_port != 0:
    exit()

# Timing check
t1 = GetTickCount()
# ... codigo normal ...
t2 = GetTickCount()
if (t2 - t1) > threshold:  # Ejecucion demasiado lenta = stepping en debugger
    exit()

Acceso a archivos y sistema de archivos

API	DLL	Uso malicioso	Sospecha
`CreateFileA/W`	kernel32	Abrir/crear archivos (payload, configuración)	Baja (muy común)
`ReadFile` / `WriteFile`	kernel32	Leer/escribir archivos	Baja
`FindFirstFileA/W`	kernel32	Enumerar archivos (ransomware)	Media (alta si combina con cifrado)
`FindNextFileA/W`	kernel32	Continuar enumeración	Media
`DeleteFileA/W`	kernel32	Eliminar archivo original (ransomware, cleanup)	Media
`GetLogicalDriveStringsA`	kernel32	Enumerar drives (ransomware busca todos los discos)	Alta
`GetDriveTypeA`	kernel32	Identificar tipo de drive (local, red, removible)	Media
`MoveFileA/W`	kernel32	Renombrar archivos (cambiar extensión)	Media (alta en contexto ransomware)

Patrón de ransomware

GetLogicalDriveStrings → FindFirstFile → FindNextFile (recursivo)
  → CreateFile → ReadFile → CryptEncrypt → WriteFile → CloseHandle
  → MoveFile (renombrar con nueva extension)
  → DeleteFile (eliminar original)

Criptografía

API	DLL	Uso malicioso	Contexto
`CryptAcquireContext`	advapi32	Inicializar proveedor criptográfico	Ransomware, comunicación cifrada
`CryptGenKey`	advapi32	Generar clave criptográfica	Ransomware
`CryptEncrypt`	advapi32	Cifrar datos	Ransomware
`CryptDecrypt`	advapi32	Descifrar datos	Descifrar configuración, payload
`CryptImportKey`	advapi32	Importar clave (clave pública RSA del atacante)	Ransomware
`CryptGenRandom`	advapi32	Generar bytes aleatorios (para claves)	Ransomware
`BCryptEncrypt`	bcrypt	CNG: cifrar (API moderna)	Ransomware moderno
`BCryptGenerateSymmetricKey`	bcrypt	CNG: generar clave simétrica	Ransomware moderno
`BCryptGenRandom`	bcrypt	CNG: CSPRNG	Generación de claves

Comunicación de red

API	DLL	Uso malicioso	Protocolo
`InternetOpenA`	wininet	Inicializar sesión de Internet	HTTP/HTTPS
`InternetConnectA`	wininet	Conectar a servidor C2	HTTP/HTTPS
`HttpOpenRequestA`	wininet	Crear request HTTP	HTTP/HTTPS
`HttpSendRequestA`	wininet	Enviar request (beacon, exfiltración)	HTTP/HTTPS
`InternetReadFile`	wininet	Leer respuesta (comandos del C2)	HTTP/HTTPS
`URLDownloadToFileA`	urlmon	Descargar archivo directamente a disco	HTTP/HTTPS
`WSAStartup`	ws2_32	Inicializar Winsock	TCP/UDP raw
`socket` / `connect` / `send` / `recv`	ws2_32	Comunicación TCP/UDP directa	TCP/UDP
`DnsQuery_A`	dnsapi	Query DNS (DNS tunneling, DGA)	DNS
`WinHttpOpen`	winhttp	Alternativa a WinINet para HTTP	HTTP/HTTPS

Patrón de C2 beacon

InternetOpen → InternetConnect → HttpOpenRequest → HttpSendRequest
  → InternetReadFile (leer comando)
  → [ejecutar comando]
  → HttpSendRequest (enviar resultado)
  → Sleep(intervalo)
  → [repetir]

Credential Access

API	DLL	Uso malicioso	ATT&CK
`OpenProcessToken`	advapi32	Abrir token de proceso para manipulación	T1134
`AdjustTokenPrivileges`	advapi32	Habilitar privilegios (SeDebugPrivilege)	T1134.001
`LookupPrivilegeValueA`	advapi32	Buscar valor de privilegio por nombre	T1134
`LsaRetrievePrivateData`	advapi32	Acceder a secretos de LSA	T1003.004
`CredEnumerateA`	advapi32	Enumerar credenciales almacenadas	T1555.004
`SamConnect` / `SamEnumerateUsersInDomain`	samlib	Acceso directo a SAM database	T1003.002
`MiniDumpWriteDump`	dbghelp	Dump de proceso (LSASS)	T1003.001

Mimikatz pattern

Mimikatz accede a LSASS (Local Security Authority Subsystem Service) para extraer credenciales. El patrón de APIs:

OpenProcess(PROCESS_VM_READ | PROCESS_QUERY_INFORMATION, lsass_pid)
  → MiniDumpWriteDump()     # Volcar memoria de LSASS a archivo
  # O alternativamente:
  → ReadProcessMemory()      # Leer directamente de la memoria de LSASS
  → [parsear estructuras de credenciales en el dump]

Captura de input (keylogging, screenshots)

API	DLL	Uso malicioso	ATT&CK
`SetWindowsHookExA(WH_KEYBOARD_LL)`	user32	Hook global de teclado (keylogger)	T1056.001
`GetAsyncKeyState`	user32	Polling de estado de teclas (keylogger alternativo)	T1056.001
`GetClipboardData`	user32	Leer contenido del portapapeles	T1115
`BitBlt`	gdi32	Captura de pantalla (screenshot)	T1113
`GetDC` / `CreateCompatibleDC`	user32/gdi32	Preparar contexto para screenshot	T1113
`GetForegroundWindow`	user32	Identificar ventana activa (logging contextual)	T1010
`GetWindowTextA`	user32	Obtener título de ventana (registrar app activa)	T1010

Nivel nativo: ntdll y syscalls directas

Por qué el malware usa ntdll directamente

Las APIs de kernel32 son wrappers que internamente llaman a ntdll. Los EDRs hookean las funciones de kernel32 y ntdll para monitorizar comportamiento. El malware avanzado bypasea estos hooks:

Nivel 1: Llamar a ntdll directamente (en vez de kernel32)

// En vez de: CreateRemoteThread (kernel32)
// Usar: NtCreateThreadEx (ntdll) - bypasea hook en kernel32

Nivel 2: Syscall directo (en vez de ntdll)

; En vez de llamar a NtAllocateVirtualMemory en ntdll (donde el EDR tiene hook)
; Ejecutar la syscall directamente:
mov r10, rcx
mov eax, 0x18        ; Syscall number de NtAllocateVirtualMemory
syscall              ; Invocar directamente al kernel

Nivel 3: Indirect syscall

; Saltar al stub de syscall DENTRO de ntdll pero DESPUES del hook del EDR
; El EDR hookea los primeros bytes de la funcion en ntdll
; Si saltas al 'syscall' instruction dentro de ntdll, bypaseas el hook

Herramientas que automatizan syscalls directas

Herramienta	Descripción
SysWhispers	Genera stubs de syscall para compilar directamente en el malware
SysWhispers2/3	Versiones mejoradas con indirect syscalls
HellsGate	Resuelve syscall numbers en runtime leyendo ntdll en memoria
Halo's Gate	Variante que recupera syscall numbers incluso si ntdll está hookeada
RecycledGate	Combina técnicas para máxima evasión

Tabla resumen: APIs por nivel de sospecha

Sospecha CRITICA (casi seguro malicioso si aparecen juntas)

VirtualAllocEx + WriteProcessMemory + CreateRemoteThread
NtUnmapViewOfSection + SetThreadContext + ResumeThread
MiniDumpWriteDump (con target = lsass.exe)
CryptEncrypt + FindFirstFile + GetLogicalDriveStrings

Sospecha ALTA

CreateRemoteThread (cross-process)
QueueUserAPC (cross-process)
SetWindowsHookEx(WH_KEYBOARD_LL)
AdjustTokenPrivileges (SeDebugPrivilege)
URLDownloadToFile

Sospecha MEDIA (depende del contexto)

RegSetValueEx (Run keys)
CreateService
InternetOpen + HttpSendRequest
FindFirstFile + FindNextFile (masivo)
GetTickCount + Sleep (timing checks)

Fuentes y referencias

Microsoft. "Windows API Index." Microsoft Docs, 2024.
Sikorski, M. & Honig, A. "Practical Malware Analysis." No Starch Press, 2012.
Russinovich, M. et al. "Windows Internals Part 1." Microsoft Press, 2017.
Mandiant. "CAPA: Identifying Malware Capabilities." https://github.com/mandiant/capa
MITRE ATT&CK. "Process Injection (T1055)." https://attack.mitre.org/techniques/T1055/
MITRE ATT&CK. "Input Capture (T1056)." https://attack.mitre.org/techniques/T1056/
jthuraisamy. "SysWhispers." https://github.com/jthuraisamy/SysWhispers
am0nsec & smelly_vx. "HellsGate." 2020.
Red Canary. "2024 Threat Detection Report." Red Canary, 2024.

Preguntas frecuentes

Libros recomendados

Windows Internals Part 1 (Russinovich)

Amazon (enlace afiliado)

Practical Malware Analysis (Sikorski & Honig)