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

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rsi
mov qword [rsp + 0x18], rdi
mov qword [rsp + 0x20], r14
mov r11, qword [rcx]
mov rsi, rdx
mov r10, qword [rcx + 8]
mov rbx, rcx
mov r9, qword [rcx + 0x10]
mov rdi, qword [rcx + 0x18]
mov rax, qword [rcx + 0x20]
shl r11, 0x38
cmp dword [rcx + 0x30], 0
je 0x140c45cde
test r8, r8
je 0x140c45cde
mov r14d, dword [rcx + 0x2c]
cmp r8, r14
jne 0x140c45cde
mov ecx, dword [rcx + 0x28]
dec ecx
cmp ecx, 6
ja case.default.0x140c45acd
lea r8, [0x140000000]
mov edx, dword [r8 + rcx*4 + 0xc45cf8]
add rdx, r8
jmp rdx
movzx ecx, byte [rbx + 0x3e]
shl rcx, 0x30
or r11, rcx
movzx ecx, byte [rbx + 0x3d]
shl rcx, 0x28
or r11, rcx
movzx ecx, byte [rbx + 0x3c]
shl rcx, 0x20
or r11, rcx
movzx ecx, byte [rbx + 0x3b]
shl rcx, 0x18
or r11, rcx
movzx ecx, byte [rbx + 0x3a]
shl rcx, 0x10
or r11, rcx
movzx ecx, byte [rbx + 0x39]
shl rcx, 8
or r11, rcx
movzx ecx, byte [rbx + 0x38]
or r11, rcx
xor rax, r11
cmp dword [rbx + 0x30], 0
jbe 0x140c45b76
mov r8d, dword [rbx + 0x30]
nop word [rax + rax]
add rdi, rax
add r10, r9
ror r9, 0x33
xor r9, r10
ror rax, 0x30
xor rax, rdi
ror r10, 0x20
add rdi, r9
add r10, rax
mov rdx, rdi
ror r9, 0x2f
mov rcx, rdi
shr rdx, 0x20
xor r9, rdi
ror rax, 0x2b
shl rcx, 0x20
mov rdi, rdx
or rdi, rcx
xor rax, r10
sub r8, 1
jne 0x140c45b30
xor r10, r11
mov ecx, 0xff
cmp r14d, 0x10
mov r8d, 0xee
cmovne r8d, ecx
mov ecx, dword [rbx + 0x34]
xor r8, rdi
test ecx, ecx
je 0x140c45be6
mov r11d, ecx
nop dword [rax]
add r8, rax
add r10, r9
ror r9, 0x33
xor r9, r10
ror rax, 0x30
xor rax, r8
ror r10, 0x20
add r8, r9
add r10, rax
mov rdx, r8
ror r9, 0x2f
mov rcx, r8
shr rdx, 0x20
xor r9, r8
ror rax, 0x2b
shl rcx, 0x20
mov r8, rdx
or r8, rcx
xor rax, r10
sub r11, 1
jne 0x140c45ba0
mov rdx, rax
xor rdx, r8
xor rdx, r9
xor rdx, r10
mov ecx, edx
mov byte [rsi], dl
shr ecx, 8
mov byte [rsi + 1], cl
mov ecx, edx
shr ecx, 0x10
mov byte [rsi + 2], cl
mov ecx, edx
shr ecx, 0x18
shr rdx, 0x20
mov byte [rsi + 3], cl
mov ecx, edx
shr ecx, 8
mov byte [rsi + 5], cl
mov ecx, edx
mov byte [rsi + 4], dl
shr ecx, 0x10
shr edx, 0x18
mov byte [rsi + 6], cl
mov byte [rsi + 7], dl
cmp dword [rbx + 0x2c], 8
je 0x140c45cd7
mov ecx, dword [rbx + 0x34]
xor r9, 0xdd
test ecx, ecx
je 0x140c45c96
mov r11d, ecx
nop dword [rax]
nop dword [rax + rax]
add r8, rax
add r10, r9
ror r9, 0x33
xor r9, r10
ror rax, 0x30
xor rax, r8
ror r10, 0x20
add r8, r9
add r10, rax
mov rdx, r8
ror r9, 0x2f
mov rcx, r8
shr rdx, 0x20
xor r9, r8
ror rax, 0x2b
shl rcx, 0x20
mov r8, rdx
or r8, rcx
xor rax, r10
sub r11, 1
jne 0x140c45c50
xor rax, r8
xor rax, r9
xor rax, r10
mov ecx, eax
mov byte [rsi + 8], al
shr ecx, 8
mov byte [rsi + 9], cl
mov ecx, eax
shr ecx, 0x10
mov byte [rsi + 0xa], cl
mov ecx, eax
shr ecx, 0x18
shr rax, 0x20
mov byte [rsi + 0xb], cl
mov ecx, eax
shr ecx, 8
mov byte [rsi + 0xd], cl
mov ecx, eax
shr ecx, 0x10
mov byte [rsi + 0xc], al
shr eax, 0x18
mov byte [rsi + 0xf], al
mov byte [rsi + 0xe], cl
mov eax, 1
jmp 0x140c45ce0
xor eax, eax
mov rbx, qword [rsp + 8]
mov rsi, qword [rsp + 0x10]
mov rdi, qword [rsp + 0x18]
mov r14, qword [rsp + 0x20]
ret
Function at 0x140c45e70
Capabilities:
Encode data using xor

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rbp
mov qword [rsp + 0x18], rsi
push rdi
push r12
push r13
push r14
push r15
mov eax, 0x20
call fcn.140cbaf80
sub rsp, rax
add qword [rcx], r8
mov r14, rcx
mov rsi, qword [rcx + 8]
mov r15, r8
mov rdi, qword [rcx + 0x10]
mov r13, rdx
mov rbp, qword [rcx + 0x18]
mov rbx, qword [rcx + 0x20]
mov ecx, dword [rcx + 0x28]
test ecx, ecx
je 0x140c45faf
mov r12d, 8
sub r12d, ecx
add rcx, 0x38
add rcx, r14
cmp r8, r12
jae 0x140c45edf
call fcn.140cfb740
add dword [r14 + 0x28], r15d
jmp 0x140c460c5
mov r8, r12
call fcn.140cfb740
movzx eax, byte [r14 + 0x3e]
lea rcx, [r14 + 0x38]
movzx r8d, byte [r14 + 0x3f]
sub r15, r12
shl r8, 8
add r13, r12
or r8, rax
movzx eax, byte [r14 + 0x3d]
shl r8, 8
or r8, rax
movzx eax, byte [r14 + 0x3c]
shl r8, 8
or r8, rax
movzx eax, byte [r14 + 0x3b]
shl r8, 8
or r8, rax
movzx eax, byte [r14 + 0x3a]
shl r8, 8
or r8, rax
movzx eax, byte [r14 + 0x39]
shl r8, 8
or r8, rax
movzx eax, byte [rcx]
shl r8, 8
or r8, rax
mov eax, dword [r14 + 0x30]
xor rbx, r8
test eax, eax
je 0x140c45faa
mov edx, eax
nop word [rax + rax]
add rbp, rbx
add rsi, rdi
ror rdi, 0x33
xor rdi, rsi
ror rbx, 0x30
xor rbx, rbp
ror rsi, 0x20
add rbp, rdi
add rsi, rbx
mov rcx, rbp
ror rdi, 0x2f
mov rax, rbp
shr rcx, 0x20
xor rdi, rbp
ror rbx, 0x2b
shl rax, 0x20
mov rbp, rcx
or rbp, rax
xor rbx, rsi
sub rdx, 1
jne 0x140c45f60
lea rcx, [r14 + 0x38]
xor rsi, r8
jmp 0x140c45fb3
lea rcx, [r14 + 0x38]
mov r12d, r15d
mov r10, r13
and r12d, 7
sub r10, r12
add r10, r15
cmp r13, r10
je 0x140c460a1
mov r11d, dword [r14 + 0x30]
lea r9, [r13 + 6]
nop dword [rax]
nop dword [rax + rax]
movzx eax, byte [r9]
movzx r8d, byte [r9 + 1]
shl r8, 8
or r8, rax
movzx eax, byte [r9 - 1]
shl r8, 8
or r8, rax
movzx eax, byte [r9 - 2]
shl r8, 8
or r8, rax
movzx eax, byte [r9 - 3]
shl r8, 8
or r8, rax
movzx eax, byte [r9 - 4]
shl r8, 8
or r8, rax
movzx eax, byte [r9 - 5]
shl r8, 8
or r8, rax
movzx eax, byte [r9 - 6]
shl r8, 8
or r8, rax
xor rbx, r8
test r11d, r11d
je 0x140c46089
mov rdx, r11
add rbp, rbx
add rsi, rdi
ror rdi, 0x33
xor rdi, rsi
ror rbx, 0x30
xor rbx, rbp
ror rsi, 0x20
add rbp, rdi
add rsi, rbx
mov rcx, rbp
ror rdi, 0x2f
mov rax, rbp
shr rcx, 0x20
xor rdi, rbp
ror rbx, 0x2b
shl rax, 0x20
mov rbp, rcx
or rbp, rax
xor rbx, rsi
sub rdx, 1
jne 0x140c46043
add r9, 8
xor rsi, r8
lea rax, [r9 - 6]
cmp rax, r10
jne 0x140c45fe0
lea rcx, [r14 + 0x38]
test r12d, r12d
je 0x140c460b1
mov r8, r12
mov rdx, r10
call fcn.140cfb740
mov dword [r14 + 0x28], r12d
mov qword [r14 + 8], rsi
mov qword [r14 + 0x10], rdi
mov qword [r14 + 0x18], rbp
mov qword [r14 + 0x20], rbx
mov rbx, qword [rsp + 0x50]
mov rbp, qword [rsp + 0x58]
mov rsi, qword [rsp + 0x60]
add rsp, 0x20
pop r15
pop r14
pop r13
pop r12
pop rdi
ret
Function at 0x140c57030
Capabilities:
Encode data using xor

