joyce8/EMBER2024-capa huggingface dataset:
Function at 0x387850
Capabilities:
Get disk information

Disassembly:
push ebp
mov ebp, esp
add esp, 0xffffff94
push ebx
push esi
push edi
mov esi, eax
xor eax, eax
push ebp
push 0x3878c2
push dword fs:[eax]
mov dword fs:[eax], esp
mov byte [esi + 1], 0
lea eax, [ebp - 0x6a]
push eax
push 0x69
call sub.kernel32.dll_GetLogicalDriveStringsA
lea ebx, [ebp - 0x6a]
xor edi, edi
jmp 0x3878aa
push ebx
call sub.kernel32.dll_GetDriveTypeA
cmp eax, 5
jne 0x3878a1
imul eax, edi, 0xa1
mov dl, byte [ebx]
mov byte [esi + eax*8 + 0x507], dl
movzx edi, byte [esi + 1]
inc edi
inc byte [esi + 1]
push ebx
call sub.kernel32.dll_lstrlenA_1
add ebx, eax
inc ebx
cmp byte [ebx], 0
jne 0x38787f
xor ebx, ebx
mov bl, byte [esi + 1]
xor eax, eax
pop edx
pop ecx
pop ecx
mov dword fs:[eax], edx
push 0x3878c9
ret

Function at 0x391498
Capabilities:
Encode data using xor

Disassembly:
push ebp
mov ebp, esp
add esp, 0xfffffe68
push ebx
push esi
xor eax, eax
mov dword [ebp - 0x198], eax
mov dword [ebp - 0x190], eax
mov dword [ebp - 0x194], eax
mov dword [ebp - 0x18c], eax
mov dword [ebp - 8], eax
xor eax, eax
push ebp
push 0x39166c
push dword fs:[eax]
mov dword fs:[eax], esp
mov eax, dword [0xbb42b8]
mov eax, dword [eax + 0x7b8]
mov edx, dword [eax]
call dword [edx + 0xc8]
test eax, eax
jle 0x391646
lea edx, [ebp - 0x18c]
mov eax, dword [0x3b3df0]
call fcn.0038daa0
lea eax, [ebp - 0x18c]
mov edx, 0x391684
call fcn.00305028
mov edx, dword [ebp - 0x18c]
lea eax, [ebp - 0x15c]
call fcn.00302d78
mov edx, 1
lea eax, [ebp - 0x15c]
call fcn.003034a8
mov eax, dword [0xbb42b8]
mov eax, dword [eax + 0x7b8]
mov edx, dword [eax]
call dword [edx + 0xc8]
dec eax
test eax, eax
jl 0x39163b
inc eax
mov dword [ebp - 0x10], eax
mov dword [ebp - 4], 0
lea ecx, [ebp - 8]
mov eax, dword [0xbb42b8]
mov eax, dword [eax + 0x7b8]
mov eax, dword [eax + 0x218]
mov edx, dword [ebp - 4]
mov ebx, dword [eax]
call dword [ebx + 0xc]
lea eax, [ebp - 0x190]
push eax
lea edx, [ebp - 0x194]
mov eax, dword [ebp - 8]
call fcn.0038da14
mov eax, dword [ebp - 0x194]
mov ecx, 5
mov edx, 0xc
call fcn.00305280
mov eax, dword [ebp - 0x190]
mov edx, 0x391698
call fcn.0030516c
je 0x39162f
mov eax, dword [ebp - 8]
call fcn.00305020
mov ebx, eax
inc ebx
lea eax, [ebp - 0x198]
mov edx, ebx
call fcn.00304f48
mov edx, dword [ebp - 0x198]
lea eax, [ebp - 8]
mov ecx, dword [ebp - 8]
call fcn.0030506c
mov esi, ebx
and esi, 0xff
mov edx, esi
lea eax, [ebp - 8]
call fcn.003053ac
lea eax, [ebp - 8]
call fcn.00305278
mov ecx, esi
lea edx, [ebp - 0x188]
call fcn.003029fc
sub esi, 2
jl 0x391616
inc esi
lea eax, [ebp - 0x187]
mov dl, byte [eax]
xor dl, bl
xor dl, byte [ebp - 4]
mov byte [eax], dl
inc eax
dec esi
jne 0x391609
lea eax, [ebp - 0xc]
push eax
xor ecx, ecx
mov cl, bl
lea edx, [ebp - 0x188]
lea eax, [ebp - 0x15c]
call fcn.00302efc
inc dword [ebp - 4]
dec dword [ebp - 0x10]
jne 0x391551
lea eax, [ebp - 0x15c]
call fcn.00302f1c
xor eax, eax
pop edx
pop ecx
pop ecx
mov dword fs:[eax], edx
push 0x391673
lea eax, [ebp - 0x198]
mov edx, 4
call fcn.00304d84
lea eax, [ebp - 8]
call fcn.00304d60
ret
Function at 0x3916a0
Capabilities:
Encode data using xor

