joyce8/EMBER2024-capa huggingface dataset:
Function at 0x4d3178
Capabilities:
Encode data using base64

Disassembly:
push ebx
push esi
push edi
add esp, 0xfffffff4
mov dword [esp + 4], ecx
mov dword [esp], edx
mov esi, eax
mov eax, dword [esp]
mov dword [esp + 8], eax
xor ebx, ebx
xor ecx, ecx
mov eax, dword [esp + 4]
mov edx, 0x55555556
imul edx
mov eax, edx
shr eax, 0x1f
add eax, edx
test eax, eax
jle 0x4d323b
mov edx, dword [esp + 8]
lea edi, [edx + ecx]
movzx edx, byte [esi + ebx]
shr edx, 2
movzx edx, byte [edx + str.ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_]
mov byte [edi], dl
movzx edx, byte [esi + ebx]
and dl, 3
movzx edx, dl
shl edx, 4
movzx edi, byte [esi + ebx + 1]
shr edi, 4
add edx, edi
movzx edx, byte [edx + str.ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_]
mov edi, dword [esp + 8]
mov byte [edi + ecx + 1], dl
movzx edx, byte [esi + ebx + 1]
and dl, 0xf
movzx edx, dl
shl edx, 2
movzx edi, byte [esi + ebx + 2]
shr edi, 6
add edx, edi
movzx edx, byte [edx + str.ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_]
mov edi, dword [esp + 8]
mov byte [edi + ecx + 2], dl
mov edx, dword [esp + 8]
lea edx, [edx + ecx + 3]
push edx
movzx edx, byte [esi + ebx + 2]
and dl, 0x3f
movzx edx, dl
movzx edx, byte [edx + str.ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_]
pop edi
mov byte [edi], dl
add ecx, 4
add ebx, 3
dec eax
jne 0x4d31ac
mov edi, dword [esp + 4]
mov eax, 0x55555556
imul edi
mov eax, edx
shr eax, 0x1f
add edx, eax
lea edx, [edx + edx*2]
sub edi, edx
dec edi
je 0x4d325d
dec edi
je 0x4d32a2
jmp 0x4d3302
mov eax, dword [esp + 8]
movzx edx, byte [esi + ebx]
shr edx, 2
movzx edx, byte [edx + str.ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_]
mov byte [eax + ecx], dl
mov eax, dword [esp + 8]
movzx edx, byte [esi + ebx]
and dl, 3
movzx edx, dl
shl edx, 4
movzx edx, byte [edx + str.ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_]
mov byte [eax + ecx + 1], dl
mov eax, dword [esp + 8]
mov byte [eax + ecx + 2], 0x3d
mov eax, dword [esp + 8]
mov byte [eax + ecx + 3], 0x3d
jmp 0x4d3302
mov eax, dword [esp + 8]
movzx edx, byte [esi + ebx]
shr edx, 2
movzx edx, byte [edx + str.ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_]
mov byte [eax + ecx], dl
movzx eax, byte [esi + ebx]
and al, 3
movzx eax, al
shl eax, 4
movzx edx, byte [esi + ebx + 1]
shr edx, 4
add eax, edx
movzx eax, byte [eax + str.ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_]
mov edx, dword [esp + 8]
mov byte [edx + ecx + 1], al
mov eax, dword [esp + 8]
movzx edx, byte [esi + ebx + 1]
and dl, 0xf
movzx edx, dl
shl edx, 2
movzx edx, byte [edx + str.ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_]
mov byte [eax + ecx + 2], dl
mov eax, dword [esp + 8]
mov byte [eax + ecx + 3], 0x3d
mov eax, dword [esp + 4]
add eax, 2
mov edx, 0x55555556
imul edx
mov eax, edx
shr eax, 0x1f
add eax, edx
shl eax, 2
add esp, 0xc
pop edi
pop esi
pop ebx
ret
Function at 0x4d337c
Capabilities:
Encode data using base64

