joyce8/EMBER2024-capa huggingface dataset:
Function at 0x5ca030
Capabilities:
Get socket status
Send data
Send data on socket

Disassembly:
sub esp, 0x10c
mov ecx, dword [esp + 0x114]
push esi
mov esi, dword [esp + 0x114]
mov dword [esp + 0xc], 1
test ecx, ecx
mov dword [esp + 0x10], esi
jne 0x5ca063
push ecx
lea eax, [esp + 0x10]
push ecx
push eax
push ecx
lea ecx, [esi + 1]
push ecx
jmp 0x5ca0bb
cmp ecx, 0xffffffff
jne 0x5ca07a
mov dword [esp + 4], 0
mov dword [esp + 8], 0
jmp 0x5ca0a9
mov eax, 0x10624dd3
imul ecx
sar edx, 6
mov eax, edx
shr eax, 0x1f
add edx, eax
mov eax, ecx
mov dword [esp + 4], edx
mov ecx, 0x3e8
cdq
idiv ecx
lea eax, [edx + edx*4]
lea eax, [eax + eax*4]
lea edx, [eax + eax*4]
shl edx, 3
mov dword [esp + 8], edx
lea eax, [esp + 4]
lea ecx, [esp + 0xc]
push eax
push 0
push ecx
lea edx, [esi + 1]
push 0
push edx
call sub.WS2_32.dll_select
test eax, eax
jge 0x5ca0d1
mov eax, 0xfffffffb
pop esi
add esp, 0x10c
ret
jne 0x5ca0e0
mov eax, 0xfffffffa
pop esi
add esp, 0x10c
ret
lea eax, [esp + 0xc]
push eax
push esi
call sub.WS2_32.dll___WSAFDIsSet
test eax, eax
je 0x5ca139
mov ecx, dword [esp + 0x11c]
mov edx, dword [esp + 0x120]
push 0
push ecx
push edx
push esi
call sub.WS2_32.dll_send
test eax, eax
jg 0x5ca121
call fcn.005c9610
push eax
call fcn.005c9c20
add esp, 4
pop esi
add esp, 0x10c
ret
mov ecx, dword [0x84ce48]
test ecx, ecx
je 0x5ca13e
mov edx, dword [ecx]
pop esi
add edx, eax
mov dword [ecx], edx
add esp, 0x10c
ret
mov eax, 0xfffffff7
pop esi
add esp, 0x10c
ret

Function at 0x5ca150
Capabilities:
Resolve dns

Disassembly:
mov eax, dword [esp + 4]
push eax
call sub.WS2_32.dll_gethostbyname
test eax, eax
jne 0x5ca15f
ret
mov ecx, dword [eax + 0xc]
push esi
push edi
mov edx, dword [ecx]
mov eax, dword [edx]
push eax
call sub.WS2_32.dll_inet_ntoa
mov edi, eax
or ecx, 0xffffffff
xor eax, eax
repne scasb al, byte es:[edi]
mov eax, dword [esp + 0x10]
not ecx
sub edi, ecx
mov edx, ecx
mov esi, edi
mov edi, eax
shr ecx, 2
rep movsd dword es:[edi], dword [esi]
mov ecx, edx
and ecx, 3
rep movsb byte es:[edi], byte [esi]
pop edi
pop esi
ret

Function at 0x5ca2f0
Capabilities:
Get local ipv4 addresses
Get socket information

Disassembly:
sub esp, 0x14
mov edx, dword [esp + 0x18]
lea eax, [esp]
lea ecx, [esp + 4]
push eax
push ecx
push edx
mov dword [esp + 0xc], 0x10
call sub.WS2_32.dll_getsockname
test eax, eax
jne 0x5ca326
mov eax, dword [esp + 6]
push eax
call sub.WS2_32.dll_ntohs
and eax, 0xffff
add esp, 0x14
ret
or eax, 0xffffffff
add esp, 0x14
ret

Function at 0x5ca330
Capabilities:
Get hostname
Resolve dns

Disassembly:
sub esp, 0x64
lea eax, [esp]
push esi
push 0x64
push eax
xor esi, esi
call sub.WS2_32.dll_gethostname
lea ecx, [esp + 4]
push ecx
call sub.WS2_32.dll_gethostbyname
test eax, eax
jne 0x5ca355
pop esi
add esp, 0x64
ret
mov edx, dword [eax + 0xc]
mov eax, dword [edx]
test eax, eax
je 0x5ca368
mov eax, dword [eax]
push eax
call sub.WS2_32.dll_inet_ntoa
mov esi, eax
mov eax, esi
pop esi
add esp, 0x64
ret
Function at 0x5ca690
Capabilities:
Terminate thread

