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

Disassembly:
sub rsp, 8
xor r11d, r11d
test rcx, rcx
je 0x1400fcbf9
test byte [rcx + 0x5c], 2
lea r10, str.0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz._
jne 0x1400fcc00
lea r10, [0x1401fbed0]
test r9d, r9d
jle 0x1400fccef
inc r8
mov qword [rsp], rbx
movzx eax, byte [r8 - 1]
cmp r9d, 3
jl 0x1400fcc71
movzx ecx, al
movzx eax, byte [r8]
shl rcx, 8
or rcx, rax
movzx eax, byte [r8 + 1]
shl rcx, 8
or rcx, rax
mov rax, rcx
shr rax, 0x12
movzx eax, byte [rax + r10]
mov byte [rdx], al
mov rax, rcx
shr rax, 0xc
and eax, 0x3f
movzx eax, byte [rax + r10]
mov byte [rdx + 1], al
mov rax, rcx
shr rax, 6
and eax, 0x3f
and ecx, 0x3f
movzx eax, byte [rax + r10]
mov byte [rdx + 2], al
movzx ecx, byte [rcx + r10]
jmp 0x1400fccc1
movzx ecx, al
shl ecx, 0x10
cmp r9d, 2
jne 0x1400fcc86
movzx eax, byte [r8]
shl eax, 8
or ecx, eax
mov rax, rcx
shr rax, 0x12
movzx eax, byte [rax + r10]
mov byte [rdx], al
mov rax, rcx
shr rax, 0xc
and eax, 0x3f
movzx eax, byte [rax + r10]
mov byte [rdx + 1], al
cmp r9d, 1
jne 0x1400fccb0
mov al, 0x3d
jmp 0x1400fccbc
shr rcx, 6
and ecx, 0x3f
movzx eax, byte [rcx + r10]
mov byte [rdx + 2], al
mov cl, 0x3d
lea rax, [rdx + 3]
add r11d, 4
lea rdx, [rax + 1]
mov byte [rax], cl
add r8, 3
sub r9d, 3
test r9d, r9d
jg 0x1400fcc10
mov rbx, qword [rsp]
mov eax, r11d
mov byte [rdx], 0
add rsp, 8
ret
mov byte [rdx], r11b
mov eax, r11d
add rsp, 8
ret

Function at 0x140102790
Capabilities:
Hash data using sha512