Disassembly:
push esi
push edi
push ebp
add esp, 0xfffffff0
mov dword [esp], ecx
mov edi, eax
mov dword [esp + 8], edx
xor esi, esi
xor ebp, ebp
xor eax, eax
mov edx, dword [esp]
test edx, edx
jns 0x4d339b
add edx, 3
sar edx, 2
test edx, edx
jle 0x4d34a8
mov dword [esp + 0xc], edx
mov edx, 4
lea eax, [esp + 4]
movzx ecx, byte [edi + esi]
cmp ecx, 0x3d
jg 0x4d33d0
je 0x4d3413
sub ecx, 0x2b
je 0x4d3409
sub ecx, 4
je 0x4d340e
dec ecx
sub ecx, 0xa
jb 0x4d33fb
jmp 0x4d3416
add ecx, 0xffffffbf
sub ecx, 0x1a
jb 0x4d33e2
add ecx, 0xfffffffa
sub ecx, 0x1a
jb 0x4d33ed
jmp 0x4d3416
movzx ecx, byte [edi + esi]
sub cl, 0x41
mov byte [eax], cl
jmp 0x4d3416
movzx ecx, byte [edi + esi]
sub cl, 0x61
add cl, 0x1a
mov byte [eax], cl
jmp 0x4d3416
movzx ecx, byte [edi + esi]
sub cl, 0x30
add cl, 0x34
mov byte [eax], cl
jmp 0x4d3416
mov byte [eax], 0x3e
jmp 0x4d3416
mov byte [eax], 0x3f
jmp 0x4d3416
mov byte [eax], 0xff
inc esi
inc eax
dec edx
jne 0x4d33b3
movzx eax, byte [esp + 4]
shl eax, 2
movzx edx, byte [esp + 5]
shr edx, 4
or al, dl
mov edx, dword [esp + 8]
mov byte [edx + ebp], al
lea eax, [ebp + 1]
movzx edx, byte [esp + 6]
cmp dl, 0xff
je 0x4d3466
cmp byte [esp + 7], 0xff
jne 0x4d3466
movzx eax, byte [esp + 5]
shl eax, 4
movzx edx, dl
shr edx, 2
or al, dl
mov edx, dword [esp + 8]
mov byte [edx + ebp + 1], al
lea eax, [ebp + 2]
inc ebp
jmp 0x4d349d
cmp dl, 0xff
je 0x4d349d
movzx eax, byte [esp + 5]
shl eax, 4
movzx edx, dl
shr edx, 2
or al, dl
mov edx, dword [esp + 8]
mov byte [edx + ebp + 1], al
mov eax, dword [esp + 8]
movzx edx, byte [esp + 6]
shl edx, 6
or dl, byte [esp + 7]
mov byte [eax + ebp + 2], dl
lea eax, [ebp + 3]
add ebp, 2
inc ebp
dec dword [esp + 0xc]
jne 0x4d33aa
add esp, 0x10
pop ebp
pop edi
pop esi
ret
Function at 0x4d9320
Capabilities:
Set file attributes

Disassembly:
push ebp
mov ebp, esp
add esp, 0xfffffd84
push ebx
push esi
push edi
xor eax, eax
mov dword [ebp - 0x27c], eax
mov dword [ebp - 0x274], eax
mov dword [ebp - 0x278], eax
lea eax, [ebp - 0x270]
mov edx, dword [0x419cac]
call fcn.0040b19c
xor eax, eax
push ebp
push 0x4d94ce
push dword fs:[eax]
mov dword fs:[eax], esp
lea eax, [ebp - 0x278]
call fcn.004d9028
lea eax, [ebp - 0x278]
mov edx, 0x4d94ec
call fcn.0040ae2c
mov eax, dword [ebp - 0x278]
call fcn.0040ac38
mov edx, eax
lea eax, [ebp - 0x274]
call fcn.0040ac98
mov eax, dword [ebp - 0x274]
mov edx, 0x4d9510
call fcn.004d90d0
push 0
push 0
mov eax, dword [0x4ed9bc]
call fcn.00469480
mov dl, 1
mov eax, dword [0x4486ac]
call fcn.00408318
mov ebx, eax
mov edx, dword [0x4ed9bc]
mov eax, ebx
call fcn.0046b8a8
push 0
push 0
mov eax, ebx
call fcn.00469480
mov eax, ebx
mov edx, dword [eax]
call dword [edx + 0xc]
mov dword [0x4ed9b4], eax
mov eax, dword [0x4ed9b4]
push eax
call fcn.00410138
pop ecx
mov dword [0x4ed9b0], eax
mov edx, dword [0x4ed9b0]
mov ecx, dword [0x4ed9b4]
mov eax, ebx
mov edi, dword [eax]
call dword [edi + 0x18]
mov eax, ebx
call fcn.00408348
mov eax, dword [0x4ed9b4]
cdq
push edx
push eax
mov cl, 1
mov dl, 0x11
mov eax, dword [0x4ed9b0]
call fcn.004d2b40
mov dword [0x4ed9b8], eax
cmp dword [0x4ed9b8], 0
je 0x4d943b
mov eax, dword [0x4ed9b8]
call fcn.004d3038
lea eax, [ebp - 0x27c]
call fcn.004d9028
lea eax, [ebp - 0x27c]
mov edx, 0x4d9520
call fcn.0040ae2c
mov eax, dword [ebp - 0x27c]
lea ecx, [ebp - 0x270]
mov edx, 0x1ff
call fcn.00421f18
test eax, eax
jne 0x4d9492
push 6
mov eax, dword [ebp - 0x25c]
call fcn.0040ac38
push eax
call sub.kernel32.dll_SetFileAttributesW
lea eax, [ebp - 0x270]
call fcn.00421f68
test eax, eax
je 0x4d9470
lea eax, [ebp - 0x270]
call fcn.00421f8c
xor eax, eax
pop edx
pop ecx
pop ecx
mov dword fs:[eax], edx
push 0x4d94d5
lea eax, [ebp - 0x27c]
mov edx, 3
call fcn.0040a1ec
lea eax, [ebp - 0x270]
mov edx, dword [0x419cac]
call fcn.0040b588
pop eax
jmp eax
Function at 0x10003bf0
Capabilities:
Contain obfuscated stackstrings
Create thread