Disassembly:
push ebp
mov ebp, esp
add esp, 0xfffffe6c
push ebx
push esi
push edi
xor eax, eax
mov dword [ebp - 0x194], eax
mov dword [ebp - 0x190], eax
mov dword [ebp - 0x10], eax
xor eax, eax
push ebp
push 0x391839
push dword fs:[eax]
mov dword fs:[eax], esp
mov eax, dword [0xbb42b8]
mov eax, dword [eax + 0x7b8]
mov edx, dword [eax]
call dword [edx + 0xd8]
lea edx, [ebp - 0x190]
mov eax, dword [0x3b3df0]
call fcn.0038daa0
lea eax, [ebp - 0x190]
mov edx, 0x391850
call fcn.00305028
mov eax, dword [ebp - 0x190]
call fcn.0030978c
test al, al
je 0x391813
lea edx, [ebp - 0x194]
mov eax, dword [0x3b3df0]
call fcn.0038daa0
lea eax, [ebp - 0x194]
mov edx, 0x391850
call fcn.00305028
mov edx, dword [ebp - 0x194]
lea eax, [ebp - 0x160]
call fcn.00302d78
mov edx, 1
lea eax, [ebp - 0x160]
call fcn.0030348c
xor eax, eax
mov dword [ebp - 0xc], eax
lea eax, [ebp - 0x14]
push eax
lea edx, [ebp - 1]
mov ecx, 1
lea eax, [ebp - 0x160]
call fcn.00302edc
dec byte [ebp - 1]
xor edx, edx
mov dl, byte [ebp - 1]
lea eax, [ebp - 0x10]
call fcn.003053ac
lea eax, [ebp - 0x14]
push eax
xor ecx, ecx
mov cl, byte [ebp - 1]
lea edx, [ebp - 0x18c]
lea eax, [ebp - 0x160]
call fcn.00302edc
xor edx, edx
mov dl, byte [ebp - 1]
lea eax, [ebp - 0x10]
call fcn.003053ac
inc byte [ebp - 1]
cmp dword [ebp - 0x14], 0
je 0x3917fb
movzx esi, byte [ebp - 1]
dec esi
test esi, esi
jle 0x3917e2
mov dword [ebp - 8], 1
lea edi, [ebp - 0x18c]
mov bl, byte [edi]
xor bl, byte [ebp - 1]
xor bl, byte [ebp - 0xc]
lea eax, [ebp - 0x10]
call fcn.00305278
mov edx, dword [ebp - 8]
mov byte [eax + edx - 1], bl
inc dword [ebp - 8]
inc edi
dec esi
jne 0x3917c4
mov eax, dword [0xbb42b8]
mov eax, dword [eax + 0x7b8]
mov eax, dword [eax + 0x218]
mov edx, dword [ebp - 0x10]
mov ecx, dword [eax]
call dword [ecx + 0x38]
inc dword [ebp - 0xc]
cmp dword [ebp - 0x14], 0
jne 0x391757
lea eax, [ebp - 0x160]
call fcn.00302f1c
xor eax, eax
pop edx
pop ecx
pop ecx
mov dword fs:[eax], edx
push 0x391840
lea eax, [ebp - 0x194]
mov edx, 2
call fcn.00304d84
lea eax, [ebp - 0x10]
call fcn.00304d60
ret

Function at 0x392980
Capabilities:
Hash data using crc32b

Disassembly:
push ebx
push esi
movzx ebx, word [0x3b0dd8]
test ebx, ebx
jb 0x3929c9
inc ebx
xor esi, esi
mov ecx, 0x3b3e3c
mov eax, esi
shl eax, 0x18
and eax, 0xffffffff
mov edx, 8
test eax, 0x80000000
jne 0x3929b0
add eax, eax
and eax, 0xffffffff
jmp 0x3929bd
add eax, eax
and eax, 0xffffffff
xor eax, 0x4c11db7
and eax, 0xffffffff
dec edx
jne 0x3929a2
mov dword [ecx], eax
inc esi
add ecx, 4
dec ebx
jne 0x392995
pop esi
pop ebx
ret
Function at 0x3a6030
Capabilities:
Clear file content