Disassembly:
push rbx
sub rsp, 0x100
test r8, r8
mov dword [rsp + 0xf4], 0x40
movabs rax, 0x6a09e667f3bcc908
lea rbx, [0x140271a80]
mov qword [rsp + 0x20], rax
cmovne rbx, r8
movabs rax, 0xbb67ae8584caa73b
mov r8, rdx
mov qword [rsp + 0x28], rax
mov rdx, rcx
movabs rax, 0x3c6ef372fe94f82b
lea rcx, [rsp + 0x20]
mov qword [rsp + 0x30], rax
movabs rax, 0xa54ff53a5f1d36f1
mov qword [rsp + 0x38], rax
movabs rax, 0x510e527fade682d1
mov qword [rsp + 0x40], rax
movabs rax, 0x9b05688c2b3e6c1f
mov qword [rsp + 0x48], rax
movabs rax, 0x1f83d9abfb41bd6b
mov qword [rsp + 0x50], rax
movabs rax, 0x5be0cd19137e2179
mov qword [rsp + 0x58], rax
xor eax, eax
mov qword [rsp + 0x60], rax
mov qword [rsp + 0x68], rax
mov dword [rsp + 0xf0], eax
call fcn.140103100
lea rdx, [rsp + 0x20]
mov rcx, rbx
call fcn.140102880
mov edx, 0xd8
lea rcx, [rsp + 0x20]
call fcn.14006bdc0
mov rax, rbx
add rsp, 0x100
pop rbx
ret
Function at 0x140107530
Capabilities:
Encrypt data using rc4 prga

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rsi
mov qword [rsp + 0x18], rdi
mov qword [rsp + 0x20], r9
push rbp
push r12
push r13
push r14
push r15
mov rbp, rsp
sub rsp, 0x30
mov rax, qword [rbp + 0x50]
mov r12, rcx
movzx ecx, byte [rax + 7]
lea rdi, [rax + 1]
mov r13, qword [rbp + 0x58]
mov rsi, rdx
movzx edx, byte [rdi + 3]
xor r15d, r15d
movzx r11d, byte [rax]
mov r14d, r8d
movzx eax, byte [rdi]
mov ebx, dword [r13]
shl eax, 8
or r11d, eax
shl ecx, 8
movzx eax, byte [rdi + 1]
shl eax, 0x10
or r11d, eax
movzx eax, byte [rdi + 2]
shl eax, 0x18
or r11d, eax
movzx eax, byte [rdi + 4]
shl eax, 8
or edx, eax
mov dword [rbp - 8], r11d
movzx eax, byte [rdi + 5]
or ecx, eax
mov byte [rbp - 0x10], r11b
shl ecx, 0x10
mov eax, r11d
shr eax, 8
or edx, ecx
mov byte [rbp - 0xf], al
mov eax, r11d
shr eax, 0x10
mov byte [rbp - 0xe], al
mov eax, r11d
shr eax, 0x18
mov byte [rbp - 0xd], al
mov eax, edx
shr eax, 8
mov byte [rbp - 0xb], al
mov eax, edx
shr eax, 0x10
mov byte [rbp - 0xa], al
mov eax, edx
shr eax, 0x18
mov dword [rbp - 4], edx
mov byte [rbp - 0xc], dl
mov byte [rbp - 9], al
test r8d, r8d
je 0x1401076d8
mov r13, qword [rbp + 0x48]
sub r12, rsi
movzx r8d, dl
movzx r9d, r11b
nop dword [rax]
dec r14d
test ebx, ebx
jne 0x140107676
lea r8d, [rbx + 1]
mov rdx, r13
lea rcx, [rbp - 8]
call fcn.1401039a0
mov r11d, dword [rbp - 8]
mov eax, r11d
mov edx, dword [rbp - 4]
movzx r9d, byte [rbp - 8]
movzx r8d, byte [rbp - 4]
shr eax, 8
mov byte [rbp - 0xf], al
mov eax, r11d
shr eax, 0x10
mov byte [rbp - 0xe], al
mov eax, r11d
shr eax, 0x18
mov byte [rbp - 0xd], al
mov eax, edx
shr eax, 8
mov byte [rbp - 0xb], al
mov eax, edx
shr eax, 0x10
mov byte [rbp - 0xa], al
mov eax, edx
shr eax, 0x18
mov byte [rbp - 9], al
inc r15d
mov byte [rbp - 0x10], r9b
mov byte [rbp - 0xc], r8b
movsxd rax, ebx
movzx ecx, byte [rbp + rax - 0x10]
xor cl, byte [r12 + rsi]
mov byte [rsi], cl
inc rsi
inc ebx
and ebx, 7
test r14d, r14d
jne 0x140107610
mov r13, qword [rbp + 0x58]
test r15d, r15d
je 0x1401076d8
mov rax, qword [rbp + 0x50]
mov byte [rax], r9b
mov eax, r11d
shr eax, 8
mov byte [rdi], al
mov eax, r11d
shr eax, 0x10
mov byte [rdi + 1], al
mov eax, edx
shr eax, 8
shr r11d, 0x18
mov byte [rdi + 2], r11b
mov byte [rdi + 3], r8b
mov byte [rdi + 4], al
mov eax, edx
shr eax, 0x10
shr edx, 0x18
mov byte [rdi + 5], al
mov byte [rdi + 6], dl
mov rsi, qword [rsp + 0x68]
mov rdi, qword [rsp + 0x70]
mov dword [r13], ebx
mov rbx, qword [rsp + 0x60]
add rsp, 0x30
pop r15
pop r14
pop r13
pop r12
pop rbp
ret
Function at 0x140108290
Capabilities:
Encrypt data using rc4 prga

