joyce8/EMBER2024-capa huggingface dataset:
Function at 0x24c7f2
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c646c], 1
jne 0x24c8a1
or dword [0x2c646c], 1
mov eax, 0x87ca
mov word [0x2c5888], ax
dec eax
mov word [0x2c588a], ax
mov ecx, 0x87c7
push ebx
mov eax, ecx
mov word [0x2c588c], ax
add eax, 0x14
push esi
mov word [0x2c588e], ax
lea esi, [ecx + 0x16]
mov eax, esi
mov word [0x2c5890], ax
add eax, 0xffffffe4
mov word [0x2c5892], ax
lea edx, [ecx + 0x10]
mov eax, edx
mov word [0x2c5894], ax
add eax, 0xfffffff9
mov ebx, eax
mov word [0x2c5896], bx
mov word [0x2c5898], bx
mov ebx, ecx
mov word [0x2c589a], bx
add ebx, 5
mov word [0x2c58a8], ax
lea eax, [ecx - 0x45]
pop esi
mov word [0x2c589c], bx
mov dword [0x2c589e], 0x87dd87d6
mov word [0x2c58a2], dx
mov dword [0x2c58a4], 0x87c787d1
mov word [0x2c58aa], ax
pop ebx
xor eax, eax
mov ecx, 0x8782
xor cx, word [eax + 0x2c5888]
add eax, 2
mov word [eax + 0x2c604e], cx
cmp eax, 0x24
jb 0x24c8a3
mov eax, 0x2c6050
ret

Function at 0x24c8c4
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c6468], 1
mov edx, 0x8782
jne 0x24c936
or dword [0x2c6468], 1
lea eax, [edx + 0x48]
mov word [0x2c58ac], ax
dec eax
mov word [0x2c58ae], ax
lea ecx, [edx + 0x45]
mov eax, ecx
mov word [0x2c58b0], ax
add eax, 0x14
mov word [0x2c58b2], ax
lea eax, [edx + 0x5b]
mov word [0x2c58b4], ax
add eax, 0xfffffffa
mov word [0x2c58b6], ax
lea eax, [edx + 0x4f]
push esi
mov esi, eax
mov eax, edx
mov word [0x2c58b8], si
mov word [0x2c58ba], cx
mov dword [0x2c58bc], 0x87d187d0
mov word [0x2c58c0], ax
pop esi
xor eax, eax
mov ecx, edx
xor cx, word [eax + 0x2c58ac]
add eax, 2
mov word [eax + 0x2c6072], cx
cmp eax, 0x16
jb 0x24c938
mov eax, 0x2c6074
ret

Function at 0x24c956
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c6464], 1
jne 0x24ca16
or dword [0x2c6464], 1
push ebx
mov eax, 0x87ca
mov word [0x2c58c4], ax
dec eax
mov word [0x2c58c6], ax
push esi
mov esi, 0x87c7
mov eax, esi
mov word [0x2c58c8], ax
add eax, 0x14
mov word [0x2c58ca], ax
lea edx, [esi + 0x16]
lea ecx, [esi - 6]
mov eax, edx
mov word [0x2c58cc], ax
mov eax, ecx
mov word [0x2c58ce], ax
add eax, 0x16
mov word [0x2c58d0], ax
lea eax, [esi + 9]
mov ebx, eax
add eax, 0xfffffffc
mov esi, eax
lea eax, [edx - 0x19]
mov word [0x2c58e4], ax
add eax, 7
mov word [0x2c58e6], ax
lea eax, [edx - 0x18]
mov word [0x2c58d8], si
mov word [0x2c58e8], ax
add eax, 0xffffffbd
pop esi
mov word [0x2c58d2], bx
mov dword [0x2c58d4], 0x87c787d0
mov dword [0x2c58da], 0x87dd87d6
mov word [0x2c58de], cx
mov dword [0x2c58e0], 0x87cc87cd
mov word [0x2c58ea], ax
pop ebx
xor eax, eax
mov ecx, 0x8782
xor cx, word [eax + 0x2c58c4]
add eax, 2
mov word [eax + 0x2c608a], cx
cmp eax, 0x28
jb 0x24ca18
mov eax, 0x2c608c
ret
Function at 0x24ca39
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c6460], 1
jne 0x24cae8
or dword [0x2c6460], 1
mov eax, 0x87ca
mov word [0x2c58ec], ax
dec eax
mov word [0x2c58ee], ax
mov edx, 0x87c7
mov eax, edx
mov word [0x2c58f0], ax
add eax, 0x14
mov word [0x2c58f2], ax
lea ecx, [edx + 0x16]
mov eax, ecx
mov word [0x2c58f4], ax
add eax, 0xffffffe4
mov word [0x2c58f6], ax
lea eax, [edx + 7]
mov word [0x2c58f8], ax
add eax, 0xfffffff5
mov word [0x2c58fa], ax
lea eax, [edx + 0xa]
push edi
mov edi, eax
add eax, 0xfffffffc
mov ecx, eax
mov word [0x2c590a], ax
lea eax, [edx + 0xf]
mov word [0x2c590c], ax
add eax, 0xffffffac
mov word [0x2c58fc], di
mov word [0x2c58fe], di
mov dword [0x2c5900], 0x87d187c7
mov dword [0x2c5904], 0x87d087dd
mov word [0x2c5908], cx
mov word [0x2c590e], ax
pop edi
xor eax, eax
mov ecx, 0x8782
xor cx, word [eax + 0x2c58ec]
add eax, 2
mov word [eax + 0x2c60b2], cx
cmp eax, 0x24
jb 0x24caea
mov eax, 0x2c60b4
ret