Disassembly:
push ebp
mov ebp, esp
sub esp, 0x38
mov dword [ebp - 0x38], ecx
jmp 0x10003c0b
push 0
push 0
push 0
push 0x10003be0
push 0
push 0
call sub.MSVCR90.dll__beginthreadex
add esp, 0x18
mov dword [ebp - 4], eax
cmp dword [ebp - 4], 0
jne 0x10003d12
mov byte [ebp - 0x34], 0x45
mov byte [ebp - 0x33], 0x52
mov byte [ebp - 0x32], 0x52
mov byte [ebp - 0x31], 0x4f
mov byte [ebp - 0x30], 0x52
mov byte [ebp - 0x2f], 0x21
mov byte [ebp - 0x2e], 0x20
mov byte [ebp - 0x2d], 0x54
mov byte [ebp - 0x2c], 0x68
mov byte [ebp - 0x2b], 0x72
mov byte [ebp - 0x2a], 0x65
mov byte [ebp - 0x29], 0x61
mov byte [ebp - 0x28], 0x64
mov byte [ebp - 0x27], 0x20
mov byte [ebp - 0x26], 0x63
mov byte [ebp - 0x25], 0x72
mov byte [ebp - 0x24], 0x65
mov byte [ebp - 0x23], 0x61
mov byte [ebp - 0x22], 0x74
mov byte [ebp - 0x21], 0x69
mov byte [ebp - 0x20], 0x6f
mov byte [ebp - 0x1f], 0x6e
mov byte [ebp - 0x1e], 0x20
mov byte [ebp - 0x1d], 0x66
mov byte [ebp - 0x1c], 0x61
mov byte [ebp - 0x1b], 0x69
mov byte [ebp - 0x1a], 0x6c
mov byte [ebp - 0x19], 0x65
mov byte [ebp - 0x18], 0x64
mov byte [ebp - 0x17], 0x2c
mov byte [ebp - 0x16], 0x20
mov byte [ebp - 0x15], 0x54
mov byte [ebp - 0x14], 0x68
mov byte [ebp - 0x13], 0x72
mov byte [ebp - 0x12], 0x65
mov byte [ebp - 0x11], 0x61
mov byte [ebp - 0x10], 0x64
mov byte [ebp - 0xf], 0x20
mov byte [ebp - 0xe], 0x43
mov byte [ebp - 0xd], 0x6f
mov byte [ebp - 0xc], 0x64
mov byte [ebp - 0xb], 0x65
mov byte [ebp - 0xa], 0x20
mov byte [ebp - 9], 0x30
mov byte [ebp - 8], 0x78
mov byte [ebp - 7], 0x38
mov byte [ebp - 6], 0x21
mov byte [ebp - 5], 0
mov ecx, dword [0x1007f370]
call fcn.100014a0
push eax
push 0
lea eax, [ebp - 0x34]
push eax
push 0
lea ecx, [ebp - 0x34]
push ecx
mov ecx, dword [0x1007f374]
call fcn.1000f4e0
jmp 0x10003d24
mov eax, dword [ebp - 4]
mov esp, ebp
pop ebp
ret