Disassembly:
push ebp
mov ebp, esp
add esp, 0xfffffff0
push ebx
push esi
mov dword [ebp - 4], eax
mov eax, dword [ebp - 4]
call fcn.00305210
xor eax, eax
push ebp
push 0x3a60e0
push dword fs:[eax]
mov dword fs:[eax], esp
mov eax, dword [0x3b11b4]
mov byte [eax], 0
mov eax, dword [0x3b11b4]
mov byte [eax], 2
mov edx, dword [ebp - 4]
mov al, 1
call fcn.0038d0c4
mov esi, eax
test esi, esi
jbe 0x3a60ca
mov edx, 0x20
mov eax, dword [ebp - 4]
call fcn.003097c0
mov edx, 2
mov eax, dword [ebp - 4]
call fcn.003095fc
mov ebx, eax
mov eax, dword [0x3b0dfc]
xor edx, edx
push edx
push eax
mov eax, esi
xor edx, edx
call fcn.00305d08
mov dword [ebp - 0x10], eax
mov dword [ebp - 0xc], edx
push dword [ebp - 0xc]
push dword [ebp - 0x10]
xor edx, edx
mov eax, ebx
call fcn.003096e4
test ebx, ebx
jns 0x3a60bd
call fcn.00303f30
push ebx
call sub.kernel32.dll_SetEndOfFile_1
mov eax, ebx
call fcn.0030971c
xor eax, eax
pop edx
pop ecx
pop ecx
mov dword fs:[eax], edx
push 0x3a60e7
lea eax, [ebp - 4]
call fcn.00304d60
ret
Function at 0x405bfe
Capabilities:
Contain obfuscated stackstrings

Disassembly:
mov byte [ebp - 0x3e], 0xec
mov byte [ebp - 0x3d], bl
mov byte [ebp - 0x3c], 0x45
mov byte [ebp - 0x3b], 0x7a
mov byte [ebp - 0x3a], 0x61
mov byte [ebp - 0x39], 0x67
mov byte [ebp - 0x38], 0x66
mov byte [ebp - 0x37], 0x72
mov byte [ebp - 0x36], 0x7f
mov byte [ebp - 0x35], 0x52
mov byte [ebp - 0x34], 0x7f
mov byte [ebp - 0x33], 0x7f
mov byte [ebp - 0x32], 0x7c
mov byte [ebp - 0x31], 0x70
mov byte [ebp - 0x30], 0x13
call fcn.00405900
loop 0x405cb8
invalid
inc ebp
clc
lea eax, [ebp - 0x6c]
push eax
mov byte [ebp - 0x6c], bl
mov byte [ebp - 0x6b], bl
mov byte [ebp - 0x6a], 0xbe
mov byte [ebp - 0x69], bl
mov byte [ebp - 0x68], 0x17
mov byte [ebp - 0x67], 0x28
mov byte [ebp - 0x66], 0x33
mov byte [ebp - 0x65], 0x35
mov byte [ebp - 0x64], 0x34
mov byte [ebp - 0x63], 0x20
mov byte [ebp - 0x62], 0x2d
mov byte [ebp - 0x61], 0x11
mov byte [ebp - 0x60], 0x33
mov byte [ebp - 0x5f], 0x2e
mov byte [ebp - 0x5e], 0x35
mov byte [ebp - 0x5d], 0x24
mov byte [ebp - 0x5c], 0x22
mov byte [ebp - 0x5b], 0x35
mov byte [ebp - 0x5a], 0x41
call fcn.00405910
push eax
push esi
push dword [ebp + 8]
call fcn.004058c5
mov dword [ebp - 0xbc], eax
lea eax, [ebp - 0x2c]
mov byte [ebp - 0x2c], bl
push eax
mov byte [ebp - 0x2b], bl
mov byte [ebp - 0x2a], 0xd4
mov byte [ebp - 0x29], bl
mov byte [ebp - 0x28], 0x67
mov byte [ebp - 0x27], 0x44
mov byte [ebp - 0x26], 0x4a
mov byte [ebp - 0x25], 0x4f
mov byte [ebp - 0x24], 0x67
mov byte [ebp - 0x23], 0x42
mov byte [ebp - 0x22], 0x49
mov byte [ebp - 0x21], 0x59
mov byte [ebp - 0x20], 0x4a
mov byte [ebp - 0x1f], 0x59
mov byte [ebp - 0x1e], 0x52
mov byte [ebp - 0x1d], 0x6a
mov byte [ebp - 0x1c], 0x2b
call fcn.00405910
push eax
push esi
push dword [ebp + 8]
call fcn.004058c5
add esp, 0x30
mov dword [ebp - 0xb8], eax
call fcn.00405900
invalid

Function at 0x405c94
Capabilities:
Contain obfuscated stackstrings

Disassembly:
mov byte [ebp - 0xd], 0xf9
mov byte [ebp - 0xc], 0xcd
invalid
inc ebp
cmc

Function at 0x406176
Capabilities:
Contain obfuscated stackstrings

Disassembly:
test dword [edx + 0x6dfffffc], edi
mov byte [ebp - 0x345], 0x40
mov byte [ebp - 0x344], 0x44
mov byte [ebp - 0x343], 0x55
mov byte [ebp - 0x342], 0x25
lea eax, [ebp - 0x354]
push eax
call fcn.00405910
pop ecx
push eax
push dword [ebp + 0x18]
push dword [ebp + 0x14]
call fcn.004058c5
add esp, 0xc
mov dword [ebp - 0x68c], eax
call dword [ebp - 0x68c]
mov dword [ebp - 0x674], eax
mov dword [ebp - 0x384], 4
inc dword [eax + eax]
add byte [eax], al