Function at 0x24ceb6
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c6448], 1
jne 0x24cf0b
or dword [0x2c6448], 1
mov dword [0x2c5998], 0xc1e5e7d0
mov dword [0x2c599c], 0xf6e3e7f0
mov dword [0x2c59a0], 0xfbe7c9e7
mov dword [0x2c59a4], 0xabaafac7
mov dword [0x2c59a8], 0xebe3e4a2
mov dword [0x2c59ac], 0xb8e6e7ee
mov word [0x2c59b0], 0x82a2
xor eax, eax
mov cl, byte [eax + 0x2c5998]
xor cl, 0x82
mov byte [eax + 0x2c6110], cl
inc eax
cmp eax, 0x1a
jb 0x24cf0d
mov eax, 0x2c6110
ret

Function at 0x24cfee
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c6444], 1
jne 0x24d054
or dword [0x2c6444], 1
mov dword [0x2c59b4], 0xeff7ecc7
mov dword [0x2c59b8], 0xf6e3f0e7
mov dword [0x2c59bc], 0xa2ecedeb
mov dword [0x2c59c0], 0xe7e6eceb
mov dword [0x2c59c4], 0xf7eda2fa
mov dword [0x2c59c8], 0xe4eda2f6
mov dword [0x2c59cc], 0xece3f0a2
mov word [0x2c59d0], 0xe7e5
mov byte [0x2c59d2], 0x82
xor eax, eax
mov cl, byte [eax + 0x2c59b4]
xor cl, 0x82
mov byte [eax + 0x2c612c], cl
inc eax
cmp eax, 0x1f
jb 0x24d056
mov eax, 0x2c612c
ret

Function at 0x24d071
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c6440], 1
jne 0x24d0bd
or dword [0x2c6440], 1
mov dword [0x2c59d4], 0xc7e5e7d0
mov dword [0x2c59d8], 0xc9eff7ec
mov dword [0x2c59dc], 0xfac7fbe7
mov dword [0x2c59e0], 0xe4a2abaa
mov dword [0x2c59e4], 0xe7eeebe3
mov dword [0x2c59e8], 0x82a2b8e6
xor eax, eax
mov cl, byte [eax + 0x2c59d4]
xor cl, 0x82
mov byte [eax + 0x2c614c], cl
inc eax
cmp eax, 0x18
jb 0x24d0bf
mov eax, 0x2c614c
ret

Function at 0x24d222
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c643c], 1
jne 0x24d257
or dword [0x2c643c], 1
mov dword [0x2c59ec], 0xeeeef7cc
mov dword [0x2c59f0], 0xecede1a2
mov dword [0x2c59f4], 0xf6fae7f6
mov byte [0x2c59f8], 0x82
xor eax, eax
mov cl, byte [eax + 0x2c59ec]
xor cl, 0x82
mov byte [eax + 0x2c6164], cl
inc eax
cmp eax, 0xd
jb 0x24d259
mov eax, 0x2c6164
ret
Function at 0x24d274
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c6438], 1
jne 0x24d2c0
or dword [0x2c6438], 1
mov dword [0x2c59fc], 0xcde5e7d0
mov dword [0x2c5a00], 0xc9ece7f2
mov dword [0x2c5a04], 0xfac7fbe7
mov dword [0x2c5a08], 0xe4a2abaa
mov dword [0x2c5a0c], 0xe7eeebe3
mov dword [0x2c5a10], 0x82a2b8e6
xor eax, eax
mov cl, byte [eax + 0x2c59fc]
xor cl, 0x82
mov byte [eax + 0x2c6174], cl
inc eax
cmp eax, 0x18
jb 0x24d2c2
mov eax, 0x2c6174
ret