Disassembly:
mov eax, dword [esp + 4]
push esi
mov esi, dword [esp + 0xc]
push esi
push eax
call fcn.005ca7c0
add esp, 8
test eax, eax
jne 0x5ca6a9
pop esi
ret
mov eax, dword [esi + 0x8c]
test eax, eax
jne 0x5ca6b5
pop esi
ret
push 0
push eax
call dword [sym.imp.KERNEL32.dll_TerminateThread]
mov dword [esi + 0x8c], 0
pop esi
ret

Function at 0x5ca6d0
Capabilities:
Terminate thread

Disassembly:
push esi
push edi
mov edi, dword [esp + 0x10]
mov eax, dword [edi + 0x38c]
mov esi, dword [edi]
push eax
call fcn.005ca9d0
add esp, 4
test esi, esi
je 0x5ca75a
mov edi, dword [esp + 0xc]
push ebp
mov ebp, dword [sym.imp.KERNEL32.dll_TerminateThread]
mov eax, dword [esi + 0x8c]
test eax, eax
je 0x5ca74e
cmp dword [esi + 8], 0xffffffff
je 0x5ca74e
push 0
push eax
call ebp
mov dword [esi + 0x8c], 0
mov ecx, dword [edi + 0xa0]
test ecx, ecx
je 0x5ca73c
mov eax, dword [esi + 0x1c]
push 0
lea edx, [eax*8]
sub edx, eax
lea eax, [ecx + edx*4]
mov ecx, dword [ecx + edx*4 + 0x14]
mov edx, dword [eax + 0xc]
add ecx, edx
push ecx
jmp 0x5ca740
push 0
push 0
push esi
push 8
push 0x15
push edi
call fcn.005c6190
add esp, 0x18
mov esi, dword [esi + 0x48]
test esi, esi
jne 0x5ca6f6
mov edi, dword [esp + 0x14]
pop ebp
mov edx, dword [edi + 0x38c]
push edx
call fcn.005ca9e0
add esp, 4
pop edi
pop esi
ret

Function at 0x5cbbd0
Capabilities:
Encode data using xor

Disassembly:
mov eax, dword [esp + 8]
mov ecx, dword [esp + 4]
mov edx, eax
dec eax
test edx, edx
je 0x5cbc0c
push ebx
push esi
lea esi, [eax + 1]
mov eax, dword [esp + 0x14]
mov edx, eax
xor ebx, ebx
mov bl, byte [ecx]
and edx, 0xff
xor edx, ebx
xor ebx, ebx
mov bl, ah
mov ax, word [edx*2 + 0x7e30ec]
xor ax, bx
inc ecx
dec esi
jne 0x5cbbe8
pop esi
pop ebx
ret
mov ax, word [esp + 0xc]
ret
Function at 0x5cf910
Capabilities:
Enumerate pe sections

