joyce8/EMBER2024-capa huggingface dataset:
Function at 0x10021ad0
Capabilities:
Hash data using sha256

Disassembly:
push ebp
mov ebp, esp
and esp, 0xfffffff8
sub esp, 0x9c
mov eax, dword [0x10209f80]
xor eax, esp
mov dword [esp + 0x98], eax
push esi
mov esi, dword [ebp + 8]
xorps xmm0, xmm0
push edx
mov edx, ecx
mov dword [esp + 0x34], 0
lea ecx, [esp + 0xc]
movlpd qword [esp + 0xc], xmm0
mov dword [esp + 0x14], 0x6a09e667
mov dword [esp + 0x18], 0xbb67ae85
mov dword [esp + 0x1c], 0x3c6ef372
mov dword [esp + 0x20], 0xa54ff53a
mov dword [esp + 0x24], 0x510e527f
mov dword [esp + 0x28], 0x9b05688c
mov dword [esp + 0x2c], 0x1f83d9ab
mov dword [esp + 0x30], 0x5be0cd19
call fcn.10021d80
lea edx, [esp + 0x80]
lea ecx, [esp + 0xc]
call fcn.10022010
mov eax, dword [ebp + 0xc]
mov ecx, 0x20
cmp eax, ecx
cmova eax, ecx
push eax
lea eax, [esp + 0x84]
push eax
push esi
call sub.VCRUNTIME140.dll_memcpy
mov ecx, dword [esp + 0xac]
add esp, 0x10
pop esi
xor ecx, esp
call fcn.100f3936
mov esp, ebp
pop ebp
ret
Function at 0x10022010
Capabilities:
Enumerate pe sections

Disassembly:
push esi
mov esi, ecx
push edi
mov edi, edx
mov ecx, dword [esi + 0x28]
cmp ecx, 0x40
jae 0x100221a4
lea eax, [ecx*8]
add dword [esi], eax
push ebx
adc dword [esi + 4], 0
mov byte [ecx + esi + 0x2c], 0x80
mov eax, dword [esi + 0x28]
inc eax
mov dword [esi + 0x28], eax
cmp eax, 0x38
jbe 0x1002206e
cmp eax, 0x40
jae 0x10022057
mov byte [eax + esi + 0x2c], 0
mov eax, dword [esi + 0x28]
inc eax
mov dword [esi + 0x28], eax
cmp eax, 0x40
jb 0x10022046
lea ebx, [esi + 0x2c]
mov ecx, esi
mov edx, ebx
call fcn.10021b90
mov dword [esi + 0x28], 0
xor eax, eax
jmp 0x10022073
lea ebx, [esi + 0x2c]
jae 0x10022084
mov byte [eax + esi + 0x2c], 0
mov eax, dword [esi + 0x28]
inc eax
mov dword [esi + 0x28], eax
cmp eax, 0x38
jb 0x10022073
movzx eax, byte [esi + 7]
mov edx, ebx
mov byte [esi + 0x64], al
mov ecx, esi
movzx eax, byte [esi + 6]
mov byte [esi + 0x65], al
movzx eax, byte [esi + 5]
mov byte [esi + 0x66], al
movzx eax, byte [esi + 4]
mov byte [esi + 0x67], al
movzx eax, byte [esi + 3]
mov byte [esi + 0x68], al
movzx eax, byte [esi + 2]
mov byte [esi + 0x69], al
movzx eax, byte [esi + 1]
mov byte [esi + 0x6a], al
movzx eax, byte [esi]
mov byte [esi + 0x6b], al
call fcn.10021b90
movzx eax, byte [esi + 0xb]
mov byte [edi], al
movzx eax, byte [esi + 0xa]
mov byte [edi + 1], al
movzx eax, byte [esi + 9]
mov byte [edi + 2], al
movzx eax, byte [esi + 8]
mov byte [edi + 3], al
movzx eax, byte [esi + 0xf]
mov byte [edi + 4], al
movzx eax, byte [esi + 0xe]
mov byte [edi + 5], al
movzx eax, byte [esi + 0xd]
mov byte [edi + 6], al
movzx eax, byte [esi + 0xc]
mov byte [edi + 7], al
movzx eax, byte [esi + 0x13]
mov byte [edi + 8], al
movzx eax, byte [esi + 0x12]
mov byte [edi + 9], al
movzx eax, byte [esi + 0x11]
mov byte [edi + 0xa], al
movzx eax, byte [esi + 0x10]
mov byte [edi + 0xb], al
movzx eax, byte [esi + 0x17]
mov byte [edi + 0xc], al
movzx eax, byte [esi + 0x16]
mov byte [edi + 0xd], al
movzx eax, byte [esi + 0x15]
mov byte [edi + 0xe], al
movzx eax, byte [esi + 0x14]
mov byte [edi + 0xf], al
movzx eax, byte [esi + 0x1b]
mov byte [edi + 0x10], al
movzx eax, byte [esi + 0x1a]
mov byte [edi + 0x11], al
movzx eax, byte [esi + 0x19]
mov byte [edi + 0x12], al
movzx eax, byte [esi + 0x18]
mov byte [edi + 0x13], al
movzx eax, byte [esi + 0x1f]
mov byte [edi + 0x14], al
movzx eax, byte [esi + 0x1e]
mov byte [edi + 0x15], al
movzx eax, byte [esi + 0x1d]
mov byte [edi + 0x16], al
movzx eax, byte [esi + 0x1c]
mov byte [edi + 0x17], al
movzx eax, byte [esi + 0x23]
mov byte [edi + 0x18], al
movzx eax, byte [esi + 0x22]
mov byte [edi + 0x19], al
movzx eax, byte [esi + 0x21]
mov byte [edi + 0x1a], al
movzx eax, byte [esi + 0x20]
mov byte [edi + 0x1b], al
movzx eax, byte [esi + 0x27]
mov byte [edi + 0x1c], al
movzx eax, byte [esi + 0x26]
mov byte [edi + 0x1d], al
movzx eax, byte [esi + 0x25]
mov byte [edi + 0x1e], al
movzx eax, byte [esi + 0x24]
mov byte [edi + 0x1f], al
pop ebx
pop edi
pop esi
ret
Function at 0x100254f0
Capabilities:
Allocate or change rwx memory
Execute shellcode via indirect call
Terminate process

