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

Disassembly:
mov qword [rsp + 8], rbx
push rbp
push rsi
push rdi
push r14
push r15
sub rsp, 0x1b0
mov rax, qword [0x1402bc7c0]
xor rax, rsp
mov qword [rsp + 0x1a0], rax
mov rdi, r9
mov rbx, r8
mov rsi, qword [rsp + 0x200]
xor edx, edx
mov r8d, 0x178
lea rcx, [rsp + 0x20]
call sub.VCRUNTIME140.dll_memset
lea rcx, [rsp + 0x20]
call fcn.140053290
nop
lea r14, [rdi + 0x48]
lea rcx, [rdi + 0x50]
call fcn.140041a70
test eax, eax
jne 0x1401b8817
xor edx, edx
lea r8d, [rax + 0x10]
lea rcx, [rdi + 0x50]
call fcn.14003d870
mov dword [r14], reloc.WS2_32.dll_inet_ntoa
cmp dword [rbx + 0x554], 0
je 0x1401b882c
lea rdx, str.Not_in_IV_mode.
jmp 0x1401b89ef
mov ecx, dword [rbx + 0x558]
cmp ecx, 0xf
ja 0x1401b89e8
mov edx, dword [r14]
add edx, ecx
cmp edx, 0xc
jbe 0x1401b884c
or dword [rbx + 0x550], 1
lea rcx, [rdi + 0x50]
call fcn.140041740
mov rsi, rax
xor r15d, r15d
mov edi, r15d
cmp dword [rbx + 0x558], r15d
jne 0x1401b88b9
test dword [r14], 0xfffffff0
jbe 0x1401b88b4
mov eax, edi
mov rcx, qword [rax + rsi]
xor qword [rbx + 0x510], rcx
lea eax, [rdi + 8]
mov rax, qword [rax + rsi]
xor qword [rbx + 0x518], rax
lea r8, [rsp + 0x20]
lea rdx, [rbx + 0x510]
mov rcx, rbx
call fcn.1401ba190
sub qword [rbx + 0x560], 0xffffffffffffff80
add edi, 0x10
mov eax, dword [r14]
and eax, 0xfffffff0
cmp edi, eax
jb 0x1401b8870
mov eax, edi
add rsi, rax
cmp edi, dword [r14]
jae 0x1401b89e4
movsxd rcx, dword [rbx + 0x558]
movzx eax, byte [rsi]
mov byte [rcx + rbx + 0x540], al
inc dword [rbx + 0x558]
lea rsi, [rsi + 1]
cmp dword [rbx + 0x558], 0x10
jne 0x1401b89d9
lea rdx, [rbx + 0x510]
movzx eax, byte [rbx + 0x540]
xor byte [rdx], al
movzx eax, byte [rbx + 0x541]
xor byte [rbx + 0x511], al
movzx eax, byte [rbx + 0x542]
xor byte [rbx + 0x512], al
movzx eax, byte [rbx + 0x543]
xor byte [rbx + 0x513], al
movzx eax, byte [rbx + 0x544]
xor byte [rbx + 0x514], al
movzx eax, byte [rbx + 0x545]
xor byte [rbx + 0x515], al
movzx eax, byte [rbx + 0x546]
xor byte [rbx + 0x516], al
movzx eax, byte [rbx + 0x547]
xor byte [rbx + 0x517], al
movzx eax, byte [rbx + 0x548]
xor byte [rbx + 0x518], al
movzx eax, byte [rbx + 0x549]
xor byte [rbx + 0x519], al
movzx eax, byte [rbx + 0x54a]
xor byte [rbx + 0x51a], al
movzx eax, byte [rbx + 0x54b]
xor byte [rbx + 0x51b], al
movzx eax, byte [rbx + 0x54c]
xor byte [rbx + 0x51c], al
movzx eax, byte [rbx + 0x54d]
xor byte [rbx + 0x51d], al
movzx eax, byte [rbx + 0x54e]
xor byte [rbx + 0x51e], al
movzx eax, byte [rbx + 0x54f]
xor byte [rbx + 0x51f], al
lea r8, [rsp + 0x20]
mov rcx, rbx
call fcn.1401ba190
mov dword [rbx + 0x558], r15d
sub qword [rbx + 0x560], 0xffffffffffffff80
inc edi
cmp edi, dword [r14]
jb 0x1401b88c2
mov bl, 1
jmp 0x1401b89fa
lea rdx, str.buflen_error.
mov rax, qword [rsi]
mov rcx, rsi
call qword [rax + 0x28]
xor bl, bl
lea rcx, [rsp + 0x20]
call fcn.1400532c0
movzx eax, bl
mov rcx, qword [rsp + 0x1a0]
xor rcx, rsp
call fcn.1401d75d0
mov rbx, qword [rsp + 0x1e0]
add rsp, 0x1b0
pop r15
pop r14
pop rdi
pop rsi
pop rbp
ret
Function at 0x1401b9f40
Capabilities:
Encode data using xor
Encrypt data using rc4 prga