Function at 0x24d2dd
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c6434], 1
jne 0x24d339
or dword [0x2c6434], 1
mov dword [0x2c5a14], 0xd3e5e7d0
mov dword [0x2c5a18], 0xfbf0e7f7
mov dword [0x2c5a1c], 0xede4eccb
mov dword [0x2c5a20], 0xaafbe7c9
mov dword [0x2c5a24], 0xe3e4a2ab
mov dword [0x2c5a28], 0xe6e7eeeb
mov word [0x2c5a2c], 0xa2b8
mov byte [0x2c5a2e], 0x82
xor eax, eax
mov cl, byte [eax + 0x2c5a14]
xor cl, 0x82
mov byte [eax + 0x2c618c], cl
inc eax
cmp eax, 0x1b
jb 0x24d33b
mov eax, 0x2c618c
ret

Function at 0x24d42c
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c6430], 1
jne 0x24d492
or dword [0x2c6430], 1
mov dword [0x2c5a30], 0xeff7ecc7
mov dword [0x2c5a34], 0xf6e3f0e7
mov dword [0x2c5a38], 0xa2ecedeb
mov dword [0x2c5a3c], 0xe7e6eceb
mov dword [0x2c5a40], 0xf7eda2fa
mov dword [0x2c5a44], 0xe4eda2f6
mov dword [0x2c5a48], 0xece3f0a2
mov word [0x2c5a4c], 0xe7e5
mov byte [0x2c5a4e], 0x82
xor eax, eax
mov cl, byte [eax + 0x2c5a30]
xor cl, 0x82
mov byte [eax + 0x2c61a8], cl
inc eax
cmp eax, 0x1f
jb 0x24d494
mov eax, 0x2c61a8
ret

Function at 0x24d4af
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c642c], 1
jne 0x24d50b
or dword [0x2c642c], 1
mov dword [0x2c5a50], 0xd3e5e7d0
mov dword [0x2c5a54], 0xfbf0e7f7
mov dword [0x2c5a58], 0xede4eccb
mov dword [0x2c5a5c], 0xaafbe7c9
mov dword [0x2c5a60], 0xe3e4a2ab
mov dword [0x2c5a64], 0xe6e7eeeb
mov word [0x2c5a68], 0xa2b8
mov byte [0x2c5a6a], 0x82
xor eax, eax
mov cl, byte [eax + 0x2c5a50]
xor cl, 0x82
mov byte [eax + 0x2c61c8], cl
inc eax
cmp eax, 0x1b
jb 0x24d50d
mov eax, 0x2c61c8
ret

Function at 0x24d66d
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c6428], 1
jne 0x24d6a2
or dword [0x2c6428], 1
mov dword [0x2c5a6c], 0xeeeef7cc
mov dword [0x2c5a70], 0xecede1a2
mov dword [0x2c5a74], 0xf6fae7f6
mov byte [0x2c5a78], 0x82
xor eax, eax
mov cl, byte [eax + 0x2c5a6c]
xor cl, 0x82
mov byte [eax + 0x2c61e4], cl
inc eax
cmp eax, 0xd
jb 0x24d6a4
mov eax, 0x2c61e4
ret

Function at 0x24d6bf
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c6424], 1
jne 0x24d70b
or dword [0x2c6424], 1
mov dword [0x2c5a7c], 0xcde5e7d0
mov dword [0x2c5a80], 0xc9ece7f2
mov dword [0x2c5a84], 0xfac7fbe7
mov dword [0x2c5a88], 0xe4a2abaa
mov dword [0x2c5a8c], 0xe7eeebe3
mov dword [0x2c5a90], 0x82a2b8e6
xor eax, eax
mov cl, byte [eax + 0x2c5a7c]
xor cl, 0x82
mov byte [eax + 0x2c61f4], cl
inc eax
cmp eax, 0x18
jb 0x24d70d
mov eax, 0x2c61f4
ret
Function at 0x24d728
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c6420], 1
jne 0x24d784
or dword [0x2c6420], 1
mov dword [0x2c5a94], 0xd3e5e7d0
mov dword [0x2c5a98], 0xfbf0e7f7
mov dword [0x2c5a9c], 0xede4eccb
mov dword [0x2c5aa0], 0xaafbe7c9
mov dword [0x2c5aa4], 0xe3e4a2ab
mov dword [0x2c5aa8], 0xe6e7eeeb
mov word [0x2c5aac], 0xa2b8
mov byte [0x2c5aae], 0x82
xor eax, eax
mov cl, byte [eax + 0x2c5a94]
xor cl, 0x82
mov byte [eax + 0x2c620c], cl
inc eax
cmp eax, 0x1b
jb 0x24d786
mov eax, 0x2c620c
ret