Disassembly:
push ebp
mov ebp, esp
sub esp, 8
mov eax, dword [0x10209f80]
xor eax, ebp
mov dword [ebp - 4], eax
push esi
push 0
call dword [sym.imp.KERNEL32.dll_GetModuleHandleA]
mov esi, eax
test esi, esi
je 0x10025531
lea eax, [ebp - 8]
push eax
push 0x40
push 0x1000
push esi
call dword [sym.imp.KERNEL32.dll_VirtualProtect]
mov eax, 0x1000
mov byte [esi], 0
lea esi, [esi + 1]
sub eax, 1
jne 0x10025526
mov eax, 0
call eax
push 0
call dword [sym.imp.KERNEL32.dll_ExitProcess]
Function at 0x10027a90
Capabilities:
Encode data using base64

Disassembly:
push ebp
mov ebp, esp
push 0xffffffffffffffff
push 0x101531ae
mov eax, dword fs:[0]
push eax
sub esp, 0x18
push esi
push edi
mov eax, dword [0x10209f80]
xor eax, ebp
push eax
lea eax, [ebp - 0xc]
mov dword fs:[0], eax
mov dword [ebp - 0x1c], 0
xorps xmm0, xmm0
mov edi, dword [ebp + 8]
movups xmmword [edi], xmm0
mov dword [edi + 0x10], 0
mov dword [edi + 0x14], 0
mov dword [edi + 0x10], 0
mov dword [edi + 0x14], 0xf
mov byte [edi], 0
mov ecx, dword [ebp + 0xc]
xor esi, esi
mov dword [ebp - 4], 0
mov dword [ebp - 0x1c], 1
cmp dword [ecx + 0x14], 0xf
mov eax, dword [ecx + 0x10]
jbe 0x10027b04
mov ecx, dword [ecx]
test eax, eax
je 0x10027c6f
nop dword [eax]
dec eax
mov dword [ebp - 0x24], eax
mov al, byte [ecx]
inc ecx
mov byte [ebp + esi - 0x14], al
inc esi
mov ah, byte [ebp - 0x12]
mov dl, byte [ebp - 0x13]
mov dh, byte [ebp - 0x14]
mov dword [ebp + 0xc], ecx
mov byte [ebp - 0xf], ah
mov byte [ebp - 0xd], dl
mov byte [ebp - 0xe], dh
cmp esi, 3
jne 0x10027ba5
mov al, dh
mov cl, dh
shr al, 2
and cl, 3
mov byte [ebp - 0x18], al
mov al, dl
shl cl, 4
shr al, 4
add cl, al
mov al, ah
mov byte [ebp - 0x17], cl
and ah, 0x3f
mov cl, dl
shr al, 6
and cl, 0xf
mov byte [ebp - 0x15], ah
shl cl, 2
add cl, al
xor esi, esi
mov byte [ebp - 0x16], cl
nop word [eax + eax]
cmp dword [0x1020b07c], 0xf
mov ecx, 0x1020b068
movzx eax, byte [ebp + esi - 0x18]
cmova ecx, dword [0x1020b068]
movzx eax, byte [eax + ecx]
mov ecx, edi
push eax
call fcn.10012020
inc esi
cmp esi, 4
jl 0x10027b70
mov ecx, dword [ebp + 0xc]
xor esi, esi
mov dl, byte [ebp - 0xd]
mov dh, byte [ebp - 0xe]
mov eax, dword [ebp - 0x24]
test eax, eax
jne 0x10027b10
mov dword [ebp + 0xc], esi
test esi, esi
je 0x10027c6f
mov eax, esi
cmp esi, 3
jge 0x10027be1
cmp eax, 3
jae 0x10027c82
mov byte [ebp + eax - 0x14], 0
inc eax
cmp eax, 3
jl 0x10027bc5
mov cl, byte [ebp - 0x12]
mov dl, byte [ebp - 0x13]
mov dh, byte [ebp - 0x14]
jmp 0x10027be4
mov cl, byte [ebp - 0xf]
mov al, dh
and dh, 3
shr al, 2
mov byte [ebp - 0x18], al
mov al, dl
shr al, 4
and dl, 0xf
shl dh, 4
add dh, al
shl dl, 2
mov al, cl
mov byte [ebp - 0x17], dh
shr al, 6
and cl, 0x3f
add dl, al
mov byte [ebp - 0x15], cl
lea eax, [esi + 1]
mov byte [ebp - 0x16], dl
mov dword [ebp - 0x24], eax
test eax, eax
jle 0x10027c4d
xor esi, esi
nop
cmp dword [0x1020b07c], 0xf
mov ecx, 0x1020b068
movzx eax, byte [ebp + esi - 0x18]
cmova ecx, dword [0x1020b068]
movzx eax, byte [eax + ecx]
mov ecx, edi
push eax
call fcn.10012020
inc esi
cmp esi, dword [ebp - 0x24]
jl 0x10027c20
mov esi, dword [ebp + 0xc]
cmp esi, 3
jge 0x10027c6f
mov eax, 3
sub eax, esi
mov dword [ebp + 0xc], eax
nop dword [eax]
push 0x3d
mov ecx, edi
call fcn.10012020
sub dword [ebp + 0xc], 1
jne 0x10027c60
mov eax, edi
mov ecx, dword [ebp - 0xc]
mov dword fs:[0], ecx
pop ecx
pop edi
pop esi
mov esp, ebp
pop ebp
ret
call fcn.100f3859
int3
Function at 0x10028360
Capabilities:
Create thread

