NtAddAtom

Prototipo

NTSTATUS NtAddAtom(
  PWSTR     AtomName,
  ULONG     Length,
  PRTL_ATOM Atom
);

Argumentos

IDs de syscalls por versión de Windows

Stub del syscall

4C 8B D1            mov r10, rcx
B8 47 00 00 00      mov eax, 0x47
F6 04 25 08 03 FE 7F 01   test byte ptr [0x7FFE0308], 1
75 03               jne short +3
0F 05               syscall
C3                  ret
CD 2E               int 2Eh
C3                  ret

Notas no documentadas

El SSN `0x47` ha sido totalmente estable de 1507 a 24H2 — los átomos son un subsistema viejo que nadie renumera. El kernel mantiene una **tabla de átomos global** independiente del proceso: cualquier proceso puede hacer `NtAddAtom` con un nombre y cualquier otro puede `NtFindAtom` para obtener el mismo ID, y luego `NtQueryInformationAtom` para recuperar el nombre. Los wrappers Win32 `GlobalAddAtom*` / `GlobalFindAtom*` / `GlobalGetAtomName*` rutean por estos syscalls. Crucialmente, `Length` está en **bytes** y el kernel no exige que el buffer sea una cadena Unicode NUL-terminada válida — guarda los bytes tal cual, lo que es la base del Atom Bombing.

Uso común por malware

**Atom Bombing** (enSilo, Tal Liberman, octubre 2016) — la técnica canónica de inyección de código construida sobre este syscall. Etapa 1: escribir shellcode en la tabla de átomos global llamando a `GlobalAddAtomA` (que termina en NtAddAtom) con los bytes del shellcode como 'nombre'. Etapa 2: encolar un APC en el proceso objetivo que llame a `GlobalGetAtomNameA` (NtQueryInformationAtom por dentro); el kernel escribe el 'nombre' del átomo — es decir, el shellcode del atacante — en un buffer del espacio de direcciones del objetivo. Etapa 3: un APC posterior o un gadget ROP transiciona ese buffer a RWX (vía NtSetContextThread + llamadas ROP a `ZwProtectVirtualMemory`). Como **la escritura en el proceso objetivo la realiza el propio kernel**, las funciones usermode hookeadas en el objetivo (NtWriteVirtualMemory, WriteProcessMemory) nunca ven los datos — derrotando a los EDR que dependen de hooks de inyección usermode. Recogido por Dridex (oleada 2017, writeup de FireEye), e incorporado como técnica base en varios RAT privados desde entonces.

Oportunidades de detección

La telemetría sobre NtAddAtom desde usermode es escasa — los átomos son tecnología de los 90 que pocos productos instrumentaron históricamente. Los EDR modernos (CrowdStrike, SentinelOne, Defender) añadieron hacia 2017-2018 reglas conductuales que buscan: (1) llamadas `GlobalAddAtomA/W` con `Length` > ~250 bytes (los átomos reales son nombres cortos de clase de ventana o cadenas DDE); (2) bytes de nombre de átomo que no roundtrip a UTF-16 válido (contenido binario); (3) `GlobalGetAtomNameA` llamado desde un hilo que acaba de despertar vía NtTestAlert / KiUserApcDispatcher en un contexto recién asignado — el patrón APC de Atom Bomb. ETW Microsoft-Windows-Kernel-Audit-API-Calls cubre estos syscalls. WinDbg / forense en vivo: la extensión `!atom` vuelca la tabla global — entradas largas con bytes no imprimibles son un IOC fuerte.

Ejemplos de syscalls directos

; Direct syscall stub for NtAddAtom (SSN 0x47, all builds)
NtAddAtom PROC
    mov  r10, rcx          ; syscall convention
    mov  eax, 47h          ; SSN
    syscall
    ret
NtAddAtom ENDP

// Atom Bomb stage 1: smuggle shellcode bytes into the global atom table.
// The Length is in bytes and the kernel does not require a NUL terminator,
// so arbitrary binary content rides in as the atom 'name'.
#include <windows.h>
#include <winternl.h>

typedef NTSTATUS (NTAPI *pNtAddAtom)(PWSTR, ULONG, PUSHORT);

USHORT AtomBombUpload(const BYTE* shellcode, ULONG cb) {
    pNtAddAtom NtAddAtom = (pNtAddAtom)GetProcAddress(
        GetModuleHandleA("ntdll.dll"), "NtAddAtom");
    USHORT atomId = 0;
    // PWSTR is just a cast — the kernel reads `cb` raw bytes regardless
    // of UTF-16 validity. Real Atom Bomb POCs round cb up to even.
    NTSTATUS s = NtAddAtom((PWSTR)shellcode,
                           (cb + 1) & ~1u,  // even byte count
                           &atomId);
    return NT_SUCCESS(s) ? atomId : 0;
}

// Cargo: ntapi = "0.4", widestring = "1"
// Register a normal short string atom — same syscall, benign use.
// Demonstrates the Length-in-bytes convention.
use ntapi::ntexapi::NtAddAtom;
use widestring::U16CString;

pub unsafe fn add_atom(name: &str) -> Option<u16> {
    let w = U16CString::from_str(name).ok()?;
    let mut atom: u16 = 0;
    let bytes = w.len() * 2; // UTF-16 byte count, excluding NUL
    let s = NtAddAtom(w.as_ptr() as _, bytes as u32, &mut atom);
    if s >= 0 { Some(atom) } else { None }
}

Mapeos MITRE ATT&CK

• T1055Process Injectionmitre ↗
• T1559Inter-Process Communicationmitre ↗
• T1106Native APImitre ↗