Function at 0x10003ef0
Capabilities:
Encrypt data using rc4 prga

Disassembly:
push ebp
mov ebp, esp
sub esp, 0xc
mov dword [ebp - 0xc], ecx
mov dword [ebp - 4], 0x6a
mov dword [ebp - 8], 0
jmp 0x10003f12
mov eax, dword [ebp - 8]
add eax, 1
mov dword [ebp - 8], eax
cmp dword [ebp - 8], 0x29
jge 0x10003f51
mov ecx, dword [ebp + 8]
add ecx, dword [ebp - 8]
movsx edx, byte [ecx + 0x10ff3b30]
xor edx, dword [ebp - 4]
mov eax, dword [ebp - 0xc]
add eax, dword [ebp - 8]
mov byte [eax], dl
mov ecx, dword [ebp - 4]
add ecx, 1
mov dword [ebp - 4], ecx
mov edx, dword [ebp - 4]
and edx, 0x800000ff
jns 0x10003f4c
dec edx
or edx, 0xffffff00
inc edx
mov dword [ebp - 4], edx
jmp 0x10003f09
mov eax, dword [ebp - 0xc]
mov byte [eax + 0x29], 0
mov eax, dword [ebp - 0xc]
mov esp, ebp
pop ebp
ret 4
Function at 0x10003f70
Capabilities:
Encrypt data using rc4 prga

Disassembly:
push ebp
mov ebp, esp
sub esp, 0xc
mov dword [ebp - 0xc], ecx
mov dword [ebp - 4], 0x88
mov dword [ebp - 8], 0
jmp 0x10003f92
mov eax, dword [ebp - 8]
add eax, 1
mov dword [ebp - 8], eax
cmp dword [ebp - 8], 0x2b
jge 0x10003fd1
mov ecx, dword [ebp + 8]
add ecx, dword [ebp - 8]
movsx edx, byte [ecx + 0x732d4b64]
xor edx, dword [ebp - 4]
mov eax, dword [ebp - 0xc]
add eax, dword [ebp - 8]
mov byte [eax], dl
mov ecx, dword [ebp - 4]
add ecx, 1
mov dword [ebp - 4], ecx
mov edx, dword [ebp - 4]
and edx, 0x800000ff
jns 0x10003fcc
dec edx
or edx, 0xffffff00
inc edx
mov dword [ebp - 4], edx
jmp 0x10003f89
mov eax, dword [ebp - 0xc]
mov byte [eax + 0x2b], 0
mov eax, dword [ebp - 0xc]
mov esp, ebp
pop ebp
ret 4

Function at 0x10003ff0
Capabilities:
Encrypt data using rc4 prga

Disassembly:
push ebp
mov ebp, esp
sub esp, 0xc
mov dword [ebp - 0xc], ecx
mov dword [ebp - 4], 0x6e
mov dword [ebp - 8], 0
jmp 0x10004012
mov eax, dword [ebp - 8]
add eax, 1
mov dword [ebp - 8], eax
cmp dword [ebp - 8], 0x26
jge 0x10004051
mov ecx, dword [ebp + 8]
add ecx, dword [ebp - 8]
movsx edx, byte [ecx - 0x60d280bc]
xor edx, dword [ebp - 4]
mov eax, dword [ebp - 0xc]
add eax, dword [ebp - 8]
mov byte [eax], dl
mov ecx, dword [ebp - 4]
add ecx, 1
mov dword [ebp - 4], ecx
mov edx, dword [ebp - 4]
and edx, 0x800000ff
jns 0x1000404c
dec edx
or edx, 0xffffff00
inc edx
mov dword [ebp - 4], edx
jmp 0x10004009
mov eax, dword [ebp - 0xc]
mov byte [eax + 0x26], 0
mov eax, dword [ebp - 0xc]
mov esp, ebp
pop ebp
ret 4

Function at 0x10004070
Capabilities:
Encrypt data using rc4 prga