Function at 0x24da32
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c641c], 1
mov ecx, 0x8782
jne 0x24daa0
or dword [0x2c641c], 1
lea eax, [ecx + 0x28]
mov word [0x2c5ab0], ax
add eax, 0x1c
mov word [0x2c5ab2], ax
lea eax, [ecx + 0x65]
mov word [0x2c5ab4], ax
add eax, 0xfffffffd
mov word [0x2c5ab6], ax
lea eax, [ecx + 0x61]
mov word [0x2c5ab8], ax
add eax, 0x14
mov word [0x2c5aba], ax
lea eax, [ecx + 0x6c]
mov word [0x2c5abc], ax
add eax, 8
mov word [0x2c5abe], ax
lea eax, [ecx + 0x29]
mov word [0x2c5ac0], ax
mov eax, ecx
mov word [0x2c5ac2], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0x2c5ab0]
add eax, 2
mov word [eax + 0x2c6226], dx
cmp eax, 0x14
jb 0x24daa2
mov eax, 0x2c6228
ret

Function at 0x24dac0
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c6418], 1
mov ecx, 0x8782
jne 0x24db2e
or dword [0x2c6418], 1
lea eax, [ecx + 0x28]
mov word [0x2c5ac4], ax
add eax, 0x3c
mov word [0x2c5ac6], ax
lea eax, [ecx + 0x65]
mov word [0x2c5ac8], ax
add eax, 0xfffffffd
mov word [0x2c5aca], ax
lea eax, [ecx + 0x61]
mov word [0x2c5acc], ax
add eax, 0x14
mov word [0x2c5ace], ax
lea eax, [ecx + 0x6c]
mov word [0x2c5ad0], ax
add eax, 8
mov word [0x2c5ad2], ax
lea eax, [ecx + 0x29]
mov word [0x2c5ad4], ax
mov eax, ecx
mov word [0x2c5ad6], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0x2c5ac4]
add eax, 2
mov word [eax + 0x2c623a], dx
cmp eax, 0x14
jb 0x24db30
mov eax, 0x2c623c
ret

Function at 0x24db4e
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c6414], 1
jne 0x24db9a
or dword [0x2c6414], 1
mov dword [0x2c5ad8], 0xcde5e7d0
mov dword [0x2c5adc], 0xc9ece7f2
mov dword [0x2c5ae0], 0xfac7fbe7
mov dword [0x2c5ae4], 0xe4a2abaa
mov dword [0x2c5ae8], 0xe7eeebe3
mov dword [0x2c5aec], 0x82a2b8e6
xor eax, eax
mov cl, byte [eax + 0x2c5ad8]
xor cl, 0x82
mov byte [eax + 0x2c6250], cl
inc eax
cmp eax, 0x18
jb 0x24db9c
mov eax, 0x2c6250
ret

Function at 0x24dbb7
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c6410], 1
jne 0x24dc13
or dword [0x2c6410], 1
mov dword [0x2c5af0], 0xd3e5e7d0
mov dword [0x2c5af4], 0xfbf0e7f7
mov dword [0x2c5af8], 0xf7eee3d4
mov dword [0x2c5afc], 0xaafac7e7
mov dword [0x2c5b00], 0xe3e4a2ab
mov dword [0x2c5b04], 0xe6e7eeeb
mov word [0x2c5b08], 0xa2b8
mov byte [0x2c5b0a], 0x82
xor eax, eax
mov cl, byte [eax + 0x2c5af0]
xor cl, 0x82
mov byte [eax + 0x2c6268], cl
inc eax
cmp eax, 0x1b
jb 0x24dc15
mov eax, 0x2c6268
ret
Function at 0x24dc30
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c640c], 1
jne 0x24dc8c
or dword [0x2c640c], 1
mov dword [0x2c5b0c], 0xd3e5e7d0
mov dword [0x2c5b10], 0xfbf0e7f7
mov dword [0x2c5b14], 0xf7eee3d4
mov dword [0x2c5b18], 0xaafac7e7
mov dword [0x2c5b1c], 0xe3e4a2ab
mov dword [0x2c5b20], 0xe6e7eeeb
mov word [0x2c5b24], 0xa2b8
mov byte [0x2c5b26], 0x82
xor eax, eax
mov cl, byte [eax + 0x2c5b0c]
xor cl, 0x82
mov byte [eax + 0x2c6284], cl
inc eax
cmp eax, 0x1b
jb 0x24dc8e
mov eax, 0x2c6284
ret

