joyce8/EMBER2024-capa huggingface dataset:
Function at 0x462b90
Capabilities:
Check for time delay via gettickcount
Query service status
Stop service

Disassembly:
push ebp
mov ebp, esp
push 0xffffffffffffffff
push 0x56fe20
mov eax, dword fs:[0]
push eax
sub esp, 0x28
mov eax, dword [0x5c125c]
xor eax, ebp
mov dword [ebp - 0x10], eax
push esi
push edi
push eax
lea eax, [ebp - 0xc]
mov dword fs:[0], eax
mov esi, ecx
push 0xf003f
push 0
push 0
call dword [sym.imp.ADVAPI32.dll_OpenSCManagerW]
mov edi, eax
mov dword [ebp - 0x34], edi
mov dword [ebp - 4], 0
test edi, edi
jne 0x462bf6
call dword [sym.imp.KERNEL32.dll_GetLastError]
test eax, eax
jle 0x462cfe
movzx eax, ax
or eax, 0x80070000
jmp 0x462cfe
push 0x24
push esi
push edi
call dword [sym.imp.ADVAPI32.dll_OpenServiceW]
mov esi, eax
mov dword [ebp - 0x30], esi
mov byte [ebp - 4], 1
test esi, esi
jne 0x462c2e
call dword [sym.imp.KERNEL32.dll_GetLastError]
mov dword [ebp - 0x30], eax
test eax, eax
jle 0x462ce7
movzx eax, ax
or eax, 0x80070000
mov dword [ebp - 0x30], eax
jmp 0x462ce7
lea eax, [ebp - 0x2c]
mov dword [ebp - 0x2c], 0
xorps xmm0, xmm0
push eax
push esi
movups xmmword [ebp - 0x28], xmm0
movq qword [ebp - 0x18], xmm0
call dword [sym.imp.ADVAPI32.dll_QueryServiceStatus]
test eax, eax
je 0x462c9f
mov eax, dword [ebp - 0x28]
cmp eax, 1
je 0x462ce0
cmp eax, 3
je 0x462ca2
lea eax, [ebp - 0x2c]
mov dword [ebp - 0x14], 0
push eax
xorps xmm0, xmm0
push 1
push esi
movups xmmword [ebp - 0x2c], xmm0
movq qword [ebp - 0x1c], xmm0
call dword [sym.imp.ADVAPI32.dll_ControlService]
test eax, eax
jne 0x462c9f
call dword [sym.imp.KERNEL32.dll_GetLastError]
mov dword [ebp - 0x30], eax
test eax, eax
jle 0x462ce7
movzx eax, ax
or eax, 0x80070000
mov dword [ebp - 0x30], eax
jmp 0x462ce7
mov eax, dword [ebp - 0x28]
cmp eax, 1
je 0x462ce0
call dword [sym.imp.KERNEL32.dll_GetTickCount]
cmp dword [ebp - 0x28], 1
mov edi, eax
je 0x462cdd
call dword [sym.imp.KERNEL32.dll_GetTickCount]
sub eax, edi
cmp eax, 0x1f40
jae 0x462d19
push 0x32
call dword [sym.imp.KERNEL32.dll_Sleep]
lea eax, [ebp - 0x2c]
push eax
push esi
call dword [sym.imp.ADVAPI32.dll_QueryServiceStatus]
cmp dword [ebp - 0x28], 1
jne 0x462cb5
mov edi, dword [ebp - 0x34]
mov dword [ebp - 0x30], 0
mov eax, dword [sym.imp.ADVAPI32.dll_CloseServiceHandle]
test esi, esi
je 0x462cf8
push esi
call eax
mov eax, dword [sym.imp.ADVAPI32.dll_CloseServiceHandle]
push edi
call eax
mov eax, dword [ebp - 0x30]
mov ecx, dword [ebp - 0xc]
mov dword fs:[0], ecx
pop ecx
pop edi
pop esi
mov ecx, dword [ebp - 0x10]
xor ecx, ebp
call fcn.004fce93
mov esp, ebp
pop ebp
ret
cmp dword [ebp - 0x28], 1
je 0x462cdd
mov edi, dword [ebp - 0x34]
mov dword [ebp - 0x30], 0x800705b4
jmp 0x462ce7
Function at 0x462d30
Capabilities:
Create service
Persist via windows service