Disassembly:
mov eax, dword [esp + 4]
test eax, eax
je 0x5cfae2
xor ecx, ecx
xor edx, edx
mov ch, byte [eax]
mov dl, byte [eax + 2]
mov cl, byte [eax + 1]
push ebx
shl ecx, 8
or ecx, edx
xor edx, edx
mov dl, byte [eax + 3]
push ebp
shl ecx, 8
or ecx, edx
xor edx, edx
mov dl, byte [eax + 6]
mov dword [eax], ecx
xor ecx, ecx
push esi
mov ch, byte [eax + 4]
push edi
mov cl, byte [eax + 5]
xor ebp, ebp
shl ecx, 8
or ecx, edx
xor edx, edx
mov dl, byte [eax + 7]
shl ecx, 8
or ecx, edx
mov edx, dword [esp + 0x18]
mov dword [eax + 4], ecx
xor ecx, ecx
mov ch, byte [eax + 8]
lea edi, [edx + 0xc]
mov cl, byte [eax + 9]
mov word [eax + 8], cx
mov ecx, dword [eax]
mov dword [edx], ecx
mov ecx, dword [eax + 4]
mov dword [edx + 4], ecx
mov cx, word [eax + 8]
mov word [edx + 8], cx
xor ecx, ecx
movzx si, byte [eax + 0xb]
mov ch, byte [eax + 0xa]
or ecx, esi
mov word [eax + 0xa], cx
mov word [edx + 0xa], cx
movzx si, byte [eax + 0xb]
xor ecx, ecx
mov ch, byte [eax + 0xa]
or ecx, esi
mov esi, dword [eax + 0xc]
mov word [eax + 0xa], cx
and ecx, 0xffff
mov ebx, ecx
shr ecx, 2
rep movsd dword es:[edi], dword [esi]
mov ecx, ebx
and ecx, 3
rep movsb byte es:[edi], byte [esi]
movzx si, byte [eax + 0x11]
mov bp, word [eax + 0xa]
xor ecx, ecx
mov ch, byte [eax + 0x10]
add ebp, 0xc
or ecx, esi
mov word [eax + 0x10], cx
mov word [edx + ebp], cx
movzx si, byte [eax + 0x11]
xor ecx, ecx
lea edi, [edx + ebp + 2]
mov ch, byte [eax + 0x10]
or ecx, esi
mov esi, dword [eax + 0x14]
mov word [eax + 0x10], cx
and ecx, 0xffff
mov ebx, ecx
shr ecx, 2
rep movsd dword es:[edi], dword [esi]
mov ecx, ebx
and ecx, 3
rep movsb byte es:[edi], byte [esi]
movzx si, byte [eax + 0x19]
xor ecx, ecx
mov cx, word [eax + 0x10]
lea ebp, [ecx + ebp + 2]
xor ecx, ecx
mov ch, byte [eax + 0x18]
or ecx, esi
lea edi, [edx + ebp + 2]
mov word [eax + 0x18], cx
mov word [edx + ebp], cx
movzx si, byte [eax + 0x19]
xor ecx, ecx
mov ch, byte [eax + 0x18]
or ecx, esi
mov esi, dword [eax + 0x1c]
mov word [eax + 0x18], cx
and ecx, 0xffff
mov ebx, ecx
shr ecx, 2
rep movsd dword es:[edi], dword [esi]
mov ecx, ebx
and ecx, 3
rep movsb byte es:[edi], byte [esi]
movzx si, byte [eax + 0x21]
xor ecx, ecx
mov cx, word [eax + 0x18]
lea ebp, [ecx + ebp + 2]
xor ecx, ecx
mov ch, byte [eax + 0x20]
or ecx, esi
lea edi, [edx + ebp + 2]
mov word [eax + 0x20], cx
mov word [edx + ebp], cx
movzx si, byte [eax + 0x21]
xor ecx, ecx
mov ch, byte [eax + 0x20]
or ecx, esi
mov esi, dword [eax + 0x24]
mov word [eax + 0x20], cx
and ecx, 0xffff
mov edx, ecx
shr ecx, 2
rep movsd dword es:[edi], dword [esi]
mov ecx, edx
xor edx, edx
and ecx, 3
rep movsb byte es:[edi], byte [esi]
mov dl, byte [eax + 6]
xor ecx, ecx
mov ch, byte [eax + 4]
pop edi
mov cl, byte [eax + 5]
pop esi
shl ecx, 8
or ecx, edx
xor edx, edx
mov dl, byte [eax + 7]
pop ebp
shl ecx, 8
or ecx, edx
xor edx, edx
mov dh, byte [eax]
mov dword [eax + 4], ecx
mov dl, byte [eax + 1]
xor ecx, ecx
mov ch, byte [eax + 8]
pop ebx
mov cl, byte [eax + 9]
mov word [eax + 8], cx
xor ecx, ecx
mov cl, byte [eax + 2]
shl edx, 8
or edx, ecx
xor ecx, ecx
mov cl, byte [eax + 3]
shl edx, 8
or edx, ecx
mov dword [eax], edx
ret
Function at 0x5d2700
Capabilities:
Hash data with md5

Disassembly:
sub esp, 0x94
mov eax, dword [esp + 0x9c]
push esi
push 0x40
lea ecx, [esp + 0x1c]
xor esi, esi
push eax
push ecx
mov dword [esp + 0x24], 0x67452301
mov dword [esp + 0x28], 0xefcdab89
mov dword [esp + 0x2c], 0x98badcfe
mov dword [esp + 0x30], 0x10325476
mov dword [esp + 0x34], esi
mov dword [esp + 0x38], esi
call fcn.005d2510
lea edx, [esp + 0x24]
lea eax, [esp + 0x10]
push edx
push eax
call fcn.005d2640
mov esi, dword [esp + 0xb0]
add esp, 0x14
xor edx, edx
mov cl, byte [esp + edx + 4]
mov al, cl
and cl, 0xf
sar al, 4
and al, 0xf
cmp al, 0xa
movsx eax, al
jge 0x5d277a
add eax, 0x30
jmp 0x5d277d
add eax, 0x57
mov byte [esi], al
cmp cl, 0xa
movsx eax, cl
jge 0x5d278c
add eax, 0x30
jmp 0x5d278f
add eax, 0x57
mov byte [esi + 1], al
inc edx
add esi, 2
cmp edx, 0x10
jl 0x5d2760
pop esi
add esp, 0x94
ret

