
Toolkit specializzato per il reverse engineering e l'analisi binaria su Windows | Deoffuscamento delle API, grafi delle chiamate, analisi di driver kernel e IOCTL
Toolkit per l'Analisi dei Binari Windows e il Reverse Engineering
RESX è uno strumento specializzato di SRE e analisi dei binari per Windows, progettato per offrire un approccio più moderno ai flussi di lavoro dei reverse engineer e degli analisti di malware. RESX è progettato appositamente per fornire informazioni approfondite sul binario che stai analizzando, sia tramite il triage delle capacità del processo, l'identificazione di un packer, il tracciamento delle chiamate API attraverso un ampio albero di funzioni, o persino il reverse engineering di un driver kernel; RESX fornisce una suite estesa di informazioni consapevoli di cosa fanno le API e a cosa possono servire (ad es. malware), costrutti dei driver, capacità degli hypervisor e alcune carenze degli strumenti di disassemblaggio mainstream.
Supponiamo di voler capire rapidamente cosa sta facendo questo binario: possiamo invocare il comando calls per ottenere un call-graph sulle API di Windows che invoca (o qualsiasi altra .dll, CRT o funzione interna se si dispone del PDB). Questo può darci molto rapidamente una base e indicatori strutturati su dove guardare successivamente; a seconda del programma, questo può anche rivelare una quantità significativa di funzionalità senza nemmeno aprire un disassembler;
> resx /calls "SAMPLE.exe" ENTRY --depth 4 --only winapi --no-pdb --time
SAMPLE.exe!entry [RVA 0x000023E0, VA 0x1400023E0]
API Call Map for entry [2 of 2 call site(s) · filter: winapi]:
├── 0x23E4 CALL sub_00002770
│ ├── 0x279E CALL KERNEL32!GetSystemTimeAsFileTime
│ ├── 0x27AE CALL KERNEL32!GetCurrentThreadId
│ ├── 0x27BB CALL KERNEL32!GetCurrentProcessId
│ └── 0x27CD CALL KERNEL32!QueryPerformanceCounter
└── 0x23ED JMP sub_00002260 [tail call]
├── 0x236A CALL sub_000019E0
│ ├── 0x1A23 CALL KERNEL32!InitializeSRWLock
│ ├── 0x1A2E CALL KERNEL32!InitializeConditionVariable
│ ├── 0x1A39 CALL sub_00001160
│ │ ├── 0x1179 CALL KERNEL32!CreateWaitableTimerExW
│ │ └── 0x11B6 CALL KERNEL32!SetWaitableTimer
│ ├── 0x1A47 CALL sub_000015B0
│ │ ├── 0x15D0 CALL KERNEL32!VirtualAlloc
│ │ ├── 0x15F2 CALL KERNEL32!VirtualAlloc
│ │ └── 0x1608 CALL KERNEL32!VirtualFree
│ ├── 0x1A55 CALL sub_00001630
│ │ ├── 0x165C CALL KERNEL32!CreateThread
│ │ ├── 0x1672 CALL KERNEL32!AcquireSRWLockExclusive
│ │ ├── 0x167F CALL KERNEL32!ReleaseSRWLockExclusive
│ │ ├── 0x1689 CALL KERNEL32!WakeConditionVariable
│ │ ├── 0x1697 CALL KERNEL32!WaitForSingleObject
│ │ └── 0x16A2 CALL KERNEL32!CloseHandle
│ ├── 0x1A63 CALL sub_00001770
│ │ ├── 0x1795 CALL KERNEL32!VirtualProtect
│ │ └── 0x17C4 CALL KERNEL32!VirtualProtect
│ ├── 0x1A71 CALL sub_000017F0
│ │ ├── 0x1820 CALL KERNEL32!CreateFileMappingW
│ │ ├── 0x185A CALL KERNEL32!MapViewOfFile
│ │ ├── 0x1884 CALL KERNEL32!FlushViewOfFile
│ │ ├── 0x18A9 CALL KERNEL32!UnmapViewOfFile
│ │ └── 0x18B2 CALL KERNEL32!CloseHandle
│ ├── 0x1A7F CALL sub_000013A0
│ │ ├── 0x13BF CALL bcrypt!BCryptGenRandom
│ │ ├── 0x13E7 CALL bcrypt!BCryptOpenAlgorithmProvider
│ │ ├── 0x142D CALL bcrypt!BCryptCreateHash
│ │ ├── 0x1478 CALL bcrypt!BCryptFinishHash
│ │ ├── 0x1488 CALL bcrypt!BCryptDestroyHash
│ │ └── 0x1494 CALL bcrypt!BCryptCloseAlgorithmProvider
│ ├── 0x1A8D CALL sub_00001920
│ │ ├── 0x1936 CALL KERNEL32!WaitForSingleObject
│ │ └── 0x1945 CALL KERNEL32!CancelWaitableTimer
│ ├── 0x1AA4 CALL KERNEL32!GetLastError
│ └── 0x1AD3 CALL sub_000018D0
│ ├── 0x18EA CALL KERNEL32!VirtualFree
│ └── 0x1901 CALL KERNEL32!CloseHandle
├── 0x2371 CALL sub_00002910
│ └── 0x2916 CALL KERNEL32!GetModuleHandleW
└── 0x2393 CALL sub_00002910 [expanded above]
RESX: completed in 10ms
Con un solo comando, abbiamo mappato una quantità significativa della funzionalità del programma:
VirtualAlloc, VirtualFree, VirtualProtect: Allocazione dinamica della memoria e manipolazione della protezione.CreateThread, WaitForSingleObject, SRWLock: Esecuzione multithread e sincronizzazione.CreateWaitableTimerExW, SetWaitableTimer: Esecuzione pianificata o ritardata.CreateFileMappingW, MapViewOfFile: File mappati in memoria o memoria condivisa.BCryptGenRandom, BCryptCreateHash: Casualità crittografica e hashing.QueryPerformanceCounter, GetSystemTimeAsFileTime: Temporizzazione ad alta risoluzione e timestamp.GetCurrentProcessId, GetCurrentThreadId, GetModuleHandleW: Introspezione di processi, thread e moduli.Da questo solo dato, possiamo dedurre che il binario esegue gestione della memoria, esecuzione concorrente, operazioni crittografiche e I/O con memoria mappata. La combinazione di modifiche alla protezione della memoria e creazione di thread può giustificare ulteriori indagini, in particolare quando si analizzano packer, framework di strumentazione o malware.
RESX va oltre l'identificazione delle chiamate API. Con l'integrazione dell'Windows SDK, può recuperare i nomi ufficiali dei parametri, risolvere le costanti di Windows, identificare i puntatori a funzione e ricostruire gli argomenti direttamente dal codice macchina, anche senza simboli PDB.
Ad esempio, usando --args:
> resx /calls "SAMPLE.exe" ENTRY --depth 5 --only winapi --no-pdb --args
├── 0x15D0 CALL KERNEL32!VirtualAlloc
│ └── args
│ ├── lpAddress = NULL
│ ├── dwSize = 0x10000
│ ├── flAllocationType = MEM_RESERVE
│ └── flProtect = PAGE_NOACCESS
│
├── 0x165C CALL KERNEL32!CreateThread
│ └── args
│ ├── lpThreadAttributes = NULL
│ ├── dwStackSize = 0
│ ├── lpStartAddress = &fn_0x000016E0
│ ├── lpParameter = arg1
│ ├── dwCreationFlags = 0
│ └── lpThreadId = NULL
│
├── 0x13BF CALL bcrypt!BCryptGenRandom
│ └── args
│ ├── hAlgorithm = NULL
│ ├── pbBuffer = ?
│ ├── cbBuffer = 0x10
│ └── dwFlags = BCRYPT_USE_SYSTEM_PREFERRED_RNG
│
└── 0x13E7 CALL bcrypt!BCryptOpenAlgorithmProvider
└── args
├── phAlgorithm = &local_10
├── pszAlgId = L"SHA256"
├── pszImplementation = NULL
└── dwFlags = 0
Da queste sole chiamate, possiamo dedurre che il binario riserva 64 KiB di spazio di indirizzamento virtuale, crea un thread in un punto di ingresso di funzione recuperato, richiede 16 byte di dati casuali crittograficamente sicuri e inizializza un provider di hashing SHA-256.