Disassembly:
push ebp
mov ebp, esp
push ebx
push esi
push edi
push 0xf003f
push 0
push 0
mov edi, edx
mov ebx, ecx
call dword [sym.imp.ADVAPI32.dll_OpenSCManagerW]
mov esi, eax
test esi, esi
jne 0x462d66
call dword [sym.imp.KERNEL32.dll_GetLastError]
test eax, eax
jle 0x462dbe
pop edi
movzx eax, ax
pop esi
or eax, 0x80070000
pop ebx
pop ebp
ret
push 0
push 0
push 0x5adf38
push 0
push 0
push dword [ebp + 8]
push 1
push 2
push dword [ebp + 0xc]
push 0xf01ff
push edi
push ebx
push esi
call dword [sym.imp.ADVAPI32.dll_CreateServiceW]
mov ebx, dword [sym.imp.ADVAPI32.dll_CloseServiceHandle]
test eax, eax
jne 0x462db4
call dword [sym.imp.KERNEL32.dll_GetLastError]
mov edi, eax
test edi, edi
jle 0x462db9
movzx edi, di
push esi
or edi, 0x80070000
call ebx
mov eax, edi
pop edi
pop esi
pop ebx
pop ebp
ret
push eax
xor edi, edi
call ebx
push esi
call ebx
mov eax, edi
pop edi
pop esi
pop ebx
pop ebp
ret
Function at 0x46dfd0
Capabilities:
Encode data using xor

Disassembly:
push ebp
mov ebp, esp
sub esp, 0x18
push ebx
push esi
mov esi, dword [ebp + 8]
mov eax, edx
push edi
mov edi, dword [ecx]
xor ebx, ebx
mov dword [ebp - 0x14], ecx
mov ecx, dword [esi]
mov edx, dword [esi + 8]
mov dword [ebp - 4], ecx
mov ecx, dword [esi + 4]
mov dword [ebp - 0xc], edx
mov edx, dword [esi + 0xc]
lea esi, [ebx + 0x10]
mov dword [ebp - 0x18], eax
mov eax, dword [eax]
mov dword [ebp - 0x10], ecx
mov dword [ebp - 8], edx
mov edx, eax
lea ebx, [ebx - 0x61c88647]
shr edx, 5
add edx, ecx
mov ecx, eax
shl ecx, 4
add ecx, dword [ebp - 4]
xor edx, ecx
lea ecx, [ebx + eax]
xor edx, ecx
add edi, edx
mov edx, edi
mov ecx, edi
shr edx, 5
add edx, dword [ebp - 8]
shl ecx, 4
add ecx, dword [ebp - 0xc]
xor edx, ecx
lea ecx, [ebx + edi]
xor edx, ecx
mov ecx, dword [ebp - 0x10]
add eax, edx
sub esi, 1
jne 0x46e004
mov ecx, dword [ebp - 0x14]
mov dword [ecx], edi
mov ecx, dword [ebp - 0x18]
pop edi
pop esi
pop ebx
mov dword [ecx], eax
mov esp, ebp
pop ebp
ret

Function at 0x46e060
Capabilities:
Encode data using xor
Encrypt data using tea

Disassembly:
push ebp
mov ebp, esp
sub esp, 0x18
push ebx
push esi
mov esi, dword [ebp + 8]
mov eax, edx
push edi
mov edi, dword [ecx]
mov ebx, 0xe3779b90
mov dword [ebp - 0x14], ecx
mov ecx, dword [esi + 8]
mov edx, dword [esi]
mov dword [ebp - 4], ecx
mov ecx, dword [esi + 0xc]
mov dword [ebp - 0xc], edx
mov edx, dword [esi + 4]
mov esi, 0x10
mov dword [ebp - 0x18], eax
mov eax, dword [eax]
mov dword [ebp - 0x10], ecx
mov dword [ebp - 8], edx
nop dword [eax]
mov edx, edi
shr edx, 5
add edx, ecx
mov ecx, edi
shl ecx, 4
add ecx, dword [ebp - 4]
xor edx, ecx
lea ecx, [edi + ebx]
xor edx, ecx
sub eax, edx
mov edx, eax
mov ecx, eax
shr edx, 5
add edx, dword [ebp - 8]
shl ecx, 4
add ecx, dword [ebp - 0xc]
xor edx, ecx
lea ecx, [eax + ebx]
xor edx, ecx
lea ebx, [ebx + 0x61c88647]
mov ecx, dword [ebp - 0x10]
sub edi, edx
sub esi, 1
jne 0x46e0a0
mov ecx, dword [ebp - 0x14]
mov dword [ecx], edi
mov ecx, dword [ebp - 0x18]
pop edi
pop esi
pop ebx
mov dword [ecx], eax
mov esp, ebp
pop ebp
ret
Function at 0x470100
Capabilities:
Hash data with md5