Disassembly:
mov qword [rsp + 0x10], rdx
push rbp
push rsi
push r12
push r13
push r14
mov eax, 0x50
call fcn.140cbaf80
sub rsp, rax
mov r14, qword [rsp + 0xa8]
xor r11d, r11d
mov rbp, qword [rsp + 0xb0]
cmp r14, 1
mov eax, r11d
mov r13, r9
mov r9, qword [rcx]
setne al
add rax, rbp
mov r12, r8
mov rsi, rcx
mov r10, 0xffffffffffffffff
cmp rax, r9
jbe 0x140c57091
xor eax, eax
add rsp, 0x50
pop r14
pop r13
pop r12
pop rsi
pop rbp
ret
mov qword [rsp + 0x80], rbx
cmp r14, 1
je 0x140c57190
lea r10, [r8 - 1]
add r10, r9
movzx ebx, byte [r10]
cmp dword [rsp + 0xb8], r11d
je 0x140c570ce
sub r9, rbx
mov eax, 1
sub r9, rbp
dec r9
mov qword [rcx], r9
jmp 0x140c571c7
lea rcx, [rbx + rax]
mov qword [rsp + 0x98], r15
mov r15d, 0x100
mov r8, r9
sub r8, rcx
mov rax, r9
xor r8, rcx
xor rax, rcx
or r8, rax
xor r8, r9
shr r8, 0x3f
dec r8
cmp r9, r15
cmovb r15, r9
test r15, r15
je 0x140c5716a
mov qword [rsp + 0x90], rdi
mov rdi, rbx
shr rdi, 0x3f
nop word [rax + rax]
mov rax, r11
lea r10, [r10 - 1]
shr rax, 0x3f
mov rcx, rbx
sub rcx, r11
inc r11
shr rcx, 0x3f
xor cl, al
xor al, dil
or cl, al
dec cl
movzx edx, cl
movzx ecx, byte [r10 + 1]
xor rcx, rbx
and rdx, rcx
not rdx
and r8, rdx
cmp r11, r15
jb 0x140c57120
mov rdi, qword [rsp + 0x90]
mov rdx, qword [rsp + 0x88]
mov r15, qword [rsp + 0x98]
lea rax, [rbx + 1]
not r8
movzx r10d, r8b
dec r10
shr r10, 0x3f
neg r10
and rax, r10
sub r9, rax
mov qword [rsi], r9
mov rax, qword [rsp + 0xc0]
mov r9, r13
mov qword [rsp + 0x40], rax
mov r8, r12
mov rax, qword [rsp + 0xa0]
mov rcx, rsi
mov qword [rsp + 0x38], r10
mov qword [rsp + 0x30], rbp
mov qword [rsp + 0x28], r14
mov qword [rsp + 0x20], rax
call fcn.140c56c60
mov rbx, qword [rsp + 0x80]
add rsp, 0x50
pop r14
pop r13
pop r12
pop rsi
pop rbp
ret
Function at 0x140c5b6b0
Capabilities:
Encode data using xor

