Émulateur matériel x86 en Rust pur et simulateur de processus Windows pour l'analyse de logiciels malveillants, l'émulation de shellcode et le dépaquetage de charges utiles. Prend en charge les exécutables PE 32/64 bits, Metasploit, Cobalt Strike et des familles complexes de logiciels malveillants.
C'est un émulateur matériel + simulateur de processus OS implémenté en pur rust.
Cette approche est très pratique pour l'analyse de malwares et d'autres choses (PE, shellcode, etc.)
Le système d'exploitation est principalement Windows, il émule un processus Windows, avec un support très basique pour Linux.
Le matériel est x86 32/64 bits, c'est rapide et fiable.
Le projet a été renommé de scemu à mwemu.
r2con2025 utilisation de radare2 depuis mwemu pour faire de l'analyse statique et de la visualisation pendant un moment d'émulation.
📦 sécurité de rust, bon pour émuler des malwares.
⚡ émulation très rapide
propulsé par la bibliothèque de désassemblage rust iced-x86, une bibliothèque géniale.
outil en ligne de commande, bibliothèque rust et bibliothèque python.
détecteur d'itérations.
suivi de la mémoire et des registres.
colorisé.
arrêt à un moment spécifique et exploration ou modification de l'état.
339 instructions CPU implémentées.
260 winapi 32 bits implémentées provenant de 15 DLL.
204 winapi 64 bits implémentées provenant de 10 DLL.
tous les appels système Linux.
chaînes SEH.
gestionnaire d'exceptions vecteur.
structures PEB, TEB.
liaison dynamique.
liaison IAT.
chargement différé.
allocateur de mémoire.
réagir avec int3.
cpuid non débogué.
émulation de shellcode 32 bits et 64 bits.
émulation d'exécutables PE32 et PE64.
émulation complète avec des charges utiles connues :
émulation partielle avec des fonctions de malware complexes :
Pendant l'émulation, vous pouvez voir le nombre d'instructions CPU émulées, qui est un identifiant unique pour un moment d'émulation.
Avec le drapeau -c, vous arrêtez l'émulation à un moment spécifique et inspectez ce qui se passe avec la console.
MWEMU emulator for malware 0.7.11
@sha0coder
USAGE:
mwemu [FLAGS] [OPTIONS]
FLAGS:
-6, --64bits enable 64bits architecture emulation
--banzai skip unimplemented instructions, and keep up emulating what can be emulated
--flags trace the flags hex value in every instruction.
-F, --fpu trace the fpu states.
-h, --handle handle Ctrl+C to spawn console
--help Prints help information
-l, --loops show loop interations, it is slow.
-m, --memory trace all the memory accesses read and write.
-n, --nocolors print without colors for redirectin to a file >out
-r, --regs print the register values in every step.
-p, --stack_trace trace stack on push/pop
-t, --test test mode
--version Prints version information
-v, --verbose -vv for view the assembly, -v only messages, without verbose only see the api calls and goes
faster
OPTIONS:
-A, --args <ARGS> provide arguments to the EXE like: --args '"aa" "bb"'
--cmd <COMMAND> launch a console command
-b, --base <ADDRESS> set base address for code
-c, --console <NUMBER> select in which moment will spawn the console to inspect.
-C, --console_addr <ADDRESS> spawn console on first eip = address
-d, --dump <FILE> load from dump.
-a, --entry <ADDRESS> entry point of the shellcode, by default starts from the beginning.
-e, --exit <POSITION> exit position of the shellcode
-f, --filename <FILE> set the shellcode binary file.
-i, --inspect <DIRECTION> monitor memory like: -i 'dword ptr [ebp + 0x24]
--iso <ISO> extract genuine system32 DLLs from a Windows ISO and use them as the maps folder, e.g. --iso ~/Downloads/win11.iso
-L, --log <LOG_FILENAME> log output to file
-M, --maps <PATH> select the memory maps folder
--mxcsr <MXCSR> set mxcsr register
--r10 <R10> set r10 register
--r11 <R11> set r11 register
--r12 <R12> set r12 register
--r13 <R13> set r13 register
--r14 <R14> set r14 register
--r15 <R15> set r15 register
--r8 <R8> set r8 register
--r9 <R9> set r9 register
--rax <RAX> set rax register
--rbp <RBP> set rbp register
--rbx <RBX> set rbx register
--rcx <RCX> set rcx register
--rdi <RDI> set rdi register
--rdx <RDX> set rdx register
-R, --reg <REGISTER1,REGISTER2> trace a specific register in every step, value and content
--rflags <RFLAGS> set rflags register
--rsi <RSI> set rsi register
--rsp <RSP> set rsp register
-x, --script <SCRIPT> launch an emulation script, see scripts_examples folder
--stack_address <ADDRESS> set stack address
-s, --string <ADDRESS> monitor string on a specific address
-T, --trace <TRACE_FILENAME> output trace to specified file
-S, --trace_start <TRACE_START> start trace at specified position
-V, --verbose_at <NUMBER> start displaying assembly at specific position (is like -vv enabled in specific
moment)
64bits needs the -6 flag, -vv for viewing ASM, and -c for spawning console at specific moment:
cargo run --release -- -f /tmp/shellcode.bin -6 -vv -c 19291
cargo run --release -- -f /bin/ls -6 -A '"-l"' -v
cargo run --release -- -f calc.exe -6 --winver win11
cargo run --release -- -f calc.exe -6 --winver win11 --syscall-mode
make tests
mwemu émule un shellcode simple détectant l'interruption execve().
notez que j'ai renommé cet outil de scemu à mwemu (en italien, scemu est un gros mot).
Nous sélectionnons la ligne pour arrêter et inspecter la mémoire.
Après avoir émulé près de 2 millions d'instructions de GuLoader win32 sous Linux, en falsifiant les cpuid et autres astuces en cours de route, il arrive à un sigtrap pour confondre les débogueurs.
Exemple de vidage mémoire sur le chargeur d'API.
Il y a plusieurs cartes par défaut, et on peut en créer d'autres avec des API comme LoadLibraryA ou manuellement depuis la console.
Émulation d'un shellcode Windows basique basé sur LdrLoadDll() qui affiche un message :
La console permet de visualiser et de modifier l'état actuel du CPU :
--- console ---
=>h
--- help ---
q ...................... quit
cls .................... clear screen
h ...................... help
s ...................... stack
v ...................... vars
r ...................... register show all
r reg .................. show reg
rc ..................... register change
f ...................... show all flags
fc ..................... clear all flags
fz ..................... toggle flag zero
fs ..................... toggle flag sign
c ...................... continue
ba ..................... breakpoint on address
bi ..................... breakpoint on instruction number
bmr .................... breakpoint on read memory
bmw .................... breakpoint on write memory
bc ..................... clear breakpoint
n ...................... next instruction
eip .................... change eip
push ................... push dword to the stack
pop .................... pop dword from stack
fpu .................... fpu view
md5 .................... check the md5 of a memory map
seh .................... view SEH
veh .................... view vectored execption pointer
m ...................... memory maps
ma ..................... memory allocs
mc ..................... memory create map
mn ..................... memory name of an address
ml ..................... memory load file content to map
mr ..................... memory read, speficy ie: dword ptr [esi]
mw ..................... memory read, speficy ie: dword ptr [esi] and then: 1af
md ..................... memory dump
mrd .................... memory read dwords
mds .................... memory dump string
mdw .................... memory dump wide string
mdd .................... memory dump to disk
mt ..................... memory test
ss ..................... search string
sb ..................... search bytes
sba .................... search bytes in all the maps
ssa .................... search string in all the maps
ll ..................... linked list walk
d ...................... dissasemble
dt ..................... dump structure
enter .................. step into
Le chargeur d'API de Cobalt Strike est le même que celui de Metasploit, en l'émulant :
Appels API de Cobalt Strike :
Appels API de Metasploit rshell :
Encodeur Metasploit SGN utilisant peu de FPU pour cacher le polymorphisme :
Encodeur Metasploit shikata-ga-nai qui commence également avec FPU :
Affichage de la structure PEB :
=>dt
structure=>peb
address=>0x7ffdf000
PEB {
reserved1: [
0x0,
0x0,
],
being_debugged: 0x0,
reserved2: 0x0,
reserved3: [
0xffffffff,
0x400000,
],
ldr: 0x77647880,
process_parameters: 0x2c1118,
reserved4: [
0x0,
0x2c0000,
0x77647380,
],
alt_thunk_list_ptr: 0x0,
reserved5: 0x0,
reserved6: 0x6,
reserved7: 0x773cd568,
reserved8: 0x0,
alt_thunk_list_ptr_32: 0x0,
reserved9: [
0x0,
...
Affichage de la structure PEB_LDR_DATA :
=>dt
structure=>PEB_LDR_DATA
address=>0x77647880
PebLdrData {
length: 0x30,
initializated: 0x1,
sshandle: 0x0,
in_load_order_module_list: ListEntry {
flink: 0x2c18b8,
blink: 0x2cff48,
},
in_memory_order_module_list: ListEntry {
flink: 0x2c18c0,
blink: 0x2cff50,
},
in_initialization_order_module_list: ListEntry {
flink: 0x2c1958,
blink: 0x2d00d0,
},
entry_in_progress: ListEntry {
flink: 0x0,
blink: 0x0,
},
}
=>
Affichage de LDR_DATA_TABLE_ENTRY et du nom du premier module :
=>dt
structure=>LDR_DATA_TABLE_ENTRY
address=>0x2c18c0
LdrDataTableEntry {
reserved1: [
0x2c1950,
0x77647894,
],
in_memory_order_module_links: ListEntry {
flink: 0x0,
blink: 0x0,
},
reserved2: [
0x0,
0x400000,
],
dll_base: 0x4014e0,
entry_point: 0x1d000,
reserved3: 0x40003e,
full_dll_name: 0x2c1716,
reserved4: [
0x0,
0x0,
0x0,
0x0,
0x0,
0x0,
0x0,
0x0,
],
reserved5: [
0x17440012,
0x4000002c,
0xffff0000,
],
checksum: 0x1d6cffff,
reserved6: 0xa640002c,
time_date_stamp: 0xcdf27764,
}
=>
Un malware cache quelque chose dans une exception :
3307726 0x4f9673: push ebp
3307727 0x4f9674: push edx
3307728 0x4f9675: push eax
3307729 0x4f9676: push ecx
3307730 0x4f9677: push ecx
3307731 0x4f9678: push 4F96F4h
3307732 0x4f967d: push dword ptr fs:[0]
Reading SEH 0x0
-------
3307733 0x4f9684: mov eax,[51068Ch]
--- console ---
=>
Inspectons les structures d'exception :
--- console ---
=>r esp
esp: 0x22de98
=>dt
structure=>cppeh_record
address=>0x22de98
CppEhRecord {
old_esp: 0x0,
exc_ptr: 0x4f96f4,
next: 0xfffffffe,
exception_handler: 0xfffffffe,
scope_table: PScopeTableEntry {
enclosing_level: 0x278,
filter_func: 0x51068c,
handler_func: 0x288,
},
try_level: 0x288,
}
=>
Et nous avons ici la routine d'erreur 0x4f96f4 et le filtre 0x51068c