Function at 0x407db3
Capabilities:
Contain obfuscated stackstrings

Disassembly:
test ah, bh
invalid
mov edi, edi
push ebp
mov ebp, esp
pop ebp
jmp 0x407951
Function at 0x433000
Capabilities:
Encode data using xor
Packed with generic packer

Disassembly:
pushal
nop
nop
nop
nop
nop
call 0x43300c
nop
nop
nop
pop eax
nop
nop
nop
add eax, 0x40a063
nop
sub eax, 0x40a009
nop
nop
nop
nop
mov ebx, dword [eax]
nop
nop
mov ecx, dword [eax + 4]
nop
nop
nop
nop
mov edx, dword [eax + 8]
nop
xor dword [ebx], edx
nop
nop
nop
add ebx, 4
nop
nop
nop
nop
cmp ebx, ecx
nop
nop
nop
nop
nop
jl 0x433030
nop
nop
nop
nop
nop
add eax, 0xc
cmp dword [eax], 0
nop
nop
nop
jne 0x43301e
nop
nop
nop
nop
nop
nop
nop
popal
nop
nop
jmp 0x431219

Function at 0x10001f70
Capabilities:
Enumerate pe sections

Disassembly:
mov edi, edi
push ebp
mov ebp, esp
mov eax, dword [ebp + 8]
xor edx, edx
push ebx
push esi
push edi
mov ecx, dword [eax + 0x3c]
add ecx, eax
movzx eax, word [ecx + 0x14]
movzx ebx, word [ecx + 6]
add eax, 0x18
add eax, ecx
test ebx, ebx
je 0x10001fae
mov edi, dword [ebp + 0xc]
mov esi, dword [eax + 0xc]
cmp edi, esi
jb 0x10001fa6
mov ecx, dword [eax + 8]
add ecx, esi
cmp edi, ecx
jb 0x10001fb0
inc edx
add eax, 0x28
cmp edx, ebx
jb 0x10001f96
xor eax, eax
pop edi
pop esi
pop ebx
pop ebp
ret

Function at 0x10002090
Capabilities:
Parse pe header

Disassembly:
mov edi, edi
push ebp
mov ebp, esp
mov eax, dword [ebp + 8]
mov ecx, 0x5a4d
cmp word [eax], cx
je 0x100020a6
xor eax, eax
pop ebp
ret
mov ecx, dword [eax + 0x3c]
add ecx, eax
xor eax, eax
cmp dword [ecx], 0x4550
jne 0x100020c1
mov edx, 0x10b
cmp word [ecx + 0x18], dx
sete al
pop ebp
ret
Function at 0x4024b0
Capabilities:
Hash data using djb2

Disassembly:
push ebp
push ebx
push edi
push esi
sub esp, 0x10
xor edi, edi
cmp dword [esp + 0x24], 0
je 0x4025b1
mov ebx, dword [esp + 0x28]
test ebx, ebx
je 0x4025b1
push ebx
call fcn.0040a5d0
add esp, 4
test eax, eax
je 0x40250a
mov ecx, 0x1505
xor ebp, ebp
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
movzx edx, byte [ebx + ebp]
test edx, edx
je 0x402511
mov esi, ecx
shl esi, 5
add esi, ecx
add esi, edx
inc ebp
mov ecx, esi
cmp eax, ebp
jne 0x4024f0
jmp 0x402513
mov esi, 0x1505
jmp 0x402513
mov esi, ecx
mov dword [esp], eax
mov ecx, dword [esp + 0x24]
mov ebx, dword [ecx + 0x20]
lea ebp, [ebx - 1]
mov eax, ebx
sub eax, 1
mov dword [esp + 0xc], eax
jb 0x4025b1
and ebp, esi
mov eax, dword [ecx + 4]
mov dword [esp + 8], eax
jmp 0x402544
inc ebp
dec ebx
je 0x4025af
mov eax, ebp
and eax, dword [esp + 0xc]
mov edx, dword [esp + 8]
mov edi, dword [edx + eax*4]
cmp edi, 0xffffffff
je 0x4025af
mov eax, dword [ecx + 8]
cmp dword [eax + edi*4], esi
jne 0x402540
mov eax, dword [ecx + 0xc]
mov eax, dword [eax + edi*4]
mov dword [esp + 4], eax
push eax
call fcn.0040a5d0
mov ecx, dword [esp + 0x28]
add esp, 4
cmp eax, dword [esp]
jne 0x402540
push dword [esp]
push dword [esp + 8]
push dword [esp + 0x30]
call fcn.0040a5f0
mov ecx, dword [esp + 0x30]
add esp, 0xc
test eax, eax
jne 0x402540
mov eax, dword [ecx + 0x10]
mov eax, dword [eax + edi*4]
test eax, eax
je 0x4025af
cmp dword [eax + 4], 2
mov edi, 0
jne 0x4025b1
mov edi, dword [eax + 8]
jmp 0x4025b1
xor edi, edi
mov eax, edi
add esp, 0x10
pop esi
pop edi
pop ebx
pop ebp
ret