Function at 0x5d27b0
Capabilities:
Encode data using xor

Disassembly:
sub esp, 0x84
push ebx
mov ebx, dword [esp + 0x90]
push ebp
mov ebp, dword [esp + 0x90]
push esi
push edi
mov ecx, 0x10
xor eax, eax
mov edi, ebp
mov esi, dword [esp + 0xa0]
rep stosd dword es:[edi], eax
mov ecx, 8
mov edi, ebx
rep stosd dword es:[edi], eax
stosw word es:[edi], ax
mov ecx, 0x20
xor eax, eax
lea edi, [esp + 0x14]
rep stosd dword es:[edi], eax
test esi, esi
mov dword [esp + 0x14], 0x9d14e9a1
mov dword [esp + 0x18], 0x593b6b0e
je 0x5d283b
mov edi, esi
or ecx, 0xffffffff
repne scasb al, byte es:[edi]
not ecx
dec ecx
cmp ecx, 0x28
jne 0x5d281f
mov byte [esi + 0x20], al
mov ecx, 0x20
jmp 0x5d2829
cmp ecx, 0x38
jle 0x5d2829
mov ecx, 0x38
mov eax, ecx
lea edi, [esp + 0x1c]
shr ecx, 2
rep movsd dword es:[edi], dword [esi]
mov ecx, eax
and ecx, 3
rep movsb byte es:[edi], byte [esi]
mov ecx, 0x7e3584
test ecx, ecx
je 0x5d286f
mov edi, ecx
or ecx, 0xffffffff
xor eax, eax
repne scasb al, byte es:[edi]
not ecx
dec ecx
cmp ecx, 0x38
jle 0x5d285a
mov ecx, 0x38
xor eax, eax
test ecx, ecx
jle 0x5d286f
mov dl, byte [eax + 0x7e3584]
xor byte [esp + eax + 0x1c], dl
inc eax
cmp eax, ecx
jl 0x5d2860
lea eax, [esp + 0x14]
push eax
push ebp
call fcn.005d2700
mov edi, ebp
or ecx, 0xffffffff
xor eax, eax
add esp, 8
repne scasb al, byte es:[edi]
not ecx
dec ecx
mov edi, str.01d0a8e3
mov edx, ecx
or ecx, 0xffffffff
repne scasb al, byte es:[edi]
not ecx
lea esi, [edx + ebp]
sub edi, ecx
mov eax, ecx
mov dword [esp + 0x10], esi
mov esi, edi
mov edi, dword [esp + 0x10]
shr ecx, 2
rep movsd dword es:[edi], dword [esi]
mov ecx, eax
mov eax, edx
cdq
and edx, 3
and ecx, 3
add eax, edx
rep movsb byte es:[edi], byte [esi]
sar eax, 2
xor ecx, ecx
test eax, eax
jle 0x5d28d4
mov esi, ebp
mov dl, byte [esi]
add esi, 4
mov byte [ecx + ebx], dl
inc ecx
cmp ecx, eax
jl 0x5d28c7
pop edi
pop esi
pop ebp
pop ebx
add esp, 0x84
ret
Function at 0x5d34a0
Capabilities:
Encode data using base64
Terminate process