Disassembly:
push ebp
mov ebp, esp
sub dword [ebp + 0xc], 1
jne 0x100283c8
push esi
mov esi, dword [ebp + 8]
push esi
call dword [sym.imp.KERNEL32.dll_DisableThreadLibraryCalls]
push 0x1020b0fc
mov dword [0x1020b0a4], esi
call dword [sym.imp.KERNEL32.dll_InitializeCriticalSection]
mov esi, dword fs:[0x30]
call dword [sym.imp.KERNEL32.dll_IsDebuggerPresent]
test eax, eax
jne 0x100283d1
cmp byte [esi + 2], al
jne 0x100283d1
mov esi, dword [sym.imp.KERNEL32.dll_CreateThread]
push eax
push eax
push eax
push 0x100221b0
push eax
push eax
call esi
push 0
push 0
push dword [0x1020b0a4]
mov dword [0x1020b0d0], eax
push 0x100257b0
push 0
push 0
call esi
pop esi
mov eax, 1
pop ebp
ret 0xc
call fcn.100254f0
int3
Function at 0x100368c0
Capabilities:
Encode data using xor
Hash data with crc32

Disassembly:
push ebp
mov ebp, esp
sub esp, 0xc
mov eax, dword [0x10209f80]
xor eax, ebp
mov dword [ebp - 4], eax
mov eax, dword [ebp + 8]
lea edx, [ebp - 8]
push ebx
push esi
push edi
mov edi, ecx
mov dword [ebp - 0xc], eax
mov dword [ebp - 8], eax
mov esi, 4
mov eax, dword [edi + 0xec]
mov ebx, dword [edi + 0xf4]
mov ebx, dword [ebx + eax*4 - 4]
not ebx
nop dword [eax + eax]
movzx eax, byte [edx]
lea edx, [edx + 1]
movzx ecx, bl
xor ecx, eax
shr ebx, 8
xor ebx, dword [ecx*4 + 0x101cd328]
sub esi, 1
jne 0x10036900
mov eax, dword [edi]
not ebx
cmp dword [eax + 0x3fe0], ebx
jne 0x10036935
push esi
push dword [ebp - 0xc]
push 4
push ebx
call fcn.10034210
add esp, 0x10
mov ecx, dword [ebp - 4]
mov eax, ebx
pop edi
pop esi
xor ecx, ebp
pop ebx
call fcn.100f3936
mov esp, ebp
pop ebp
ret 4

Function at 0x100369b0
Capabilities:
Encode data using xor
Hash data with crc32