Disassembly:
mov qword [rsp + 0x10], rbx
push rbp
push rsi
push rdi
sub rsp, 0x40
mov rax, qword [0x1402bc7c0]
xor rax, rsp
mov qword [rsp + 0x30], rax
mov rax, qword [rcx]
lea rdx, [rsp + 0x20]
mov rbx, r8
xorps xmm0, xmm0
add r8, 0x500
movups xmmword [rsp + 0x20], xmm0
call qword [rax + 0x20]
xor edi, edi
xorps xmm0, xmm0
movups xmmword [rbx + 0x540], xmm0
mov esi, edi
xorps xmm1, xmm1
movups xmmword [rbx + 0x510], xmm1
mov qword [rbx + 0x550], rdi
mov dword [rbx + 0x558], edi
mov qword [rbx + 0x560], rdi
mov qword [rbx + 0x568], rdi
movups xmmword [rsp + 0x20], xmm0
mov r8, qword [rbx + 0x570]
lea rdx, [rsp + 0x20]
add r8, 8
mov byte [rsp + 0x20], dil
add r8, rsi
lea rcx, [rbx + 0x500]
call fcn.1401b9130
inc edi
add rsi, 0x10
cmp edi, 0x100
jl 0x1401b9fb0
mov eax, 0x1000
lea r11, [0x140270b30]
nop
mov r10d, pe_nt_image_headers64
nop word [rax + rax]
mov rdx, qword [rbx + 0x570]
movzx ecx, byte [rdx + rax - 0xfea]
movzx r9d, byte [rdx + rax - 0xfe9]
mov byte [rdx + rax + 0x17], cl
mov rdx, qword [rbx + 0x570]
movzx ecx, byte [rdx + rax - 0xfeb]
mov byte [rdx + rax + 0x16], cl
mov rdx, qword [rbx + 0x570]
movzx ecx, byte [rdx + rax - 0xfec]
mov byte [rdx + rax + 0x15], cl
mov rdx, qword [rbx + 0x570]
movzx ecx, byte [rdx + rax - 0xfed]
mov byte [rdx + rax + 0x14], cl
mov rdx, qword [rbx + 0x570]
movzx ecx, byte [rdx + rax - 0xfee]
mov byte [rdx + rax + 0x13], cl
mov rdx, qword [rbx + 0x570]
movzx ecx, byte [rdx + rax - 0xfef]
mov byte [rdx + rax + 0x12], cl
mov rdx, qword [rbx + 0x570]
movzx ecx, byte [rdx + rax - 0xff0]
mov byte [rdx + rax + 0x11], cl
mov rdx, qword [rbx + 0x570]
movzx ecx, byte [rdx + rax - 0xff1]
mov byte [rdx + rax + 0x10], cl
mov rdx, qword [rbx + 0x570]
movzx ecx, byte [rdx + rax - 0xff2]
mov byte [rdx + rax + 0xf], cl
mov rdx, qword [rbx + 0x570]
movzx ecx, byte [rdx + rax - 0xff3]
mov byte [rdx + rax + 0xe], cl
mov rdx, qword [rbx + 0x570]
movzx ecx, byte [rdx + rax - 0xff4]
mov byte [rdx + rax + 0xd], cl
mov rdx, qword [rbx + 0x570]
movzx ecx, byte [rdx + rax - 0xff5]
mov byte [rdx + rax + 0xc], cl
mov rdx, qword [rbx + 0x570]
movzx ecx, byte [rdx + rax - 0xff6]
mov byte [rdx + rax + 0xb], cl
mov rdx, qword [rbx + 0x570]
movzx ecx, byte [rdx + rax - 0xff7]
mov byte [rdx + rax + 0xa], cl
mov rdx, qword [rbx + 0x570]
movzx ecx, byte [rdx + rax - 0xff8]
mov byte [rdx + rax + 9], cl
lea ecx, [r9 + r9]
mov rdx, qword [rbx + 0x570]
movzx ecx, byte [rcx + r11]
mov byte [rax + rdx + 8], cl
lea ecx, [r9 + r9]
mov r8, qword [rbx + 0x570]
movzx ecx, byte [rcx + r11 + 1]
xor byte [r8 + rax + 9], cl
add rax, 0x10
sub r10, 1
jne 0x1401ba000
cmp rax, 0x10000
jl 0x1401b9ff0
mov al, 1
mov rcx, qword [rsp + 0x30]
xor rcx, rsp
call fcn.1401d75d0
mov rbx, qword [rsp + 0x68]
add rsp, 0x40
pop rdi
pop rsi
pop rbp
ret
Function at 0x1401bde10
Capabilities:
Encrypt data using blowfish

