joyce8/EMBER2024-capa huggingface dataset:
Function at 0x1401b8ac0
Capabilities:
Check for software breakpoints

Disassembly:
mov eax, gethostname
call fcn.140215a20
sub rsp, rax
mov r11, rcx
cmp dword [rsp + 0x60], r9d
jne 0x1401b8baf
movzx r10d, byte [r8]
lea eax, [r10 - 0x6a]
cmp al, 1
ja 0x1401b8baf
mov qword [rsp + 0x30], rbx
lea rdx, [r8 + 1]
cmp r10b, 0x6b
jne 0x1401b8b5e
lea ebx, [r9 - 3]
xor eax, eax
test ebx, ebx
jle 0x1401b8b1a
movzx ecx, byte [rdx]
inc rdx
cmp cl, 0xba
je 0x1401b8b1a
cmp cl, 0xbb
jne 0x1401b8b4d
inc eax
cmp eax, ebx
jl 0x1401b8b04
sub ebx, eax
test eax, eax
jne 0x1401b8b62
mov dword [rsp + 0x20], 0x83
lea r9, [0x1402fcf78]
mov edx, 0x80
lea ecx, [rdx - 0x7c]
lea r8d, [rdx + 0xa]
call fcn.1401404e0
mov rbx, qword [rsp + 0x30]
or eax, 0xffffffff
add rsp, 0x38
ret
mov dword [rsp + 0x20], 0x7b
lea r9, [0x1402fcf60]
jmp 0x1401b8b2f
lea ebx, [r9 - 2]
movsxd rax, ebx
cmp byte [rax + rdx], 0xcc
je 0x1401b8b98
mov edx, 0x80
mov dword [rsp + 0x20], Ordinal_143
lea r9, [0x1402fcf90]
lea ecx, [rdx - 0x7c]
lea r8d, [rdx + 0xb]
call fcn.1401404e0
mov rbx, qword [rsp + 0x30]
or eax, 0xffffffff
add rsp, 0x38
ret
mov r8d, ebx
mov rcx, r11
call fcn.140218780
mov eax, ebx
mov rbx, qword [rsp + 0x30]
add rsp, 0x38
ret
mov edx, 0x80
mov dword [rsp + 0x20], reloc.WS2_32.dll_WSASetLastError
lea r9, str..crypto_rsa_rsa_x931.c
lea ecx, [rdx - 0x7c]
lea r8d, [rdx + 9]
call fcn.1401404e0
or eax, 0xffffffff
add rsp, 0x38
ret

Function at 0x1401c19f0
Capabilities:
Encode data using base64

Disassembly:
xor r10d, r10d
test r8d, r8d
jle 0x1401c1ae3
lea r9, [rdx + 1]
lea r11, str.ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_
cmp r8d, 3
jl 0x1401c1a6b
movzx eax, byte [r9]
movzx edx, byte [r9 - 1]
shl rdx, 8
or rdx, rax
movzx eax, byte [r9 + 1]
shl rdx, 8
or rdx, rax
mov rax, rdx
shr rax, 0x12
movzx eax, byte [rax + r11]
mov byte [rcx], al
mov rax, rdx
shr rax, 0xc
and eax, 0x3f
movzx eax, byte [rax + r11]
mov byte [rcx + 1], al
mov rax, rdx
shr rax, 6
and eax, 0x3f
movzx eax, byte [rax + r11]
mov byte [rcx + 2], al
add rcx, 3
and edx, 0x3f
movzx eax, byte [rdx + r11]
mov byte [rcx], al
jmp 0x1401c1ac4
movzx edx, byte [r9 - 1]
shl edx, 0x10
cmp r8d, 2
jne 0x1401c1a82
movzx eax, byte [r9]
shl eax, 8
or edx, eax
mov rax, rdx
shr rax, 0x12
movzx eax, byte [rax + r11]
mov byte [rcx], al
mov rax, rdx
shr rax, 0xc
and eax, 0x3f
movzx eax, byte [rax + r11]
mov byte [rcx + 1], al
cmp r8d, 1
jne 0x1401c1aae
lea eax, [r8 + 0x3c]
jmp 0x1401c1aba
shr rdx, 6
and edx, 0x3f
movzx eax, byte [rdx + r11]
mov byte [rcx + 2], al
add rcx, 3
mov byte [rcx], 0x3d
add r10d, 4
add r9, 3
sub r8d, 3
inc rcx
test r8d, r8d
jg 0x1401c1a07
mov byte [rcx], 0
mov eax, r10d
ret
mov byte [rcx], r10b
mov eax, r10d
ret
Function at 0x1401c3d90
Capabilities:
Encode data using xor