Disassembly:
push ebp
mov ebp, esp
sub esp, 0xc
mov dword [ebp - 0xc], ecx
mov dword [ebp - 4], 0x11
mov dword [ebp - 8], 0
jmp 0x10004092
mov eax, dword [ebp - 8]
add eax, 1
mov dword [ebp - 8], eax
cmp dword [ebp - 8], 0x2c
jge 0x100040d1
mov ecx, dword [ebp + 8]
add ecx, dword [ebp - 8]
movsx edx, byte [ecx + 0x55e3c3ab]
xor edx, dword [ebp - 4]
mov eax, dword [ebp - 0xc]
add eax, dword [ebp - 8]
mov byte [eax], dl
mov ecx, dword [ebp - 4]
add ecx, 1
mov dword [ebp - 4], ecx
mov edx, dword [ebp - 4]
and edx, 0x800000ff
jns 0x100040cc
dec edx
or edx, 0xffffff00
inc edx
mov dword [ebp - 4], edx
jmp 0x10004089
mov eax, dword [ebp - 0xc]
mov byte [eax + 0x2c], 0
mov eax, dword [ebp - 0xc]
mov esp, ebp
pop ebp
ret 4

Function at 0x100040f0
Capabilities:
Encrypt data using rc4 prga

Disassembly:
push ebp
mov ebp, esp
sub esp, 0xc
mov dword [ebp - 0xc], ecx
mov dword [ebp - 4], 0x8f
mov dword [ebp - 8], 0
jmp 0x10004112
mov eax, dword [ebp - 8]
add eax, 1
mov dword [ebp - 8], eax
cmp dword [ebp - 8], 0xa
jge 0x10004151
mov ecx, dword [ebp + 8]
add ecx, dword [ebp - 8]
movsx edx, byte [ecx + 0x5e301c7e]
xor edx, dword [ebp - 4]
mov eax, dword [ebp - 0xc]
add eax, dword [ebp - 8]
mov byte [eax], dl
mov ecx, dword [ebp - 4]
add ecx, 1
mov dword [ebp - 4], ecx
mov edx, dword [ebp - 4]
and edx, 0x800000ff
jns 0x1000414c
dec edx
or edx, 0xffffff00
inc edx
mov dword [ebp - 4], edx
jmp 0x10004109
mov eax, dword [ebp - 0xc]
mov byte [eax + 0xa], 0
mov eax, dword [ebp - 0xc]
mov esp, ebp
pop ebp
ret 4
Function at 0x10004190
Capabilities:
Encrypt data using rc4 prga

Disassembly:
push ebp
mov ebp, esp
sub esp, 0xc
mov dword [ebp - 0xc], ecx
mov dword [ebp - 4], 0xac
mov dword [ebp - 8], 0
jmp 0x100041b2
mov eax, dword [ebp - 8]
add eax, 1
mov dword [ebp - 8], eax
cmp dword [ebp - 8], 9
jge 0x100041f1
mov ecx, dword [ebp + 8]
add ecx, dword [ebp - 8]
movsx edx, byte [ecx - 0x2472d89b]
xor edx, dword [ebp - 4]
mov eax, dword [ebp - 0xc]
add eax, dword [ebp - 8]
mov byte [eax], dl
mov ecx, dword [ebp - 4]
add ecx, 1
mov dword [ebp - 4], ecx
mov edx, dword [ebp - 4]
and edx, 0x800000ff
jns 0x100041ec
dec edx
or edx, 0xffffff00
inc edx
mov dword [ebp - 4], edx
jmp 0x100041a9
mov eax, dword [ebp - 0xc]
mov byte [eax + 9], 0
mov eax, dword [ebp - 0xc]
mov esp, ebp
pop ebp
ret 4

Function at 0x10004210
Capabilities:
Encrypt data using rc4 prga

Disassembly:
push ebp
mov ebp, esp
sub esp, 0xc
mov dword [ebp - 0xc], ecx
mov dword [ebp - 4], 0x34
mov dword [ebp - 8], 0
jmp 0x10004232
mov eax, dword [ebp - 8]
add eax, 1
mov dword [ebp - 8], eax
cmp dword [ebp - 8], 0x12
jge 0x10004271
mov ecx, dword [ebp + 8]
add ecx, dword [ebp - 8]
movsx edx, byte [ecx - 0x5392584]
xor edx, dword [ebp - 4]
mov eax, dword [ebp - 0xc]
add eax, dword [ebp - 8]
mov byte [eax], dl
mov ecx, dword [ebp - 4]
add ecx, 1
mov dword [ebp - 4], ecx
mov edx, dword [ebp - 4]
and edx, 0x800000ff
jns 0x1000426c
dec edx
or edx, 0xffffff00
inc edx
mov dword [ebp - 4], edx
jmp 0x10004229
mov eax, dword [ebp - 0xc]
mov byte [eax + 0x12], 0
mov eax, dword [ebp - 0xc]
mov esp, ebp
pop ebp
ret 4
Function at 0x100057d0
Capabilities:
Contain obfuscated stackstrings