Disassembly:
push rbx
push rbp
push rsi
push rdi
push r14
push r15
mov eax, 0x68
call fcn.140cbaf80
sub rsp, rax
mov rax, qword [0x140f4c000]
xor rax, rsp
mov qword [rsp + 0x58], rax
mov eax, dword [rcx + 0x3c]
mov rdi, r9
mov rbp, r8
mov r14, rdx
mov rsi, rcx
test eax, eax
je 0x140c5b7e3
movups xmm0, xmmword [rcx + 0x10]
mov r15, qword [rcx + 0x20]
lea rbx, [rcx + 0x10]
dec eax
mov dword [rsp + 0x28], 1
mov dword [rcx + 0x3c], eax
xor r9d, r9d
mov eax, dword [rbx + 8]
xor r8d, r8d
and al, 0x7f
mov dword [rsp + 0x30], edi
movups xmmword [rsp + 0x48], xmm0
and byte [rsp + 0x54], 0x7f
xor edx, edx
mov byte [rsp + 0x50], al
mov rcx, r15
lea rax, [rsp + 0x48]
mov qword [rsp + 0x20], rax
call fcn.140b035e0
test eax, eax
je 0x140c5b7e3
mov eax, dword [rsp + 0x30]
lea r8, [rsp + 0x30]
mov r9, r14
mov dword [rsp + 0x20], eax
mov rdx, rbp
mov rcx, r15
call fcn.140b04360
test eax, eax
je 0x140c5b7e3
mov r9, rdi
lea rdx, [rsp + 0x38]
mov r8, rbp
mov rcx, rsi
call fcn.140c5bde0
test eax, eax
je 0x140c5b7e3
lea rax, [rbx + 0xf]
xor r8d, r8d
lea rcx, [rsp + 0x38]
cmp rcx, rax
ja 0x140c5b7b9
lea rax, [rsp + 0x47]
cmp rax, rbx
jb 0x140c5b7b9
lea rcx, [rsp + 0x38]
mov eax, r8d
sub rbx, rcx
nop
lea rdx, [rsp + 0x38]
add rdx, rax
inc rax
movzx ecx, byte [rbx + rdx]
xor byte [rdx], cl
cmp rax, 0x10
jl 0x140c5b7a0
jmp 0x140c5b7cc
movdqu xmm1, xmmword [rsp + 0x38]
movdqu xmm0, xmmword [rbx]
xorps xmm1, xmm0
movdqu xmmword [rsp + 0x38], xmm1
mov rax, qword [rsp + 0x38]
or rax, qword [rsp + 0x40]
je 0x140c5b7ff
mov rdx, rdi
mov rcx, rbp
call fcn.140001240
xor eax, eax
mov rcx, qword [rsp + 0x58]
xor rcx, rsp
call fcn.140cbacb0
add rsp, 0x68
pop r15
pop r14
pop rdi
pop rsi
pop rbp
pop rbx
ret
mov dword [rsi + 0x38], r8d
mov eax, edi
jmp 0x140c5b7e5
Function at 0x140c675c0
Capabilities:
Decrypt data using aes via x86 extensions
Encrypt data using aes via x86 extensions
Resolve function by parsing pe exports