Disassembly:
push ebp
mov ebp, esp
push 0xffffffffffffffff
push 0x572793
mov eax, dword fs:[0]
push eax
sub esp, 0xac
mov eax, dword [0x5c125c]
xor eax, ebp
mov dword [ebp - 0x10], eax
push esi
push eax
lea eax, [ebp - 0xc]
mov dword fs:[0], eax
mov eax, ecx
mov esi, dword [ebp + 8]
mov edx, dword [ebp + 0xc]
mov dword [ebp - 0x9c], 0
mov dword [ebp - 0x14], 0xf
mov dword [ebp - 0x18], 0
mov byte [ebp - 0x28], 0
mov dword [ebp - 4], 0
mov ecx, dword [eax + 8]
cmp edx, ecx
jbe 0x47018d
lea eax, [ebp - 0x28]
mov dword [esi + 0x14], 0xf
mov dword [esi + 0x10], 0
mov ecx, esi
push eax
mov byte [esi], 0
call fcn.00408630
mov ecx, dword [ebp - 0x14]
cmp ecx, 0x10
jb 0x47024f
inc ecx
push ecx
jmp 0x470244
mov eax, dword [eax + 4]
sub ecx, edx
push ecx
add eax, edx
mov byte [ebp - 0x30], 0
push eax
lea ecx, [ebp - 0x98]
mov dword [ebp - 0x84], 0
mov dword [ebp - 0x88], 0
mov dword [ebp - 0x98], 0x67452301
mov dword [ebp - 0x94], 0xefcdab89
mov dword [ebp - 0x90], 0x98badcfe
mov dword [ebp - 0x8c], 0x10325476
call fcn.0046ee30
lea eax, [ebp - 0xb4]
push eax
lea ecx, [ebp - 0x98]
call fcn.0046f7b0
push eax
lea ecx, [ebp - 0x28]
mov byte [ebp - 4], 1
call fcn.004078f0
mov eax, dword [ebp - 0xa0]
cmp eax, 0x10
jb 0x47021e
inc eax
lea ecx, [ebp - 0xb4]
push eax
push dword [ebp - 0xb4]
call fcn.004086f0
lea eax, [ebp - 0x28]
mov dword [esi + 0x14], 0xf
mov dword [esi + 0x10], 0
mov ecx, esi
push eax
mov byte [esi], 0
call fcn.00408630
mov eax, dword [ebp - 0x14]
cmp eax, 0x10
jb 0x47024f
inc eax
push eax
push dword [ebp - 0x28]
lea ecx, [ebp - 0x28]
call fcn.004086f0
mov eax, esi
mov ecx, dword [ebp - 0xc]
mov dword fs:[0], ecx
pop ecx
pop esi
mov ecx, dword [ebp - 0x10]
xor ecx, ebp
call fcn.004fce93
mov esp, ebp
pop ebp
ret 8
Function at 0x470280
Capabilities:
Encrypt data using aes
Reference aes constants

Disassembly:
push ebp
mov ebp, esp
push ecx
movzx eax, byte [edx]
push ebx
push esi
mov esi, ecx
mov ebx, 4
mov byte [esi], al
movzx eax, byte [edx + 1]
mov byte [esi + 1], al
movzx eax, byte [edx + 2]
mov byte [esi + 2], al
movzx eax, byte [edx + 3]
mov byte [esi + 3], al
movzx eax, byte [edx + 4]
mov byte [esi + 4], al
movzx eax, byte [edx + 5]
mov byte [esi + 5], al
movzx eax, byte [edx + 6]
mov byte [esi + 6], al
movzx eax, byte [edx + 7]
mov byte [esi + 7], al
movzx eax, byte [edx + 8]
mov byte [esi + 8], al
movzx eax, byte [edx + 9]
mov byte [esi + 9], al
movzx eax, byte [edx + 0xa]
mov byte [esi + 0xa], al
movzx eax, byte [edx + 0xb]
mov byte [esi + 0xb], al
movzx eax, byte [edx + 0xc]
mov byte [esi + 0xc], al
lea eax, [esi + 0xd]
mov cl, byte [edx + 0xd]
mov byte [eax], cl
mov cl, byte [edx + 0xe]
mov byte [esi + 0xe], cl
mov cl, byte [edx + 0xf]
mov byte [esi + 0xf], cl
nop word [eax + eax]
mov cl, byte [eax]
mov dl, byte [eax + 1]
mov ch, byte [eax + 2]
mov dh, byte [eax - 1]
mov byte [ebp - 3], cl
mov byte [ebp - 1], dl
mov byte [ebp - 2], ch
test bl, 3
jne 0x47035b
movzx ecx, cl
mov dl, dh
mov dh, byte [ecx + 0x5a8368]
movzx ecx, byte [ebp - 1]
mov cl, byte [ecx + 0x5a8368]
mov byte [ebp - 3], cl
movzx ecx, byte [ebp - 2]
mov cl, byte [ecx + 0x5a8368]
mov byte [ebp - 1], cl
movzx ecx, dl
mov dl, byte [ebp - 1]
mov cl, byte [ecx + 0x5a8368]
mov byte [ebp - 2], cl
mov ecx, ebx
shr ecx, 2
xor dh, byte [ecx + 0x5a8468]
mov ch, byte [ebp - 2]
mov cl, byte [eax - 0xd]
inc ebx
xor cl, dh
mov byte [eax + 3], cl
mov cl, byte [eax - 0xc]
xor cl, byte [ebp - 3]
mov byte [eax + 4], cl
mov cl, byte [eax - 0xb]
xor cl, dl
mov byte [eax + 5], cl
mov cl, byte [eax - 0xa]
xor cl, ch
mov byte [eax + 6], cl
add eax, 4
cmp ebx, 0x2c
jb 0x470300
pop esi
pop ebx
mov esp, ebp
pop ebp
ret