Disassembly:
push ebp
mov ebp, esp
sub esp, 0x438
mov dword [ebp - 0x438], ecx
mov dword [ebp - 0x434], 0
lea eax, [ebp - 0x30]
push eax
call dword [sym.imp.KERNEL32.dll_GetLocalTime]
mov byte [ebp - 0x20], 0x25
mov byte [ebp - 0x1f], 0x30
mov byte [ebp - 0x1e], 0x32
mov byte [ebp - 0x1d], 0x64
mov byte [ebp - 0x1c], 0x3a
mov byte [ebp - 0x1b], 0x25
mov byte [ebp - 0x1a], 0x30
mov byte [ebp - 0x19], 0x32
mov byte [ebp - 0x18], 0x64
mov byte [ebp - 0x17], 0x3a
mov byte [ebp - 0x16], 0x25
mov byte [ebp - 0x15], 0x30
mov byte [ebp - 0x14], 0x32
mov byte [ebp - 0x13], 0x64
mov byte [ebp - 0x12], 0x20
mov byte [ebp - 0x11], 0x2d
mov byte [ebp - 0x10], 0x20
mov byte [ebp - 0xf], 0x25
mov byte [ebp - 0xe], 0x30
mov byte [ebp - 0xd], 0x32
mov byte [ebp - 0xc], 0x64
mov byte [ebp - 0xb], 0x2f
mov byte [ebp - 0xa], 0x25
mov byte [ebp - 9], 0x30
mov byte [ebp - 8], 0x32
mov byte [ebp - 7], 0x64
mov byte [ebp - 6], 0x2f
mov byte [ebp - 5], 0x25
mov byte [ebp - 4], 0x64
mov byte [ebp - 3], 0x20
mov byte [ebp - 2], 0x20
mov byte [ebp - 1], 0
movzx ecx, word [ebp - 0x30]
push ecx
movzx edx, word [ebp - 0x2e]
push edx
movzx eax, word [ebp - 0x2a]
push eax
movzx ecx, word [ebp - 0x24]
push ecx
movzx edx, word [ebp - 0x26]
push edx
movzx eax, word [ebp - 0x28]
push eax
lea ecx, [ebp - 0x20]
push ecx
push 0x2000
lea edx, [ebp - 0x430]
push edx
call fcn.1003dbf0
add esp, 0x24
lea eax, [ebp - 0x430]
push eax
mov ecx, dword [ebp + 8]
call fcn.100014e0
mov ecx, dword [ebp - 0x434]
or ecx, 1
mov dword [ebp - 0x434], ecx
mov eax, dword [ebp + 8]
mov esp, ebp
pop ebp
ret 4

Function at 0x10005960
Capabilities:
Print debug messages

Disassembly:
push ebp
mov ebp, esp
push 0xffffffffffffffff
push 0x10040c6b
mov eax, dword fs:[0]
push eax
mov dword fs:[0], esp
mov eax, 0x3f6c
call fcn.1003d970
lea eax, [ebp + 0x14]
mov dword [ebp - 0x10], eax
mov ecx, dword [ebp - 0x10]
push ecx
mov edx, dword [ebp + 0x10]
push edx
push 0x2000
lea eax, [ebp - 0x1f54]
push eax
call fcn.1003dc20
add esp, 0x10
mov dword [ebp - 0x10], 0
lea ecx, [ebp - 0x3f70]
push ecx
mov ecx, dword [ebp + 8]
call fcn.100057d0
mov dword [ebp - 0x3f74], eax
mov edx, dword [ebp - 0x3f74]
mov dword [ebp - 0x3f78], edx
mov dword [ebp - 4], 0
lea eax, [ebp - 0x1f54]
push eax
mov ecx, dword [ebp - 0x3f78]
call fcn.10001580
push eax
push str._Time__s_n_s
push 0x2000
lea ecx, [ebp - 0x3f54]
push ecx
call fcn.1003dbf0
add esp, 0x14
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x3f70]
call fcn.10001560
lea edx, [ebp - 0x3f54]
push edx
call dword [sym.imp.KERNEL32.dll_OutputDebugStringA]
mov ecx, dword [ebp - 0xc]
mov dword fs:[0], ecx
mov esp, ebp
pop ebp
ret
Function at 0x100077f0
Capabilities:
Write file on windows