Disassembly:
sub esp, 0x118
mov ecx, 0x3f
mov eax, 0x80808080
push ebx
push ebp
push esi
push edi
lea edi, [esp + 0x28]
rep stosd dword es:[edi], eax
stosw word es:[edi], ax
stosb byte es:[edi], al
mov eax, 0x41
mov cl, al
sub cl, 0x41
mov byte [esp + eax + 0x28], cl
inc eax
cmp eax, 0x5a
jle 0x5d34c2
mov eax, 0x61
mov dl, al
sub dl, 0x47
mov byte [esp + eax + 0x28], dl
inc eax
cmp eax, 0x7a
jle 0x5d34d6
mov eax, 0x30
mov cl, al
add cl, 4
mov byte [esp + eax + 0x28], cl
inc eax
cmp eax, 0x39
jle 0x5d34ea
mov edi, dword [esp + 0x12c]
or ecx, 0xffffffff
xor eax, eax
xor ebp, ebp
repne scasb al, byte es:[edi]
not ecx
dec ecx
mov byte [esp + 0x53], 0x3e
mov byte [esp + 0x57], 0x3f
mov byte [esp + 0x65], 0
mov dword [esp + 0x18], ebp
je 0x5d367d
mov ebx, dword [esp + 0x130]
mov dword [esp + 0x10], 3
mov dword [esp + 0x14], 4
mov edx, dword [esp + 0x18]
mov ecx, dword [esp + 0x12c]
xor eax, eax
lea esi, [edx + ecx]
movsx ecx, byte [esi + eax]
mov dl, byte [esp + ecx + 0x28]
test dl, 0x80
jne 0x5d364e
mov byte [esp + eax + 0x20], cl
mov byte [esp + eax + 0x1c], dl
inc eax
cmp eax, 4
jl 0x5d354c
mov esi, dword [esp + 0x138]
mov edx, dword [esp + 0x10]
cmp edx, dword [esi]
jle 0x5d35b6
mov eax, dword [esp + 0x14]
push eax
call fcn.005e1717
mov ecx, dword [esi]
mov esi, ebx
mov edx, ecx
mov edi, eax
shr ecx, 2
rep movsd dword es:[edi], dword [esi]
mov ecx, edx
push ebx
and ecx, 3
mov dword [esp + 0x2c], eax
rep movsb byte es:[edi], byte [esi]
call fcn.005e162e
mov ecx, dword [esp + 0x140]
mov eax, dword [esp + 0x18]
mov ebx, dword [esp + 0x2c]
add esp, 8
mov dword [ecx], eax
mov ecx, dword [esp + 0x1c]
mov edi, dword [esp + 0x10]
mov dl, ch
mov al, cl
sar dl, 4
shl al, 2
or dl, al
mov eax, dword [esp + 0x14]
mov byte [ebx + ebp], dl
inc ebp
inc eax
mov cl, ch
mov dword [esp + 0x14], eax
mov al, byte [esp + 0x1e]
mov dl, al
inc edi
sar dl, 2
shl cl, 4
or dl, cl
mov ecx, dword [esp + 0x14]
shl al, 6
or al, byte [esp + 0x1f]
mov byte [ebx + ebp], dl
inc ebp
mov edx, edi
inc ecx
inc edx
mov byte [ebx + ebp], al
mov al, byte [esp + 0x22]
inc ebp
inc ecx
inc edx
mov dword [esp + 0x10], edi
cmp al, 0x3d
mov dword [esp + 0x14], ecx
mov dword [esp + 0x10], edx
je 0x5d3663
mov cl, byte [esp + 0x23]
xor eax, eax
cmp cl, 0x3d
setne al
add eax, 2
cmp eax, 3
jl 0x5d3663
mov edx, dword [esp + 0x18]
mov edi, dword [esp + 0x12c]
or ecx, 0xffffffff
xor eax, eax
add edx, 4
repne scasb al, byte es:[edi]
not ecx
dec ecx
mov dword [esp + 0x18], edx
cmp edx, ecx
jae 0x5d3684
jmp 0x5d353c
push ecx
push str.Illegal_character__c_in_input._n
call fcn.005e314d
add esp, 8
push 1
call fcn.005e331e
mov eax, dword [esp + 0x134]
mov byte [ebx + ebp], 0
pop edi
pop esi
mov dword [eax], ebp
mov eax, ebx
pop ebp
pop ebx
add esp, 0x118
ret
mov ebx, dword [esp + 0x130]
mov ecx, dword [esp + 0x134]
mov byte [ebx + ebp], 0
pop edi
pop esi
mov dword [ecx], ebp
mov eax, ebx
pop ebp
pop ebx
add esp, 0x118
ret
Function at 0x5d9970
Capabilities:
Encrypt data using des