Function at 0x470390
Capabilities:
Encode data using xor

Disassembly:
push ebp
mov ebp, esp
push ecx
push ebx
push esi
lea eax, [ecx + 2]
mov esi, 4
nop
mov dl, byte [eax + 1]
lea eax, [eax + 4]
mov bh, byte [eax - 4]
mov dh, dl
mov cl, byte [eax - 6]
xor dh, bh
mov bl, byte [eax - 5]
mov byte [ebp - 2], cl
mov byte [ebp - 3], dl
mov dl, dh
xor dl, cl
xor dl, bl
mov byte [ebp - 1], dl
mov dl, cl
xor dl, bl
mov cl, dl
add dl, dl
shr cl, 7
movzx ecx, cl
imul ecx, ecx, 0x1b
xor cl, dl
mov dl, bl
xor cl, byte [ebp - 2]
xor dl, bh
xor cl, byte [ebp - 1]
mov byte [eax - 6], cl
mov cl, dl
shr cl, 7
add dl, dl
movzx ecx, cl
imul ecx, ecx, 0x1b
xor cl, dl
mov dl, byte [ebp - 3]
xor cl, bl
xor dl, byte [ebp - 2]
mov bl, byte [ebp - 1]
xor cl, bl
mov byte [eax - 5], cl
mov cl, dh
shr cl, 7
add dh, dh
movzx ecx, cl
imul ecx, ecx, 0x1b
xor cl, dh
xor cl, bh
xor cl, bl
mov byte [eax - 4], cl
mov cl, dl
shr cl, 7
add dl, dl
movzx ecx, cl
imul ecx, ecx, 0x1b
xor cl, dl
xor cl, byte [ebp - 3]
xor cl, bl
mov byte [eax - 3], cl
sub esi, 1
jne 0x4703a0
pop esi
pop ebx
mov esp, ebp
pop ebp
ret
Function at 0x470640
Capabilities:
Encode data using xor
Encrypt data using aes
Reference aes constants