Disassembly:
mov qword [rsp + 0x18], rbp
push rdi
push r14
push r15
sub rsp, 0x20
mov qword [rsp + 0x48], rsi
mov rdi, rcx
mov rsi, qword [rcx + 8]
mov rbp, r9
sub rsi, rcx
mov r14, r8
sub rsi, 0x10
mov ecx, 0x2000000
sar rsi, 2
mov r15d, edx
call fcn.140c6e430
test eax, eax
je 0x140c67611
mov rcx, rdi
shr rcx, 2
and ecx, 3
je 0x140c67611
mov eax, 4
sub eax, ecx
jmp 0x140c67613
xor eax, eax
cmp eax, esi
je 0x140c6764b
mov qword [rsp + 0x40], rbx
mov ebx, eax
mov eax, dword [rdi]
add rbx, 4
inc eax
shl eax, 4
movsxd r8, eax
mov eax, esi
lea rbx, [rdi + rbx*4]
add rax, 4
mov rcx, rbx
lea rdx, [rdi + rax*4]
call fcn.140cfb740
mov qword [rdi + 8], rbx
mov rbx, qword [rsp + 0x40]
mov ecx, 0x2000000
call fcn.140c6e430
mov rsi, qword [rsp + 0x48]
mov rcx, rdi
test eax, eax
je 0x140c6767d
mov r9, rbp
mov r8, r14
mov edx, r15d
mov rbp, qword [rsp + 0x50]
add rsp, 0x20
pop r15
pop r14
pop rdi
jmp fcn.140c6e0c0
mov r8, rbp
mov rdx, r14
cmp r15d, 1
jne 0x140c6769c
mov rbp, qword [rsp + 0x50]
add rsp, 0x20
pop r15
pop r14
pop rdi
jmp fcn.140c69360
mov rbp, qword [rsp + 0x50]
add rsp, 0x20
pop r15
pop r14
pop rdi
jmp fcn.140c68b80
Function at 0x140c69ee0
Capabilities:
Encode data using xor

Disassembly:
mov qword [rsp + 0x10], rbx
mov qword [rsp + 0x18], rbp
push rsi
push rdi
push r12
push r14
push r15
sub rsp, 0x60
mov rax, qword [0x140f4c000]
xor rax, rsp
mov qword [rsp + 0x50], rax
xorps xmm0, xmm0
lea r14, [rsp + 0x20]
xor ebp, ebp
mov r15, rdx
movups xmmword [rsp + 0x20], xmm0
mov esi, ebp
mov rbx, rcx
movups xmmword [rsp + 0x30], xmm0
movups xmmword [rsp + 0x40], xmm0
nop word [rax + rax]
mov eax, reloc.WS2_32.dll_recv
add byte [rbx + rax - 1], 1
jne 0x140c69f44
dec rax
test rax, rax
jg 0x140c69f35
mov r9, r14
lea rcx, [rbx + 0x28]
mov r8, rbx
mov edx, 1
call fcn.140c675c0
mov edi, eax
test eax, eax
jne 0x140c69fc5
add r14, 0x10
add esi, 0x10
cmp esi, 0x30
jl 0x140c69f30
lea rax, [rsp + 0x20]
sub r15, rax
nop dword [rax]
nop word [rax + rax]
lea rax, [rsp + 0x20]
add rax, rbp
add rbp, 0x10
movdqu xmm0, xmmword [rax]
movdqu xmm1, xmmword [r15 + rax]
xorps xmm1, xmm0
movdqu xmmword [rax], xmm1
cmp rbp, 0x30
jl 0x140c69f80
mov r8d, 0x100
lea rdx, [rsp + 0x20]
lea rcx, [rbx + 0x28]
call fcn.140c681c0
mov edi, eax
test eax, eax
jne 0x140c69fc5
movups xmm0, xmmword [rsp + 0x40]
movups xmmword [rbx], xmm0
mov edx, gethostbyaddr
lea rcx, [rsp + 0x20]
call fcn.140c6d8e0
mov eax, edi
mov rcx, qword [rsp + 0x50]
xor rcx, rsp
call fcn.140cbacb0
lea r11, [rsp + 0x60]
mov rbx, qword [r11 + 0x38]
mov rbp, qword [r11 + 0x40]
mov rsp, r11
pop r15
pop r14
pop r12
pop rdi
pop rsi
ret
Function at 0x140c6d900
Capabilities:
Encrypt data using aes via x86 extensions