Function at 0x24de08
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c6408], 1
jne 0x24de54
or dword [0x2c6408], 1
mov dword [0x2c5b28], 0xcde5e7d0
mov dword [0x2c5b2c], 0xc9ece7f2
mov dword [0x2c5b30], 0xfac7fbe7
mov dword [0x2c5b34], 0xe4a2abaa
mov dword [0x2c5b38], 0xe7eeebe3
mov dword [0x2c5b3c], 0x82a2b8e6
xor eax, eax
mov cl, byte [eax + 0x2c5b28]
xor cl, 0x82
mov byte [eax + 0x2c62a0], cl
inc eax
cmp eax, 0x18
jb 0x24de56
mov eax, 0x2c62a0
ret

Function at 0x24de71
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c6404], 1
jne 0x24ded7
or dword [0x2c6404], 1
mov dword [0x2c5b40], 0xd1e5e7d0
mov dword [0x2c5b44], 0xe3d4f6e7
mov dword [0x2c5b48], 0xc7e7f7ee
mov dword [0x2c5b4c], 0xf6f1aafa
mov dword [0x2c5b50], 0xe5ecebf0
mov dword [0x2c5b54], 0xe3e4a2ab
mov dword [0x2c5b58], 0xe6e7eeeb
mov word [0x2c5b5c], 0xa2b8
mov byte [0x2c5b5e], 0x82
xor eax, eax
mov cl, byte [eax + 0x2c5b40]
xor cl, 0x82
mov byte [eax + 0x2c62b8], cl
inc eax
cmp eax, 0x1f
jb 0x24ded9
mov eax, 0x2c62b8
ret

Function at 0x24e043
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c6400], 1
jne 0x24e08f
or dword [0x2c6400], 1
mov dword [0x2c5b60], 0xcde5e7d0
mov dword [0x2c5b64], 0xc9ece7f2
mov dword [0x2c5b68], 0xfac7fbe7
mov dword [0x2c5b6c], 0xe4a2abaa
mov dword [0x2c5b70], 0xe7eeebe3
mov dword [0x2c5b74], 0x82a2b8e6
xor eax, eax
mov cl, byte [eax + 0x2c5b60]
xor cl, 0x82
mov byte [eax + 0x2c62d8], cl
inc eax
cmp eax, 0x18
jb 0x24e091
mov eax, 0x2c62d8
ret

Function at 0x24e0ac
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c63fc], 1
jne 0x24e10b
or dword [0x2c63fc], 1
mov dword [0x2c5b78], 0xd1e5e7d0
mov dword [0x2c5b7c], 0xe3d4f6e7
mov dword [0x2c5b80], 0xc7e7f7ee
mov dword [0x2c5b84], 0xf5e6aafa
mov dword [0x2c5b88], 0xabe6f0ed
mov dword [0x2c5b8c], 0xebe3e4a2
mov dword [0x2c5b90], 0xb8e6e7ee
mov word [0x2c5b94], 0x82a2
xor eax, eax
mov cl, byte [eax + 0x2c5b78]
xor cl, 0x82
mov byte [eax + 0x2c62f0], cl
inc eax
cmp eax, 0x1e
jb 0x24e10d
mov eax, 0x2c62f0
ret

Function at 0x24e278
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c63f8], 1
jne 0x24e2f2
or dword [0x2c63f8], 1
mov dword [0x2c5b98], 0xf6f1f7cf
mov dword [0x2c5b9c], 0xe7f2f1a2
mov dword [0x2c5ba0], 0xfbe4ebe1
mov dword [0x2c5ba4], 0xeca2e3a2
mov dword [0x2c5ba8], 0xe7afeced
mov dword [0x2c5bac], 0xfbf6f2ef
mov dword [0x2c5bb0], 0xe0f7f1a2
mov dword [0x2c5bb4], 0xa2fbe7e9
mov dword [0x2c5bb8], 0xebf0f6f1
mov word [0x2c5bbc], 0xe5ec
mov byte [0x2c5bbe], 0x82
xor eax, eax
mov cl, byte [eax + 0x2c5b98]
xor cl, 0x82
mov byte [eax + 0x2c6310], cl
inc eax
cmp eax, 0x27
jb 0x24e2f4
mov eax, 0x2c6310
ret
Function at 0x24e30f
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c63f4], 1
jne 0x24e35b
or dword [0x2c63f4], 1
mov dword [0x2c5bc0], 0xcde5e7d0
mov dword [0x2c5bc4], 0xc9ece7f2
mov dword [0x2c5bc8], 0xfac7fbe7
mov dword [0x2c5bcc], 0xe4a2abaa
mov dword [0x2c5bd0], 0xe7eeebe3
mov dword [0x2c5bd4], 0x82a2b8e6
xor eax, eax
mov cl, byte [eax + 0x2c5bc0]
xor cl, 0x82
mov byte [eax + 0x2c6338], cl
inc eax
cmp eax, 0x18
jb 0x24e35d
mov eax, 0x2c6338
ret