Disassembly:
mov qword [rsp + 0x10], rbx
mov qword [rsp + 0x18], rbp
mov qword [rsp + 0x20], r9
push rsi
push rdi
push r12
push r14
push r15
sub rsp, 0x30
mov rax, qword [rsp + 0x90]
mov r15, rcx
movzx ecx, byte [rax + 7]
lea rdi, [rax + 1]
mov r12, qword [rsp + 0x98]
mov rsi, rdx
movzx edx, byte [rdi + 3]
xor r14d, r14d
movzx r11d, byte [rax]
mov ebp, r8d
movzx eax, byte [rdi]
mov ebx, dword [r12]
shl eax, 8
or r11d, eax
shl ecx, 8
movzx eax, byte [rdi + 1]
shl eax, 0x10
or r11d, eax
movzx eax, byte [rdi + 2]
shl eax, 0x18
or r11d, eax
movzx eax, byte [rdi + 4]
shl eax, 8
or edx, eax
mov dword [rsp + 0x28], r11d
movzx eax, byte [rdi + 5]
or ecx, eax
mov byte [rsp + 0x20], r11b
shl ecx, 0x10
mov eax, r11d
shr eax, 8
or edx, ecx
mov byte [rsp + 0x21], al
mov eax, r11d
shr eax, 0x10
mov byte [rsp + 0x22], al
mov eax, r11d
shr eax, 0x18
mov byte [rsp + 0x23], al
mov eax, edx
shr eax, 8
mov byte [rsp + 0x25], al
mov eax, edx
shr eax, 0x10
mov byte [rsp + 0x26], al
mov eax, edx
shr eax, 0x18
mov dword [rsp + 0x2c], edx
mov byte [rsp + 0x24], dl
mov byte [rsp + 0x27], al
test r8d, r8d
je 0x140108451
mov r12, qword [rsp + 0x78]
sub r15, rsi
mov qword [rsp + 0x60], r13
mov r13, qword [rsp + 0x88]
dec ebp
test ebx, ebx
jne 0x1401083e4
mov r8, qword [rsp + 0x80]
lea rcx, [rsp + 0x28]
mov r9, r13
mov rdx, r12
call fcn.140105e60
mov r11d, dword [rsp + 0x28]
mov eax, r11d
mov edx, dword [rsp + 0x2c]
shr eax, 8
mov byte [rsp + 0x21], al
mov eax, r11d
shr eax, 0x10
mov byte [rsp + 0x22], al
mov eax, r11d
shr eax, 0x18
mov byte [rsp + 0x23], al
mov eax, edx
shr eax, 8
mov byte [rsp + 0x25], al
mov eax, edx
shr eax, 0x10
mov byte [rsp + 0x26], al
mov eax, edx
shr eax, 0x18
mov byte [rsp + 0x27], al
inc r14d
mov byte [rsp + 0x20], r11b
mov byte [rsp + 0x24], dl
movsxd rax, ebx
movzx ecx, byte [rsp + rax + 0x20]
xor cl, byte [r15 + rsi]
mov byte [rsi], cl
inc rsi
inc ebx
and ebx, 7
test ebp, ebp
jne 0x140108378
mov r13, qword [rsp + 0x60]
mov r12, qword [rsp + 0x98]
test r14d, r14d
je 0x140108451
mov rax, qword [rsp + 0x90]
mov byte [rax], r11b
mov eax, r11d
shr eax, 8
mov byte [rdi], al
mov eax, r11d
shr eax, 0x10
mov byte [rdi + 1], al
mov eax, edx
shr eax, 8
shr r11d, 0x18
mov byte [rdi + 2], r11b
mov byte [rdi + 3], dl
mov byte [rdi + 4], al
mov eax, edx
shr eax, 0x10
shr edx, 0x18
mov byte [rdi + 5], al
mov byte [rdi + 6], dl
mov rbp, qword [rsp + 0x70]
mov dword [r12], ebx
mov rbx, qword [rsp + 0x68]
add rsp, 0x30
pop r15
pop r14
pop r12
pop rdi
pop rsi
ret
Function at 0x1401097b0
Capabilities:
Encrypt data using rc4 prga

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rsi
mov qword [rsp + 0x18], rdi
mov qword [rsp + 0x20], r9
push rbp
push r12
push r13
push r14
push r15
mov rbp, rsp
sub rsp, 0x30
mov rax, qword [rbp + 0x50]
mov rsi, rdx
movzx edx, byte [rax + 4]
lea rdi, [rax + 1]
mov r13, qword [rbp + 0x58]
lea r9, [rdi + 5]
mov r12, rcx
shl edx, 0x18
movzx r10d, byte [rax]
xor r15d, r15d
movzx eax, byte [rdi]
mov r14d, r8d
movzx ecx, byte [r9]
mov ebx, dword [r13]
shl eax, 0x10
shl r10d, 0x18
or r10d, eax
shl ecx, 8
movzx eax, byte [rdi + 1]
shl eax, 8
or r10d, eax
movzx eax, byte [rdi + 2]
or r10d, eax
movzx eax, byte [rdi + 4]
shl eax, 0x10
or edx, eax
mov dword [rbp - 8], r10d
movzx eax, byte [r9 + 1]
or ecx, eax
mov byte [rbp - 0xd], r10b
or edx, ecx
mov eax, r10d
shr eax, 0x18
mov byte [rbp - 0x10], al
mov eax, r10d
shr eax, 0x10
mov byte [rbp - 0xf], al
mov eax, r10d
shr eax, 8
mov byte [rbp - 0xe], al
mov eax, edx
shr eax, 0x18
mov byte [rbp - 0xc], al
mov eax, edx
shr eax, 0x10
mov byte [rbp - 0xb], al
mov eax, edx
shr eax, 8
mov dword [rbp - 4], edx
mov byte [rbp - 0xa], al
mov byte [rbp - 9], dl
test r8d, r8d
je 0x14010994d
mov r13, qword [rbp + 0x48]
sub r12, rsi
movzx r8d, dl
movzx r9d, r10b
nop
dec r14d
test ebx, ebx
jne 0x1401098ef
mov rdx, r13
lea rcx, [rbp - 8]
call fcn.140108da0
mov r10d, dword [rbp - 8]
mov eax, r10d
mov edx, dword [rbp - 4]
movzx r9d, r10b
shr eax, 0x18
movzx r8d, dl
mov byte [rbp - 0x10], al
mov eax, r10d
shr eax, 0x10
mov byte [rbp - 0xf], al
mov eax, r10d
shr eax, 8
mov byte [rbp - 0xe], al
mov eax, edx
shr eax, 0x18
mov byte [rbp - 0xc], al
mov eax, edx
shr eax, 0x10
mov byte [rbp - 0xb], al
mov eax, edx
shr eax, 8
mov byte [rbp - 0xa], al
inc r15d
mov byte [rbp - 0xd], r10b
mov byte [rbp - 9], dl
movsxd rax, ebx
movzx ecx, byte [rbp + rax - 0x10]
xor cl, byte [r12 + rsi]
mov byte [rsi], cl
inc rsi
inc ebx
and ebx, 7
test r14d, r14d
jne 0x140109890
mov r13, qword [rbp + 0x58]
test r15d, r15d
je 0x14010994d
mov rcx, qword [rbp + 0x50]
mov eax, r10d
shr eax, 0x18
mov byte [rcx], al
mov eax, r10d
shr eax, 0x10
mov byte [rdi], al
mov eax, edx
shr eax, 0x18
shr r10d, 8
mov byte [rdi + 1], r10b
mov byte [rdi + 2], r9b
mov byte [rdi + 3], al
mov eax, edx
shr eax, 0x10
mov byte [rdi + 4], al
shr edx, 8
mov byte [rdi + 5], dl
mov byte [rdi + 6], r8b
mov rsi, qword [rsp + 0x68]
mov rdi, qword [rsp + 0x70]
mov dword [r13], ebx
mov rbx, qword [rsp + 0x60]
add rsp, 0x30
pop r15
pop r14
pop r13
pop r12
pop rbp
ret
Function at 0x14010a760
Capabilities:
Encrypt data using rc4 prga

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rsi
mov qword [rsp + 0x18], rdi
mov qword [rsp + 0x20], r9
push rbp
push r12
push r13
push r14
push r15
mov rbp, rsp
sub rsp, 0x30
mov rax, qword [rbp + 0x50]
mov r12, rcx
movzx ecx, byte [rax + 7]
lea rdi, [rax + 1]
mov r13, qword [rbp + 0x58]
mov rsi, rdx
movzx edx, byte [rdi + 3]
xor r15d, r15d
movzx r11d, byte [rax]
mov r14d, r8d
movzx eax, byte [rdi]
mov ebx, dword [r13]
shl eax, 8
or r11d, eax
shl ecx, 8
movzx eax, byte [rdi + 1]
shl eax, 0x10
or r11d, eax
movzx eax, byte [rdi + 2]
shl eax, 0x18
or r11d, eax
movzx eax, byte [rdi + 4]
shl eax, 8
or edx, eax
mov dword [rbp - 8], r11d
movzx eax, byte [rdi + 5]
or ecx, eax
mov byte [rbp - 0x10], r11b
shl ecx, 0x10
mov eax, r11d
shr eax, 8
or edx, ecx
mov byte [rbp - 0xf], al
mov eax, r11d
shr eax, 0x10
mov byte [rbp - 0xe], al
mov eax, r11d
shr eax, 0x18
mov byte [rbp - 0xd], al
mov eax, edx
shr eax, 8
mov byte [rbp - 0xb], al
mov eax, edx
shr eax, 0x10
mov byte [rbp - 0xa], al
mov eax, edx
shr eax, 0x18
mov dword [rbp - 4], edx
mov byte [rbp - 0xc], dl
mov byte [rbp - 9], al
test r8d, r8d
je 0x14010a900
mov r13, qword [rbp + 0x48]
sub r12, rsi
movzx r8d, dl
movzx r9d, r11b
nop dword [rax]
dec r14d
test ebx, ebx
jne 0x14010a8a2
mov rdx, r13
lea rcx, [rbp - 8]
call fcn.14010a400
mov r11d, dword [rbp - 8]
mov eax, r11d
mov edx, dword [rbp - 4]
movzx r9d, byte [rbp - 8]
movzx r8d, byte [rbp - 4]
shr eax, 8
mov byte [rbp - 0xf], al
mov eax, r11d
shr eax, 0x10
mov byte [rbp - 0xe], al
mov eax, r11d
shr eax, 0x18
mov byte [rbp - 0xd], al
mov eax, edx
shr eax, 8
mov byte [rbp - 0xb], al
mov eax, edx
shr eax, 0x10
mov byte [rbp - 0xa], al
mov eax, edx
shr eax, 0x18
mov byte [rbp - 9], al
inc r15d
mov byte [rbp - 0x10], r9b
mov byte [rbp - 0xc], r8b
movsxd rax, ebx
movzx ecx, byte [rbp + rax - 0x10]
xor cl, byte [r12 + rsi]
mov byte [rsi], cl
inc rsi
inc ebx
and ebx, 7
test r14d, r14d
jne 0x14010a840
mov r13, qword [rbp + 0x58]
test r15d, r15d
je 0x14010a900
mov rax, qword [rbp + 0x50]
mov byte [rax], r9b
mov eax, r11d
shr eax, 8
mov byte [rdi], al
mov eax, r11d
shr eax, 0x10
mov byte [rdi + 1], al
mov eax, edx
shr eax, 8
shr r11d, 0x18
mov byte [rdi + 2], r11b
mov byte [rdi + 3], r8b
mov byte [rdi + 4], al
mov eax, edx
shr eax, 0x10
shr edx, 0x18
mov byte [rdi + 5], al
mov byte [rdi + 6], dl
mov rsi, qword [rsp + 0x68]
mov rdi, qword [rsp + 0x70]
mov dword [r13], ebx
mov rbx, qword [rsp + 0x60]
add rsp, 0x30
pop r15
pop r14
pop r13
pop r12
pop rbp
ret
Function at 0x14010b580
Capabilities:
Encode data using xor

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, r8
call fcn.14010b7f0
test eax, eax
js 0x14010b7e4
mov ecx, dword [rbx + 0xf0]
lea eax, [rcx*4]
movsxd r9, eax
test eax, eax
jle 0x14010b613
lea r8, [rbx + 8]
xor r10d, r10d
lea r8, [r8 + r9*4]
lea rax, [rbx + 8]
nop dword [rax]
mov edx, dword [rax - 8]
add r10, 4
mov ecx, dword [r8 - 8]
lea r8, [r8 - 0x10]
mov dword [rax - 8], ecx
lea rax, [rax + 0x10]
mov ecx, dword [r8 + 0xc]
sub r9, 4
mov dword [r8 + 8], edx
mov edx, dword [rax - 0x14]
mov dword [rax - 0x14], ecx
mov ecx, dword [r8 + 0x10]
mov dword [r8 + 0xc], edx
mov edx, dword [rax - 0x10]
mov dword [rax - 0x10], ecx
mov ecx, dword [r8 + 0x14]
mov dword [r8 + 0x10], edx
mov edx, dword [rax - 0xc]
mov dword [rax - 0xc], ecx
mov dword [r8 + 0x14], edx
cmp r10, r9
jl 0x14010b5c0
mov ecx, dword [rbx + 0xf0]
mov r11d, 1
cmp ecx, r11d
jle 0x14010b7e2
mov qword [rsp + 0x30], rdi
lea r10, [rbx + 4]
lea rdi, [0x140000000]
nop dword [rax]
nop word [rax + rax]
mov r9d, dword [r10 + 0x10]
lea r10, [r10 + 0x10]
mov edx, dword [r10 - 4]
inc r11d
movzx eax, byte [r10 - 3]
movzx ecx, byte [rdi + rax*4 + 0x1ff6b0]
mov eax, edx
shr rax, 0x18
mov r8d, dword [rdi + rcx*4 + 0x200ab0]
movzx eax, byte [rdi + rax*4 + 0x1ff6b0]
xor r8d, dword [rdi + rax*4 + 0x2002b0]
movzx eax, dl
movzx ecx, byte [rdi + rax*4 + 0x1ff6b0]
movzx eax, byte [r10 - 2]
xor r8d, dword [rdi + rcx*4 + 0x200eb0]
movzx ecx, byte [rdi + rax*4 + 0x1ff6b0]
mov eax, r9d
shr eax, 0x10
xor r8d, dword [rdi + rcx*4 + 0x2006b0]
movzx ecx, al
mov eax, r9d
shr eax, 8
mov dword [r10 - 4], r8d
movzx edx, byte [rdi + rcx*4 + 0x1ff6b0]
movzx ecx, al
mov r8d, dword [rdi + rdx*4 + 0x2006b0]
movzx eax, byte [rdi + rcx*4 + 0x1ff6b0]
xor r8d, dword [rdi + rax*4 + 0x200ab0]
mov eax, r9d
shr rax, 0x18
movzx ecx, byte [rdi + rax*4 + 0x1ff6b0]
movzx eax, r9b
mov r9d, dword [r10 + 4]
xor r8d, dword [rdi + rcx*4 + 0x2002b0]
movzx ecx, byte [rdi + rax*4 + 0x1ff6b0]
mov eax, r9d
shr eax, 0x10
xor r8d, dword [rdi + rcx*4 + 0x200eb0]
movzx ecx, al
mov eax, r9d
shr eax, 8
mov dword [r10], r8d
movzx edx, byte [rdi + rcx*4 + 0x1ff6b0]
movzx ecx, al
mov r8d, dword [rdi + rdx*4 + 0x2006b0]
movzx eax, byte [rdi + rcx*4 + 0x1ff6b0]
xor r8d, dword [rdi + rax*4 + 0x200ab0]
mov eax, r9d
shr rax, 0x18
movzx ecx, byte [rdi + rax*4 + 0x1ff6b0]
movzx eax, r9b
mov r9d, dword [r10 + 8]
xor r8d, dword [rdi + rcx*4 + 0x2002b0]
movzx ecx, byte [rdi + rax*4 + 0x1ff6b0]
mov eax, r9d
shr eax, 0x10
xor r8d, dword [rdi + rcx*4 + 0x200eb0]
movzx ecx, al
mov eax, r9d
shr eax, 8
mov dword [r10 + 4], r8d
movzx edx, byte [rdi + rcx*4 + 0x1ff6b0]
movzx ecx, al
mov r8d, dword [rdi + rdx*4 + 0x2006b0]
movzx eax, byte [rdi + rcx*4 + 0x1ff6b0]
xor r8d, dword [rdi + rax*4 + 0x200ab0]
mov eax, r9d
shr rax, 0x18
movzx ecx, byte [rdi + rax*4 + 0x1ff6b0]
movzx eax, r9b
xor r8d, dword [rdi + rcx*4 + 0x2002b0]
movzx ecx, byte [rdi + rax*4 + 0x1ff6b0]
xor r8d, dword [rdi + rcx*4 + 0x200eb0]
mov dword [r10 + 8], r8d
cmp r11d, dword [rbx + 0xf0]
jl 0x14010b640
mov rdi, qword [rsp + 0x30]
xor eax, eax
add rsp, 0x20
pop rbx
ret
Function at 0x14010cc40
Capabilities:
Encode data using xor