Disassembly:
push ebp
mov ebp, esp
push 0xffffffffffffffff
push 0x10040a78
mov eax, dword fs:[0]
push eax
mov dword fs:[0], esp
sub esp, 0x5c
push esi
mov dword [ebp - 0x64], ecx
mov eax, dword [ebp - 0x64]
cmp dword [eax + 0x3c], 0
je 0x10007823
mov ecx, dword [ebp - 0x64]
movzx edx, byte [ecx + 0x41]
test edx, edx
jne 0x1000782f
mov al, 1
jmp 0x100079d2
mov dword [ebp - 0x10], 8
call fcn.100045a0
push eax
mov eax, dword [ebp - 0x64]
mov edx, dword [eax]
mov ecx, dword [ebp - 0x64]
mov eax, dword [edx + 4]
call eax
mov dword [ebp - 0x38], eax
call fcn.100045a0
mov dword [ebp - 0x3c], eax
lea ecx, [ebp - 0x38]
push ecx
lea edx, [ebp - 0x3c]
push edx
call fcn.10004580
add esp, 8
movzx eax, al
test eax, eax
je 0x10007872
xor al, al
jmp 0x100079d2
push 0
push 8
lea ecx, [ebp - 0x30]
call fcn.10007100
mov dword [ebp - 4], 0
lea ecx, [ebp - 0x14]
push ecx
lea edx, [ebp - 0x44]
push edx
lea ecx, [ebp - 0x30]
call fcn.100034a0
mov ecx, eax
call fcn.10007d60
mov esi, eax
lea ecx, [ebp - 0x30]
call fcn.100015a0
add esi, eax
push esi
lea eax, [ebp - 0x4c]
push eax
lea ecx, [ebp - 0x30]
call fcn.100034a0
mov ecx, eax
call fcn.10007d60
push eax
mov ecx, dword [ebp - 0x64]
add ecx, 0x44
push ecx
mov edx, dword [ebp - 0x64]
mov ecx, dword [edx + 0x3c]
call fcn.100081d0
mov dword [ebp - 0x68], eax
cmp dword [ebp - 0x68], 0
je 0x100078ed
cmp dword [ebp - 0x68], 1
je 0x100078f4
cmp dword [ebp - 0x68], 3
je 0x1000798e
jmp 0x100079a6
mov eax, dword [ebp - 0x64]
mov byte [eax + 0x41], 0
lea ecx, [ebp - 0x54]
push ecx
lea ecx, [ebp - 0x30]
call fcn.100034a0
mov ecx, eax
call fcn.10007d60
mov edx, dword [ebp - 0x14]
sub edx, eax
mov dword [ebp - 0x34], edx
je 0x10007957
mov eax, dword [ebp - 0x64]
mov ecx, dword [eax + 0x4c]
push ecx
mov edx, dword [ebp - 0x34]
push edx
push 1
lea eax, [ebp - 0x5c]
push eax
lea ecx, [ebp - 0x30]
call fcn.100034a0
mov ecx, eax
call fcn.10007d60
push eax
call sub.MSVCR90.dll_fwrite
add esp, 0x10
cmp dword [ebp - 0x34], eax
je 0x10007957
mov byte [ebp - 0x5d], 0
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x30]
call fcn.10001560
mov al, byte [ebp - 0x5d]
jmp 0x100079d2
mov ecx, dword [ebp - 0x64]
movzx edx, byte [ecx + 0x41]
test edx, edx
jne 0x1000797a
mov byte [ebp - 0x5e], 1
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x30]
call fcn.10001560
mov al, byte [ebp - 0x5e]
jmp 0x100079d2
cmp dword [ebp - 0x34], 0
jne 0x1000798c
push 0
push 8
lea ecx, [ebp - 0x30]
call fcn.10007140
jmp 0x100079be
mov byte [ebp - 0x5f], 1
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x30]
call fcn.10001560
mov al, byte [ebp - 0x5f]
jmp 0x100079d2
mov byte [ebp - 0x60], 0
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x30]
call fcn.10001560
mov al, byte [ebp - 0x60]
jmp 0x100079d2
jmp 0x10007885
mov ecx, dword [ebp - 0xc]
mov dword fs:[0], ecx
pop esi
mov esp, ebp
pop ebp
ret
Function at 0x1000adc0
Capabilities:
Contain obfuscated stackstrings
Create thread