Disassembly:
movups xmm1, xmmword [rdx]
aeskeygenassist xmm0, xmm1, 1
pshufd xmm3, xmm0, 0xff
xorps xmm3, xmm1
movups xmmword [rcx], xmm1
pslldq xmm1, 4
xorps xmm3, xmm1
pslldq xmm1, 4
xorps xmm3, xmm1
pslldq xmm1, 4
xorps xmm3, xmm1
aeskeygenassist xmm0, xmm3, 2
pshufd xmm1, xmm0, 0xff
xorps xmm1, xmm3
movdqu xmmword [rcx + 0x10], xmm3
pslldq xmm3, 4
movdqa xmm0, xmm3
pslldq xmm3, 4
xorps xmm0, xmm1
movdqa xmm2, xmm3
xorps xmm2, xmm0
pslldq xmm3, 4
xorps xmm2, xmm3
aeskeygenassist xmm0, xmm2, 4
pshufd xmm1, xmm0, 0xff
xorps xmm1, xmm2
movdqu xmmword [rcx + 0x20], xmm2
pslldq xmm2, 4
movdqa xmm0, xmm2
pslldq xmm2, 4
xorps xmm0, xmm1
movdqa xmm3, xmm2
xorps xmm3, xmm0
pslldq xmm2, 4
xorps xmm3, xmm2
aeskeygenassist xmm0, xmm3, 8
pshufd xmm1, xmm0, 0xff
xorps xmm1, xmm3
movdqu xmmword [rcx + 0x30], xmm3
pslldq xmm3, 4
movdqa xmm0, xmm3
pslldq xmm3, 4
xorps xmm0, xmm1
movdqa xmm2, xmm3
xorps xmm2, xmm0
pslldq xmm3, 4
xorps xmm2, xmm3
aeskeygenassist xmm0, xmm2, 0x10
pshufd xmm1, xmm0, 0xff
xorps xmm1, xmm2
movdqu xmmword [rcx + 0x40], xmm2
pslldq xmm2, 4
movdqa xmm0, xmm2
pslldq xmm2, 4
xorps xmm0, xmm1
movdqa xmm3, xmm2
xorps xmm3, xmm0
pslldq xmm2, 4
xorps xmm3, xmm2
aeskeygenassist xmm0, xmm3, 0x20
pshufd xmm1, xmm0, 0xff
xorps xmm1, xmm3
movdqu xmmword [rcx + 0x50], xmm3
pslldq xmm3, 4
movdqa xmm0, xmm3
pslldq xmm3, 4
xorps xmm0, xmm1
movdqa xmm2, xmm3
xorps xmm2, xmm0
pslldq xmm3, 4
xorps xmm2, xmm3
aeskeygenassist xmm0, xmm2, 0x40
pshufd xmm1, xmm0, 0xff
xorps xmm1, xmm2
movdqu xmmword [rcx + 0x60], xmm2
pslldq xmm2, 4
movdqa xmm0, xmm2
pslldq xmm2, 4
movdqa xmm3, xmm2
xorps xmm0, xmm1
xorps xmm3, xmm0
pslldq xmm2, 4
xorps xmm3, xmm2
aeskeygenassist xmm0, xmm3, 0x80
pshufd xmm1, xmm0, 0xff
xorps xmm1, xmm3
movdqu xmmword [rcx + 0x70], xmm3
pslldq xmm3, 4
movdqa xmm0, xmm3
pslldq xmm3, 4
xorps xmm0, xmm1
movdqa xmm2, xmm3
xorps xmm2, xmm0
pslldq xmm3, 4
xorps xmm2, xmm3
aeskeygenassist xmm0, xmm2, 0x1b
pshufd xmm1, xmm0, 0xff
xorps xmm1, xmm2
movdqu xmmword [rcx + 0x80], xmm2
pslldq xmm2, 4
movdqa xmm0, xmm2
pslldq xmm2, 4
xorps xmm0, xmm1
movdqa xmm3, xmm2
xorps xmm3, xmm0
pslldq xmm2, 4
xorps xmm3, xmm2
aeskeygenassist xmm0, xmm3, 0x36
pshufd xmm1, xmm0, 0xff
xorps xmm1, xmm3
movdqu xmmword [rcx + 0x90], xmm3
pslldq xmm3, 4
movdqa xmm0, xmm3
pslldq xmm3, 4
xorps xmm0, xmm1
movdqa xmm1, xmm3
xorps xmm1, xmm0
pslldq xmm3, 4
xorps xmm1, xmm3
movdqu xmmword [rcx + 0xa0], xmm1
ret
Function at 0x140c6e0c0
Capabilities:
Decrypt data using aes via x86 extensions
Encrypt data using aes via x86 extensions