Disassembly:
mov qword [rsp + 0x20], r9
push rbx
push rbp
push rsi
push rdi
push r13
push r14
push r15
sub rsp, 0x40
mov r15, qword [rsp + 0xa8]
mov r14, rdx
mov rdx, qword [rsp + 0xb0]
mov r10, r9
mov rdi, r8
mov rbp, rcx
mov ebx, dword [rdx]
test ebx, ebx
je 0x14010cc97
test rdi, rdi
je 0x14010cc97
mov eax, ebx
dec rdi
movzx ecx, byte [rax + r15]
xor cl, byte [rbp]
inc rbp
mov byte [r14], cl
inc r14
inc ebx
and ebx, 0xf
jne 0x14010cc75
mov r9, qword [rsp + 0xb8]
mov r13d, reloc.WS2_32.dll_recv
mov qword [rsp + 0x38], r12
mov esi, 1
cmp rdi, r13
jb 0x14010cdbb
mov rcx, rdi
xor ebx, ebx
shr rcx, 4
mov r15, r14
imul rax, rcx, 0xfffffffffffffff0
mov r12, rbp
mov dword [rsp + 0x20], ebx
mov rbx, qword [rsp + 0xa8]
add rdi, rax
mov rax, rcx
mov qword [rsp + 0x90], rdi
mov rdi, qword [rsp + 0x98]
sub r15, rbx
shl rax, 4
sub r12, rbx
add r14, rax
add rbp, rax
mov qword [rsp + 0x88], r14
mov qword [rsp + 0x80], rbp
mov r14, rcx
mov rbp, qword [rsp + 0xa0]
nop dword [rax + rax]
mov r8, rdi
mov rdx, rbx
mov rcx, rbp
call r9
mov r8d, r13d
lea rdx, [rbp + 0x10]
mov ecx, esi
nop word [rax + rax]
movzx eax, byte [rdx - 1]
lea rdx, [rdx - 1]
add ecx, eax
mov byte [rdx], cl
shr ecx, 8
add r8d, 0xffffffff
jne 0x14010cd40
mov rax, rbx
lea edx, [r8 + 2]
nop dword [rax]
mov rcx, qword [r12 + rax]
xor rcx, qword [rax]
mov qword [r15 + rax], rcx
lea rax, [rax + 8]
sub rdx, rsi
jne 0x14010cd60
mov r9, qword [rsp + 0xb8]
add r15, r13
add r12, r13
sub r14, rsi
jne 0x14010cd20
mov ebx, dword [rsp + 0x20]
mov rdi, qword [rsp + 0x90]
mov r14, qword [rsp + 0x88]
mov rbp, qword [rsp + 0x80]
mov r15, qword [rsp + 0xa8]
mov rdx, qword [rsp + 0xb0]
mov r10, qword [rsp + 0x98]
test rdi, rdi
je 0x14010ce22
mov r12, qword [rsp + 0xa0]
mov r8, r10
mov rcx, r12
mov rdx, r15
call r9
lea rcx, [r12 + 0x10]
nop dword [rax]
movzx eax, byte [rcx - 1]
lea rcx, [rcx - 1]
add esi, eax
mov byte [rcx], sil
shr esi, 8
add r13d, 0xffffffff
jne 0x14010cde0
nop word [rax + rax]
mov ecx, ebx
inc ebx
movzx eax, byte [rcx + rbp]
xor al, byte [rcx + r15]
mov byte [rcx + r14], al
sub rdi, 1
jne 0x14010ce00
mov rax, qword [rsp + 0xb0]
mov dword [rax], ebx
jmp 0x14010ce24
mov dword [rdx], ebx
mov r12, qword [rsp + 0x38]
add rsp, 0x40
pop r15
pop r14
pop r13
pop rdi
pop rsi
pop rbp
pop rbx
ret
Function at 0x14010ce40
Capabilities:
Encode data using xor

