NtAddAtom

Prototype

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

Arguments

IDs de syscalls par version de Windows

Stub du 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

Notes non documentées

Le SSN `0x47` est totalement stable de 1507 à 24H2 — les atomes sont un sous-système ancien que personne ne renumérote. Le noyau maintient une **table d'atomes globale** indépendante du processus : n'importe quel processus peut `NtAddAtom` un nom et n'importe quel autre peut `NtFindAtom` pour récupérer le même ID, puis `NtQueryInformationAtom` pour récupérer le nom. Les wrappers Win32 `GlobalAddAtom*` / `GlobalFindAtom*` / `GlobalGetAtomName*` passent par ces syscalls. Crucialement, `Length` est en **octets** et le noyau n'exige pas que le buffer soit une chaîne Unicode NUL-terminée valide — il stocke ce qu'on lui donne, ce qui est le fondement de l'Atom Bombing.

Usage courant par les malwares

**Atom Bombing** (enSilo, Tal Liberman, octobre 2016) — la technique canonique d'injection de code bâtie sur ce syscall. Étape 1 : écrire du shellcode dans la table d'atomes globale en appelant `GlobalAddAtomA` (qui aboutit à NtAddAtom) avec les octets du shellcode comme « nom ». Étape 2 : enqueuer un APC dans le processus cible qui appelle `GlobalGetAtomNameA` (NtQueryInformationAtom dessous) ; le noyau écrit le « nom » de l'atome — c'est-à-dire le shellcode de l'attaquant — dans un buffer de l'espace d'adresses de la cible. Étape 3 : un APC de suivi ou un gadget ROP transitionne ce buffer en RWX (via NtSetContextThread + appels ROP `ZwProtectVirtualMemory`). Parce que **l'écriture dans le processus cible est effectuée par le noyau lui-même**, les fonctions usermode hookées dans la cible (NtWriteVirtualMemory, WriteProcessMemory) ne voient jamais les données — défaisant les EDR qui s'appuient sur les hooks d'injection usermode. Repris par Dridex (vague 2017, write-up FireEye), et intégré comme technique de base dans plusieurs RAT privés depuis.

Opportunités de détection

La télémétrie sur NtAddAtom depuis l'usermode est rare — les atomes sont une techno des années 90 que peu de produits ont historiquement instrumentée. Les EDR modernes (CrowdStrike, SentinelOne, Defender) ont ajouté vers 2017-2018 des règles comportementales qui cherchent : (1) appels `GlobalAddAtomA/W` avec `Length` > ~250 octets (les vrais atomes sont des noms courts de classes de fenêtre ou des chaînes DDE) ; (2) octets de nom d'atome qui ne roundtrip pas en UTF-16 valide (contenu binaire) ; (3) `GlobalGetAtomNameA` appelé depuis un thread qui vient de se réveiller via NtTestAlert / KiUserApcDispatcher dans un contexte fraîchement alloué — le pattern d'APC Atom Bomb. ETW Microsoft-Windows-Kernel-Audit-API-Calls couvre ces syscalls. WinDbg / forensic live : l'extension `!atom` dump la table globale — des entrées longues avec des octets non imprimables sont un IOC fort.

Exemples de syscalls directs

; 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 }
}

Mappings MITRE ATT&CK

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