Disassembly:
lea rax, [0x1402bb000]
ret

Function at 0x1401bde20
Capabilities:
Encrypt data using blowfish

Disassembly:
lea rax, [0x1402bb050]
ret
Function at 0x1401c40f0
Capabilities:
Resolve function by parsing pe exports

Disassembly:
cmp byte [rcx + 0x3b0], 0
mov r9, r8
mov r8, rdx
lea rdx, [rcx + 0xb0]
jne 0x1401c1100
jmp 0x1401c2f20

Function at 0x1401c4bc0
Capabilities:
Encrypt data using rc4 prga

Disassembly:
mov qword [rsp + 0x18], rbx
mov qword [rsp + 0x20], rbp
push rsi
push rdi
push r14
sub rsp, 0x20
mov ebx, 0x80
mov qword [rsp + 0x40], r12
mov r14d, r9d
mov esi, r8d
mov r12, rdx
mov rdi, rcx
cmp r8d, ebx
jbe 0x1401c4bf1
mov esi, ebx
jmp 0x1401c4bfb
mov eax, 1
cmp esi, eax
cmovb esi, eax
mov qword [rsp + 0x48], r15
mov r15d, 0x400
test r14d, r14d
jne 0x1401c4c10
mov r14d, r15d
jmp 0x1401c4c17
cmp r14d, r15d
cmova r14d, r15d
mov edx, esi
mov rcx, r12
call fcn.140041250
mov rcx, r12
mov ebp, esi
call fcn.140041740
mov r12, qword [rsp + 0x40]
cmp esi, ebx
jbe 0x1401c4c3b
xor al, al
jmp 0x1401c4d65
test r14d, r14d
mov r8d, esi
lea rcx, [rdi + 0xb0]
mov rdx, rax
cmove r14d, r15d
mov r15d, esi
call sub.VCRUNTIME140.dll_memcpy
lea r11, [0x1402750f0]
cmp esi, ebx
jae 0x1401c4ca9
lea eax, [rsi - 1]
movzx r8d, byte [rax + rdi + 0xb0]
lea rdx, [rdi + 0xb0]
add rdx, r15
nop dword [rax + rax]
mov eax, ebp
lea rdx, [rdx + 1]
sub eax, esi
inc ebp
movzx ecx, byte [rax + rdi + 0xb0]
movzx eax, r8b
add rcx, rax
movzx eax, cl
movzx r8d, byte [rax + r11]
mov byte [rdx - 1], r8b
cmp ebp, ebx
jb 0x1401c4c80
lea eax, [r14 + 7]
mov r8d, ebx
shr eax, 3
lea r9, [rdi + 0xb0]
sub r8d, eax
neg r14d
mov eax, r8d
movzx ecx, r14b
add r9, rax
and cl, 7
mov edx, 0xff
sar rdx, cl
movzx eax, byte [r9]
and rdx, rax
movzx r10d, byte [rdx + r11]
mov byte [r9], r10b
test r8d, r8d
je 0x1401c4d14
nop dword [rax]
movzx eax, r10b
lea ebx, [rbx - 1]
movzx ecx, byte [rbx + rdi + 0xb0]
lea r9, [r9 - 1]
xor rcx, rax
movzx r10d, byte [rcx + r11]
mov byte [r9], r10b
add r8d, 0xffffffff
jne 0x1401c4cf0
mov r9d, 0x3f
lea r10, [rdi + 0x12e]
mov r11d, pe_nt_image_headers64
nop word [rax + rax]
lea r8d, [r9 + r9]
movzx ecx, byte [r8 + rdi + 0xb0]
lea eax, [r8 + 1]
movzx edx, byte [rax + rdi + 0xb0]
lea r10, [r10 - 2]
imul edx, r11d
mov eax, r9d
dec r9d
add dx, cx
mov word [r10 + 2], dx
test eax, eax
jne 0x1401c4d30
mov al, 1
mov r15, qword [rsp + 0x48]
mov rbx, qword [rsp + 0x50]
mov rbp, qword [rsp + 0x58]
add rsp, 0x20
pop r14
pop rdi
pop rsi
ret

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

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rdi
mov r10d, dword [rdx + 0x458]
mov rbx, r8
mov r11d, dword [rdx + 0x45c]
movsxd rdi, r9d
test r9d, r9d
jle 0x1401c595f
nop dword [rax]
nop word [rax + rax]
inc r10b
lea rbx, [rbx + 1]
movzx r10d, r10b
mov r9d, dword [rdx + r10*4 + 0x58]
lea r8, [rdx + r10*4]
lea eax, [r11 + r9]
movzx r11d, al
mov ecx, dword [rdx + r11*4 + 0x58]
mov dword [r8 + 0x58], ecx
mov dword [rdx + r11*4 + 0x58], r9d
add r9b, cl
movzx eax, r9b
movzx ecx, byte [rdx + rax*4 + 0x58]
xor byte [rbx - 1], cl
sub rdi, 1
jne 0x1401c5920
mov rbx, qword [rsp + 8]
mov rdi, qword [rsp + 0x10]
mov dword [rdx + 0x45c], r11d
mov dword [rdx + 0x458], r10d
ret
Function at 0x1401c5fb0
Capabilities:
Encrypt data using salsa20 or chacha
Enumerate pe sections

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rbp
mov qword [rsp + 0x18], rsi
push rdi
sub rsp, 0x20
mov rdi, r8
mov rbx, rdx
test r8, r8
je 0x1401c61b7
lea rcx, [rdx + 0x18]
call fcn.140041a70
cmp eax, 0x20
jne 0x1401c61b7
lea rbp, [rbx + 0x50]
mov rcx, rbp
call fcn.140041a70
cmp eax, 0xc
jb 0x1401c61b7
lea rcx, [rbx + 0x18]
call fcn.140041740
mov rcx, rbp
mov rbx, rax
call fcn.140041740
mov dword [rdi], 0x61707865
mov r8, rax
mov dword [rdi + 4], 0x3320646e
mov dword [rdi + 8], 0x79622d32
mov dword [rdi + 0xc], 0x6b206574
movzx ecx, byte [rbx + 2]
movzx eax, byte [rbx]
movzx edx, byte [rbx + 3]
shl edx, 8
or edx, ecx
movzx ecx, byte [rbx + 1]
shl edx, 8
or edx, ecx
shl edx, 8
or edx, eax
mov dword [rdi + 0x10], edx
movzx eax, byte [rbx + 6]
movzx ecx, byte [rbx + 7]
shl ecx, 8
or ecx, eax
movzx eax, byte [rbx + 5]
shl ecx, 8
or ecx, eax
movzx eax, byte [rbx + 4]
shl ecx, 8
or ecx, eax
mov dword [rdi + 0x14], ecx
movzx eax, byte [rbx + 0xa]
movzx ecx, byte [rbx + 0xb]
shl ecx, 8
or ecx, eax
movzx eax, byte [rbx + 9]
shl ecx, 8
or ecx, eax
movzx eax, byte [rbx + 8]
shl ecx, 8
or ecx, eax
mov dword [rdi + 0x18], ecx
movzx eax, byte [rbx + 0xe]
movzx ecx, byte [rbx + 0xf]
shl ecx, 8
or ecx, eax
movzx eax, byte [rbx + 0xd]
shl ecx, 8
or ecx, eax
movzx eax, byte [rbx + 0xc]
shl ecx, 8
or ecx, eax
mov dword [rdi + 0x1c], ecx
movzx eax, byte [rbx + 0x12]
movzx ecx, byte [rbx + 0x13]
shl ecx, 8
or ecx, eax
movzx eax, byte [rbx + 0x11]
shl ecx, 8
or ecx, eax
movzx eax, byte [rbx + 0x10]
shl ecx, 8
or ecx, eax
mov dword [rdi + 0x20], ecx
movzx eax, byte [rbx + 0x16]
movzx ecx, byte [rbx + 0x17]
shl ecx, 8
or ecx, eax
movzx eax, byte [rbx + 0x15]
shl ecx, 8
or ecx, eax
movzx eax, byte [rbx + 0x14]
shl ecx, 8
or ecx, eax
mov dword [rdi + 0x24], ecx
movzx ecx, byte [rbx + 0x1b]
movzx eax, byte [rbx + 0x1a]
shl ecx, 8
or ecx, eax
shl ecx, 8
movzx eax, byte [rbx + 0x19]
or ecx, eax
movzx eax, byte [rbx + 0x18]
shl ecx, 8
or ecx, eax
mov dword [rdi + 0x28], ecx
movzx eax, byte [rbx + 0x1e]
movzx ecx, byte [rbx + 0x1f]
shl ecx, 8
or ecx, eax
movzx eax, byte [rbx + 0x1d]
shl ecx, 8
or ecx, eax
movzx eax, byte [rbx + 0x1c]
shl ecx, 8
or ecx, eax
mov dword [rdi + 0x30], 0
mov dword [rdi + 0x2c], ecx
movzx eax, byte [r8 + 2]
movzx ecx, byte [r8 + 3]
shl ecx, 8
or ecx, eax
movzx eax, byte [r8 + 1]
shl ecx, 8
or ecx, eax
movzx eax, byte [r8]
shl ecx, 8
or ecx, eax
mov dword [rdi + 0x34], ecx
movzx eax, byte [r8 + 6]
movzx ecx, byte [r8 + 7]
shl ecx, 8
or ecx, eax
movzx eax, byte [r8 + 5]
shl ecx, 8
or ecx, eax
movzx eax, byte [r8 + 4]
shl ecx, 8
or ecx, eax
mov dword [rdi + 0x38], ecx
movzx eax, byte [r8 + 0xa]
movzx ecx, byte [r8 + 0xb]
shl ecx, 8
or ecx, eax
movzx eax, byte [r8 + 9]
shl ecx, 8
or ecx, eax
movzx eax, byte [r8 + 8]
shl ecx, 8
or ecx, eax
mov al, 1
mov dword [rdi + 0x3c], ecx
jmp 0x1401c61b9
xor al, al
mov rbx, qword [rsp + 0x30]
mov rbp, qword [rsp + 0x38]
mov rsi, qword [rsp + 0x40]
add rsp, 0x20
pop rdi
ret
Function at 0x1401c8bd0
Capabilities:
Get socket status