Function at 0x24e378
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c63f0], 1
jne 0x24e3ca
or dword [0x2c63f0], 1
mov dword [0x2c5bd8], 0xe7c6cad1
mov dword [0x2c5bdc], 0xe7f6e7ee
mov dword [0x2c5be0], 0xaafbe7c9
mov dword [0x2c5be4], 0xe3e4a2ab
mov dword [0x2c5be8], 0xe6e7eeeb
mov word [0x2c5bec], 0xa2b8
mov byte [0x2c5bee], 0x82
xor eax, eax
mov cl, byte [eax + 0x2c5bd8]
xor cl, 0x82
mov byte [eax + 0x2c6350], cl
inc eax
cmp eax, 0x17
jb 0x24e3cc
mov eax, 0x2c6350
ret

Function at 0x24e519
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c63ec], 1
jne 0x24e565
or dword [0x2c63ec], 1
mov dword [0x2c5bf0], 0xcde5e7d0
mov dword [0x2c5bf4], 0xc9ece7f2
mov dword [0x2c5bf8], 0xfac7fbe7
mov dword [0x2c5bfc], 0xe4a2abaa
mov dword [0x2c5c00], 0xe7eeebe3
mov dword [0x2c5c04], 0x82a2b8e6
xor eax, eax
mov cl, byte [eax + 0x2c5bf0]
xor cl, 0x82
mov byte [eax + 0x2c6368], cl
inc eax
cmp eax, 0x18
jb 0x24e567
mov eax, 0x2c6368
ret

Function at 0x24e582
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c63e8], 1
jne 0x24e5d5
or dword [0x2c63e8], 1
mov dword [0x2c5c08], 0xe7c6cad1
mov dword [0x2c5c0c], 0xe7f6e7ee
mov dword [0x2c5c10], 0xf7eee3d4
mov dword [0x2c5c14], 0xa2abaae7
mov dword [0x2c5c18], 0xeeebe3e4
mov dword [0x2c5c1c], 0xa2b8e6e7
mov byte [0x2c5c20], 0x82
xor eax, eax
mov cl, byte [eax + 0x2c5c08]
xor cl, 0x82
mov byte [eax + 0x2c6380], cl
inc eax
cmp eax, 0x19
jb 0x24e5d7
mov eax, 0x2c6380
ret

Function at 0x24e8ae
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c63e4], 1
jne 0x24e969
or dword [0x2c63e4], 1
mov dword [0x2c5c28], 0xc6c1c0c3
mov dword [0x2c5c2c], 0xcac5c4c7
mov dword [0x2c5c30], 0xcec9c8cb
mov dword [0x2c5c34], 0xd2cdcccf
mov dword [0x2c5c38], 0xd6d1d0d3
mov dword [0x2c5c3c], 0xdad5d4d7
mov dword [0x2c5c40], 0xe0e3d8db
mov dword [0x2c5c44], 0xe4e7e6e1
mov dword [0x2c5c48], 0xe8ebeae5
mov dword [0x2c5c4c], 0xecefeee9
mov dword [0x2c5c50], 0xf0f3f2ed
mov dword [0x2c5c54], 0xf4f7f6f1
mov dword [0x2c5c58], 0xf8fbfaf5
mov dword [0x2c5c5c], 0xb1b0b3b2
mov dword [0x2c5c60], 0xb5b4b7b6
mov dword [0x2c5c64], 0xada9bbba
mov byte [0x2c5c68], 0x82
xor eax, eax
mov cl, byte [eax + 0x2c5c28]
xor cl, 0x82
mov byte [eax + 0x2c63a0], cl
inc eax
cmp eax, 0x41
jb 0x24e96b
mov eax, 0x2c63a0
ret
Function at 0x24ea16
Capabilities:
Encode data using base64