Disassembly:
movups xmm0, xmmword [r8]
mov rax, qword [rcx + 8]
mov r8d, dword [rcx]
dec r8d
xorps xmm0, xmmword [rax]
add rax, 0x10
test edx, edx
jne 0x140c6e0fb
test r8d, r8d
je 0x140c6e0ef
nop
aesdec xmm0, xmmword [rax]
add rax, 0x10
add r8d, 0xffffffff
jne 0x140c6e0e0
aesdeclast xmm0, xmmword [rax]
movups xmmword [r9], xmm0
xor eax, eax
ret
test r8d, r8d
je 0x140c6e10f
aesenc xmm0, xmmword [rax]
add rax, 0x10
add r8d, 0xffffffff
jne 0x140c6e100
aesenclast xmm0, xmmword [rax]
movups xmmword [r9], xmm0
xor eax, eax
ret

Function at 0x140c6e4a0
Capabilities:
Encrypt data using aes via x86 extensions

Disassembly:
movsxd rax, r8d
shl rax, 4
add rax, rdx
movdqu xmm0, xmmword [rax]
sub rax, 0x10
movdqu xmmword [rcx], xmm0
add rcx, 0x10
cmp rax, rdx
jbe 0x140c6e4d6
nop
aesimc xmm0, xmmword [rax]
sub rax, 0x10
movdqu xmmword [rcx], xmm0
lea rcx, [rcx + 0x10]
cmp rax, rdx
ja 0x140c6e4c0
movdqu xmm0, xmmword [rax]
movdqu xmmword [rcx], xmm0
ret
Function at 0x140c823d0
Capabilities:
Encrypt data using openssl rsa

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rsi
mov qword [rsp + 0x18], rdi
push r14
sub rsp, 0x20
mov rsi, rcx
lea rbx, [0x140db41f0]
mov r14, rdx
mov rcx, rbx
test rsi, rsi
je 0x140c8242e
cmp qword [0x140db41f0], 0
je 0x140c8242e
mov rdi, qword [rsi + 8]
cmp qword [rcx + 8], rdi
jne 0x140c82421
mov rdx, qword [rsi + 0x10]
mov r8, rdi
mov rcx, qword [rcx]
call fcn.140cfb640
test eax, eax
je 0x140c82449
add rbx, 0x28
mov rcx, rbx
cmp qword [rbx], 0
jne 0x140c82408
mov eax, 0xffffffd2
mov rbx, qword [rsp + 0x30]
mov rsi, qword [rsp + 0x38]
mov rdi, qword [rsp + 0x40]
add rsp, 0x20
pop r14
ret
test rbx, rbx
je 0x140c8242e
mov eax, dword [rbx + 0x20]
mov dword [r14], eax
xor eax, eax
jmp 0x140c82433

Function at 0x140c82500
Capabilities:
Encrypt data using openssl rsa

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rsi
mov qword [rsp + 0x18], rdi
mov qword [rsp + 0x20], r14
push r15
sub rsp, 0x20
mov rsi, rcx
lea rbx, [0x140db3fc0]
mov r14, r8
mov r15, rdx
mov rcx, rbx
test rsi, rsi
je 0x140c82566
cmp qword [0x140db3fc0], 0
je 0x140c82566
mov rdi, qword [rsi + 8]
cmp qword [rcx + 8], rdi
jne 0x140c82559
mov rdx, qword [rsi + 0x10]
mov r8, rdi
mov rcx, qword [rcx]
call fcn.140cfb640
test eax, eax
je 0x140c82586
add rbx, 0x28
mov rcx, rbx
cmp qword [rbx], 0
jne 0x140c82540
mov eax, 0xffffffd2
mov rbx, qword [rsp + 0x30]
mov rsi, qword [rsp + 0x38]
mov rdi, qword [rsp + 0x40]
mov r14, qword [rsp + 0x48]
add rsp, 0x20
pop r15
ret
test rbx, rbx
je 0x140c82566
mov eax, dword [rbx + 0x20]
mov dword [r15], eax
mov eax, dword [rbx + 0x24]
mov dword [r14], eax
xor eax, eax
jmp 0x140c8256b
Function at 0x140c85220
Capabilities:
Hash data using sha384
Hash data using sha512