Disassembly:
sub esp, 0xf4
xor ecx, ecx
push ebx
push ebp
push esi
mov esi, dword [esp + 0x104]
push edi
xor eax, eax
mov al, byte [ecx + str.80_]
mov edx, eax
and eax, 7
sar edx, 3
mov bl, byte [eax*2 + 0x8068e4]
mov dl, byte [edx + esi]
test bl, dl
setne al
mov byte [esp + ecx + 0x4c], al
inc ecx
cmp ecx, 0x38
jl 0x5d9983
mov eax, 0x1e
xor edx, edx
mov dword [esp + 0x10], eax
cmp dword [esp + 0x10c], 1
je 0x5d99c4
lea eax, [edx + edx]
lea edi, [esp + eax*4 + 0x88]
lea ebp, [esp + eax*4 + 0x84]
xor eax, eax
xor ecx, ecx
mov cl, byte [edx + 0x80698c]
mov dword [edi], 0
mov dword [ebp], 0
mov esi, ecx
cmp ecx, 0x1c
jge 0x5d99f6
mov bl, byte [esp + ecx + 0x4c]
jmp 0x5d99fa
mov bl, byte [esp + ecx + 0x30]
mov byte [esp + eax + 0x14], bl
inc eax
inc ecx
cmp eax, 0x1c
jl 0x5d99eb
mov eax, 0x1c
lea ecx, [esi + 0x1c]
cmp ecx, 0x38
jge 0x5d9a18
mov bl, byte [esp + ecx + 0x4c]
jmp 0x5d9a1c
mov bl, byte [esp + ecx + 0x30]
mov byte [esp + eax + 0x14], bl
inc eax
inc ecx
cmp eax, 0x38
jl 0x5d9a0d
xor ecx, ecx
mov eax, 0x8068f4
xor ebx, ebx
mov bl, byte [ecx + 0x80699c]
cmp byte [esp + ebx + 0x14], 0
je 0x5d9a47
mov esi, dword [eax]
mov ebx, dword [ebp]
or ebx, esi
mov dword [ebp], ebx
xor ebx, ebx
mov bl, byte [ecx + 0x8069b4]
cmp byte [esp + ebx + 0x14], 0
je 0x5d9a5e
mov esi, dword [eax]
mov ebx, dword [edi]
or ebx, esi
mov dword [edi], ebx
add eax, 4
inc ecx
cmp eax, str.80_
jl 0x5d9a2e
mov eax, dword [esp + 0x10]
inc edx
sub eax, 2
cmp eax, 0xfffffffe
mov dword [esp + 0x10], eax
jg 0x5d99b7
lea edx, [esp + 0x84]
push edx
call fcn.005d9aa0
add esp, 4
pop edi
pop esi
pop ebp
pop ebx
add esp, 0xf4
ret
Function at 0x5f49e4
Capabilities:
Get graphical window text

Disassembly:
push esi
mov esi, ecx
mov ecx, dword [esi + 0x38]
test ecx, ecx
jne 0x5f4a1c
push dword [esi + 0x1c]
call dword [sym.imp.USER32.dll_GetWindowTextLengthA]
lea ecx, [eax + 1]
push ecx
mov ecx, dword [esp + 0xc]
push eax
call fcn.005f2a71
push eax
push dword [esi + 0x1c]
call dword [sym.imp.USER32.dll_GetWindowTextA]
mov ecx, dword [esp + 8]
push 0xffffffffffffffff
call fcn.005f2a49
jmp 0x5f4a28
mov eax, dword [ecx]
push dword [esp + 8]
call dword [eax + 0x88]
pop esi
ret 4

Function at 0x5f60d5
Capabilities:
Extract resource via kernel32 functions

Disassembly:
push ebx
push esi
push edi
xor edi, edi
cmp dword [esp + 0x10], edi
mov ebx, ecx
je 0x5f6117
call fcn.005fc1ca
mov esi, dword [eax + 0xc]
push 0xf0
push dword [esp + 0x14]
push esi
call dword [sym.imp.KERNEL32.dll_FindResourceA]
cmp eax, edi
je 0x5f6117
push eax
push esi
call dword [sym.imp.KERNEL32.dll_LoadResource]
cmp eax, edi
jne 0x5f610e
xor eax, eax
jmp 0x5f611f
push eax
call dword [sym.imp.KERNEL32.dll_LockResource]
mov edi, eax
push edi
mov ecx, ebx
call fcn.005f6125
pop edi
pop esi
pop ebx
ret 4

Function at 0x5fc6fa
Capabilities:
Get thread local storage value

Disassembly:
push ebx
push esi
mov esi, ecx
lea ebx, [esi + 0x1c]
push ebx
call dword [sym.imp.KERNEL32.dll_EnterCriticalSection]
cmp dword [esp + 0x10], 0
jne 0x5fc728
push dword [esi]
call dword [sym.imp.KERNEL32.dll_TlsGetValue]
test eax, eax
je 0x5fc746
push dword [esp + 0xc]
mov ecx, esi
push eax
call fcn.005fc660
jmp 0x5fc746
mov eax, dword [esi + 0x14]
test eax, eax
je 0x5fc746
push edi
push dword [esp + 0x10]
mov edi, dword [eax + 4]
mov ecx, esi
push eax
call fcn.005fc660
test edi, edi
mov eax, edi
jne 0x5fc730
pop edi
push ebx
call dword [sym.imp.KERNEL32.dll_LeaveCriticalSection]
pop esi
pop ebx
ret 8
Function at 0x403657
Capabilities:
Parse pe header