Disassembly:
mov qword [rsp + 0x18], rbx
mov qword [rsp + 0x20], rsi
push r14
mov eax, reloc.WLDAP32.dll_Ordinal_32
call fcn.140215a20
sub rsp, rax
mov rax, qword [rcx + 8]
lea r14d, [r9 + 1]
mov rbx, rdx
mov rsi, rcx
mov r9, qword [rax + 0xc8]
test byte [r9 + 0x70], 1
je 0x1401c3df6
mov ecx, dword [rdx + 4]
lea eax, [r14 + r8]
cmp eax, ecx
jbe 0x1401c3de3
xor eax, eax
mov rbx, qword [rsp + 0x40]
mov rsi, qword [rsp + 0x48]
add rsp, 0x20
pop r14
ret
mov eax, r8d
add qword [rdx + 0x10], rax
add qword [rdx + 0x18], rax
sub ecx, r8d
mov dword [rdx + 4], ecx
jmp 0x1401c3dfc
cmp r14d, dword [rdx + 4]
ja 0x1401c3dd0
mov ecx, dword [rdx + 4]
mov rax, qword [rdx + 0x10]
dec ecx
mov qword [rsp + 0x30], rbp
or ebp, 0xffffffff
test dword [rsi + 0x19c], 0x200
mov qword [rsp + 0x38], rdi
movzx edi, byte [rcx + rax]
je 0x1401c3e6f
cmp qword [rsi + 0xe0], 0
jne 0x1401c3e6f
mov rcx, qword [rsi + 0x80]
lea rdx, [0x14032dbe8]
add rcx, 8
mov r8d, 8
call fcn.14014c450
test eax, eax
jne 0x1401c3e5d
test dil, 1
jne 0x1401c3e5d
mov rax, qword [rsi + 0x80]
or dword [rax], 8
mov rax, qword [rsi + 0x80]
test byte [rax], 8
je 0x1401c3e6f
test edi, edi
je 0x1401c3e6f
add edi, ebp
mov rcx, qword [rsi + 0xd0]
mov rcx, qword [rcx]
call fcn.140151cc0
bt eax, 0x15
jae 0x1401c3e93
sub ebp, edi
mov eax, 1
add dword [rbx + 4], ebp
jmp 0x1401c3f4a
mov r11d, dword [rbx + 4]
lea ecx, [rdi + r14]
mov esi, 0xff
mov r8d, r11d
sub r8d, ecx
mov eax, r11d
xor r8d, ecx
xor eax, ecx
or r8d, eax
lea eax, [r11 - 1]
xor r8d, r11d
shr r8d, 0x1f
dec r8d
cmp eax, esi
cmovb esi, eax
xor r9d, r9d
test esi, esi
je 0x1401c3f1a
mov rbp, qword [rbx + 0x10]
mov r10d, edi
shr r10d, 0x1f
nop word [rax + rax]
mov eax, r9d
mov ecx, edi
sub ecx, r9d
shr eax, 0x1f
shr ecx, 0x1f
xor cl, al
xor al, r10b
or cl, al
mov eax, r11d
sub eax, r9d
xor cl, r10b
dec cl
dec eax
movzx edx, cl
inc r9d
movzx ecx, byte [rax + rbp]
xor ecx, edi
and edx, ecx
not edx
and r8d, edx
cmp r9d, esi
jb 0x1401c3ee0
not r8d
movzx eax, r8b
lea ecx, [rax - 1]
not eax
shr eax, 0x1f
shr ecx, 0x1f
and ecx, eax
lea eax, [rdi + 1]
neg ecx
and eax, ecx
sub r11d, eax
shl eax, 8
or dword [rbx], eax
mov eax, ecx
and eax, 1
mov dword [rbx + 4], r11d
not ecx
or eax, ecx
mov rbp, qword [rsp + 0x30]
mov rdi, qword [rsp + 0x38]
mov rbx, qword [rsp + 0x40]
mov rsi, qword [rsp + 0x48]
add rsp, 0x20
pop r14
ret
Function at 0x1401c6780
Capabilities:
Authenticate hmac
Encode data using xor