Disassembly:
mov byte [rsp + 0x20], r9b
push rbp
push rsi
push r14
sub rsp, 0x40
movzx r10d, r9b
mov esi, r8d
mov r14d, edx
mov rbp, rcx
cmp r8d, 0x32
jbe 0x1401c8d3b
test edx, edx
je 0x1401c8d3b
mov qword [rsp + 0x30], r15
mov r15, qword [rsp + 0x90]
mov dword [r15], 0xffffffff
cmp dword [rcx + 0x10], 0
jne 0x1401c8c3b
mov rcx, qword [rsp + 0x88]
lea rdx, str.No_sockets_exists_for_fdSetSelect.
mov rax, qword [rcx]
call qword [rax + 0x28]
mov r15, qword [rsp + 0x30]
xor al, al
add rsp, 0x40
pop r14
pop rsi
pop rbp
ret
mov qword [rsp + 0x60], rbx
mov al, 1
mov qword [rsp + 0x68], rdi
xor edi, edi
mov qword [rsp + 0x70], r12
mov r12, qword [rsp + 0x98]
mov qword [rsp + 0x38], r13
mov r13, qword [rsp + 0x88]
mov ecx, 1
mov ebx, r14d
cmp esi, edi
jbe 0x1401c8c7a
mov ebx, esi
sub ebx, edi
cmp ebx, r14d
cmova ebx, r14d
test al, al
je 0x1401c8c86
shr ebx, 1
cmp ebx, 1
cmovb ebx, ecx
mov r9, r13
mov qword [rsp + 0x20], r15
movzx r8d, r10b
mov edx, ebx
mov rcx, rbp
call fcn.1401c8d70
mov ecx, dword [r15]
cmp ecx, 0xffffffff
je 0x1401c8cfb
test ecx, ecx
jg 0x1401c8cfb
add edi, ebx
cmp edi, esi
jae 0x1401c8d1d
test r12, r12
je 0x1401c8cc2
mov rdx, r13
mov rcx, r12
call fcn.1400c5620
test al, al
jne 0x1401c8ccc
movzx r10d, byte [rsp + 0x78]
xor al, al
jmp 0x1401c8c63
mov rax, qword [r13]
lea rdx, str.socket_set_select_aborted_by_application_callback
mov rcx, r13
call qword [rax + 0x28]
xor eax, eax
mov dword [r15], eax
mov rcx, qword [rbp + 8]
mov dword [rbp + 0x10], eax
mov dword [rbp + 0x1018], eax
test rcx, rcx
je 0x1401c8cf9
call fcn.1400e9d90
mov al, 1
mov r13, qword [rsp + 0x38]
mov r12, qword [rsp + 0x70]
mov rdi, qword [rsp + 0x68]
mov rbx, qword [rsp + 0x60]
mov r15, qword [rsp + 0x30]
add rsp, 0x40
pop r14
pop rsi
pop rbp
ret
mov rcx, qword [rbp + 8]
xor ebx, ebx
mov dword [rbp + 0x10], ebx
mov dword [rbp + 0x1018], ebx
test rcx, rcx
je 0x1401c8d36
call fcn.1400e9d90
mov dword [r15], ebx
jmp 0x1401c8cf9
mov rax, qword [rsp + 0x90]
movzx r8d, r10b
mov r9, qword [rsp + 0x88]
mov edx, esi
mov qword [rsp + 0x80], rax
add rsp, 0x40
pop r14
pop rsi
pop rbp
jmp fcn.1401c8d70
Function at 0x1401c8d70
Capabilities:
Get socket status