Disassembly:
push ebp
mov ebp, esp
sub esp, 0xc
mov eax, dword [0x10209f80]
xor eax, ebp
mov dword [ebp - 4], eax
mov eax, dword [ebp + 8]
lea edx, [ebp - 8]
push ebx
push esi
push edi
mov edi, ecx
mov dword [ebp - 0xc], eax
mov dword [ebp - 8], eax
mov esi, 4
mov eax, dword [edi + 0xec]
mov ebx, dword [edi + 0xf4]
mov ebx, dword [ebx + eax*4 - 4]
not ebx
nop dword [eax + eax]
movzx eax, byte [edx]
lea edx, [edx + 1]
movzx ecx, bl
xor ecx, eax
shr ebx, 8
xor ebx, dword [ecx*4 + 0x101cd328]
sub esi, 1
jne 0x100369f0
mov eax, dword [edi]
not ebx
cmp dword [eax + 0x3fe0], ebx
jne 0x10036a25
push esi
push dword [ebp - 0xc]
push 0xc
push ebx
call fcn.10034210
add esp, 0x10
mov ecx, dword [ebp - 4]
mov eax, ebx
pop edi
pop esi
xor ecx, ebp
pop ebx
call fcn.100f3936
mov esp, ebp
pop ebp
ret 4

Function at 0x10036a40
Capabilities:
Encode data using xor
Hash data with crc32

Disassembly:
push ebp
mov ebp, esp
sub esp, 0x14
mov eax, dword [0x10209f80]
xor eax, ebp
mov dword [ebp - 4], eax
mov eax, dword [ebp + 8]
mov edx, ecx
push esi
push edi
lea esi, [ebp - 0x14]
mov edi, 0x10
movss xmm1, dword [edx + 0x108]
movss xmm0, dword [eax]
movss xmm2, dword [edx + 0x10c]
subss xmm0, xmm1
mov ecx, dword [edx + 0xec]
movss dword [ebp - 0x14], xmm0
movss xmm0, dword [eax + 4]
subss xmm0, xmm2
movss dword [ebp - 0x10], xmm0
movss xmm0, dword [eax + 8]
subss xmm0, xmm1
movss dword [ebp - 0xc], xmm0
movss xmm0, dword [eax + 0xc]
mov eax, dword [edx + 0xf4]
subss xmm0, xmm2
mov edx, dword [eax + ecx*4 - 4]
movss dword [ebp - 8], xmm0
not edx
nop dword [eax + eax]
movzx eax, byte [esi]
lea esi, [esi + 1]
movzx ecx, dl
xor ecx, eax
shr edx, 8
xor edx, dword [ecx*4 + 0x101cd328]
sub edi, 1
jne 0x10036ac0
mov ecx, dword [ebp - 4]
not edx
pop edi
xor ecx, ebp
mov eax, edx
pop esi
call fcn.100f3936
mov esp, ebp
pop ebp
ret 4
Function at 0x10036af0
Capabilities:
Encode data using xor
Hash data with crc32

Disassembly:
push ebp
mov ebp, esp
sub esp, 8
mov eax, dword [0x10209f80]
xor eax, ebp
mov dword [ebp - 4], eax
push ebx
mov ebx, dword [ebp + 0xc]
lea edx, [ebp - 8]
push esi
push edi
mov edi, dword [ebp + 8]
not ebx
mov dword [ebp - 8], edi
mov esi, 4
movzx eax, byte [edx]
lea edx, [edx + 1]
movzx ecx, bl
xor ecx, eax
shr ebx, 8
xor ebx, dword [ecx*4 + 0x101cd328]
sub esi, 1
jne 0x10036b16
mov eax, dword [0x1020b1f4]
not ebx
cmp dword [eax + 0x3fe0], ebx
jne 0x10036b4c
push esi
push edi
push 4
push ebx
call fcn.10034210
add esp, 0x10
mov ecx, dword [ebp - 4]
mov eax, ebx
pop edi
pop esi
xor ecx, ebp
pop ebx
call fcn.100f3936
mov esp, ebp
pop ebp
ret

Function at 0x10038080
Capabilities:
Hash data with crc32