Disassembly:
push rbx
push rbp
push rsi
push rdi
push r12
push r14
mov eax, 0xb8
call fcn.140215a20
sub rsp, rax
mov rax, qword [0x140320c20]
xor rax, rsp
mov qword [rsp + 0xa0], rax
mov r12, qword [rsp + 0x110]
xor ebx, ebx
movsxd rsi, r8d
mov rbp, r9
mov r14, rdx
mov rdi, rcx
mov eax, ebx
test r9, r9
je 0x1401c67e6
cmp r9, qword [rcx]
je 0x1401c67dc
test rdx, rdx
je 0x1401c69d9
test r8d, r8d
js 0x1401c69d9
mov eax, 1
mov qword [rcx], r9
jmp 0x1401c67f2
mov rbp, qword [rcx]
test rbp, rbp
je 0x1401c69d9
mov qword [rsp + 0xb0], r15
test r14, r14
je 0x1401c68d5
mov rcx, rbp
call fcn.140152170
mov r15d, eax
cmp eax, 0x80
jle 0x1401c682d
lea r8, str.j____int_sizeof_ctx__key_
mov edx, reloc.WS2_32.dll_WSACleanup
lea rcx, str..cryptohmachmac.c
call fcn.14014c270
cmp r15d, esi
jge 0x1401c6884
mov r8, r12
lea rcx, [rdi + 8]
mov rdx, rbp
call fcn.140127700
test eax, eax
je 0x1401c69c8
mov r8, rsi
lea rcx, [rdi + 8]
mov rdx, r14
call fcn.140127960
test eax, eax
je 0x1401c69c8
lea r14, [rdi + 0x98]
mov r8, r14
lea rdx, [rdi + 0x9c]
lea rcx, [rdi + 8]
call fcn.140127620
test eax, eax
je 0x1401c69c8
jmp 0x1401c68ac
cmp esi, 0x80
ja 0x1401c69c8
mov r8, rsi
lea rcx, [rdi + 0x9c]
mov rdx, r14
call fcn.140218780
lea r14, [rdi + 0x98]
mov dword [r14], esi
mov ecx, dword [r14]
cmp ecx, 0x80
je 0x1401c68dd
mov eax, ecx
mov r8d, 0x80
sub r8d, ecx
xor edx, edx
lea rcx, [rdi + 0x9c]
add rcx, rax
call fcn.140218bd0
jmp 0x1401c68dd
test eax, eax
je 0x1401c69b7
lea rcx, [rsp + 0x20]
mov rax, rdi
sub rax, rcx
mov rdx, rbx
lea rsi, [rax + 0x9c]
lea r14, [rax + 0x9d]
nop dword [rax]
lea rcx, [rsp + 0x20]
add rcx, rdx
add rdx, 2
movzx eax, byte [rsi + rcx]
xor al, 0x36
mov byte [rcx], al
movzx eax, byte [r14 + rcx]
xor al, 0x36
mov byte [rcx + 1], al
cmp rdx, 0x80
jl 0x1401c6900
mov r8, r12
lea rcx, [rdi + 0x38]
mov rdx, rbp
call fcn.140127700
test eax, eax
je 0x1401c69c8
mov rcx, rbp
call fcn.140152170
movsxd r8, eax
lea rdx, [rsp + 0x20]
lea rcx, [rdi + 0x38]
call fcn.140127960
test eax, eax
je 0x1401c69c8
nop dword [rax + rax]
lea rcx, [rsp + 0x20]
add rcx, rbx
add rbx, 2
movzx eax, byte [rsi + rcx]
xor al, 0x5c
mov byte [rcx], al
movzx eax, byte [r14 + rcx]
xor al, 0x5c
mov byte [rcx + 1], al
cmp rbx, 0x80
jl 0x1401c6960
mov r8, r12
lea rcx, [rdi + 0x68]
mov rdx, rbp
call fcn.140127700
test eax, eax
je 0x1401c69c8
mov rcx, rbp
call fcn.140152170
movsxd r8, eax
lea rdx, [rsp + 0x20]
lea rcx, [rdi + 0x68]
call fcn.140127960
test eax, eax
je 0x1401c69c8
lea rdx, [rdi + 0x38]
lea rcx, [rdi + 8]
call fcn.140127a70
test eax, eax
jne 0x1401c69cc
xor eax, eax
jmp 0x1401c69d1
mov eax, 1
mov r15, qword [rsp + 0xb0]
mov rcx, qword [rsp + 0xa0]
xor rcx, rsp
call fcn.140215090
add rsp, 0xb8
pop r14
pop r12
pop rdi
pop rsi
pop rbp
pop rbx
ret
Function at 0x1401c7460
Capabilities:
Resolve dns

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rbp
mov qword [rsp + 0x18], rsi
push rdi
mov eax, gethostbyname
call fcn.140215a20
sub rsp, rax
mov rsi, rdx
lea ebp, [rax - 0x2f]
mov rbx, rcx
call fcn.1401c79b0
mov edi, eax
test eax, eax
jns 0x1401c74b4
lea r9, [0x140301b28]
mov dword [rsp + 0x20], 0x7b
lea edx, [rbp + 0x69]
lea ecx, [rbp + 0x1f]
lea r8d, [rbp + 0x6b]
call fcn.1401404e0
jmp 0x1401c7595
call fcn.1401c78a0
cmp eax, ebp
jne 0x1401c75a9
test edi, edi
jle 0x1401c74cc
mov eax, ebp
jmp 0x1401c75b2
mov r9d, Ordinal_143
lea r8, [0x140301b40]
lea edx, [r9 - 0x78]
lea ecx, [rdx - 0xd]
call fcn.14014ba50
mov rcx, rbx
call qword [sym.imp.WS2_32.dll_gethostbyname]
mov rdx, rax
test rax, rax
jne 0x1401c7516
lea r9, [0x140301b58]
mov dword [rsp + 0x20], __WSAFDIsSet
lea edx, [rax + 0x6a]
lea ecx, [rax + 0x20]
lea r8d, [rax + 0x66]
call fcn.1401404e0
jmp 0x1401c7577
cmp word [rax + 0x10], 2
je 0x1401c753f
mov edx, 0x6a
mov dword [rsp + 0x20], 0x99
lea r9, [0x140301b70]
lea ecx, [rdx - 0x4a]
lea r8d, [rdx + 1]
call fcn.1401404e0
jmp 0x1401c7577
mov rax, qword [rax + 0x18]
xor ebp, ebp
mov rcx, qword [rax]
movzx eax, byte [rcx]
mov byte [rsi], al
mov rax, qword [rdx + 0x18]
mov rcx, qword [rax]
movzx eax, byte [rcx + 1]
mov byte [rsi + 1], al
mov rax, qword [rdx + 0x18]
mov rcx, qword [rax]
movzx eax, byte [rcx + 2]
mov byte [rsi + 2], al
mov rax, qword [rdx + 0x18]
mov rcx, qword [rax]
movzx eax, byte [rcx + 3]
mov byte [rsi + 3], al
mov edx, reloc.WS2_32.dll_shutdown
lea r8, [0x140301b88]
mov r9d, 0xa2
lea ecx, [rdx - 0xc]
call fcn.14014ba50
test ebp, ebp
je 0x1401c75ad
mov r8, rbx
lea rdx, str.host
mov ecx, 2
call fcn.14013f940
xor eax, eax
jmp 0x1401c75b2
mov eax, 1
mov rbx, qword [rsp + 0x40]
mov rbp, qword [rsp + 0x48]
mov rsi, qword [rsp + 0x50]
add rsp, 0x30
pop rdi
ret