Disassembly:
push rbx
push rsi
push rdi
push r14
push r15
sub rsp, 0x40
mov rax, qword [0x1402bc7c0]
xor rax, rsp
mov qword [rsp + 0x38], rax
mov r14, qword [rsp + 0x90]
xor r15d, r15d
mov rsi, r9
movzx r10d, r8b
mov r9d, edx
mov rbx, rcx
mov r8d, r15d
mov dword [r14], 0xffffffff
mov eax, dword [rcx + 0x1018]
mov dword [rcx + 0x10], eax
test eax, eax
je 0x1401c8ddc
nop word [rax + rax]
mov edx, r8d
inc r8d
mov rax, qword [rcx + rdx*8 + 0x1020]
mov qword [rcx + rdx*8 + 0x18], rax
cmp r8d, dword [rcx + 0x1018]
jb 0x1401c8dc0
cmp dword [rcx + 0x10], r15d
jne 0x1401c8df9
mov rax, qword [rsi]
lea rdx, str.No_sockets_exists_for_fdSetSelect.
mov rcx, rsi
call qword [rax + 0x28]
xor al, al
jmp 0x1401c8f41
mov eax, 0x10624dd3
mul r9d
shr edx, 6
imul eax, edx, 0x3e8
mov dword [rsp + 0x30], edx
sub r9d, eax
imul eax, r9d, 0x3e8
xor r9d, r9d
mov dword [rsp + 0x34], eax
lea rax, [rsp + 0x30]
mov qword [rsp + 0x20], rax
test r10b, r10b
je 0x1401c8e37
xor r8d, r8d
lea rdx, [rcx + 0x10]
jmp 0x1401c8e3d
lea r8, [rcx + 0x10]
xor edx, edx
xor ecx, ecx
call qword [sym.imp.WS2_32.dll_select]
mov dword [r14], eax
cmp eax, 0xffffffff
jne 0x1401c8e7d
mov rax, qword [rsi]
lea rdx, str.select_system_call_failed.
mov rcx, rsi
call qword [rax + 0x28]
mov rcx, qword [rbx + 8]
mov dword [rbx + 0x10], r15d
mov dword [rbx + 0x1018], r15d
test rcx, rcx
je 0x1401c8df2
call fcn.1400e9d90
xor al, al
jmp 0x1401c8f41
cmp dword [rbx + 0x10], r15d
jne 0x1401c8ea5
mov rcx, qword [rbx + 8]
mov dword [rbx + 0x10], r15d
mov dword [rbx + 0x1018], r15d
test rcx, rcx
je 0x1401c8f3f
call fcn.1400e9d90
jmp 0x1401c8f3f
call fcn.1400e9da0
mov rsi, rax
test rax, rax
je 0x1401c8df2
mov qword [rsp + 0x80], rbp
movsxd rbp, dword [rbx + 0x10]
test rbp, rbp
jle 0x1401c8f20
mov rdi, r15
nop word [rax + rax]
movsxd rax, dword [rbx + 0x1018]
mov edx, r15d
mov rcx, r15
test eax, eax
jle 0x1401c8f18
mov r8, qword [rbx + rdi*8 + 0x18]
mov r9, rax
lea rax, [rbx + 0x1020]
cmp r8, qword [rax]
je 0x1401c8f05
inc edx
inc rcx
add rax, 8
cmp rcx, r9
jl 0x1401c8ef0
jmp 0x1401c8f18
mov rcx, qword [rbx + 8]
call fcn.1400e9e50
mov edx, eax
mov rcx, rsi
call fcn.1400e9d30
inc rdi
cmp rdi, rbp
jl 0x1401c8ed0
mov rcx, qword [rbx + 8]
mov rbp, qword [rsp + 0x80]
test rcx, rcx
je 0x1401c8f3b
mov rax, qword [rcx]
mov edx, 1
call qword [rax]
mov qword [rbx + 8], rsi
mov al, 1
mov rcx, qword [rsp + 0x38]
xor rcx, rsp
call fcn.1401d75d0
add rsp, 0x40
pop r15
pop r14
pop rdi
pop rsi
pop rbx
ret
Function at 0x1401d0440
Capabilities:
Encode data using xor

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rbp
mov qword [rsp + 0x18], rsi
push rdi
sub rsp, 0x20
mov rbx, rcx
movsxd rdi, r8d
add rcx, 8
mov rsi, rdx
call fcn.140041740
lea rcx, [rbx + 0x38]
mov rbp, rax
call fcn.140041740
mov r9d, dword [rsi + rdi*4 + 4]
mov rcx, rdi
mov r10d, dword [rsi + rcx*4]
lea rdi, [rsi + rdi*4]
xor r10d, dword [rbp]
lea rsi, [rsi + rcx*4]
xor ebx, ebx
mov r11, rax
nop
inc ebx
mov ecx, r10d
and ecx, 0xff0000
mov eax, r10d
shr rax, 0x18
bts rcx, 0x18
shr rcx, 0x10
mov edx, dword [r11 + rcx*4]
add edx, dword [r11 + rax*4]
mov eax, r10d
and eax, 0xff00
bts rax, 0x11
shr rax, 8
xor edx, dword [r11 + rax*4]
movzx eax, r10b
or rax, 0x300
add edx, dword [r11 + rax*4]
xor edx, dword [rbp + rbx*4]
inc ebx
xor r9d, edx
mov ecx, r9d
and ecx, 0xff0000
mov eax, r9d
shr rax, 0x18
bts rcx, 0x18
shr rcx, 0x10
mov edx, dword [r11 + rcx*4]
add edx, dword [r11 + rax*4]
mov eax, r9d
and eax, 0xff00
bts rax, 0x11
shr rax, 8
xor edx, dword [r11 + rax*4]
movzx eax, r9b
or rax, 0x300
add edx, dword [r11 + rax*4]
xor edx, dword [rbp + rbx*4]
xor r10d, edx
cmp ebx, 0xe
jbe 0x1401d0490
xor r9d, dword [rbp + 0x44]
mov rbx, qword [rsp + 0x30]
mov rbp, qword [rsp + 0x38]
mov dword [rsi], r9d
mov rsi, qword [rsp + 0x40]
mov dword [rdi + 4], r10d
add rsp, 0x20
pop rdi
ret
Function at 0x1401d0920
Capabilities:
Encode data using xor
Encrypt data using rc4 prga