Disassembly:
push ebp
mov ebp, esp
sub esp, 0x3c
mov dword [ebp - 0x3c], ecx
jmp 0x1000addb
push 0
push 0
push 0
push 0x1000adb0
push 0
push 0
call sub.MSVCR90.dll__beginthreadex
add esp, 0x18
mov dword [ebp - 4], eax
cmp dword [ebp - 4], 0
jne 0x1000aee6
mov byte [ebp - 0x38], 0x45
mov byte [ebp - 0x37], 0x52
mov byte [ebp - 0x36], 0x52
mov byte [ebp - 0x35], 0x4f
mov byte [ebp - 0x34], 0x52
mov byte [ebp - 0x33], 0x21
mov byte [ebp - 0x32], 0x20
mov byte [ebp - 0x31], 0x54
mov byte [ebp - 0x30], 0x68
mov byte [ebp - 0x2f], 0x72
mov byte [ebp - 0x2e], 0x65
mov byte [ebp - 0x2d], 0x61
mov byte [ebp - 0x2c], 0x64
mov byte [ebp - 0x2b], 0x20
mov byte [ebp - 0x2a], 0x63
mov byte [ebp - 0x29], 0x72
mov byte [ebp - 0x28], 0x65
mov byte [ebp - 0x27], 0x61
mov byte [ebp - 0x26], 0x74
mov byte [ebp - 0x25], 0x69
mov byte [ebp - 0x24], 0x6f
mov byte [ebp - 0x23], 0x6e
mov byte [ebp - 0x22], 0x20
mov byte [ebp - 0x21], 0x66
mov byte [ebp - 0x20], 0x61
mov byte [ebp - 0x1f], 0x69
mov byte [ebp - 0x1e], 0x6c
mov byte [ebp - 0x1d], 0x65
mov byte [ebp - 0x1c], 0x64
mov byte [ebp - 0x1b], 0x2c
mov byte [ebp - 0x1a], 0x20
mov byte [ebp - 0x19], 0x54
mov byte [ebp - 0x18], 0x68
mov byte [ebp - 0x17], 0x72
mov byte [ebp - 0x16], 0x65
mov byte [ebp - 0x15], 0x61
mov byte [ebp - 0x14], 0x64
mov byte [ebp - 0x13], 0x20
mov byte [ebp - 0x12], 0x43
mov byte [ebp - 0x11], 0x6f
mov byte [ebp - 0x10], 0x64
mov byte [ebp - 0xf], 0x65
mov byte [ebp - 0xe], 0x20
mov byte [ebp - 0xd], 0x30
mov byte [ebp - 0xc], 0x78
mov byte [ebp - 0xb], 0x31
mov byte [ebp - 0xa], 0x32
mov byte [ebp - 9], 0x21
mov byte [ebp - 8], 0
mov ecx, dword [0x1007f370]
call fcn.100014a0
push eax
push 0
lea eax, [ebp - 0x38]
push eax
push 0
lea ecx, [ebp - 0x38]
push ecx
mov ecx, dword [0x1007f374]
call fcn.1000f4e0
jmp 0x1000aef8
mov eax, dword [ebp - 4]
mov esp, ebp
pop ebp
ret

Function at 0x1000af00
Capabilities:
Encrypt data using rc4 prga

Disassembly:
push ebp
mov ebp, esp
sub esp, 0xc
mov dword [ebp - 0xc], ecx
mov dword [ebp - 4], 0xd9
mov dword [ebp - 8], 0
jmp 0x1000af22
mov eax, dword [ebp - 8]
add eax, 1
mov dword [ebp - 8], eax
cmp dword [ebp - 8], 5
jge 0x1000af61
mov ecx, dword [ebp + 8]
add ecx, dword [ebp - 8]
movsx edx, byte [ecx + 0x3a94b1e3]
xor edx, dword [ebp - 4]
mov eax, dword [ebp - 0xc]
add eax, dword [ebp - 8]
mov byte [eax], dl
mov ecx, dword [ebp - 4]
add ecx, 1
mov dword [ebp - 4], ecx
mov edx, dword [ebp - 4]
and edx, 0x800000ff
jns 0x1000af5c
dec edx
or edx, 0xffffff00
inc edx
mov dword [ebp - 4], edx
jmp 0x1000af19
mov eax, dword [ebp - 0xc]
mov byte [eax + 5], 0
mov eax, dword [ebp - 0xc]
mov esp, ebp
pop ebp
ret 4