Skip to content
KitploitKITPLOIT
StrumentiExploitsBlog
Log in
Invia
StrumentiExploitsBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

FeedContattoPrivacy© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
RESX — Toolkit specializzato per il reverse engineering e l'analisi binaria su Windows | Deoffuscamento delle API, grafi delle chiamate, analisi di driver kernel e IOCTL | Kitploit
Strumenti/GitHubGitHub/ryftenius/resx
Analisi StaticaAnalisi delle VulnerabilitàReverse EngineeringInformatica ForenseAnalisi MalwareAnalisi di BinariBinary Exploitation
GitHubryftenius/resx

RESX

Toolkit specializzato per il reverse engineering e l'analisi binaria su Windows | Deoffuscamento delle API, grafi delle chiamate, analisi di driver kernel e IOCTL

Vedi Repository
102 giorni faNon ancora revisionato

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →
Condividi

RESX

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.

Dimostrazioni ed Esempi

Triage dei Binari e Grafi delle Chiamate API

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.

Analisi statica consapevole delle API

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.

Risoluzione dinamica delle API e deoffuscamento

Scarica lo strumento