Disassembly:
push ebp
mov ebp, esp
push ebx
mov ebx, dword [ebp + 0x10]
push esi
mov esi, dword [ebp + 8]
not ebx
push edi
mov edi, dword [ebp + 0xc]
mov eax, ebx
test edi, edi
je 0x100380e3
mov cl, byte [esi]
lea esi, [esi + 1]
dec edi
cmp cl, 0x23
jne 0x100380c6
cmp edi, 2
jb 0x100380c6
cmp byte [esi], cl
jne 0x100380c6
cmp byte [esi + 1], cl
jne 0x100380c6
mov eax, ebx
movzx ecx, cl
movzx edx, al
xor edx, ecx
shr eax, 8
xor eax, dword [edx*4 + 0x101cd328]
jmp 0x10038097
movzx edx, al
movzx ecx, cl
xor edx, ecx
shr eax, 8
xor eax, dword [edx*4 + 0x101cd328]
test edi, edi
jne 0x10038097
pop edi
pop esi
not eax
pop ebx
pop ebp
ret
mov cl, byte [esi]
inc esi
test cl, cl
je 0x10038118
nop word [eax + eax]
cmp cl, 0x23
jne 0x100380ff
cmp byte [esi], cl
jne 0x100380ff
cmp byte [esi + 1], cl
cmove eax, ebx
movzx edx, al
movzx ecx, cl
xor edx, ecx
shr eax, 8
mov cl, byte [esi]
inc esi
xor eax, dword [edx*4 + 0x101cd328]
test cl, cl
jne 0x100380f0
pop edi
pop esi
not eax
pop ebx
pop ebp
ret
Function at 0x10038360
Capabilities:
Encrypt data using rc4 prga

Disassembly:
push ebp
mov ebp, esp
mov eax, dword [ebp + 8]
sub esp, 0x10
xor ecx, ecx
push ebx
push esi
push edi
mov esi, dword [ebp + 0xc]
mov dword [ebp - 0x10], ecx
test esi, esi
je 0x10038380
cmp eax, esi
jae 0x100384d7
mov bl, byte [eax]
test bl, bl
je 0x100384d7
movzx ecx, bl
mov edx, esi
shr ecx, 3
movsx edi, byte [ecx + 0x101cdcfc]
xor ecx, ecx
test edi, edi
mov dword [ebp - 8], edi
sete cl
add ecx, edi
mov dword [ebp - 0xc], ecx
test esi, esi
jne 0x100383af
lea edx, [ecx + eax]
cmp eax, edx
lea esi, [eax + 1]
sbb cl, cl
and cl, bl
mov byte [ebp - 4], cl
cmp esi, edx
jae 0x100383c6
mov bl, byte [esi]
mov byte [ebp - 1], bl
jmp 0x100383ca
mov byte [ebp - 1], 0
lea esi, [eax + 2]
cmp esi, edx
jae 0x100383d5
mov ch, byte [esi]
jmp 0x100383d7
xor ch, ch
lea ebx, [eax + 3]
mov byte [ebp - 3], ch
cmp ebx, edx
jae 0x100383e5
mov bl, byte [ebx]
jmp 0x100383e7
xor bl, bl
mov edi, dword [edi*4 + 0x101cdd1c]
movzx esi, byte [ebp - 1]
movzx edx, ch
movzx ecx, cl
and edi, ecx
mov byte [ebp - 2], bl
shl edi, 6
mov ecx, esi
and ecx, 0x3f
movzx ebx, bl
or edi, ecx
and esi, 0xc0
shl edi, 6
mov ecx, edx
and ecx, 0x3f
and edx, 0xc0
or edi, ecx
mov ecx, ebx
and ecx, 0x3f
shr ebx, 2
or ebx, edx
shl edi, 6
or edi, ecx
shr ebx, 2
mov ecx, dword [ebp - 8]
or ebx, esi
mov esi, dword [ebp - 8]
shr ebx, 2
mov ecx, dword [ecx*4 + 0x101cdd44]
shr edi, cl
cmp edi, dword [esi*4 + 0x101cdd30]
sbb ecx, ecx
xor edx, edx
and ecx, 0x40
or ebx, ecx
mov ecx, edi
and ecx, 0xfffff800
cmp ecx, 0xd800
mov ecx, 0x80
cmove edx, ecx
mov ecx, 0xffff
or ebx, edx
cmp ecx, edi
sbb ecx, ecx
and ecx, 0x100
or ebx, ecx
mov ecx, dword [esi*4 + 0x101cdd58]
xor ebx, 0x2a
sar ebx, cl
test ebx, ebx
je 0x100384c9
xor edx, edx
cmp byte [ebp - 2], dl
setne dl
xor ecx, ecx
cmp byte [ebp - 3], cl
setne cl
add edx, ecx
xor ecx, ecx
cmp byte [ebp - 1], cl
setne cl
add edx, ecx
xor ecx, ecx
cmp byte [ebp - 4], cl
setne cl
add edx, ecx
cmp dword [ebp - 0xc], edx
cmovl edx, dword [ebp - 0xc]
mov ecx, edx
add eax, ecx
mov ecx, dword [ebp - 0x10]
inc ecx
jmp 0x1003836e
mov ecx, dword [ebp - 0xc]
add eax, ecx
mov ecx, dword [ebp - 0x10]
inc ecx
jmp 0x1003836e
pop edi
pop esi
mov eax, ecx
pop ebx
mov esp, ebp
pop ebp
ret
Function at 0x10038540
Capabilities:
Encrypt data using rc4 prga