Function at 0x4025e0
Capabilities:
Hash data using djb2

Disassembly:
push ebp
push ebx
push edi
push esi
sub esp, 0x18
fldz
fstp qword [esp + 0x10]
cmp dword [esp + 0x2c], 0
je 0x40264b
mov esi, dword [esp + 0x30]
test esi, esi
je 0x40264b
push esi
call fcn.0040a5d0
add esp, 4
test eax, eax
je 0x40262a
mov ecx, 0x1505
xor edi, edi
movzx edx, byte [esi + edi]
test edx, edx
je 0x402631
mov ebp, ecx
shl ebp, 5
add ebp, ecx
add ebp, edx
inc edi
mov ecx, ebp
cmp eax, edi
jne 0x402610
jmp 0x402633
mov ebp, 0x1505
jmp 0x402633
mov ebp, ecx
mov dword [esp], eax
mov ecx, dword [esp + 0x2c]
mov edi, dword [ecx + 0x20]
lea ebx, [edi - 1]
mov eax, edi
sub eax, 1
mov dword [esp + 0xc], eax
jae 0x402657
fld qword [esp + 0x10]
add esp, 0x18
pop esi
pop edi
pop ebx
pop ebp
ret
and ebx, ebp
mov eax, dword [ecx + 4]
mov dword [esp + 8], eax
jmp 0x402674
inc ebx
dec edi
je 0x40264b
mov eax, ebx
and eax, dword [esp + 0xc]
mov edx, dword [esp + 8]
mov esi, dword [edx + eax*4]
cmp esi, 0xffffffff
je 0x40264b
mov eax, dword [ecx + 8]
cmp dword [eax + esi*4], ebp
jne 0x402670
mov eax, dword [ecx + 0xc]
mov eax, dword [eax + esi*4]
mov dword [esp + 4], eax
push eax
call fcn.0040a5d0
mov ecx, dword [esp + 0x30]
add esp, 4
cmp eax, dword [esp]
jne 0x402670
push dword [esp]
push dword [esp + 8]
push dword [esp + 0x38]
call fcn.0040a5f0
mov ecx, dword [esp + 0x38]
add esp, 0xc
test eax, eax
jne 0x402670
mov eax, dword [ecx + 0x10]
mov eax, dword [eax + esi*4]
test eax, eax
je 0x40264b
cmp dword [eax + 4], 3
jne 0x40264b
fld qword [eax + 8]
fstp qword [esp + 0x10]
jmp 0x40264b
Function at 0x402710
Capabilities:
Hash data using djb2

Disassembly:
push ebp
push ebx
push edi
push esi
sub esp, 0x10
xor edi, edi
cmp dword [esp + 0x24], 0
je 0x402811
mov ebx, dword [esp + 0x28]
test ebx, ebx
je 0x402811
push ebx
call fcn.0040a5d0
add esp, 4
test eax, eax
je 0x40276a
mov ecx, 0x1505
xor ebp, ebp
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
movzx edx, byte [ebx + ebp]
test edx, edx
je 0x402771
mov esi, ecx
shl esi, 5
add esi, ecx
add esi, edx
inc ebp
mov ecx, esi
cmp eax, ebp
jne 0x402750
jmp 0x402773
mov esi, 0x1505
jmp 0x402773
mov esi, ecx
mov dword [esp], eax
mov ecx, dword [esp + 0x24]
mov ebx, dword [ecx + 0x20]
lea ebp, [ebx - 1]
mov eax, ebx
sub eax, 1
mov dword [esp + 0xc], eax
jb 0x402811
and ebp, esi
mov eax, dword [ecx + 4]
mov dword [esp + 8], eax
jmp 0x4027a4
inc ebp
dec ebx
je 0x40280f
mov eax, ebp
and eax, dword [esp + 0xc]
mov edx, dword [esp + 8]
mov edi, dword [edx + eax*4]
cmp edi, 0xffffffff
je 0x40280f
mov eax, dword [ecx + 8]
cmp dword [eax + edi*4], esi
jne 0x4027a0
mov eax, dword [ecx + 0xc]
mov eax, dword [eax + edi*4]
mov dword [esp + 4], eax
push eax
call fcn.0040a5d0
mov ecx, dword [esp + 0x28]
add esp, 4
cmp eax, dword [esp]
jne 0x4027a0
push dword [esp]
push dword [esp + 8]
push dword [esp + 0x30]
call fcn.0040a5f0
mov ecx, dword [esp + 0x30]
add esp, 0xc
test eax, eax
jne 0x4027a0
mov eax, dword [ecx + 0x10]
mov eax, dword [eax + edi*4]
test eax, eax
je 0x40280f
cmp dword [eax + 4], 5
mov edi, 0
jne 0x402811
mov edi, dword [eax + 8]
jmp 0x402811
xor edi, edi
mov eax, edi
add esp, 0x10
pop esi
pop edi
pop ebx
pop ebp
ret