Function at 0x1401c9f30
Capabilities:
Resolve function by parsing pe exports

Disassembly:
mov qword [rsp + 8], rbx
push rdi
mov eax, reloc.WLDAP32.dll_Ordinal_32
call fcn.140215a20
sub rsp, rax
mov edi, edx
mov rbx, rcx
test edx, edx
jle 0x1401c9f5c
mov eax, 1
mov rbx, qword [rsp + 0x30]
add rsp, 0x20
pop rdi
ret
call fcn.1401cfe70
test eax, eax
je 0x1401c9f92
mov rcx, rbx
call fcn.140166a80
test eax, 0x3000
jne 0x1401c9f9f
cmp dword [rbx + 0x284], 0
jne 0x1401c9f9f
mov rcx, rbx
call fcn.140159870
mov rcx, rax
mov edx, 1
call fcn.140120e80
mov eax, edi
mov rbx, qword [rsp + 0x30]
add rsp, 0x20
pop rdi
ret
mov rcx, rbx
mov rbx, qword [rsp + 0x30]
add rsp, 0x20
pop rdi
jmp fcn.1401cfd80
Function at 0x1401cfd80
Capabilities:
Resolve function by parsing pe exports

Disassembly:
push rbx
mov eax, reloc.WLDAP32.dll_Ordinal_32
call fcn.140215a20
sub rsp, rax
lea rdx, [rsp + 0x38]
mov rbx, rcx
call fcn.1401cfc70
test rax, rax
je 0x1401cfe66
cmp dword [rsp + 0x38], 0
jg 0x1401cfe66
cmp dword [rsp + 0x3c], 0
jg 0x1401cfe66
mov rcx, qword [rbx + 0x88]
movzx eax, word [rcx + 0x31c]
add ax, ax
mov word [rcx + 0x31c], ax
mov rax, qword [rbx + 0x88]
cmp word [rax + 0x31c], 0x3c
jbe 0x1401cfdf0
mov ecx, reloc.WLDAP32.dll_Ordinal_60
mov word [rax + 0x31c], cx
mov rcx, rbx
call fcn.1401d00a0
mov rcx, rbx
call fcn.1401cf4e0
test eax, eax
jns 0x1401cfe0d
or eax, 0xffffffff
add rsp, 0x20
pop rbx
ret
mov rax, qword [rbx + 0x88]
inc dword [rax + 0x308]
mov rax, qword [rbx + 0x88]
cmp dword [rax + 0x308], 2
jbe 0x1401cfe34
mov dword [rax + 0x308], 1
cmp dword [rbx + 0x284], 0
mov rcx, rbx
je 0x1401cfe54
mov dword [rbx + 0x284], 0
add rsp, 0x20
pop rbx
jmp fcn.1401c9550
call fcn.1401d00a0
mov rcx, rbx
add rsp, 0x20
pop rbx
jmp fcn.1401ca310
xor eax, eax
add rsp, 0x20
pop rbx
ret
Function at 0x1401d7cb0
Capabilities:
Encode data using xor