Disassembly:
push ebp
mov ebp, esp
sub esp, 0x18
mov eax, dword [ebp + 0xc]
dec eax
push ebx
mov ebx, dword [ebp + 8]
mov ecx, ebx
mov dword [ebp - 0x14], ecx
lea eax, [ebx + eax*2]
mov dword [ebp - 0x18], eax
cmp ebx, eax
mov eax, dword [ebp + 0x10]
jae 0x100386f6
push esi
mov esi, dword [ebp + 0x14]
mov dword [ebp - 0x10], eax
push edi
nop dword [eax]
test esi, esi
je 0x1003857c
cmp eax, esi
jae 0x100386f1
mov bl, byte [eax]
mov byte [ebp + 0xf], bl
test bl, bl
je 0x100386f1
movzx ecx, bl
mov edx, esi
shr ecx, 3
xor ebx, ebx
movsx ecx, byte [ecx + 0x101cdcfc]
test ecx, ecx
mov dword [ebp - 0xc], ecx
sete bl
add ebx, ecx
test esi, esi
jne 0x100385ab
lea edx, [ebx + eax]
cmp eax, edx
lea esi, [eax + 1]
sbb cl, cl
and cl, byte [ebp + 0xf]
mov byte [ebp - 3], cl
cmp esi, edx
jae 0x100385c3
mov ch, byte [esi]
mov byte [ebp + 0xf], ch
jmp 0x100385c7
mov byte [ebp + 0xf], 0
lea esi, [eax + 2]
cmp esi, edx
jae 0x100385d2
mov ch, byte [esi]
jmp 0x100385d4
xor ch, ch
lea esi, [eax + 3]
mov byte [ebp - 2], ch
cmp esi, edx
jae 0x100385e2
mov al, byte [esi]
jmp 0x100385e4
xor al, al
movzx esi, byte [ebp + 0xf]
movzx edx, ch
movzx ecx, cl
movzx edi, al
mov byte [ebp - 1], al
mov eax, dword [ebp - 0xc]
mov eax, dword [eax*4 + 0x101cdd1c]
and eax, ecx
mov ecx, esi
and ecx, 0x3f
mov dword [ebp - 8], eax
shl dword [ebp - 8], 6
and esi, 0xc0
or dword [ebp - 8], ecx
mov ecx, edx
shl dword [ebp - 8], 6
and ecx, 0x3f
or dword [ebp - 8], ecx
and edx, 0xc0
shl dword [ebp - 8], 6
mov ecx, edi
mov eax, dword [ebp - 8]
and ecx, 0x3f
or eax, ecx
shr edi, 2
mov ecx, dword [ebp - 0xc]
or edi, edx
shr edi, 2
or edi, esi
shr edi, 2
mov ecx, dword [ecx*4 + 0x101cdd44]
shr eax, cl
mov esi, eax
mov dword [ebp - 8], eax
mov eax, dword [ebp - 0xc]
cmp esi, dword [eax*4 + 0x101cdd30]
sbb ecx, ecx
xor edx, edx
and ecx, 0x40
or edi, ecx
mov ecx, esi
and ecx, 0xfffff800
cmp ecx, 0xd800
mov ecx, 0x80
cmove edx, ecx
mov ecx, 0xffff
or edi, edx
cmp ecx, esi
sbb ecx, ecx
and ecx, 0x100
or edi, ecx
mov ecx, dword [eax*4 + 0x101cdd58]
mov eax, dword [ebp - 0x10]
xor edi, 0x2a
sar edi, cl
test edi, edi
je 0x100386d4
xor edx, edx
mov esi, 0xfffd
cmp byte [ebp - 1], dl
setne dl
xor ecx, ecx
cmp byte [ebp - 2], cl
setne cl
add edx, ecx
xor ecx, ecx
cmp byte [ebp + 0xf], cl
setne cl
add edx, ecx
xor ecx, ecx
cmp byte [ebp - 3], cl
setne cl
add edx, ecx
cmp ebx, edx
cmovl edx, ebx
mov ebx, edx
mov ecx, dword [ebp - 0x14]
add eax, ebx
mov dword [ebp - 0x10], eax
mov word [ecx], si
add ecx, 2
mov esi, dword [ebp + 0x14]
mov dword [ebp - 0x14], ecx
cmp ecx, dword [ebp - 0x18]
jb 0x10038570
mov ebx, dword [ebp + 8]
pop edi
pop esi
xor edx, edx
mov word [ecx], dx
mov edx, dword [ebp + 0x18]
test edx, edx
je 0x10038704
mov dword [edx], eax
sub ecx, ebx
sar ecx, 1
mov eax, ecx
pop ebx
mov esp, ebp
pop ebp
ret
Function at 0x1003a2f0
Capabilities:
Write file on windows