Function at 0x402b40
Capabilities:
Hash data using djb2

Disassembly:
push ebp
push ebx
push edi
push esi
sub esp, 0x10
xor eax, eax
cmp dword [esp + 0x24], 0
je 0x402bad
mov esi, dword [esp + 0x28]
test esi, esi
je 0x402bad
push esi
call fcn.0040a5d0
add esp, 4
test eax, eax
je 0x402b8a
mov ecx, 0x1505
xor edi, edi
nop
nop
nop
nop
movzx edx, byte [esi + edi]
test edx, edx
je 0x402b91
mov ebx, ecx
shl ebx, 5
add ebx, ecx
add ebx, edx
inc edi
mov ecx, ebx
cmp eax, edi
jne 0x402b70
jmp 0x402b93
mov ebx, 0x1505
jmp 0x402b93
mov ebx, ecx
mov dword [esp], eax
mov ecx, dword [esp + 0x24]
mov edi, dword [ecx + 0x20]
lea ebp, [edi - 1]
mov eax, edi
sub eax, 1
mov dword [esp + 0xc], eax
jae 0x402bb5
xor eax, eax
add esp, 0x10
pop esi
pop edi
pop ebx
pop ebp
ret
and ebp, ebx
mov eax, dword [ecx + 4]
mov dword [esp + 8], eax
jmp 0x402bc4
inc ebp
dec edi
je 0x402bab
mov eax, ebp
and eax, dword [esp + 0xc]
mov edx, dword [esp + 8]
mov esi, dword [edx + eax*4]
cmp esi, 0xffffffff
je 0x402bab
mov eax, dword [ecx + 8]
cmp dword [eax + esi*4], ebx
jne 0x402bc0
mov eax, dword [ecx + 0xc]
mov eax, dword [eax + esi*4]
mov dword [esp + 4], eax
push eax
call fcn.0040a5d0
mov ecx, dword [esp + 0x28]
add esp, 4
cmp eax, dword [esp]
jne 0x402bc0
push dword [esp]
push dword [esp + 8]
push dword [esp + 0x30]
call fcn.0040a5f0
mov ecx, dword [esp + 0x30]
add esp, 0xc
test eax, eax
jne 0x402bc0
mov eax, dword [ecx + 0x10]
mov ecx, dword [eax + esi*4]
test ecx, ecx
mov eax, 0
je 0x402bad
xor eax, eax
mov edx, dword [esp + 0x2c]
cmp dword [ecx + 4], edx
sete al
jmp 0x402bad
Function at 0x40ab00
Capabilities:
Encode data using xor
Generate random numbers using a mersenne twister

Disassembly:
push esi
mov eax, dword [case.0x43fe40.45]
cmp eax, 0x270
jne 0x40ab5f
mov eax, 0xfffff640
mov edx, dword [0x44ac00]
nop
nop
nop
nop
nop
nop
nop
nop
and edx, 0x80000000
mov esi, dword [eax + 0x44b5c4]
mov ecx, esi
and ecx, 0x7ffffffe
or ecx, edx
mov edx, esi
and esi, 1
neg esi
and esi, 0x9908b0df
xor esi, dword [eax + 0x44bbf4]
shr ecx, 1
xor esi, ecx
mov dword [eax + 0x44bf80], esi
add eax, 4
jne 0x40ab20
mov eax, 0x270
jmp 0x40ab75
cmp eax, 0x4e0
jb 0x40ab75
mov ecx, 0x44abfc
call fcn.0040ad40
mov eax, dword [case.0x43fe40.45]
lea ecx, [eax + 1]
mov dword [case.0x43fe40.45], ecx
mov eax, dword [eax*4 + 0x44ac00]
mov ecx, eax
shr ecx, 0xb
and ecx, dword [0x44bf80]
xor ecx, eax
mov eax, ecx
shl eax, 7
and eax, 0x9d2c5680
xor eax, ecx
mov ecx, eax
shl ecx, 0xf
and ecx, 0xefc40000
xor ecx, eax
shr ecx, 0x12
and eax, 0x7fff
xor eax, ecx
pop esi
ret

Function at 0x40ad40
Capabilities:
Encode data using xor
Generate random numbers using a mersenne twister