Disassembly:
mov eax, Ordinal_41
call fcn.140215a20
sub rsp, rax
add rsp, 0x28
jmp 0x1401d7cb0
push rbx
mov eax, reloc.WLDAP32.dll_Ordinal_32
call fcn.140215a20
sub rsp, rax
mov rbx, r8
call fcn.1401d7f00
test eax, eax
js 0x1401d7eee
mov eax, dword [rbx + 0xf0]
xor r10d, r10d
shl eax, 2
movsxd r9, eax
test eax, eax
jle 0x1401d7d3d
lea r8, [rbx + 8]
lea r8, [r8 + r9*4]
lea rax, [rbx + 8]
nop
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 0x1401d7cf0
mov r11d, 1
cmp dword [rbx + 0xf0], r11d
jle 0x1401d7eec
mov qword [rsp + 0x30], rdi
lea r10, [rbx + 2]
lea rdi, [0x140000000]
mov r8d, dword [r10 + 0xe]
lea r10, [r10 + 0x10]
mov eax, r8d
inc r11d
shr rax, 0x18
movzx edx, byte [rdi + rax*4 + 0x273bd0]
movzx eax, byte [r10 - 1]
mov r9d, dword [rdi + rdx*4 + 0x2747d0]
movzx ecx, byte [rdi + rax*4 + 0x273bd0]
movzx eax, r8b
xor r9d, dword [rdi + rcx*4 + 0x274fd0]
movzx ecx, byte [rdi + rax*4 + 0x273bd0]
movzx eax, byte [r10]
xor r9d, dword [rdi + rcx*4 + 0x2753d0]
movzx ecx, byte [rdi + rax*4 + 0x273bd0]
movzx eax, byte [r10 + 3]
xor r9d, dword [rdi + rcx*4 + 0x274bd0]
movzx edx, byte [rdi + rax*4 + 0x273bd0]
movzx eax, byte [r10 + 4]
mov dword [r10 - 2], r9d
mov r9d, dword [r10 + 2]
mov r8d, dword [rdi + rdx*4 + 0x274fd0]
movzx ecx, byte [rdi + rax*4 + 0x273bd0]
mov eax, r9d
shr rax, 0x18
xor r8d, dword [rdi + rcx*4 + 0x274bd0]
movzx ecx, byte [rdi + rax*4 + 0x273bd0]
movzx eax, r9b
mov r9d, dword [r10 + 6]
xor r8d, dword [rdi + rcx*4 + 0x2747d0]
movzx ecx, byte [rdi + rax*4 + 0x273bd0]
movzx eax, byte [r10 + 7]
xor r8d, dword [rdi + rcx*4 + 0x2753d0]
movzx edx, byte [rdi + rax*4 + 0x273bd0]
movzx eax, byte [r10 + 8]
mov dword [r10 + 2], r8d
mov r8d, dword [rdi + rdx*4 + 0x274fd0]
movzx ecx, byte [rdi + rax*4 + 0x273bd0]
mov eax, r9d
shr rax, 0x18
xor r8d, dword [rdi + rcx*4 + 0x274bd0]
movzx ecx, byte [rdi + rax*4 + 0x273bd0]
movzx eax, r9b
mov r9d, dword [r10 + 0xa]
xor r8d, dword [rdi + rcx*4 + 0x2747d0]
movzx ecx, byte [rdi + rax*4 + 0x273bd0]
movzx eax, byte [r10 + 0xb]
xor r8d, dword [rdi + rcx*4 + 0x2753d0]
movzx edx, byte [rdi + rax*4 + 0x273bd0]
movzx eax, byte [r10 + 0xc]
mov dword [r10 + 6], r8d
mov r8d, dword [rdi + rdx*4 + 0x274fd0]
movzx ecx, byte [rdi + rax*4 + 0x273bd0]
mov eax, r9d
shr rax, 0x18
xor r8d, dword [rdi + rcx*4 + 0x274bd0]
movzx ecx, byte [rdi + rax*4 + 0x273bd0]
movzx eax, r9b
xor r8d, dword [rdi + rcx*4 + 0x2747d0]
movzx ecx, byte [rdi + rax*4 + 0x273bd0]
xor r8d, dword [rdi + rcx*4 + 0x2753d0]
mov dword [r10 + 0xa], r8d
cmp r11d, dword [rbx + 0xf0]
jl 0x1401d7d60
mov rdi, qword [rsp + 0x30]
xor eax, eax
add rsp, 0x20
pop rbx
ret
Function at 0x1401d8bc0
Capabilities:
Encode data using xor

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x20], r9
push rbp
push rsi
push rdi
push r12
push r13
push r14
push r15
mov eax, gethostbyname
call fcn.140215a20
sub rsp, rax
mov rdi, r8
mov r14, rdx
mov r8, qword [rsp + 0xa0]
mov r15, rcx
mov ebx, dword [r8]
mov dword [rsp + 0x80], ebx
test ebx, ebx
je 0x1401d8c38
mov rdx, qword [rsp + 0x98]
nop dword [rax]
test rdi, rdi
je 0x1401d8c31
mov eax, ebx
dec rdi
movzx ecx, byte [rax + rdx]
xor cl, byte [r15]
inc r15
mov byte [r14], cl
inc r14
inc ebx
and ebx, 0xf
jne 0x1401d8c10
mov dword [rsp + 0x80], ebx
mov rcx, qword [rsp + 0x90]
mov esi, recv
movzx r13d, byte [rcx + 0xc]
lea r12, [rcx + 0xc]
mov r10, qword [rsp + 0xa8]
shl r13d, 8
movzx eax, byte [rcx + 0xd]
lea ebp, [rsi - 0xb]
or r13d, eax
movzx eax, byte [rcx + 0xe]
shl r13d, 8
or r13d, eax
movzx eax, byte [rcx + 0xf]
shl r13d, 8
or r13d, eax
cmp rdi, 0x10
jb 0x1401d8d5d
mov eax, 0x10000000
mov ebx, esi
nop dword [rax + rax]
mov rsi, rdi
shr rsi, 4
cmp rsi, rax
cmova rsi, rax
add r13d, esi
mov eax, r13d
cmp rax, rsi
jae 0x1401d8caf
sub rsi, rax
xor r13d, r13d
mov qword [rsp + 0x20], rcx
mov r8, rsi
mov rcx, r15
mov rdx, r14
call r10
mov rcx, qword [rsp + 0x90]
mov eax, r13d
shr eax, 0x18
mov byte [r12], al
mov eax, r13d
shr eax, 0x10
mov byte [rcx + 0xd], al
mov eax, r13d
shr eax, 8
mov byte [rcx + 0xe], al
mov byte [rcx + 0xf], r13b
test r13d, r13d
jne 0x1401d8d1d
mov r8d, ebx
mov ecx, ebp
mov rdx, r12
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 0x1401d8d00
mov rcx, qword [rsp + 0x90]
mov r9, qword [rsp + 0x88]
mov eax, 0x10000000
mov r10, qword [rsp + 0xa8]
shl rsi, 4
sub rdi, rsi
add r14, rsi
add r15, rsi
cmp rdi, 0x10
jae 0x1401d8c90
mov ebx, dword [rsp + 0x80]
mov esi, recv
mov r8, qword [rsp + 0xa0]
test rdi, rdi
je 0x1401d8e12
mov rax, qword [rsp + 0x98]
xor edx, edx
mov qword [rsp + 0x20], rcx
mov r8, rbp
mov rcx, rax
mov qword [rax], rdx
mov qword [rax + 8], rdx
mov rdx, rax
call r10
mov rcx, qword [rsp + 0x90]
inc r13d
mov eax, r13d
shr eax, 0x18
mov byte [r12], al
mov eax, r13d
shr eax, 0x10
mov byte [rcx + 0xd], al
mov eax, r13d
shr eax, 8
mov byte [rcx + 0xe], al
mov byte [rcx + 0xf], r13b
test r13d, r13d
jne 0x1401d8dd9
nop dword [rax + rax]
movzx eax, byte [r12 - 1]
lea r12, [r12 - 1]
add ebp, eax
mov byte [r12], bpl
shr ebp, 8
add esi, 0xffffffff
jne 0x1401d8dc0
mov rdx, qword [rsp + 0x98]
nop dword [rax]
nop word [rax + rax]
mov ecx, ebx
inc ebx
movzx eax, byte [rcx + r15]
xor al, byte [rcx + rdx]
mov byte [rcx + r14], al
sub rdi, 1
jne 0x1401d8df0
mov rax, qword [rsp + 0xa0]
mov dword [rax], ebx
jmp 0x1401d8e15
mov dword [r8], ebx
mov rbx, qword [rsp + 0x70]
add rsp, 0x30
pop r15
pop r14
pop r13
pop r12
pop rdi
pop rsi
pop rbp
ret
Function at 0x1401d94e0
Capabilities:
Encode data using xor