Disassembly:
push ebp
mov ebp, esp
sub esp, 0xc
push ebx
push esi
push edi
mov eax, edx
mov edi, ecx
mov dword [ebp - 0xc], eax
sub edx, edi
mov esi, edi
mov ebx, 4
nop dword [eax]
mov ecx, 4
mov al, byte [edx + esi]
xor byte [esi], al
inc esi
sub ecx, 1
jne 0x470665
sub ebx, 1
jne 0x470660
mov esi, dword [ebp - 0xc]
add esi, 0x10
mov dword [ebp - 8], 9
mov ebx, edi
mov dword [ebp - 4], 4
nop dword [eax + eax]
mov ecx, ebx
mov edx, 4
nop word [eax + eax]
movzx eax, byte [ecx]
lea ecx, [ecx + 4]
mov al, byte [eax + 0x5a8368]
mov byte [ecx - 4], al
sub edx, 1
jne 0x4706a0
inc ebx
sub dword [ebp - 4], 1
jne 0x470690
mov cl, byte [edi + 1]
movzx eax, byte [edi + 5]
mov byte [edi + 1], al
movzx eax, byte [edi + 9]
mov byte [edi + 5], al
movzx eax, byte [edi + 0xd]
mov byte [edi + 9], al
movzx eax, byte [edi + 0xa]
mov byte [edi + 0xd], cl
mov cl, byte [edi + 2]
mov byte [edi + 2], al
movzx eax, byte [edi + 0xe]
mov byte [edi + 0xa], cl
mov cl, byte [edi + 6]
mov byte [edi + 6], al
movzx eax, byte [edi + 0xf]
mov byte [edi + 0xe], cl
mov cl, byte [edi + 3]
mov byte [edi + 3], al
movzx eax, byte [edi + 0xb]
mov byte [edi + 0xf], al
movzx eax, byte [edi + 7]
mov byte [edi + 7], cl
mov ecx, edi
mov byte [edi + 0xb], al
call fcn.00470390
mov eax, edi
mov ebx, 4
nop dword [eax]
mov edx, 4
mov cl, byte [esi]
inc esi
xor byte [eax], cl
inc eax
sub edx, 1
jne 0x470725
sub ebx, 1
jne 0x470720
sub dword [ebp - 8], 1
jne 0x470682
mov esi, edi
lea ebx, [edx + 4]
mov ecx, esi
mov edx, 4
nop dword [eax + eax]
movzx eax, byte [ecx]
lea ecx, [ecx + 4]
mov al, byte [eax + 0x5a8368]
mov byte [ecx - 4], al
sub edx, 1
jne 0x470750
inc esi
sub ebx, 1
jne 0x470744
mov cl, byte [edi + 1]
lea esi, [edx + 4]
movzx eax, byte [edi + 5]
mov byte [edi + 1], al
movzx eax, byte [edi + 9]
mov byte [edi + 5], al
movzx eax, byte [edi + 0xd]
mov byte [edi + 9], al
movzx eax, byte [edi + 0xa]
mov byte [edi + 0xd], cl
mov cl, byte [edi + 2]
mov byte [edi + 2], al
movzx eax, byte [edi + 0xe]
mov byte [edi + 0xa], cl
mov cl, byte [edi + 6]
mov byte [edi + 6], al
movzx eax, byte [edi + 0xf]
mov byte [edi + 0xe], cl
mov cl, byte [edi + 3]
mov byte [edi + 3], al
movzx eax, byte [edi + 0xb]
mov byte [edi + 0xf], al
movzx eax, byte [edi + 7]
mov byte [edi + 7], cl
mov ecx, dword [ebp - 0xc]
mov byte [edi + 0xb], al
add ecx, 0xa0
mov edx, 4
nop dword [eax + eax]
mov al, byte [ecx]
inc ecx
xor byte [edi], al
inc edi
sub edx, 1
jne 0x4707d0
sub esi, 1
jne 0x4707c6
pop edi
pop esi
pop ebx
mov esp, ebp
pop ebp
ret
Function at 0x4707f0
Capabilities:
Encode data using xor
Encrypt data using aes
Reference aes constants