Disassembly:
push ebp
mov ebp, esp
push esi
mov esi, dword [ebp + 8]
push edi
cmp dword [esi + 0x5dc0], 0
lea ecx, [esi + 0x5dc4]
je 0x1003a355
push 0
call fcn.10047450
push dword [ebp + 0x10]
lea ecx, [esi + 0x5dc4]
push dword [ebp + 0xc]
call fcn.10046dd0
mov edx, dword [esi + 0x5dc4]
mov ecx, 0x1020b1f0
push dword [esi + 0x5dc0]
lea eax, [edx - 1]
neg edx
sbb edx, edx
and edx, eax
mov eax, dword [esi + 0x5dcc]
test eax, eax
push edx
cmovne ecx, eax
push 1
push ecx
call dword [sym.imp.api_ms_win_crt_stdio_l1_1_0.dll_fwrite]
add esp, 0x10
pop edi
pop esi
pop ebp
ret
push dword [ebp + 0x10]
push dword [ebp + 0xc]
call fcn.10046dd0
pop edi
pop esi
pop ebp
ret
Function at 0x100421e0
Capabilities:
Write file on windows

Disassembly:
push ebp
mov ebp, esp
mov eax, dword [0x1020b1f4]
push esi
mov esi, dword [ebp + 8]
mov dword [eax + 0x5d54], 0
test esi, esi
je 0x10042239
lea eax, [ebp + 8]
mov dword [ebp + 8], 0
push edi
push eax
call fcn.10042240
push 0x101ce968
push esi
mov edi, eax
call fcn.100375b0
mov esi, eax
add esp, 0xc
test esi, esi
je 0x10042238
push esi
push dword [ebp + 8]
push 1
push edi
call dword [sym.imp.api_ms_win_crt_stdio_l1_1_0.dll_fwrite]
push esi
call dword [sym.imp.api_ms_win_crt_stdio_l1_1_0.dll_fclose]
add esp, 0x14
pop edi
pop esi
pop ebp
ret
Function at 0x1004f900
Capabilities:
Resolve function by parsing pe exports

Disassembly:
push esi
mov esi, ecx
mov eax, dword [esi + 8]
test eax, eax
je 0x1004f927
push eax
mov dword [esi + 4], 0
mov dword [esi], 0
call fcn.1003a490
add esp, 4
mov dword [esi + 8], 0
mov eax, dword [esi + 0x14]
test eax, eax
je 0x1004f94c
push eax
mov dword [esi + 0x10], 0
mov dword [esi + 0xc], 0
call fcn.1003a490
add esp, 4
mov dword [esi + 0x14], 0
mov eax, dword [esi + 0x20]
test eax, eax
je 0x1004f971
push eax
mov dword [esi + 0x1c], 0
mov dword [esi + 0x18], 0
call fcn.1003a490
add esp, 4
mov dword [esi + 0x20], 0
mov dword [esi + 0x24], 0
mov dword [esi + 0x28], 0
mov dword [esi + 0x34], 0
mov dword [esi + 0x38], 0
mov eax, dword [esi + 0x44]
test eax, eax
je 0x1004f9b2
push eax
mov dword [esi + 0x40], 0
mov dword [esi + 0x3c], 0
call fcn.1003a490
add esp, 4
mov dword [esi + 0x44], 0
mov eax, dword [esi + 0x50]
test eax, eax
je 0x1004f9d7
push eax
mov dword [esi + 0x4c], 0
mov dword [esi + 0x48], 0
call fcn.1003a490
add esp, 4
mov dword [esi + 0x50], 0
mov eax, dword [esi + 0x5c]
test eax, eax
je 0x1004f9fc
push eax
mov dword [esi + 0x58], 0
mov dword [esi + 0x54], 0
call fcn.1003a490
add esp, 4
mov dword [esi + 0x5c], 0
lea ecx, [esi + 0x78]
pop esi
jmp fcn.1004b3a0
Function at 0x100520f0
Capabilities:
Get geographical location
Get keyboard layout