Disassembly:
mov dword [esi], edi
push esi
call dword [0x41a028]
mov ecx, dword [esi + 0x10]
mov dword [0x4a2620], ecx
mov eax, dword [esi + 4]
mov dword [0x41a0f5], eax
mov edx, dword [esi + 8]
mov dword [0x4a2630], edx
mov esi, dword [esi + 0xc]
and esi, 0x7fff
mov dword [0x4a2624], esi
cmp ecx, 2
je fcn.00403657
or esi, 0x8000
mov dword [0x4a2624], esi
shl eax, 8
add eax, edx
mov dword [0x41a47a], eax
xor edi, edi
push edi
call dword [0x41a03c]
cmp word [eax], 0x5a4d
jne 0x4036df
mov ecx, dword [eax + 0x3c]
add ecx, eax
cmp dword [ecx], 0x4550
jne 0x40367d
movzx eax, word [ecx + 0x18]
cmp eax, 0x10b
je 0x4036dd
cmp eax, 0x20b
je 0x403704
mov dword [ebp - 0x1c], edi
cmp dword [ecx + 0x84], 0xe
jbe 0x403711
xor eax, eax
cmp dword [ecx + 0xf8], edi
cmp dword [ecx + 0x74], 0xe
jbe 0x40369a
xor eax, eax
cmp dword [ecx + 0xe8], edi
mov dword [ebp - 0x1c], eax
push 1
call fcn.00402869
pop ecx
test eax, eax
jne 0x4036f8
push 0x1c
call fcn.00402d36
pop ecx
call fcn.00403657
test eax, eax
jne 0x403715
push 0x10
call fcn.00403427
pop ecx
call fcn.00403657
mov dword [ebp - 4], edi
call fcn.00402fed
test eax, eax
jge 0x40377a
push 0x1b
call fcn.00402869
pop ecx
call dword [0x41a030]
mov dword [0x41a30a], eax
call fcn.00402fed
mov dword [0x41a2ef], eax
call fcn.00401c00
test eax, eax
jge 0x4037c9
push 8
call fcn.00403e78
pop ecx
call fcn.00402869
test eax, eax
jge 0x403782
push 9
call fcn.00403657
pop ecx
push 1
call fcn.00402869
pop ecx
mov dword [ebp - 0x24], eax
cmp eax, edi
je 0x4037f1
push eax
call fcn.00402d36
pop ecx
mov eax, dword [0x41a505]
mov dword [0x41a3ea], eax
push eax
push dword [0x41a04c]
push dword [0x41a074]
call fcn.00402fed
add esp, 0xc
mov esi, eax
mov dword [ebp - 0x28], esi
cmp dword [ebp - 0x1c], edi
jne 0x403735
push esi
call fcn.00401c00
call fcn.00402d36
mov eax, dword [ebp - 0x14]
mov ecx, dword [eax]
mov ecx, dword [ecx]
mov dword [ebp - 0x20], ecx
push eax
push ecx
call fcn.00402869
pop ecx
pop ecx
ret
mov eax, 0x41a224
ret

Function at 0x404891
Capabilities:
Authenticate hmac
Check os version
Encode data using base64
Encrypt data using speck
Get number of processors
Resolve function by parsing pe exports

Disassembly:
push ebp
mov ebp, esp
sub esp, 0x70
add eax, ecx
add ecx, eax
xor edx, eax
call fcn.004043a8
or eax, esi
and ecx, eax
cmp dword [ebp - 0x3c], 0xffffffae
jne 0x4048b8
push dword [esi + 0x118]
push dword [ebp - 0x30]
cmp dword [ebp - 0x3c], 1
je 0x4048ca
pop ecx
pop edi
pop esi
pop ebx
mov esp, ebp
mov dword [ebp - 0x30], esp
xor edi, edx
mov dword [ebp - 0x6c], ebx
add esp, 0xffffff5c
push dword [ebp - 0x50]
mov dword [ebp - 0x64], edx
cmp dword [ebp - 0x3c], 1
je 0x4048f5
dec edx
js 0x4048f0
mov dword [ecx + 8], esi
Function at 0x404943
Capabilities:
Check os version
Get number of processors
Resolve function by parsing pe exports

