NtSetEaFile

Prototype

NTSTATUS NtSetEaFile(
  HANDLE                  FileHandle,
  PIO_STATUS_BLOCK        IoStatusBlock,
  PFILE_FULL_EA_INFORMATION Buffer,
  ULONG                   Length
);

Arguments

IDs de syscalls par version de Windows

Stub du syscall

4C 8B D1            mov r10, rcx
B8 A0 01 00 00      mov eax, 0x1A0     ; Win11 24H2 SSN
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

Les attributs étendus NTFS sont un héritage d'OS/2 HPFS conservé dans NTFS : une liste de blobs `nom=valeur` (max ~64 Ko au total) accrochée à n'importe quel fichier, *distincte* à la fois du flux de données principal et des Alternate Data Streams nommés. Ils sont adressables via `FileFullEaInformation` dans `SetFileInformationByHandle`, mais `NtSetEaFile` est le chemin direct. Chaque enregistrement est un `FILE_FULL_EA_INFORMATION` (NextEntryOffset, Flags, EaNameLength, EaValueLength, EaName[], valeur). Les EA survivent aux copies entre volumes NTFS mais sont silencieusement supprimés par FAT32/exFAT, la plupart des archiveurs et presque tous les agents de synchronisation cloud — ce qui les rend précisément intéressants pour les attaquants.

Usage courant par les malwares

Stockage furtif. Les implants déposent configuration, fragments de payload chiffrés ou shellcode mis en scène dans l'EA d'un fichier anodin (souvent une DLL système ou un fichier de données bénin dans `%ProgramData%`) où `dir`, l'Explorateur et la plupart des scanners AV de fichiers ne regardent jamais. BlackEnergy v2/v3 stockait son payload pilote dans des EA ; la variante précoce de Stuxnet abusait des EA pour cacher des composants. Le chemin d'analyse des EA dans win32k a aussi été à l'origine de plusieurs familles LPE (CVE-2022-21882 et la famille plus large xxxClientAllocCacheableObject). Côté offensif, les EA sont également un canal latéral pratique pour TOCTOU entre deux processus malveillants.

Opportunités de détection

Les EA sont invisibles avec l'outillage par défaut. Cherchez-les explicitement : `fsutil file queryEA <chemin>`, Sysinternals `Streams` (ADS uniquement — ne couvre PAS les EA), `EAExtractor`, ou outils forensiques NTFS qui analysent les attributs MFT `$EA` et `$EA_INFORMATION`. ETW Microsoft-Windows-Kernel-File fournit les événements FileSetEa. Indicateurs suspects : enregistrements EA sur les fichiers `.exe`/`.dll` dans `system32`, blobs EA de plus de quelques centaines d'octets, noms d'EA ne correspondant pas aux motifs Cygwin/WSL ou HPFS hérités. Les EDR qui n'hookent que la couche Win32 (SetFileInformationByHandle) manqueront les appels `NtSetEaFile` directs.

Exemples de syscalls directs

// Write a 'config.bin' EA onto an existing file. Visible only via fsutil queryEA.
HANDLE h = CreateFileW(L"C:\\ProgramData\\update.dat", FILE_WRITE_EA, 0, NULL,
                       OPEN_EXISTING, 0, NULL);

const char* eaName  = "CONFIG.BIN"; // ASCII, will be uppercased by NTFS
UCHAR eaNameLen     = (UCHAR)strlen(eaName);
USHORT eaValueLen   = (USHORT)payloadLen; // <= 0xFFFF per record

ULONG bufSize = sizeof(FILE_FULL_EA_INFORMATION) + eaNameLen + 1 + eaValueLen;
bufSize = (bufSize + 3) & ~3u;            // 4-byte alignment
PFILE_FULL_EA_INFORMATION ea = calloc(1, bufSize);
ea->NextEntryOffset = 0;
ea->Flags           = 0;
ea->EaNameLength    = eaNameLen;
ea->EaValueLength   = eaValueLen;
memcpy(ea->EaName, eaName, eaNameLen + 1);
memcpy(ea->EaName + eaNameLen + 1, payload, eaValueLen);

IO_STATUS_BLOCK iosb;
NTSTATUS st = NtSetEaFile(h, &iosb, ea, bufSize);

; NtSetEaFile direct syscall (Win11 24H2 SSN 0x1A0)
NtSetEaFile PROC
    mov  r10, rcx
    mov  eax, 1A0h
    syscall
    ret
NtSetEaFile ENDP

// Cargo: windows-sys = "0.59" (Win32_Foundation, Win32_System_LibraryLoader)
use std::ffi::CString;
use windows_sys::Win32::Foundation::*;
use windows_sys::Win32::System::LibraryLoader::*;

type NtSetEaFileFn = unsafe extern "system" fn(
    HANDLE, *mut u8 /* IoStatusBlock */, *const u8 /* Buffer */, u32 /* Length */,
) -> i32;

unsafe fn write_ea(handle: HANDLE, name: &str, value: &[u8]) -> i32 {
    let name_c = CString::new(name).unwrap();
    let n_len = name_c.as_bytes().len() as u8;
    let v_len = value.len() as u16;
    let mut size = 8usize + 1 + n_len as usize + 1 + v_len as usize;
    size = (size + 3) & !3;
    let mut buf = vec![0u8; size];
    buf[4] = 0;            // Flags
    buf[5] = n_len;        // EaNameLength
    buf[6..8].copy_from_slice(&v_len.to_le_bytes());
    let off_name = 8;
    buf[off_name..off_name + n_len as usize].copy_from_slice(name_c.as_bytes());
    let off_val = off_name + n_len as usize + 1;
    buf[off_val..off_val + value.len()].copy_from_slice(value);

    let nt = GetModuleHandleA(b"ntdll.dll\0".as_ptr());
    let f: NtSetEaFileFn = std::mem::transmute(
        GetProcAddress(nt, b"NtSetEaFile\0".as_ptr()).unwrap()
    );
    let mut iosb = [0u8; 16];
    f(handle, iosb.as_mut_ptr(), buf.as_ptr(), size as u32)
}

Mappings MITRE ATT&CK

• T1564.004Hide Artifacts: NTFS File Attributesmitre ↗
• T1564Hide Artifactsmitre ↗
• T1106Native APImitre ↗