Disassembly:
push ebx
push edi
push esi
mov esi, dword [ecx + 0x9c4]
mov eax, 0x3fe
nop
nop
and esi, 0x80000000
mov edi, dword [ecx + eax*4 - 0x630]
mov edx, edi
and edx, 0x7ffffffe
or edx, esi
shr edx, 1
mov esi, edi
and edi, 1
neg edi
and edi, 0x9908b0df
xor edi, dword [ecx + eax*4]
xor edi, edx
mov dword [ecx + eax*4 - 0xff4], edi
inc eax
cmp eax, 0x4e1
jne 0x40ad50
mov eax, 0x353
mov edx, 0x80000000
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
lea esi, [eax - 0x270]
mov ebx, dword [ecx + eax*4 + 4]
and ebx, edx
and esi, 1
mov edi, eax
or edi, 1
add edi, esi
mov esi, dword [ecx + edi*4 + 4]
mov edi, esi
and edi, 0x7ffffffe
or edi, ebx
shr edi, 1
and esi, 1
neg esi
and esi, 0x9908b0df
xor esi, dword [ecx + eax*4 - 0xd48]
xor esi, edi
mov dword [ecx + eax*4 - 0x9bc], esi
inc eax
cmp eax, 0x4df
jne 0x40ada0
mov esi, 0x80000000
and esi, dword [ecx + 0x1380]
mov edx, dword [ecx + 4]
mov eax, edx
and eax, 0x7ffffffe
or eax, esi
shr eax, 1
and edx, 1
neg edx
xor eax, dword [ecx + 0x634]
and edx, 0x9908b0df
xor eax, edx
mov dword [ecx + 0x9c0], eax
mov dword [ecx], 0
pop esi
pop edi
pop ebx
ret
Function at 0x40af90
Capabilities:
Encrypt data using rc4 prga

Disassembly:
push ebp
push ebx
push edi
push esi
sub esp, 0x404
mov dword [esp], ecx
mov esi, dword [esp + 0x418]
movzx ecx, word [esi]
lea ebp, [esp + 4]
test cx, cx
je 0x40b0cd
mov edx, 0x1ff
nop
nop
nop
nop
nop
nop
nop
movzx ebx, cx
lea edi, [esi + 2]
cmp bx, 0x7f
ja 0x40afe0
lea ecx, [ebp + 1]
mov byte [ebp], bl
jmp 0x40b070
cmp ebx, 0x7ff
ja 0x40b010
cmp edx, 2
jb 0x40b010
mov ecx, ebx
shr ecx, 6
add cl, 0xc0
mov byte [ebp], cl
and bl, 0x3f
or bl, 0x80
lea ecx, [ebp + 2]
mov byte [ebp + 1], bl
jmp 0x40b070
mov ecx, ebx
and ecx, 0xfc00
cmp ecx, 0xd800
jne 0x40b08a
cmp edx, 4
jb 0x40b08a
movzx ecx, word [esi + 2]
shl ebx, 0xa
lea eax, [ebx + ecx]
add eax, 0xfca02400
mov ebx, eax
shr ebx, 0x12
add bl, 0xf0
mov byte [ebp], bl
mov ebx, eax
shr ebx, 0xc
and bl, 0x3f
or bl, 0x80
mov byte [ebp + 1], bl
add esi, 4
shr eax, 6
and al, 0x3f
or al, 0x80
mov byte [ebp + 2], al
mov al, 0x3f
sub al, cl
and al, 0x3f
xor al, 0xbf
lea ecx, [ebp + 4]
mov byte [ebp + 3], al
mov edi, esi
nop
nop
nop
nop
nop
nop
add edx, ebp
sub edx, ecx
mov esi, edi
mov ebp, ecx
movzx ecx, word [esi]
test cx, cx
je 0x40b0cd
test edx, edx
jne 0x40afc0
jmp 0x40b0cd
movzx eax, cx
cmp eax, 0xdc00
jne 0x40b098
mov esi, edi
jmp 0x40b078
cmp edx, 3
jb 0x40b0c9
mov eax, ebx
shr eax, 0xc
or al, 0xe0
mov byte [ebp], al
mov eax, ebx
shr eax, 6
mov ecx, eax
not ecx
or ecx, 0x3f
add ecx, eax
add cl, 0x81
mov byte [ebp + 1], cl
and bl, 0x3f
or bl, 0x80
lea ecx, [ebp + 3]
mov byte [ebp + 2], bl
jmp 0x40b070
mov ecx, ebp
jmp 0x40b070
mov esi, dword [esp + 0x420]
mov edx, dword [esp + 0x41c]
mov byte [ebp], 0
xor eax, eax
jmp 0x40b0f8
mov byte [esp + eax + 0x204], bl
inc eax
movzx ecx, byte [esp + eax + 4]
mov bl, 0x2f
cmp ecx, 0x5c
je 0x40b0f0
test ecx, ecx
je 0x40b10c
mov ebx, ecx
jmp 0x40b0f0
mov byte [esp + eax + 0x204], 0
lea eax, [esp + 0x204]
push 0
push 0
push 0
mov ecx, dword [esp + 0xc]
push dword [ecx + 8]
add ecx, 0x10
push 0
push 0
push esi
push edx
push eax
push ecx
call fcn.00405ad0
add esp, 0x28
test eax, eax
setne al
add esp, 0x404
pop esi
pop edi
pop ebx
pop ebp
ret 0xc
Function at 0x40ca80
Capabilities:
Encrypt data using rc4 prga