Disassembly:
push ebp
mov ebp, esp
sub esp, 0xc
push ebx
mov eax, edx
mov ebx, 4
push esi
push edi
mov dword [ebp - 8], eax
mov esi, ecx
lea edi, [eax + 0xa0]
nop dword [eax + eax]
mov edx, 4
mov al, byte [edi]
inc edi
xor byte [ecx], al
inc ecx
sub edx, 1
jne 0x470815
sub ebx, 1
jne 0x470810
mov eax, dword [ebp - 8]
add eax, 0x90
mov byte [ebp - 1], 9
mov dword [ebp - 0xc], eax
movzx eax, byte [esi + 9]
mov edi, esi
mov cl, byte [esi + 0xd]
mov ebx, 4
mov byte [esi + 0xd], al
movzx eax, byte [esi + 5]
mov byte [esi + 9], al
movzx eax, byte [esi + 1]
mov byte [esi + 5], al
movzx eax, byte [esi + 0xa]
mov byte [esi + 1], cl
mov cl, byte [esi + 2]
mov byte [esi + 2], al
movzx eax, byte [esi + 0xe]
mov byte [esi + 0xa], cl
mov cl, byte [esi + 6]
mov byte [esi + 6], al
movzx eax, byte [esi + 7]
mov byte [esi + 0xe], cl
mov cl, byte [esi + 3]
mov byte [esi + 3], al
movzx eax, byte [esi + 0xb]
mov byte [esi + 7], al
movzx eax, byte [esi + 0xf]
mov byte [esi + 0xb], al
mov byte [esi + 0xf], cl
nop dword [eax + eax]
mov ecx, edi
mov edx, 4
nop word [eax + eax]
movzx eax, byte [ecx]
lea ecx, [ecx + 4]
mov al, byte [eax + 0x5a8268]
mov byte [ecx - 4], al
sub edx, 1
jne 0x4708a0
inc edi
sub ebx, 1
jne 0x470890
mov edx, dword [ebp - 0xc]
mov eax, esi
mov ebx, 4
mov edi, 4
nop dword [eax]
mov cl, byte [edx]
inc edx
xor byte [eax], cl
inc eax
sub edi, 1
jne 0x4708d0
sub ebx, 1
jne 0x4708c4
mov ecx, esi
call fcn.00470440
mov dl, byte [ebp - 1]
sub dword [ebp - 0xc], 0x10
dec dl
mov byte [ebp - 1], dl
test dl, dl
jne 0x470834
movzx eax, byte [esi + 9]
mov edi, esi
mov cl, byte [esi + 0xd]
mov ebx, 4
mov byte [esi + 0xd], al
movzx eax, byte [esi + 5]
mov byte [esi + 9], al
movzx eax, byte [esi + 1]
mov byte [esi + 5], al
movzx eax, byte [esi + 0xa]
mov byte [esi + 1], cl
mov cl, byte [esi + 2]
mov byte [esi + 2], al
movzx eax, byte [esi + 0xe]
mov byte [esi + 0xa], cl
mov cl, byte [esi + 6]
mov byte [esi + 6], al
movzx eax, byte [esi + 7]
mov byte [esi + 0xe], cl
mov cl, byte [esi + 3]
mov byte [esi + 3], al
movzx eax, byte [esi + 0xb]
mov byte [esi + 7], al
movzx eax, byte [esi + 0xf]
mov byte [esi + 0xb], al
mov byte [esi + 0xf], cl
mov ecx, edi
mov edx, 4
nop dword [eax]
movzx eax, byte [ecx]
lea ecx, [ecx + 4]
mov al, byte [eax + 0x5a8268]
mov byte [ecx - 4], al
sub edx, 1
jne 0x470960
inc edi
sub ebx, 1
jne 0x470952
sub dword [ebp - 8], esi
mov dword [ebp - 0xc], 4
mov edx, dword [ebp - 8]
mov ecx, 4
nop dword [eax]
mov al, byte [edx + esi]
xor byte [esi], al
inc esi
sub ecx, 1
jne 0x470990
sub dword [ebp - 0xc], 1
jne 0x470984
pop edi
pop esi
pop ebx
mov esp, ebp
pop ebp
ret
Function at 0x4709b0
Capabilities:
Encode data using xor

Disassembly:
push ebp
mov ebp, esp
sub esp, 8
push ebx
mov ebx, dword [ebp + 8]
mov eax, ecx
push esi
mov dword [ebp - 4], eax
add eax, 0xb0
mov dword [ebp - 8], eax
mov esi, eax
push edi
mov edi, edx
test ebx, ebx
je 0x470a05
dec ebx
shr ebx, 4
inc ebx
mov eax, edi
sub esi, edi
mov edx, 0x10
nop
mov cl, byte [esi + eax]
lea eax, [eax + 1]
xor byte [eax - 1], cl
sub edx, 1
jne 0x4709e0
mov edx, dword [ebp - 4]
mov ecx, edi
call fcn.00470640
mov esi, edi
add edi, 0x10
sub ebx, 1
jne 0x4709d6
mov eax, dword [ebp - 8]
movups xmm0, xmmword [esi]
pop edi
pop esi
movups xmmword [eax], xmm0
pop ebx
mov esp, ebp
pop ebp
ret

Function at 0x470a20
Capabilities:
Encode data using xor

Disassembly:
push ebp
mov ebp, esp
push ecx
push ebx
mov ebx, dword [ebp + 8]
mov dword [ebp - 4], ecx
push esi
mov esi, edx
test ebx, ebx
je 0x470a6f
push edi
dec ebx
lea edi, [ecx + 0xb0]
shr ebx, 4
sub edi, esi
inc ebx
movups xmm0, xmmword [esi]
mov edx, ecx
mov ecx, esi
call fcn.004707f0
mov ecx, 0x10
mov al, byte [edi + esi]
xor byte [esi], al
inc esi
sub ecx, 1
jne 0x470a51
mov ecx, dword [ebp - 4]
sub edi, 0x10
movups xmmword [ecx + 0xb0], xmm0
sub ebx, 1
jne 0x470a40
pop edi
pop esi
pop ebx
mov esp, ebp
pop ebp
ret

Function at 0x470a80
Capabilities:
Encrypt data using rc4 ksa