Disassembly:
mov qword [rsp + 0x18], rbx
mov qword [rsp + 0x10], rdx
push rbp
push rsi
push rdi
push r12
push r13
push r14
push r15
sub rsp, 0x30
mov r14, rcx
xor ebx, ebx
add rcx, 8
mov qword [rsp + 0x20], rbx
mov r13d, r8d
call fcn.140041a70
cdq
lea rcx, [r14 + 0x38]
and edx, 3
add eax, edx
sar eax, 2
movsxd rsi, eax
call fcn.140041a70
cdq
lea rcx, [r14 + 8]
and edx, 3
add eax, edx
sar eax, 2
mov dword [rsp + 0x88], eax
call fcn.140041740
lea rcx, [r14 + 0x38]
mov r15, rax
call fcn.140041740
mov r12, rax
test rsi, rsi
jle 0x1401d0a2a
mov r10, qword [rsp + 0x78]
mov r9d, ebx
mov eax, ebx
nop
movsxd rcx, eax
inc eax
cdq
idiv r13d
movzx r8d, byte [rcx + r10]
movsxd rax, edx
shl r8d, 8
movzx ecx, byte [rax + r10]
lea eax, [rdx + 1]
cdq
or ecx, r8d
idiv r13d
shl ecx, 8
movsxd rax, edx
movzx r8d, byte [rax + r10]
lea eax, [rdx + 1]
cdq
or r8d, ecx
idiv r13d
shl r8d, 8
movsxd rax, edx
movzx ecx, byte [rax + r10]
lea eax, [rdx + 1]
cdq
or ecx, r8d
xor dword [r15 + r9*4], ecx
inc r9
idiv r13d
mov eax, edx
cmp r9, rsi
jl 0x1401d09a0
mov rdi, rbx
xor r8d, r8d
lea rdx, [rsp + 0x20]
mov rcx, r14
call fcn.1401d0440
mov eax, dword [rsp + 0x20]
mov dword [r15 + rdi*4], eax
mov eax, dword [rsp + 0x24]
mov dword [r15 + rdi*4 + 4], eax
add rdi, 2
cmp rdi, rsi
jl 0x1401d0a00
movsxd rdi, dword [rsp + 0x88]
test rdi, rdi
jle 0x1401d0a6a
nop word [rax + rax]
xor r8d, r8d
lea rdx, [rsp + 0x20]
mov rcx, r14
call fcn.1401d0440
mov eax, dword [rsp + 0x20]
mov dword [r12 + rbx*4], eax
mov eax, dword [rsp + 0x24]
mov dword [r12 + rbx*4 + 4], eax
add rbx, 2
cmp rbx, rdi
jl 0x1401d0a40
mov rbx, qword [rsp + 0x80]
add rsp, 0x30
pop r15
pop r14
pop r13
pop r12
pop rdi
pop rsi
pop rbp
ret
Function at 0x1401d3330
Capabilities:
Compute adler32 checksum