Disassembly:
push ebp
mov ebp, esp
push ecx
mov ecx, dword [ebp + 8]
push ebx
push esi
push edi
mov edi, eax
xor edx, edx
push 3
lea eax, [ecx + 2]
pop ebx
div ebx
mov esi, dword [ebp + 0x10]
shl eax, 2
inc eax
cmp dword [esi], eax
jae 0x24ea40
mov dword [esi], eax
xor al, al
jmp 0x24eb18
mov eax, ecx
xor edx, edx
push 3
pop ecx
div ecx
mov esi, dword [ebp + 0xc]
mov ecx, dword [0x2c09ac]
xor edx, edx
imul eax, eax, 3
test eax, eax
je 0x24eabc
dec eax
push 3
pop ebx
div ebx
inc eax
mov edx, eax
mov dword [ebp - 4], eax
imul edx, edx, 3
movzx eax, byte [edi]
shr eax, 2
mov al, byte [eax + ecx]
mov byte [esi], al
movzx eax, byte [edi + 1]
movzx ebx, byte [edi]
shr eax, 4
shl ebx, 4
add eax, ebx
and eax, 0x3f
mov al, byte [eax + ecx]
mov byte [esi + 1], al
movzx eax, byte [edi + 2]
movzx ebx, byte [edi + 1]
shr eax, 6
lea eax, [eax + ebx*4]
and eax, 0x3f
mov al, byte [eax + ecx]
mov byte [esi + 2], al
movzx eax, byte [edi + 2]
and eax, 0x3f
mov al, byte [eax + ecx]
mov byte [esi + 3], al
add esi, 4
add edi, 3
dec dword [ebp - 4]
jne 0x24ea6a
cmp edx, dword [ebp + 8]
jae 0x24eb0b
movzx eax, byte [edi]
inc edx
cmp edx, dword [ebp + 8]
jae 0x24ead0
movzx edi, byte [edi + 1]
jmp 0x24ead2
xor edi, edi
mov ebx, eax
shr ebx, 2
and ebx, 0x3f
mov bl, byte [ebx + ecx]
mov byte [esi], bl
mov ebx, edi
shr ebx, 4
shl eax, 4
add ebx, eax
and ebx, 0x3f
mov al, byte [ebx + ecx]
mov byte [esi + 1], al
cmp edx, dword [ebp + 8]
jae 0x24eaff
and edi, 0xf
mov cl, byte [ecx + edi*4]
jmp 0x24eb01
mov cl, 0x3d
mov byte [esi + 2], cl
mov byte [esi + 3], 0x3d
add esi, 4
mov eax, dword [ebp + 0x10]
mov byte [esi], 0
sub esi, dword [ebp + 0xc]
mov dword [eax], esi
mov al, 1
pop edi
pop esi
pop ebx
leave
ret
Function at 0x250850
Capabilities:
Hash data using sha1

Disassembly:
push ebp
mov ebp, esp
mov eax, dword [ebp + 8]
xor ecx, ecx
mov dword [eax + 8], 0x67452301
mov dword [eax + 0xc], 0xefcdab89
mov dword [eax + 0x10], 0x98badcfe
mov dword [eax + 0x14], 0x10325476
mov dword [eax + 0x18], 0xc3d2e1f0
mov dword [eax + 0x1c], ecx
mov dword [eax], ecx
mov dword [eax + 4], ecx
xor eax, eax
pop ebp
ret

Function at 0x250940
Capabilities:
Enumerate pe sections

Disassembly:
push ebp
mov ebp, esp
push esi
mov esi, dword [ebp + 8]
mov eax, dword [esi + 0x1c]
mov edx, 0x40
cmp eax, edx
jb 0x250959
lea eax, [edx - 0x30]
pop esi
pop ebp
ret
lea ecx, [eax*8]
add dword [esi], ecx
push ebx
mov ebx, 0
adc dword [esi + 4], ebx
push edi
mov byte [eax + esi + 0x20], 0x80
mov edi, 1
add dword [esi + 0x1c], edi
mov eax, dword [esi + 0x1c]
mov ecx, 0x38
cmp eax, ecx
jbe 0x2509b2
cmp eax, edx
jae 0x25099e
lea esp, [esp]
mov byte [eax + esi + 0x20], bl
add dword [esi + 0x1c], edi
mov eax, dword [esi + 0x1c]
cmp eax, edx
jb 0x250990
lea edx, [esi + 0x20]
push esi
call fcn.00250350
add esp, 4
mov dword [esi + 0x1c], ebx
mov ecx, 0x38
cmp dword [esi + 0x1c], ecx
jae 0x2509cf
jmp 0x2509c0
mov edx, dword [esi + 0x1c]
mov byte [esi + edx + 0x20], bl
add dword [esi + 0x1c], edi
cmp dword [esi + 0x1c], ecx
jb 0x2509c0
movzx eax, byte [esi + 7]
movzx ecx, byte [esi + 6]
movzx edx, byte [esi + 5]
mov byte [esi + 0x58], al
movzx eax, byte [esi + 4]
mov byte [esi + 0x59], cl
movzx ecx, byte [esi + 3]
mov byte [esi + 0x5a], dl
movzx edx, byte [esi + 2]
mov byte [esi + 0x5b], al
movzx eax, byte [esi + 1]
mov byte [esi + 0x5c], cl
movzx ecx, byte [esi]
mov byte [esi + 0x5d], dl
lea edx, [esi + 0x20]
push esi
mov byte [esi + 0x5e], al
mov byte [esi + 0x5f], cl
call fcn.00250350
movzx edx, byte [esi + 0xb]
mov eax, dword [ebp + 0xc]
mov byte [eax], dl
movzx ecx, byte [esi + 0xa]
mov byte [eax + 1], cl
movzx edx, byte [esi + 9]
mov byte [eax + 2], dl
movzx ecx, byte [esi + 8]
mov byte [eax + 3], cl
movzx edx, byte [esi + 0xf]
mov byte [eax + 4], dl
movzx ecx, byte [esi + 0xe]
mov byte [eax + 5], cl
movzx edx, byte [esi + 0xd]
mov byte [eax + 6], dl
movzx ecx, byte [esi + 0xc]
mov byte [eax + 7], cl
movzx edx, byte [esi + 0x13]
mov byte [eax + 8], dl
movzx ecx, byte [esi + 0x12]
mov byte [eax + 9], cl
movzx edx, byte [esi + 0x11]
mov byte [eax + 0xa], dl
movzx ecx, byte [esi + 0x10]
mov byte [eax + 0xb], cl
movzx edx, byte [esi + 0x17]
mov byte [eax + 0xc], dl
movzx ecx, byte [esi + 0x16]
mov byte [eax + 0xd], cl
movzx edx, byte [esi + 0x15]
mov byte [eax + 0xe], dl
movzx ecx, byte [esi + 0x14]
mov byte [eax + 0xf], cl
movzx edx, byte [esi + 0x1b]
mov byte [eax + 0x10], dl
movzx ecx, byte [esi + 0x1a]
mov byte [eax + 0x11], cl
movzx edx, byte [esi + 0x19]
add esp, 4
mov byte [eax + 0x12], dl
movzx ecx, byte [esi + 0x18]
pop edi
pop ebx
mov byte [eax + 0x13], cl
xor eax, eax
pop esi
pop ebp
ret
Function at 0x2510e0
Capabilities:
Encode data using xor