Disassembly:
xor eax, eax
movabs r8, 0xcbbb9d5dc1059ed8
mov qword [rcx], rax
test edx, edx
mov qword [rcx + 8], rax
movabs rax, 0x6a09e667f3bcc908
cmovne rax, r8
movabs r8, 0x629a292a367cd507
mov qword [rcx + 0x10], rax
movabs rax, 0xbb67ae8584caa73b
cmovne rax, r8
movabs r8, 0x9159015a3070dd17
mov qword [rcx + 0x18], rax
movabs rax, 0x3c6ef372fe94f82b
cmovne rax, r8
movabs r8, 0x152fecd8f70e5939
mov qword [rcx + 0x20], rax
movabs rax, 0xa54ff53a5f1d36f1
cmovne rax, r8
movabs r8, 0x67332667ffc00b31
mov qword [rcx + 0x28], rax
movabs rax, 0x510e527fade682d1
cmovne rax, r8
movabs r8, 0x8eb44a8768581511
mov qword [rcx + 0x30], rax
movabs rax, 0x9b05688c2b3e6c1f
cmovne rax, r8
movabs r8, 0xdb0c2e0d64f98fa7
mov qword [rcx + 0x38], rax
movabs rax, 0x1f83d9abfb41bd6b
cmovne rax, r8
movabs r8, 0x47b5481dbefa4fa4
mov qword [rcx + 0x40], rax
movabs rax, 0x5be0cd19137e2179
cmovne rax, r8
mov qword [rcx + 0x48], rax
xor eax, eax
mov dword [rcx + 0xd0], edx
ret
Function at 0x140c8b530
Capabilities:
Hash data using sha224
Hash data using sha256

Disassembly:
xor eax, eax
mov r8d, 0xc1059ed8
mov qword [rcx], rax
test edx, edx
mov eax, 0x6a09e667
cmovne eax, r8d
mov r8d, 0x367cd507
mov dword [rcx + 8], eax
mov eax, 0xbb67ae85
cmovne eax, r8d
mov r8d, 0x3070dd17
mov dword [rcx + 0xc], eax
mov eax, 0x3c6ef372
cmovne eax, r8d
mov r8d, 0xf70e5939
mov dword [rcx + 0x10], eax
mov eax, 0xa54ff53a
cmovne eax, r8d
mov r8d, 0xffc00b31
mov dword [rcx + 0x14], eax
mov eax, 0x510e527f
cmovne eax, r8d
mov r8d, 0x68581511
mov dword [rcx + 0x18], eax
mov eax, 0x9b05688c
cmovne eax, r8d
mov r8d, 0x64f98fa7
mov dword [rcx + 0x1c], eax
mov eax, 0x1f83d9ab
cmovne eax, r8d
mov r8d, 0xbefa4fa4
mov dword [rcx + 0x20], eax
mov eax, 0x5be0cd19
cmovne eax, r8d
mov dword [rcx + 0x24], eax
xor eax, eax
mov dword [rcx + 0x68], edx
ret
Function at 0x140c8cc60
Capabilities:
Encode data using xor

Disassembly:
mov qword [rsp + 0x20], rsi
push rdi
push r15
mov rax, qword [rdx + 8]
mov r15, r8
mov rsi, rdx
mov rdi, rcx
cmp qword [rcx + 8], rax
je 0x140c8cc89
mov eax, 0xfffffffc
mov rsi, qword [rsp + 0x30]
pop r15
pop rdi
ret
mov r11d, dword [rcx]
mov eax, dword [rdx]
sar eax, 1
mov qword [rsp + 0x18], rbx
and eax, 1
sar r11d, 1
and r11d, 1
mov qword [rsp + 0x28], r14
xor eax, r11d
mov ebx, eax
and ebx, r11d
mov dword [r8], ebx
mov r14, qword [rcx + 8]
test r14, r14
je 0x140c8cd80
mov qword [rsp + 0x20], rbp
mov ebp, 1
sub ebp, r11d
nop dword [rax]
mov rcx, qword [rdi + 0x10]
mov r10d, 1
sub r10d, eax
mov r8, qword [rcx + r14*8 - 8]
mov rcx, qword [rsi + 0x10]
mov rdx, qword [rcx + r14*8 - 8]
mov rcx, rdx
sub rdx, r8
xor rcx, r8
shr rdx, 0x3f
mov r9, rcx
shr r8, 0x3f
not r9
shr rcx, 0x3f
and ecx, r8d
shr r9, 0x3f
and r9d, edx
or r9d, ecx
and r10d, r9d
or eax, r9d
and r10d, r11d
or r10d, ebx
mov ebx, 1
mov dword [r15], r10d
sub ebx, eax
mov rcx, qword [rsi + 0x10]
and ebx, ebp
mov r8, qword [rcx + r14*8 - 8]
mov rcx, qword [rdi + 0x10]
mov rdx, qword [rcx + r14*8 - 8]
mov rcx, rdx
sub rdx, r8
xor rcx, r8
shr rdx, 0x3f
mov r9, rcx
shr r8, 0x3f
not r9
shr rcx, 0x3f
shr r9, 0x3f
and ecx, r8d
and r9d, edx
or r9d, ecx
and ebx, r9d
or eax, r9d
or ebx, r10d
mov dword [r15], ebx
sub r14, 1
jne 0x140c8ccd0
mov rbp, qword [rsp + 0x20]
mov r14, qword [rsp + 0x28]
xor eax, eax
mov rbx, qword [rsp + 0x18]
mov rsi, qword [rsp + 0x30]
pop r15
pop rdi
ret