Disassembly:
mov dword [ecx + 4], esi
add ecx, 0xc
xor eax, eax
push dword [ebp - 0x4c]
cmp dword [ebp - 0x3c], 1
je 0x40490b
mov esp, ebp
pop ebp
pop edi
pop esi
mov eax, 0x41a2b3
cmp dword [ebp - 0x3c], 0x400002
jne 0x404920
and ebx, 0xffffffe0
and ecx, 0x41a45f
push dword [ebp - 0x40]
mov dword [ebp - 0x20], 0x1c8d8
xor edi, dword [ebp - 0x58]
sub edi, eax
push dword [ebp - 0x20]
sub esi, dword [ebp - 0x64]
call fcn.0041257c
cmp dword [ebp - 0x3c], 1
je 0x404947
test eax, eax
jne 0x4048ed
mov ebx, dword [ebp - 0x30]
lea ebx, [ebx - 0x98]
push ebx
push dword [ebp - 0x20]
call fcn.0040456b
or ecx, dword [ebp - 0x1c]
mov edi, dword [ebp - 0x30]
lea edi, [edi - 4]
push edi
push dword [ebp - 0x68]
call fcn.0040456b
cmp dword [ebp - 0x3c], 0xffffffe1
jne 0x40497c
mov dword [ebp - 4], eax
cmp ebx, 8
je 0x40491a
lea ecx, [ebp - 0x50]
push ecx
xor edi, esi
push dword [ebp - 0x68]
mov dword [ebp - 0x5c], edx
call fcn.0040456b
mov dword [ebp - 0x64], eax

Function at 0x404c1a
Capabilities:
Authenticate hmac
Check os version
Encode data using base64
Encrypt data using speck
Get number of processors
Resolve function by parsing pe exports

Disassembly:
call fcn.0040d57d
mov ecx, dword [ebp + 0x18]
mov edx, dword [esi + 0x10]
push ecx
push edx

Function at 0x404e33
Capabilities:
Check os version
Get number of processors
Resolve function by parsing pe exports

Disassembly:
sub eax, 0x58
je 0x40da5b

Function at 0x404fe7
Capabilities:
Authenticate hmac
Check os version
Encode data using base64
Encrypt data using speck
Get number of processors
Resolve function by parsing pe exports

Disassembly:
mov esi, ecx
call fcn.0041688f
mov dword [esi], 0x434678
mov eax, esi
pop esi
pop ebp
Function at 0x405985
Capabilities:
Check os version
Encrypt data using speck
Get number of processors
Resolve function by parsing pe exports

Disassembly:
je 0x40c525
dec eax
xor eax, dword [ebp - 0x38]

Function at 0x406074
Capabilities:
Check os version
Encrypt data using speck
Get number of processors
Resolve function by parsing pe exports

Disassembly:
mov ebx, ecx
mov edx, ecx
and ebx, 4
and edx, 0x41a1ac
mov dword [edx + 0xc], 0
and edx, ecx
add edi, 0x9701
mov esi, dword [ebp - 0x54]
xor dword [ebp - 0x48], edi
and word [ebp - 0x6c], 0xcad
mov ecx, dword [ebp - 0x68]
lea esi, [ecx + 0x10]
mov dword [ebp - 0x54], esi
or ebx, esi
mov byte [ebp - 0x1c], 0x92
mov eax, dword [ebp - 0x54]
add dword [ebp - 0x64], eax
cmp dword [ebp - 0x3c], 0x1c
jne 0x4060c3

Function at 0x4060bd
Capabilities:
Check os version
Encrypt data using speck
Get number of processors
Resolve function by parsing pe exports

Disassembly:
mov eax, dword [ebp - 0x1b8]
mov dword [eax], 0x2a2a42e9
mov esi, dword [ebp - 0x54]
lea eax, [edx + edi*2 + 0x1d95]
or ebx, ecx
mov dword [esi + 4], 0xb0447394
xor esi, dword [ebp - 0x38]
add dword [ebp - 0x5c], esi
mov esi, dword [ebp - 0x54]
and edi, esi
and ecx, dword [ebp - 0x2c]
mov dword [esi + 8], 0
mov byte [ebp - 0x44], 0x19
cmp dword [ebp - 0x28], 0x7d
jne 0x406116
mov byte [ebp - 4], 0xb
call eax
push eax
push 0x41a1d1
push esi
call fcn.00408d1e
cmp dword [ebp - 0x3c], 0x58
jne 0x40613b
push dword [esi + 0xf8]
call fcn.00406eda
push dword [esi + 0xfc]
call fcn.00411f9c
push dword [esi + 0x100]
mov ecx, dword [ebp - 0x54]
xor dword [ebp - 0x44], edx
add ebx, eax
mov ebx, dword [ebp - 0x68]
xor edi, dword [ebp - 0x44]
cmp dword [ebp - 0x3c], 0x400002
jne 0x40615d