Disassembly:
mov qword [rsp + 0x18], rbx
mov qword [rsp + 0x20], rsi
push r14
mov eax, reloc.WLDAP32.dll_Ordinal_32
call fcn.140215a20
sub rsp, rax
cmp qword [rcx + 0x38], 0
mov rbx, r8
mov r14, rdx
mov rsi, rcx
je 0x1401d951f
mov eax, 0xfffffffe
mov rbx, qword [rsp + 0x40]
mov rsi, qword [rsp + 0x48]
add rsp, 0x20
pop r14
ret
mov rcx, qword [rcx + 0x30]
movabs rax, 0x2000000000000000
add rcx, rbx
cmp rcx, rax
ja 0x1401d95f0
cmp rcx, rbx
jb 0x1401d95f0
mov qword [rsp + 0x38], rdi
mov edi, dword [rsi + 0x174]
mov qword [rsi + 0x30], rcx
test edi, edi
je 0x1401d9584
test rbx, rbx
je 0x1401d9573
movzx eax, byte [r14]
dec rbx
mov ecx, edi
inc r14
xor byte [rcx + rsi + 0x40], al
inc edi
and edi, 0xf
jne 0x1401d9555
jmp 0x1401d9577
test edi, edi
jne 0x1401d95d2
lea rdx, [rsi + 0x60]
lea rcx, [rsi + 0x40]
call fcn.1401da940
mov qword [rsp + 0x30], rbp
mov rbp, rbx
and rbp, 0xfffffffffffffff0
je 0x1401d95ab
lea rdx, [rsi + 0x60]
mov r9, rbp
lea rcx, [rsi + 0x40]
mov r8, r14
call fcn.1401da770
add r14, rbp
sub rbx, rbp
mov rbp, qword [rsp + 0x30]
test rbx, rbx
je 0x1401d95d2
mov edi, ebx
lea rcx, [rsi + 0x40]
sub r14, rsi
nop
movzx eax, byte [r14 + rcx - 0x40]
xor byte [rcx], al
lea rcx, [rcx + 1]
sub rbx, 1
jne 0x1401d95c0
mov dword [rsi + 0x174], edi
xor eax, eax
mov rdi, qword [rsp + 0x38]
mov rbx, qword [rsp + 0x40]
mov rsi, qword [rsp + 0x48]
add rsp, 0x20
pop r14
ret
mov rbx, qword [rsp + 0x40]
or eax, 0xffffffff
mov rsi, qword [rsp + 0x48]
add rsp, 0x20
pop r14
ret
Function at 0x1401da770
Capabilities:
Encode data using add xor sub operations
Encode data using xor

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rbp
mov qword [rsp + 0x18], rsi
mov qword [rsp + 0x20], rdi
push r12
push r13
push r14
push r15
mov rsi, rcx
lea r14, [r8 + 0xe]
sub rsi, r8
lea r13, [0x140275900]
mov r12, r9
mov rbp, rdx
mov r11, rcx
nop word [rax + rax]
movzx eax, byte [r11 + 0xf]
mov rdi, r14
movzx ecx, byte [r14 + 1]
mov r15d, reloc.WS2_32.dll_ntohs
xor rcx, rax
mov r9, rcx
and ecx, 0xf
add rcx, rcx
and r9, 0xfffffffffffffff0
mov r8, qword [rbp + rcx*8]
mov rcx, qword [rbp + rcx*8 + 8]
mov rax, r8
mov rdx, rcx
shr r8, 4
and edx, 0xf
shl rax, 0x3c
shr rcx, 4
or rax, rcx
mov rbx, qword [r13 + rdx*8]
xor rbx, r8
xor rbx, qword [r9 + rbp]
xor rax, qword [r9 + rbp + 8]
nop word [rax + rax]
movzx ecx, byte [rdi]
mov r9, rbx
movzx edx, byte [rsi + rdi]
lea rdi, [rdi - 1]
xor rdx, rcx
shr rbx, 4
mov rcx, rax
shl r9, 0x3c
shr rax, 4
and ecx, 0xf
or r9, rax
mov r10, rdx
and r10, 0xfffffffffffffff0
and edx, 0xf
add rdx, rdx
mov r8, qword [r13 + rcx*8]
xor r8, rbx
xor r9, qword [rbp + rdx*8 + 8]
xor r8, qword [rbp + rdx*8]
mov rcx, r9
and ecx, 0xf
shr r9, 4
mov rax, r8
shr r8, 4
shl rax, 0x3c
or rax, r9
mov rbx, qword [r13 + rcx*8]
xor rax, qword [r10 + rbp + 8]
xor rbx, r8
xor rbx, qword [r10 + rbp]
sub r15, 1
jne 0x1401da810
mov rdx, rbx
mov byte [r11 + 7], bl
shr rdx, 0x20
add r14, 0x10
mov ecx, edx
mov byte [r11 + 3], dl
shr ecx, 0x18
sub rsi, 0x10
mov byte [r11], cl
mov ecx, edx
shr ecx, 0x10
mov byte [r11 + 1], cl
mov ecx, edx
shr ecx, 8
mov rdx, rax
mov byte [r11 + 2], cl
mov ecx, ebx
shr ecx, 0x18
mov byte [r11 + 4], cl
mov ecx, ebx
shr ecx, 0x10
mov byte [r11 + 5], cl
mov ecx, ebx
shr ecx, 8
mov byte [r11 + 6], cl
shr rdx, 0x20
mov ecx, edx
mov byte [r11 + 0xb], dl
shr ecx, 0x18
mov byte [r11 + 8], cl
mov ecx, edx
shr ecx, 0x10
mov byte [r11 + 9], cl
mov ecx, edx
shr ecx, 8
mov byte [r11 + 0xa], cl
mov ecx, eax
shr ecx, 0x18
mov byte [r11 + 0xc], cl
mov ecx, eax
shr ecx, 0x10
mov byte [r11 + 0xd], cl
mov ecx, eax
shr ecx, 8
mov byte [r11 + 0xe], cl
mov byte [r11 + 0xf], al
sub r12, 0x10
jne 0x1401da7b0
mov rbx, qword [rsp + 0x28]
mov rbp, qword [rsp + 0x30]
mov rsi, qword [rsp + 0x38]
mov rdi, qword [rsp + 0x40]
pop r15
pop r14
pop r13
pop r12
ret
Function at 0x1401da940
Capabilities:
Encode data using add xor sub operations
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
movzx eax, byte [rcx + 0xf]
lea r14, [0x140275900]
mov r10d, eax
mov rdi, rdx
and eax, 0xf
and r10, 0xfffffffffffffff0
add rax, rax
mov esi, select
mov r9, qword [rdx + rax*8]
mov r8, qword [rdx + rax*8 + 8]
mov r11, r9
mov rax, r8
shr r9, 4
and eax, 0xf
shl r11, 0x3c
shr r8, 4
or r11, r8
mov rbx, qword [r14 + rax*8]
xor rbx, r9
xor rbx, qword [r10 + rdx]
xor r11, qword [r10 + rdx + 8]
nop word [rax + rax]
movzx edx, byte [rsi + rcx]
mov rax, r11
shr r11, 4
mov r9, rbx
shr rbx, 4
and eax, 0xf
shl r9, 0x3c
mov r10d, edx
or r9, r11
and r10, 0xfffffffffffffff0
and edx, 0xf
mov r8, qword [r14 + rax*8]
add rdx, rdx
xor r8, rbx
xor r9, qword [rdi + rdx*8 + 8]
xor r8, qword [rdi + rdx*8]
mov rax, r9
and eax, 0xf
shr r9, 4
mov r11, r8
shr r8, 4
shl r11, 0x3c
or r11, r9
mov rbx, qword [r14 + rax*8]
xor r11, qword [r10 + rdi + 8]
xor rbx, r8
xor rbx, qword [r10 + rdi]
sub rsi, 1
jns 0x1401da9b0
mov rsi, qword [rsp + 0x10]
mov rdx, rbx
mov rdi, qword [rsp + 0x18]
mov r14, qword [rsp + 0x20]
shr rdx, 0x20
mov eax, edx
mov byte [rcx + 3], dl
shr eax, 0x18
mov byte [rcx], al
mov eax, edx
shr eax, 0x10
mov byte [rcx + 1], al
mov eax, edx
shr eax, 8
mov rdx, r11
mov byte [rcx + 2], al
mov eax, ebx
shr eax, 0x18
mov byte [rcx + 4], al
mov eax, ebx
shr eax, 0x10
mov byte [rcx + 5], al
mov eax, ebx
shr eax, 8
mov byte [rcx + 6], al
shr rdx, 0x20
mov eax, edx
mov byte [rcx + 7], bl
mov rbx, qword [rsp + 8]
shr eax, 0x18
mov byte [rcx + 8], al
mov eax, edx
shr eax, 0x10
mov byte [rcx + 9], al
mov eax, edx
shr eax, 8
mov byte [rcx + 0xa], al
mov eax, r11d
shr eax, 0x18
mov byte [rcx + 0xc], al
mov eax, r11d
shr eax, 0x10
mov byte [rcx + 0xd], al
mov eax, r11d
shr eax, 8
mov byte [rcx + 0xe], al
mov byte [rcx + 0xb], dl
mov byte [rcx + 0xf], r11b
ret