Function at 0x140c918d0
Capabilities:
Encode data using add xor sub operations
Encrypt data using rc4 prga

Disassembly:
mov qword [rsp + 8], rbx
mov r11d, dword [rcx]
mov r10, rcx
mov ebx, dword [rcx + 4]
test rdx, rdx
je 0x140c91932
sub r8, r9
nop word [rax + rax]
lea eax, [r11 + 1]
movzx r11d, al
lea r9, [r9 + 1]
movzx ecx, byte [r11 + r10 + 8]
lea eax, [rbx + rcx]
movzx ebx, al
movzx eax, byte [rbx + r10 + 8]
mov byte [r11 + r10 + 8], al
add al, cl
mov byte [rbx + r10 + 8], cl
movzx eax, al
movzx ecx, byte [rax + r10 + 8]
xor cl, byte [r9 + r8 - 1]
mov byte [r9 - 1], cl
sub rdx, 1
jne 0x140c918f0
mov dword [r10 + 4], ebx
xor eax, eax
mov rbx, qword [rsp + 8]
mov dword [r10], r11d
ret
Function at 0x140c92520
Capabilities:
Encode data using xor

Disassembly:
mov qword [rsp + 0x20], r9
mov qword [rsp + 0x18], r8
push rbx
push rbp
push rsi
push rdi
push r12
push r15
sub rsp, 0x28
xor r15d, r15d
mov r12, r9
mov rbx, r8
mov rbp, rdx
mov rdi, rcx
test rdx, rdx
je 0x140c9257e
mov r10, rbx
mov rcx, r9
sub r10, r9
mov rdx, qword [rdi + 0x80]
cmp rdx, 0x40
jae 0x140c9257e
movzx eax, byte [r10 + rcx]
inc r15
xor al, byte [rdx + rdi + 0x40]
mov byte [rcx], al
inc rcx
inc qword [rdi + 0x80]
sub rbp, 1
jne 0x140c92553
lea rsi, [rdi + 0x40]
cmp rbp, 0x40
jb 0x140c92689
mov qword [rsp + 0x60], r13
mov r12, rbp
mov qword [rsp + 0x20], r14
mov r13, rbx
shr r12, 6
lea rbx, [r9 + 1]
imul rax, r12, 0xffffffffffffffc0
mov r14, rdi
sub r13, r9
sub r14, r15
add rbp, rax
sub r14, r9
mov rax, r12
shl rax, 6
add rbx, r15
add r14, 0x40
add r15, rax
nop dword [rax + rax]
mov rdx, rsi
mov rcx, rdi
call fcn.140c91d50
inc dword [rdi + 0x30]
mov ecx, 8
nop dword [rax]
nop word [rax + rax]
movzx eax, byte [r14 + rbx - 1]
xor al, byte [rbx + r13 - 1]
mov byte [rbx - 1], al
movzx eax, byte [r14 + rbx]
xor al, byte [rbx + r13]
mov byte [rbx], al
movzx eax, byte [r14 + rbx + 1]
xor al, byte [rbx + r13 + 1]
mov byte [rbx + 1], al
movzx eax, byte [r14 + rbx + 2]
xor al, byte [rbx + r13 + 2]
mov byte [rbx + 2], al
movzx eax, byte [r14 + rbx + 3]
xor al, byte [rbx + r13 + 3]
mov byte [rbx + 3], al
movzx eax, byte [r14 + rbx + 4]
xor al, byte [rbx + r13 + 4]
mov byte [rbx + 4], al
movzx eax, byte [r14 + rbx + 5]
xor al, byte [rbx + r13 + 5]
mov byte [rbx + 5], al
movzx eax, byte [r14 + rbx + 6]
xor al, byte [rbx + r13 + 6]
mov byte [rbx + 6], al
add rbx, 8
sub rcx, 1
jne 0x140c925f0
sub r14, 0x40
sub r12, 1
jne 0x140c925d0
mov r14, qword [rsp + 0x20]
mov r13, qword [rsp + 0x60]
mov r12, qword [rsp + 0x78]
mov rbx, qword [rsp + 0x70]
test rbp, rbp
je 0x140c926cd
mov rdx, rsi
mov rcx, rdi
call fcn.140c91d50
inc dword [rdi + 0x30]
mov rcx, rbp
sub r15, rdi
lea rdx, [r15 + rbx]
lea r8, [r15 + r12]
nop word [rax + rax]
movzx eax, byte [rsi + rdx - 0x40]
xor al, byte [rsi]
mov byte [r8 + rsi - 0x40], al
lea rsi, [rsi + 1]
sub rcx, 1
jne 0x140c926b0
mov qword [rdi + 0x80], rbp
xor eax, eax
add rsp, 0x28
pop r15
pop r12
pop rdi
pop rsi
pop rbp
pop rbx
ret