Disassembly:
push ebp
mov ebp, esp
push esi
mov esi, dword [ebp + 8]
cmp dword [esi + 0x23c], 0
jne 0x251234
mov eax, dword [esi + 0x240]
cmp eax, 0x10
jge 0x251234
test eax, eax
js 0x251234
mov eax, dword [esi + 0x234]
push eax
call fcn.002550e0
add esp, 4
test eax, eax
jne 0x251239
mov ecx, dword [esi + 0x240]
mov eax, dword [ebp + 0x10]
lea edx, [ecx + eax]
cmp edx, 0xc
jbe 0x25113a
or dword [esi + 0x238], 1
push ebx
push edi
xor edi, edi
test ecx, ecx
jne 0x251195
mov ecx, eax
and ecx, 0xfffffff0
mov dword [ebp + 8], ecx
jbe 0x25118e
lea ebx, [esi + 0x1f4]
xor eax, eax
mov edx, dword [ebp + 0xc]
lea ecx, [eax + edi]
mov ecx, dword [ecx + edx]
xor dword [ebx + eax], ecx
add eax, 4
cmp eax, 0x10
jb 0x251154
push ebx
push esi
call fcn.00255050
add esp, 8
add dword [esi + 0x248], 0x80
adc dword [esi + 0x24c], 0
add edi, 0x10
cmp edi, dword [ebp + 8]
jb 0x251152
mov eax, dword [ebp + 0x10]
mov ebx, dword [ebp + 0xc]
add ebx, edi
jmp 0x251198
mov ebx, dword [ebp + 0xc]
cmp edi, eax
jae 0x25122d
sub eax, edi
mov dword [ebp + 8], eax
mov ecx, 1
lea ebx, [ebx]
mov al, byte [ebx]
mov edx, dword [esi + 0x240]
mov byte [esi + edx + 0x224], al
add dword [esi + 0x240], ecx
add ebx, ecx
cmp dword [esi + 0x240], 0x10
jne 0x251223
lea edi, [esi + 0x1f4]
mov eax, edi
mov ecx, 4
lea ecx, [ecx]
movzx edx, byte [eax + 0x30]
xor byte [eax], dl
movzx edx, byte [eax + 0x31]
xor byte [eax + 1], dl
movzx edx, byte [eax + 0x32]
xor byte [eax + 2], dl
movzx edx, byte [eax + 0x33]
xor byte [eax + 3], dl
add eax, 4
dec ecx
jne 0x2511e0
push edi
push esi
call fcn.00255050
xor eax, eax
add esp, 8
add dword [esi + 0x248], 0x80
mov dword [esi + 0x240], eax
adc dword [esi + 0x24c], eax
mov ecx, 1
sub dword [ebp + 8], ecx
jne 0x2511b0
pop edi
pop ebx
xor eax, eax
pop esi
pop ebp
ret
mov eax, 0x10
pop esi
pop ebp
ret