Function at 0x1401de870
Capabilities:
Encode data using xor

Disassembly:
mov eax, gethostname
call fcn.140215a20
sub rsp, rax
cmp dword [rsp + 0x68], 0
je 0x1401de899
lea rax, [0x1401dce40]
mov qword [rsp + 0x68], rax
add rsp, 0x38
jmp fcn.1401d87f0
lea rax, [0x1401dbfa0]
mov qword [rsp + 0x68], rax
add rsp, 0x38
jmp fcn.1401d8520
Function at 0x1401df2b0
Capabilities:
Check for time delay via gettickcount

Disassembly:
mov eax, Ordinal_41
call fcn.140215a20
sub rsp, rax
cmp dword [reloc.WS2_32.dll_accept], 0
je 0x1401df2f8
lea rcx, [rsp + 0x38]
call qword [sym.imp.KERNEL32.dll_QueryPerformanceCounter]
test eax, eax
jne 0x1401df2dd
mov dword [reloc.WS2_32.dll_accept], eax
jmp 0x1401df2f8
xorps xmm2, xmm2
lea rcx, [rsp + 0x38]
mov edx, 8
call fcn.14013cc50
cmp dword [reloc.WS2_32.dll_accept], 0
jne 0x1401df314
call qword [sym.imp.KERNEL32.dll_GetTickCount]
xorps xmm2, xmm2
lea rcx, [rsp + 0x30]
mov edx, 4
mov dword [rsp + 0x30], eax
call fcn.14013cc50
add rsp, 0x28
ret