Disassembly:
push ebp
push ebx
push edi
push esi
push eax
mov edx, dword [esp + 0x20]
mov eax, dword [esp + 0x18]
movzx ebx, byte [edx]
test bl, bl
je 0x40ccf1
mov esi, dword [esp + 0x24]
mov edi, dword [esp + 0x1c]
dec edi
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
test esi, esi
je 0x40cabc
cmp edx, esi
jae 0x40ccf1
test edi, edi
je 0x40ccf1
movzx ebp, bl
test bl, bl
js 0x40caf0
inc edx
lea ecx, [eax + 2]
mov word [eax], bp
mov esi, ecx
sub esi, eax
sar esi, 1
sub edi, esi
mov eax, ecx
mov esi, dword [esp + 0x24]
mov bh, byte [edx]
mov bl, bh
test bh, bh
jne 0x40cab0
jmp 0x40ccf1
mov ecx, ebp
and ecx, 0xffffffe0
cmp ecx, 0xc0
jne 0x40cb28
cmp bl, 0xc2
jb 0x40cae0
mov bh, byte [edx + 1]
movzx esi, bh
mov ecx, esi
and ecx, 0xffffffc0
cmp ecx, 0x80
jne 0x40cb8a
and ebp, 0x1f
shl ebp, 6
add edx, 2
and esi, 0x3f
or esi, ebp
jmp 0x40cbd8
mov ecx, ebp
and ecx, 0xfffffff0
cmp ecx, 0xe0
jne 0x40cb52
movzx ecx, byte [edx + 1]
cmp bl, 0xed
je 0x40cb94
cmp ebp, 0xe0
jne 0x40cb9d
mov ebx, ecx
add bl, 0x40
cmp bl, 0xe0
jb 0x40cadc
jmp 0x40cb9d
mov ecx, ebp
and ecx, 0xfffffff8
cmp ecx, 0xf0
jne 0x40ccd0
cmp bl, 0xf4
ja 0x40cae0
movzx ecx, byte [edx + 1]
je 0x40cbef
cmp ebp, 0xf0
jne 0x40cbf8
mov bh, cl
add bh, 0x40
cmp bh, 0xd0
jb 0x40cadc
jmp 0x40cbf8
inc edx
mov esi, dword [esp + 0x24]
jmp 0x40cae2
cmp cl, 0x9f
ja 0x40cadc
mov esi, ecx
and esi, 0xffffffc0
cmp esi, 0x80
jne 0x40ccd7
mov bh, byte [edx + 2]
movzx esi, bh
mov dword [esp], esi
and esi, 0xffffffc0
cmp esi, 0x80
jne 0x40cbe3
shl ebp, 0xc
and ecx, 0x3f
shl ecx, 6
or ecx, ebp
add edx, 3
mov esi, dword [esp]
and esi, 0x3f
or esi, ecx
lea ecx, [eax + 2]
mov word [eax], si
jmp 0x40cad2
add edx, 2
mov esi, dword [esp + 0x24]
jmp 0x40cae2
cmp cl, 0x8f
ja 0x40cadc
mov esi, ecx
and esi, 0xffffffc0
cmp esi, 0x80
jne 0x40ccd7
movzx ebp, byte [edx + 2]
mov esi, ebp
not esi
or esi, 0xc0
add esi, ebp
cmp esi, 0x7f
jne 0x40ccdd
mov bh, byte [edx + 3]
movzx esi, bh
mov dword [esp], esi
and esi, 0xffffffc0
cmp esi, 0x80
jne 0x40cce5
and bl, 7
movzx esi, bl
shl esi, 0x12
shl ecx, 0xc
and ebp, 0x3f
shl ebp, 6
add ecx, esi
lea esi, [ecx + ebp]
add esi, 0xfff80000
add edx, 4
and esi, 0xfffff800
cmp esi, 0xd800
je 0x40cadc
lea esi, [ecx + ebp]
mov ebx, dword [esp]
and ebx, 0x3f
add ebx, esi
add ebx, 0xfff80000
cmp ebx, 0x10000
jb 0x40cadc
cmp edi, 2
jb 0x40ccd0
add ecx, ebp
add ecx, 0x9f4b2545
add ecx, 0x60abdabb
shr ecx, 0xa
mov esi, ecx
xor esi, 0x2400
or ecx, 0x3ff
and ecx, esi
or ecx, 0xd800
mov word [eax], cx
and ebx, 0x3ff
or ebx, 0xdc00
lea ecx, [eax + 4]
mov word [eax + 2], bx
jmp 0x40cad2
mov ecx, eax
jmp 0x40cad2
inc edx
jmp 0x40cadc
add edx, 2
jmp 0x40cadc
add edx, 3
mov esi, dword [esp + 0x24]
jmp 0x40cae2
mov word [eax], 0
sub eax, dword [esp + 0x18]
sar eax, 1
add esp, 4
pop esi
pop edi
pop ebx
pop ebp
ret