Disassembly:
mov qword [rsp + 0x20], r9
push rbx
push rbp
push rsi
push rdi
push r13
push r14
push r15
sub rsp, 0x40
mov r11, r9
mov rbx, r8
mov r9, qword [rsp + 0xb0]
mov r14, rdx
mov rbp, rcx
mov edi, dword [r9]
mov dword [rsp + 0x30], edi
test edi, edi
je 0x14010cea5
mov rdx, qword [rsp + 0xa8]
nop word [rax + rax]
test rbx, rbx
je 0x14010cea1
mov eax, edi
dec rbx
movzx ecx, byte [rax + rdx]
xor cl, byte [rbp]
inc rbp
mov byte [r14], cl
inc r14
inc edi
and edi, 0xf
jne 0x14010ce80
mov dword [rsp + 0x30], edi
mov rax, qword [rsp + 0xa0]
mov esi, 1
mov r8d, dword [rax + 0xc]
lea r15, [rax + 0xc]
mov r10, qword [rsp + 0xb8]
mov qword [rsp + 0x80], r12
lea r13d, [rsi + 0xb]
bswap r8d
mov dword [rsp + 0x90], r8d
cmp rbx, 0x10
jb 0x14010cfc5
mov rdi, qword [rsp + 0xa0]
mov eax, 0x10000000
mov rdx, rbx
mov qword [rsp + 0x20], rdi
shr rdx, 4
mov r9, r11
cmp rdx, rax
cmova rdx, rax
add r8d, edx
mov r12, rdx
mov eax, r8d
mov ecx, r8d
sub r12, rax
cmp rax, rdx
cmovae r12, rdx
xor r8d, r8d
cmp rax, rdx
mov rdx, r14
cmovae r8d, ecx
mov rcx, rbp
mov dword [rsp + 0x90], r8d
mov r8, r12
call r10
mov r8d, dword [rsp + 0x90]
mov eax, r8d
bswap eax
mov dword [r15], eax
test r8d, r8d
jne 0x14010cf7d
mov r8d, r13d
mov eax, esi
mov rdx, r15
nop word [rax + rax]
movzx ecx, byte [rdx - 1]
lea rdx, [rdx - 1]
add eax, ecx
mov byte [rdx], al
shr eax, 8
add r8d, 0xffffffff
jne 0x14010cf60
mov r8d, dword [rsp + 0x90]
mov r10, qword [rsp + 0xb8]
mov eax, 0x10000000
mov r11, qword [rsp + 0x98]
shl r12, 4
sub rbx, r12
add r14, r12
add rbp, r12
cmp rbx, 0x10
jae 0x14010cef0
mov edi, dword [rsp + 0x30]
mov r9, qword [rsp + 0xb0]
mov rax, qword [rsp + 0xa0]
mov dword [rsp + 0x90], r8d
test rbx, rbx
je 0x14010d052
mov r12, qword [rsp + 0xa8]
xor ecx, ecx
mov r9, r11
mov qword [rsp + 0x20], rax
mov r8, rsi
mov rdx, r12
mov qword [r12], rcx
mov qword [r12 + 8], rcx
mov rcx, r12
call r10
mov r8d, dword [rsp + 0x90]
add r8d, esi
bswap r8d
mov dword [r15], r8d
jne 0x14010d030
nop dword [rax + rax]
movzx eax, byte [r15 - 1]
lea r15, [r15 - 1]
add esi, eax
mov byte [r15], sil
shr esi, 8
add r13d, 0xffffffff
jne 0x14010d010
nop word [rax + rax]
mov ecx, edi
inc edi
movzx eax, byte [rcx + rbp]
xor al, byte [rcx + r12]
mov byte [rcx + r14], al
sub rbx, 1
jne 0x14010d030
mov rax, qword [rsp + 0xb0]
mov dword [rax], edi
jmp 0x14010d055
mov dword [r9], edi
mov r12, qword [rsp + 0x80]
add rsp, 0x40
pop r15
pop r14
pop r13
pop rdi
pop rsi
pop rbp
pop rbx
ret
Function at 0x14010d070
Capabilities:
Encode data using xor