Disassembly:
push ebp
mov ebp, esp
sub esp, 8
mov eax, dword [ebp + 8]
mov dword [ebp - 8], edx
mov byte [ebp - 1], 0
push ebx
mov ebx, ecx
push esi
push edi
test eax, eax
je 0x470aa0
cmp eax, 0x100
jbe 0x470ab4
push 0x54
push 0x5a8474
push str.key_len___0__key_len___256
call fcn.0051ee9d
add esp, 0xc
mov ecx, 0x40
mov dword [ebx + 0x200], 1
mov esi, 0x5a84c0
mov dword [ebx + 0x204], 1
mov edi, ebx
mov word [ebx + 0x208], 0
rep movsd dword es:[edi], dword [esi]
mov edi, dword [ebp + 8]
xor esi, esi
xor edx, edx
mov cl, byte [esi + ebx]
mov eax, esi
div edi
mov eax, dword [ebp - 8]
movzx eax, byte [edx + eax]
mov dl, byte [ebp - 1]
add al, cl
add dl, al
mov byte [ebp - 1], dl
movzx edx, dl
movzx eax, byte [edx + ebx]
mov byte [esi + ebx], al
inc esi
mov byte [edx + ebx], cl
cmp esi, 0x100
jb 0x470ae4
lea edi, [ebx + 0x100]
mov esi, ebx
mov ecx, 0x40
rep movsd dword es:[edi], dword [esi]
pop edi
pop esi
pop ebx
mov esp, ebp
pop ebp
ret

Function at 0x470b30
Capabilities:
Encode data using xor
Encrypt data using rc4 prga

Disassembly:
push ebp
mov ebp, esp
push ecx
push ebx
push esi
mov esi, dword [ebp + 8]
push edi
mov edi, ecx
mov ecx, dword [ebp + 0xc]
mov eax, dword [edi + 0x200]
sub edx, eax
mov bh, byte [edi + 0x208]
add ecx, eax
sub esi, eax
mov dword [ebp - 4], ecx
mov dword [ebp + 8], esi
cmp eax, ecx
jae 0x470b95
sub edx, esi
mov dword [ebp + 0xc], edx
movzx esi, al
mov bl, byte [esi + edi]
add bh, bl
movzx edx, bh
movzx ecx, byte [edx + edi]
mov byte [esi + edi], cl
mov byte [edx + edi], bl
movzx ecx, byte [esi + edi]
mov edx, dword [ebp + 8]
add cl, bl
mov esi, dword [ebp + 0xc]
add edx, eax
movzx ecx, cl
inc eax
movzx ecx, byte [ecx + edi]
xor cl, byte [esi + edx]
mov byte [edx], cl
cmp eax, dword [ebp - 4]
jb 0x470b60
mov byte [edi + 0x208], bh
mov dword [edi + 0x200], eax
pop edi
pop esi
pop ebx
mov esp, ebp
pop ebp
ret
Function at 0x470bb0
Capabilities:
Encode data using xor
Encrypt data using rc4 prga

Disassembly:
push ebp
mov ebp, esp
sub esp, 0xc
push ebx
push esi
push edi
mov edi, ecx
mov ecx, dword [ebp + 0xc]
mov dword [ebp - 0xc], edi
mov eax, dword [edi + 0x204]
lea esi, [edi + 0x100]
sub dword [ebp + 8], eax
add ecx, eax
mov bh, byte [edi + 0x209]
sub edx, eax
mov dword [ebp - 4], esi
mov dword [ebp - 8], ecx
cmp eax, ecx
jae 0x470c2a
sub edx, dword [ebp + 8]
mov edi, edx
nop dword [eax]
mov edx, dword [ebp - 4]
movzx ecx, al
add esi, ecx
mov bl, byte [esi]
add bh, bl
movzx ecx, bh
add edx, ecx
movzx ecx, byte [edx]
mov byte [esi], cl
mov byte [edx], bl
movzx ecx, byte [esi]
mov edx, dword [ebp + 8]
add cl, bl
mov esi, dword [ebp - 4]
add edx, eax
movzx ecx, cl
inc eax
movzx ecx, byte [ecx + esi]
xor cl, byte [edi + edx]
mov byte [edx], cl
cmp eax, dword [ebp - 8]
jb 0x470bf0
mov edi, dword [ebp - 0xc]
mov byte [edi + 0x209], bh
mov dword [edi + 0x204], eax
pop edi
pop esi
pop ebx
mov esp, ebp
pop ebp
ret
Function at 0x4719c0
Capabilities:
Encode data using xor
Hash data using murmur3

