mwemuorg/mwemuSimulador de hardware x86 puro em Rust e simulador de processos Windows para análise de malware, emulação de shellcode e descompactação de payloads. Suporta executáveis PE de 32/64 bits, Metasploit, Cobalt Strike e famílias complexas de malware.
# MWEmu
[](https://github.com/mwemuorg/mwemu/actions/workflows/ci.yaml)
[](https://crates.io/crates/mwemu)
[](https://crates.io/crates/libmwemu)
[](https://docs.rs/libmwemu)
[](https://pypi.org/project/pymwemu/)
[](./LICENSE)
[](https://blog.rust-lang.org/)
[](https://mcpservers.org/servers/mwemu-github-io)
## Documentação oficial
[mwemu.github.io](https://mwemu.github.io)
## O que é isto?
É um emulador de hardware + simulador de processos de SO implementado em rust puro.
Esta abordagem é muito conveniente para análise de malware e outras coisas (PE, shellcode etc)
O SO é principalmente windows, emula um processo windows, com algum suporte muito básico para linux.
O hardware é x86 32/64bits, é rápido e fiável.
## Três formas de usar o software
- linha de comandos mwemu https://github.com/mwemuorg/mwemu
- crate libmwemu https://crates.io/crates/libmwemu
- pymwemu https://pypi.org/project/pymwemu/
## nota sobre scemu
O projeto foi renomeado de scemu para mwemu.
## Alguns Vídeos
[r2con2025](https://www.youtube.com/watch?v=-TFL-_-nIqA) a usar radare2 a partir do mwemu para fazer análise estática e visualização dentro de um momento de emulação.
[algumas demos](https://www.youtube.com/@JesusOlmos-wm8ch/videos)
## Funcionalidades
- 📦 segurança do rust, bom para emular malware.
- Todas as dependências estão em rust.
- ⚡ emulação muito rápida
- [benchmarks](https://github.com/mwemuorg/mwemu/blob/main/BENCHMARK.md)
- 25.767.432 instruções/segundo
- 680.000 instruções/segundo imprimindo cada instrução -vv.
- teste você mesmo: time mwemu -f test/exe64win_enigma.bin -6 -v -c 20000000 --cmd q
- suportado pelo iced-x86, uma fantástica biblioteca de desassemblagem em rust.
- ferramenta de linha de comandos, biblioteca rust e biblioteca python.
- detetor de iterações.
- rastreamento de memória e registos.
- colorizado.
- parar num momento específico e explorar o estado ou modificá-lo.
- 339 instruções de CPU implementadas.
- 260 winapi de 32bits implementadas de 15 dlls.
- 204 winapi de 64bits implementadas de 10 dlls.
- todas as syscalls de linux.
- cadeias SEH.
- vectored exception handler.
- estruturas PEB, TEB.
- linking dinâmico.
- binding de IAT.
- delay loading.
- alocador de memória.
- reagir com int3.
- cpuid não depurado.
- emulação de shellcode de 32bits e 64bits.
- emulação de executáveis pe32 e pe64.
- emulação completa com payloads conhecidos:
- shellcodes do metasploit.
- encoders do metasploit.
- cobalt strike.
- shellgen.
- guloader (não totalmente por agora, mas chega mais longe que o depurador)
- mars stealer pe32.
- bumblebee.
- emulação parcial com funções complexas de malware:
- guloader
- xloader
- danabot
## pymwemu vs malware
- raccoon, desencriptação de strings
- vidar, desencriptação de strings
- xloader, desencriptação total, keygen, construção da encriptação de url.
- lokibot, desobfuscação de api
- mars unpacking e obtenção de ioc
- shikata decoding e obtenção de ioc
- danabot desencriptação de strings
- zloader desencriptação de strings
- bumblebee unpacking após emular 25.515.274.634 instruções.
- enigma loader desobfuscação de api e desencriptação de drop
- bugsleep unpack
- gozi desencriptação de bss e preditor de dga.
## Capturar um momento de emulação
Durante a emulação pode ver o número de instruções de cpu emuladas, que é um ID único para um momento de emulação.
Com a flag -c para a emulação num momento específico e inspeciona o que se está a passar com a consola.
## Utilização
```
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)
```
## Exemplos de linha de comandos
64bits precisa da flag -6, -vv para ver o ASM, e -c para abrir a consola num momento específico:
```bash
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
```
## Testes
make tests
## Alguns casos de uso
mwemu emula um shellcode simples detetando o interrupt execve().
note que renomeei esta ferramenta de scemu para mwemu (em italiano scemu é uma palavra feia)
Selecionamos a linha para parar e inspecionar a memória.
Após emular perto de 2 milhões de instruções do GuLoader win32 em linux, falsificando cpuid's e outros truques pelo caminho, chega a um sigtrap para confundir depuradores.
Exemplo de memory dump no api loader.
Existem vários maps por defeito, e podem ser criados mais com apis como LoadLibraryA ou manualmente a partir da consola.
Emulando shellcode básico de windows baseado em LdrLoadDLl() que imprime uma mensagem:
A consola permite ver e editar o estado atual da 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
```
O api loader do cobalt strike é o mesmo que o do metasploit, a emulá-lo:
API do Cobalt Strike chamada:
API do Metasploit rshell chamada:
Encoder SGN do Metasploit a usar alguns fpu para esconder o polimorfismo:
Encoder shikata-ga-nai do Metasploit que também começa com fpu:
A mostrar a estrutura 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,
...
```
A mostrar a estrutura `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,
},
}
=>
```
A mostrar `LDR_DATA_TABLE_ENTRY` e o nome do primeiro módulo
```
=>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,
}
=>
```
Um malware está a esconder algo numa exceção
```
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 ---
=>
```
Vamos inspecionar as estruturas de exceção:
```
--- 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,
}
=>
```
E aqui temos a rotina de erro 0x4f96f4 e o filtro 0x51068c
## Star History
[](https://star-history.dera.page/#mwemuorg/mwemu&type=date&legend=top-left)