Disassembly:
mov qword [rsp + 0x20], r9
push rbx
push rbp
push rsi
push rdi
push r12
push r15
sub rsp, 0x28
mov rsi, qword [rsp + 0x88]
mov r10, r9
mov rbp, qword [rsp + 0x80]
mov rdi, r8
mov r15, rdx
mov r12, rcx
mov ebx, dword [rsi]
test ebx, ebx
je 0x14010d0c5
test rdi, rdi
je 0x14010d0c5
mov eax, ebx
dec rdi
movzx ecx, byte [rax + rbp]
xor cl, byte [r12]
inc r12
mov byte [r15], cl
inc r15
inc ebx
and ebx, 0xf
jne 0x14010d0a3
mov r9, qword [rsp + 0x90]
cmp rdi, 0x10
jb 0x14010d189
mov qword [rsp + 0x60], r13
mov rsi, r15
mov r13, rdi
mov qword [rsp + 0x20], r14
shr r13, 4
mov r14, r12
imul rax, r13, 0xfffffffffffffff0
sub rsi, rbp
sub r14, rbp
add rdi, rax
mov rax, r13
shl rax, 4
add r15, rax
mov qword [rsp + 0x68], r15
add r12, rax
mov r15, qword [rsp + 0x78]
mov r8, r15
mov rdx, rbp
mov rcx, rbp
call r9
cmp ebx, 0x10
jae 0x14010d155
mov edx, recv
mov eax, ebx
sub edx, ebx
add rax, rbp
shr edx, 3
inc edx
nop dword [rax]
nop dword [rax + rax]
mov rcx, qword [r14 + rax]
xor rcx, qword [rax]
mov qword [rsi + rax], rcx
lea rax, [rax + 8]
sub rdx, 1
jne 0x14010d140
mov r9, qword [rsp + 0x90]
add rsi, 0x10
add r14, 0x10
xor ebx, ebx
sub r13, 1
jne 0x14010d112
mov r15, qword [rsp + 0x68]
mov r10, qword [rsp + 0x78]
mov rsi, qword [rsp + 0x88]
mov r14, qword [rsp + 0x20]
mov r13, qword [rsp + 0x60]
test rdi, rdi
je 0x14010d1b6
mov r8, r10
mov rdx, rbp
mov rcx, rbp
call r9
nop word [rax + rax]
mov ecx, ebx
inc ebx
movzx eax, byte [rcx + r12]
xor al, byte [rcx + rbp]
mov byte [rcx + r15], al
sub rdi, 1
jne 0x14010d1a0
mov dword [rsi], ebx
add rsp, 0x28
pop r15
pop r12
pop rdi
pop rsi
pop rbp
pop rbx
ret