Disassembly:
mov qword [rsp + 0x10], rbp
mov qword [rsp + 0x18], rsi
push rdi
sub rsp, 0x20
mov eax, dword [rcx + 0x28]
mov rbp, rdx
cmp eax, r8d
mov esi, eax
mov rdi, rcx
cmova esi, r8d
test esi, esi
jne 0x1401d3367
xor eax, eax
mov rbp, qword [rsp + 0x38]
mov rsi, qword [rsp + 0x40]
add rsp, 0x20
pop rdi
ret
sub eax, esi
mov qword [rsp + 0x30], rbx
cmp byte [rcx + 0x18], 0
mov dword [rcx + 0x28], eax
je 0x1401d34cb
mov r9, qword [rcx + 0x20]
mov r11d, esi
mov r8d, dword [rcx + 0x1c]
movzx ecx, r8w
shr r8d, 0x10
test r9, r9
jne 0x1401d33a0
lea r8d, [r9 + 1]
jmp 0x1401d34c7
mov edx, 0x15b0
cmp r11d, edx
cmovb edx, r11d
sub r11d, edx
cmp edx, 0x10
jb 0x1401d3470
mov r10d, edx
shr r10, 4
nop
movzx eax, byte [r9]
add edx, 0xfffffff0
add ecx, eax
movzx eax, byte [r9 + 1]
add r8d, ecx
add ecx, eax
movzx eax, byte [r9 + 2]
add r8d, ecx
add ecx, eax
movzx eax, byte [r9 + 3]
add r8d, ecx
add ecx, eax
movzx eax, byte [r9 + 4]
add r8d, ecx
add ecx, eax
movzx eax, byte [r9 + 5]
add r8d, ecx
add ecx, eax
movzx eax, byte [r9 + 6]
add r8d, ecx
add ecx, eax
movzx eax, byte [r9 + 7]
add r8d, ecx
add ecx, eax
movzx eax, byte [r9 + 8]
add r8d, ecx
add ecx, eax
movzx eax, byte [r9 + 9]
add r8d, ecx
add ecx, eax
movzx eax, byte [r9 + 0xa]
add r8d, ecx
add ecx, eax
movzx eax, byte [r9 + 0xb]
add r8d, ecx
add ecx, eax
movzx eax, byte [r9 + 0xc]
add r8d, ecx
add ecx, eax
movzx eax, byte [r9 + 0xd]
add r8d, ecx
add ecx, eax
movzx eax, byte [r9 + 0xe]
add r8d, ecx
add ecx, eax
movzx eax, byte [r9 + 0xf]
add r8d, ecx
add r9, 0x10
add ecx, eax
add r8d, ecx
sub r10, 1
jne 0x1401d33c0
test edx, edx
je 0x1401d3491
nop dword [rax]
nop dword [rax + rax]
movzx eax, byte [r9]
inc r9
add ecx, eax
add r8d, ecx
add edx, 0xffffffff
jne 0x1401d3480
mov eax, 0x80078071
mul ecx
shr edx, 0xf
imul eax, edx, 0xffff000f
add ecx, eax
mov eax, 0x80078071
mul r8d
shr edx, 0xf
imul eax, edx, 0xffff000f
add r8d, eax
test r11d, r11d
jne 0x1401d33a0
shl r8d, 0x10
or r8d, ecx
mov dword [rdi + 0x1c], r8d
mov rdx, qword [rdi + 0x20]
mov rcx, rbp
mov r8d, esi
mov ebx, esi
call sub.VCRUNTIME140.dll_memcpy
add qword [rdi + 0x20], rbx
mov eax, esi
add dword [rdi + 0x2c], esi
mov rsi, qword [rsp + 0x40]
mov rbx, qword [rsp + 0x30]
mov rbp, qword [rsp + 0x38]
add rsp, 0x20
pop rdi
ret