Disassembly:
push ebp
mov ebp, esp
sub esp, 0x128
push ebx
push esi
mov ebx, ecx
lea esi, [edx + 1]
push edi
mov dword [ebp - 0x24], ebx
xor edi, edi
nop word [eax + eax]
movzx edx, byte [esi - 1]
lea esi, [esi + 4]
movzx eax, byte [esi - 4]
shl edx, 8
or edx, eax
movzx eax, byte [esi - 3]
shl edx, 8
or edx, eax
movzx eax, byte [esi - 2]
shl edx, 8
or edx, eax
mov dword [ebp + edi*4 - 0x128], edx
inc edi
cmp edi, 0x10
jb 0x4719e0
cmp edi, 0x40
jae 0x471a5f
mov ebx, 0x40
lea eax, [ebp + edi*4 - 0x130]
sub ebx, edi
mov edx, dword [eax]
lea eax, [eax + 4]
mov esi, dword [eax - 0x38]
mov edi, edx
mov ecx, edx
rol edi, 0xf
rol ecx, 0xd
xor edi, ecx
shr edx, 0xa
xor edi, edx
mov ecx, esi
mov edx, esi
ror ecx, 7
rol edx, 0xe
xor edx, ecx
shr esi, 3
xor edx, esi
add edi, edx
add edi, dword [eax - 0x3c]
add edi, dword [eax - 0x18]
mov dword [eax + 4], edi
sub ebx, 1
jne 0x471a22
mov ebx, dword [ebp - 0x24]
mov eax, dword [ebx + 0x50]
xor edx, edx
mov dword [ebp - 0x28], eax
mov edi, eax
mov eax, dword [ebx + 0x54]
mov dword [ebp - 0x10], eax
mov eax, dword [ebx + 0x58]
mov dword [ebp - 4], eax
mov eax, dword [ebx + 0x5c]
mov dword [ebp - 0x14], eax
mov eax, dword [ebx + 0x60]
mov dword [ebp - 0x18], eax
mov eax, dword [ebx + 0x64]
mov dword [ebp - 8], eax
mov eax, dword [ebx + 0x68]
mov dword [ebp - 0xc], eax
mov eax, dword [ebx + 0x6c]
mov ebx, dword [ebp - 0x18]
mov dword [ebp - 0x1c], eax
mov dword [ebp - 0x20], edx
nop dword [eax]
mov esi, ebx
mov eax, ebx
rol eax, 7
mov ecx, ebx
ror esi, 0xb
not ecx
and ecx, dword [ebp - 0xc]
xor esi, eax
mov eax, ebx
ror eax, 6
xor esi, eax
mov eax, dword [ebp - 8]
and eax, ebx
xor ecx, eax
mov eax, edi
add esi, ecx
rol eax, 0xa
add esi, dword [edx + 0x5a85c0]
add esi, dword [ebp + edx - 0x128]
mov edx, edi
add esi, dword [ebp - 0x1c]
ror edx, 0xd
xor edx, eax
mov eax, edi
ror eax, 2
xor edx, eax
mov eax, dword [ebp - 0x10]
mov ecx, eax
and eax, edi
xor ecx, edi
and ecx, dword [ebp - 4]
xor ecx, eax
mov eax, dword [ebp - 0xc]
add edx, ecx
mov dword [ebp - 0x1c], eax
mov eax, dword [ebp - 8]
mov ecx, edi
mov dword [ebp - 8], ebx
mov ebx, dword [ebp - 0x14]
lea edi, [edx + esi]
mov dword [ebp - 0xc], eax
mov edx, dword [ebp - 0x20]
add ebx, esi
mov eax, dword [ebp - 4]
add edx, 4
mov dword [ebp - 0x14], eax
mov eax, dword [ebp - 0x10]
mov dword [ebp - 4], eax
mov dword [ebp - 0x10], ecx
mov dword [ebp - 0x20], edx
cmp edx, 0x100
jb 0x471aa0
mov eax, dword [ebp - 0x28]
add eax, edi
mov dword [ebp - 0x18], ebx
mov ebx, dword [ebp - 0x24]
pop edi
pop esi
add dword [ebx + 0x54], ecx
mov dword [ebx + 0x50], eax
mov eax, dword [ebp - 4]
add dword [ebx + 0x58], eax
mov eax, dword [ebp - 0x14]
add dword [ebx + 0x5c], eax
mov eax, dword [ebp - 0x18]
add dword [ebx + 0x60], eax
mov eax, dword [ebp - 8]
add dword [ebx + 0x64], eax
mov eax, dword [ebp - 0xc]
add dword [ebx + 0x68], eax
mov eax, dword [ebp - 0x1c]
add dword [ebx + 0x6c], eax
pop ebx
mov esp, ebp
pop ebp
ret