Disassembly:
push esi
call fcn.10036730
test eax, eax
je 0x10052104
call fcn.10036bb0
mov esi, dword [eax + 0x68]
jmp 0x10052106
xor esi, esi
push 0
call dword [sym.imp.USER32.dll_GetKeyboardLayout]
push 4
add esi, 0x24
shr eax, 0x10
push esi
push 0x20001004
push eax
call dword [sym.imp.KERNEL32.dll_GetLocaleInfoA]
test eax, eax
jne 0x10052129
mov dword [esi], eax
pop esi
ret
Function at 0x1006d3f0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push ebp
mov ebp, esp
push 0xffffffffffffffff
push 0x10153e9b
mov eax, dword fs:[0]
push eax
sub esp, 0x30
push ebx
push esi
push edi
mov eax, dword [0x10209f80]
xor eax, ebp
push eax
lea eax, [ebp - 0xc]
mov dword fs:[0], eax
mov ebx, ecx
mov dword [ebp - 0x10], ebx
mov dword [ebp - 0x18], ebx
mov esi, dword [ebp + 8]
lea edi, [ebx + 4]
mov dword [ebp - 0x34], ebx
push 0x24
mov dword [ebp - 0x24], edi
mov eax, dword [esi]
mov dword [ebx], eax
mov dword [edi], 0
mov dword [edi + 4], 0
call fcn.100f33de
add esp, 4
mov dword [eax], eax
mov dword [eax + 4], eax
mov dword [edi], eax
lea ecx, [ebx + 0xc]
mov dword [ebp - 4], 0
mov dword [ecx], 0
mov dword [ecx + 4], 0
mov dword [ecx + 8], 0
mov eax, dword [esi + 0x18]
mov dword [ebx + 0x18], eax
mov eax, dword [esi + 0x1c]
mov dword [ebx + 0x1c], eax
mov eax, dword [esi + 0x10]
sub eax, dword [esi + 0xc]
push dword [edi]
sar eax, 2
push eax
mov byte [ebp - 4], 1
call fcn.10027050
mov eax, dword [esi + 4]
mov dword [ebp - 0x18], eax
mov esi, dword [eax]
cmp esi, eax
je 0x1006d5d1
nop dword [eax]
cmp dword [esi + 0x1c], 0xf
lea ebx, [esi + 8]
mov edx, ebx
jbe 0x1006d4ad
mov edx, dword [ebx]
xor ecx, ecx
mov edi, 0x811c9dc5
cmp dword [ebx + 0x10], ecx
jbe 0x1006d4d2
nop dword [eax]
movzx eax, byte [edx + ecx]
inc ecx
xor eax, edi
imul edi, eax, 0x1000193
cmp ecx, dword [ebx + 0x10]
jb 0x1006d4c0
mov ecx, dword [ebp - 0x10]
lea eax, [ebp - 0x20]
push edi
push ebx
push eax
call fcn.10022860
cmp dword [ebp - 0x1c], 0
jne 0x1006d5c3
mov eax, dword [ebp - 0x10]
cmp dword [eax + 8], 0x71c71c7
je 0x1006d5e7
mov eax, dword [ebp - 0x24]
mov dword [ebp - 0x30], eax
push 0x24
mov byte [ebp - 4], 2
mov dword [ebp - 0x2c], 0
call fcn.100f33de
add esp, 4
mov dword [ebp - 0x28], eax
mov dword [ebp - 0x2c], eax
add eax, 8
mov ecx, eax
mov dword [ebp - 0x14], eax
push ebx
call fcn.10012540
mov ecx, dword [ebp - 0x14]
mov eax, dword [ebx + 0x18]
mov dword [ecx + 0x18], eax
mov ebx, dword [ebp - 0x10]
mov byte [ebp - 4], 3
mov ecx, dword [ebx + 8]
inc ecx
mov eax, ecx
shr eax, 0x1f
movd xmm0, ecx
cvtdq2pd xmm0, xmm0
addsd xmm0, qword [eax*8 + 0x10158270]
mov eax, dword [ebx + 0x1c]
cvtpd2ps xmm1, xmm0
movd xmm0, eax
cvtdq2pd xmm0, xmm0
shr eax, 0x1f
addsd xmm0, qword [eax*8 + 0x10158270]
cvtpd2ps xmm0, xmm0
divss xmm1, xmm0
comiss xmm1, dword [ebx]
jbe 0x1006d5a7
push ecx
mov ecx, ebx
call fcn.100843a0
push eax
mov ecx, ebx
call fcn.10027190
push edi
push dword [ebp - 0x14]
lea eax, [ebp - 0x3c]
mov ecx, ebx
push eax
call fcn.10022860
mov ecx, dword [eax]
mov eax, dword [eax + 4]
mov dword [ebp - 0x20], ecx
mov dword [ebp - 0x1c], eax
jmp 0x1006d5aa
mov ecx, dword [ebp - 0x20]
push dword [ebp - 0x28]
mov dword [ebp - 0x2c], 0
push ecx
push edi
mov ecx, ebx
call fcn.10085a20
mov byte [ebp - 4], 1
jmp 0x1006d5c6
mov ebx, dword [ebp - 0x10]
mov esi, dword [esi]
cmp esi, dword [ebp - 0x18]
jne 0x1006d4a0
mov eax, ebx
mov ecx, dword [ebp - 0xc]
mov dword fs:[0], ecx
pop ecx
pop edi
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 8
push str.unordered_map_set_too_long
call sub.MSVCP140.dll_void___cdecl_std::_Xlength_error_char_const__
int3