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

Disassembly:
mov qword [rsp + 0x20], rbx
push rdi
push r14
push r15
mov eax, 0x20
call fcn.140c4c230
sub rsp, rax
mov rdi, qword [rcx + 0x28]
mov rbx, rdx
mov r15, rcx
cmp rdx, rdi
ja 0x140ba2070
shl rbx, 4
add rbx, qword [rcx + 0x58]
mov rax, rbx
mov rbx, qword [rsp + 0x58]
add rsp, 0x20
pop r15
pop r14
pop rdi
ret
mov rcx, qword [rcx + 0x30]
cmp rbx, rcx
jb 0x140ba20bd
sub rdx, rcx
lea r8, str.cryptomodesocb128.c
add rdx, 4
mov r9d, WSAStartup
and rdx, 0xfffffffffffffffc
add rdx, rcx
mov rcx, qword [r15 + 0x58]
mov qword [r15 + 0x30], rdx
shl rdx, 4
call fcn.140a85be0
test rax, rax
jne 0x140ba20b9
mov rbx, qword [rsp + 0x58]
add rsp, 0x20
pop r15
pop r14
pop rdi
ret
mov qword [r15 + 0x58], rax
mov qword [rsp + 0x40], rbp
mov rbp, rdi
mov qword [rsp + 0x48], rsi
mov qword [rsp + 0x50], r12
mov r12, rbx
shl rbp, 4
sub r12, rdi
nop dword [rax]
mov rcx, qword [r15 + 0x58]
mov edx, 1
add rcx, rbp
movzx edi, byte [rcx]
lea rsi, [rcx + 0x10]
shr dil, 7
mov r8, rsi
neg dil
and dil, 0x87
call fcn.140ba1c10
xor byte [rsi + 0xf], dil
add rbp, 0x10
sub r12, 1
jne 0x140ba20e0
mov r12, qword [rsp + 0x50]
mov rsi, qword [rsp + 0x48]
mov rbp, qword [rsp + 0x40]
mov qword [r15 + 0x28], rbx
shl rbx, 4
add rbx, qword [r15 + 0x58]
mov rax, rbx
mov rbx, qword [rsp + 0x58]
add rsp, 0x20
pop r15
pop r14
pop rdi
ret
Function at 0x140ba63f0
Capabilities:
Encode data using xor

Disassembly:
mov eax, reloc.WS2_32.dll_getservbyport
call fcn.140c4c230
sub rsp, rax
cmp dword [rsp + 0x68], 0
je 0x140ba6419
lea rax, [0x140ba49c0]
mov qword [rsp + 0x68], rax
add rsp, 0x38
jmp fcn.140b9d640
lea rax, [0x140ba3b70]
mov qword [rsp + 0x68], rax
add rsp, 0x38
jmp fcn.140b9d380
Function at 0x140ba90d0
Capabilities:
Hash data using sha1

Disassembly:
push rbx
mov eax, 0x20
call fcn.140c4c230
sub rsp, rax
mov rbx, rcx
call fcn.140b96b10
test eax, eax
jne 0x140ba90f1
add rsp, 0x20
pop rbx
ret
lea rcx, [rbx + 0x5c]
add rsp, 0x20
pop rbx
jmp fcn.140a94200
Function at 0x140babf70
Capabilities:
Hash data using sha512

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rbp
mov qword [rsp + 0x18], rsi
push rdi
mov eax, 0x20
call fcn.140c4c230
sub rsp, rax
mov rbx, rdx
mov rdi, rcx
add rcx, 0x40
xor edx, edx
mov r8d, 0xb0
call fcn.140c85fe0
movabs rsi, 0x1f83d9abfb41bd6b
movabs rbp, 0x5be0cd19137e2179
mov qword [rdi + 0x30], rsi
movabs rcx, 0x6a09e667f3bcc908
mov qword [rdi + 0x38], rbp
movabs rdx, 0xbb67ae8584caa73b
mov qword [rdi], rcx
movabs r8, 0x3c6ef372fe94f82b
mov qword [rdi + 8], rdx
movabs r9, 0xa54ff53a5f1d36f1
mov qword [rdi + 0x10], r8
movabs r10, 0x510e527fade682d1
mov qword [rdi + 0x18], r9
movabs r11, 0x9b05688c2b3e6c1f
mov qword [rdi + 0x20], r10
mov qword [rdi + 0x28], r11
movzx eax, byte [rbx]
mov qword [rdi + 0xe8], rax
mov rax, qword [rbx]
xor rax, rcx
mov qword [rdi], rax
mov rax, qword [rbx + 8]
xor rax, rdx
mov qword [rdi + 8], rax
mov rax, qword [rbx + 0x10]
xor rax, r8
mov qword [rdi + 0x10], rax
mov rax, qword [rbx + 0x18]
xor rax, r9
mov qword [rdi + 0x18], rax
mov rax, qword [rbx + 0x20]
xor rax, r10
mov qword [rdi + 0x20], rax
mov rax, qword [rbx + 0x28]
xor rax, r11
mov qword [rdi + 0x28], rax
mov rax, qword [rbx + 0x30]
xor rax, rsi
mov rsi, qword [rsp + 0x40]
mov qword [rdi + 0x30], rax
mov rax, qword [rbx + 0x38]
mov rbx, qword [rsp + 0x30]
xor rax, rbp
mov rbp, qword [rsp + 0x38]
mov qword [rdi + 0x38], rax
add rsp, 0x20
pop rdi
ret

Function at 0x140bae6d0
Capabilities:
Hash data using sha256

Disassembly:
xorps xmm0, xmm0
movups xmmword [rcx + 0x20], xmm0
movups xmmword [rcx + 0x30], xmm0
movups xmmword [rcx + 0x40], xmm0
movups xmmword [rcx + 0x50], xmm0
movups xmmword [rcx + 0x60], xmm0
movups xmmword [rcx + 0x70], xmm0
mov dword [rcx], 0x6a09e667
mov dword [rcx + 4], 0xbb67ae85
mov dword [rcx + 8], 0x3c6ef372
mov dword [rcx + 0xc], 0xa54ff53a
mov dword [rcx + 0x10], 0x510e527f
mov dword [rcx + 0x14], 0x9b05688c
mov dword [rcx + 0x18], 0x1f83d9ab
mov dword [rcx + 0x1c], 0x5be0cd19
movzx eax, byte [rdx]
mov qword [rcx + 0x78], rax
mov eax, dword [rdx]
xor eax, 0x6a09e667
mov dword [rcx], eax
mov eax, dword [rdx + 4]
xor eax, 0xbb67ae85
mov dword [rcx + 4], eax
mov eax, dword [rdx + 8]
xor eax, 0x3c6ef372
mov dword [rcx + 8], eax
mov eax, dword [rdx + 0xc]
xor eax, 0xa54ff53a
mov dword [rcx + 0xc], eax
mov eax, dword [rdx + 0x10]
xor eax, 0x510e527f
mov dword [rcx + 0x10], eax
mov eax, dword [rdx + 0x14]
xor eax, 0x9b05688c
mov dword [rcx + 0x14], eax
mov eax, dword [rdx + 0x18]
xor eax, 0x1f83d9ab
mov dword [rcx + 0x18], eax
mov eax, dword [rdx + 0x1c]
xor eax, 0x5be0cd19
mov dword [rcx + 0x1c], eax
ret
Function at 0x140baecd0
Capabilities:
Encode data using xor

Disassembly:
test r8, r8
je 0x140baeec5
push rbx
mov eax, 0xd0
call fcn.140c4c230
sub rsp, rax
mov rax, qword [0x140db81c0]
xor rax, rsp
mov qword [rsp + 0xb0], rax
mov qword [rsp + 0xe8], rbp
mov rbx, rdx
mov qword [rsp + 0xf0], rsi
lea rbp, [r8 - 1]
mov qword [rsp + 0xf8], rdi
mov qword [rsp + 0xc8], r14
lea r14, [rcx + 0xc]
shr rbp, 3
mov qword [rsp + 0xc0], r15
inc rbp
lea r15, [rcx + 0x14]
nop word [rax + rax]
movzx eax, byte [rbx + 1]
mov rcx, r14
movzx edi, byte [rbx]
movzx esi, byte [rbx + 4]
lea rbx, [rbx + 8]
shl eax, 8
or edi, eax
movzx eax, byte [rbx - 6]
shl eax, 0x10
or edi, eax
movzx eax, byte [rbx - 5]
shl eax, 0x18
or edi, eax
movzx eax, byte [rbx - 3]
shl eax, 8
or esi, eax
mov dword [rsp + 0x20], edi
movzx eax, byte [rbx - 2]
shl eax, 0x10
or esi, eax
mov dword [rsp + 0x28], edi
movzx eax, byte [rbx - 1]
and byte [r14], 0xdf
and byte [r15], 0xbf
or byte [r14], 0x40
or byte [r15], 0x20
shl eax, 0x18
or esi, eax
mov dword [rsp + 0x24], esi
mov dword [rsp + 0x2c], esi
call fcn.140b95020
lea rdx, [rsp + 0x30]
mov rcx, r14
call fcn.140b949d0
mov r8d, 1
lea rdx, [rsp + 0x30]
lea rcx, [rsp + 0x28]
call fcn.140b91620
mov rcx, r15
call fcn.140b95020
lea rdx, [rsp + 0x30]
mov rcx, r15
call fcn.140b949d0
mov r8d, 1
lea rdx, [rsp + 0x30]
lea rcx, [rsp + 0x20]
call fcn.140b91620
mov edx, dword [rsp + 0x20]
mov ecx, dword [rsp + 0x24]
xor edx, edi
xor edi, dword [rsp + 0x28]
xor ecx, esi
xor esi, dword [rsp + 0x2c]
mov eax, edi
shr eax, 8
mov byte [r14 + 1], al
mov eax, edi
shr eax, 0x10
mov byte [r14 + 2], al
mov eax, ecx
shr eax, 8
mov byte [r14 + 5], al
mov eax, ecx
shr eax, 0x10
mov byte [r14 + 6], al
mov eax, edx
shr eax, 8
mov byte [r15 + 1], al
mov eax, edx
shr eax, 0x10
mov byte [r14], dil
shr edi, 0x18
mov byte [r14 + 4], cl
shr ecx, 0x18
mov byte [r15], dl
shr edx, 0x18
mov byte [r15 + 3], dl
mov byte [r14 + 3], dil
mov byte [r14 + 7], cl
mov byte [r15 + 2], al
mov byte [r15 + 4], sil
mov eax, esi
shr eax, 8
mov byte [r15 + 5], al
mov eax, esi
shr eax, 0x10
shr esi, 0x18
mov byte [r15 + 6], al
mov byte [r15 + 7], sil
sub rbp, 1
jne 0x140baed40
mov r15, qword [rsp + 0xc0]
mov r14, qword [rsp + 0xc8]
mov rdi, qword [rsp + 0xf8]
mov rsi, qword [rsp + 0xf0]
mov rbp, qword [rsp + 0xe8]
mov rcx, qword [rsp + 0xb0]
xor rcx, rsp
call fcn.140c4bf60
add rsp, 0xd0
pop rbx
ret
Function at 0x140bbff70
Capabilities:
Encrypt data using rc4 prga

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rdi
xor r10d, r10d
movsxd rbx, r8d
mov r11, rdx
mov rdi, rcx
test r8d, r8d
jle 0x140bbffaf
mov r9, rdx
mov rdx, rcx
sub rdx, r9
movzx eax, byte [r9]
cmp byte [rdx + r9], al
jne 0x140bbffaf
inc r9
inc r10d
mov rax, r9
sub rax, r11
cmp rax, rbx
jl 0x140bbff94
lea edx, [r8 - 1]
movsxd rax, edx
test edx, edx
js 0x140bbffda
mov r8, rdi
lea rcx, [rax + r11]
sub r8, r11
cmp byte [rcx + r8], 0
jne 0x140bbffda
cmp byte [rcx], 0xff
jne 0x140bbffda
dec edx
dec rcx
cmp rcx, r11
jns 0x140bbffc4
cmp r10d, edx
jl case.0x140bc0033.2
jle 0x140bbfff8
lea eax, [r10*8]
mov rbx, qword [rsp + 8]
mov rdi, qword [rsp + 0x10]
ret
movsxd rax, r10d
movzx r8d, byte [rax + r11]
movzx r9d, byte [rax + rdi]
movzx edx, r8b
xor dl, r9b
movzx eax, dl
dec eax
cmp eax, 0x7e
ja case.0x140bc0033.2
lea r11, [0x140000000]
cdqe
movzx eax, byte [r11 + rax + 0xbc00a8]
mov ecx, dword [r11 + rax*4 + 0xbc0088]
add rcx, r11
jmp rcx
mov eax, 7
jmp 0x140bc0064
mov eax, 6
jmp 0x140bc0064
mov eax, 5
jmp 0x140bc0064
mov eax, 4
jmp 0x140bc0064
mov eax, 3
jmp 0x140bc0064
mov eax, 2
jmp 0x140bc0064
mov eax, 1
test dl, r9b
jne case.0x140bc0033.2
and r8b, dl
lea eax, [rax + r10*8]
cmp r8b, dl
je 0x140bc007a
mov eax, 0xffffffff
mov rbx, qword [rsp + 8]
mov rdi, qword [rsp + 0x10]
ret
Function at 0x140bd6da0
Capabilities:
Encrypt data using rc4 prga

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rsi
mov qword [rsp + 0x18], rdi
movzx r9d, byte [rdx]
lea eax, [r8 - 1]
movzx r11d, r9b
movsxd r10, eax
shr r11b, 7
xor edi, edi
mov esi, r8d
mov rbx, rcx
test eax, eax
jle 0x140bd6e04
mov r8, rcx
sub rdx, rcx
mov edi, eax
nop word [rax + rax]
movzx ecx, byte [r8 + rdx + 1]
lea r8, [r8 + 1]
add r9b, r9b
movzx eax, cl
shr al, 7
or al, r9b
movzx r9d, cl
mov byte [r8 - 1], al
sub r10, 1
jne 0x140bd6de0
cmp esi, 0x10
mov eax, 0x87
mov rsi, qword [rsp + 0x10]
mov ecx, 0x1b
cmove ecx, eax
movsxd rax, edi
mov rdi, qword [rsp + 0x18]
neg r11b
and cl, r11b
add r9b, r9b
xor cl, r9b
mov byte [rax + rbx], cl
mov rbx, qword [rsp + 8]
ret
Function at 0x140bd8310
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 0x140bd858e
test r8, r8
je 0x140bd858e
mov r14d, dword [rcx + 0x2c]
cmp r8, r14
jne 0x140bd858e
mov ecx, dword [rcx + 0x28]
dec ecx
cmp ecx, 6
ja case.default.0x140bd837d
lea r8, [0x140000000]
mov edx, dword [r8 + rcx*4 + 0xbd85a8]
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 0x140bd8426
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 0x140bd83e0
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 0x140bd8496
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 0x140bd8450
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 0x140bd8587
mov ecx, dword [rbx + 0x34]
xor r9, 0xdd
test ecx, ecx
je 0x140bd8546
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 0x140bd8500
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 0x140bd8590
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 0x140bd8720
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.140c4c230
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 0x140bd885f
mov r12d, 8
sub r12d, ecx
add rcx, 0x38
add rcx, r14
cmp r8, r12
jae 0x140bd878f
call fcn.140c85940
add dword [r14 + 0x28], r15d
jmp 0x140bd8975
mov r8, r12
call fcn.140c85940
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 0x140bd885a
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 0x140bd8810
lea rcx, [r14 + 0x38]
xor rsi, r8
jmp 0x140bd8863
lea rcx, [r14 + 0x38]
mov r12d, r15d
mov r10, r13
and r12d, 7
sub r10, r12
add r10, r15
cmp r13, r10
je 0x140bd8951
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 0x140bd8939
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 0x140bd88f3
add r9, 8
xor rsi, r8
lea rax, [r9 - 6]
cmp rax, r10
jne 0x140bd8890
lea rcx, [r14 + 0x38]
test r12d, r12d
je 0x140bd8961
mov r8, r12
mov rdx, r10
call fcn.140c85940
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 0x140be9930
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.140c4c230
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 0x140be9991
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 0x140be9a90
lea r10, [r8 - 1]
add r10, r9
movzx ebx, byte [r10]
cmp dword [rsp + 0xb8], r11d
je 0x140be99ce
sub r9, rbx
mov eax, 1
sub r9, rbp
dec r9
mov qword [rcx], r9
jmp 0x140be9ac7
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 0x140be9a6a
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 0x140be9a20
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.140be9560
mov rbx, qword [rsp + 0x80]
add rsp, 0x50
pop r14
pop r13
pop r12
pop rsi
pop rbp
ret
Function at 0x140bea040
Capabilities:
Encode data using xor

Disassembly:
push rbx
push rbp
push rsi
push rdi
push r14
push r15
mov eax, 0x68
call fcn.140c4c230
sub rsp, rax
mov rax, qword [0x140db81c0]
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 0x140bea173
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.140aa2dd0
test eax, eax
je 0x140bea173
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.140aa3a60
test eax, eax
je 0x140bea173
mov r9, rdi
lea rdx, [rsp + 0x38]
mov r8, rbp
mov rcx, rsi
call fcn.140bea770
test eax, eax
je 0x140bea173
lea rax, [rbx + 0xf]
xor r8d, r8d
lea rcx, [rsp + 0x38]
cmp rcx, rax
ja 0x140bea149
lea rax, [rsp + 0x47]
cmp rax, rbx
jb 0x140bea149
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 0x140bea130
jmp 0x140bea15c
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 0x140bea18f
mov rdx, rdi
mov rcx, rbp
call fcn.140001240
xor eax, eax
mov rcx, qword [rsp + 0x58]
xor rcx, rsp
call fcn.140c4bf60
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 0x140bea175
Function at 0x140bf3af0
Capabilities:
Encode data using xor

Disassembly:
mov qword [rsp + 0x20], rsi
push r12
push r14
push r15
sub rsp, 0x30
mov rsi, r9
mov r14, r8
mov r15d, edx
mov r12, rcx
test r8b, 0xf
je 0x140bf3b26
mov eax, 0xffffffde
mov rsi, qword [rsp + 0x68]
add rsp, 0x30
pop r15
pop r14
pop r12
ret
mov qword [rsp + 0x50], rbx
mov qword [rsp + 0x58], rbp
mov qword [rsp + 0x60], rdi
movaps xmmword [rsp + 0x20], xmm6
test r8, r8
je 0x140bf3c76
mov rbx, qword [rsp + 0x78]
test r15d, r15d
jne 0x140bf3bdb
mov rbp, qword [rsp + 0x70]
mov rdi, rsi
sub rdi, rbx
nop dword [rax]
movups xmm6, xmmword [rbp]
mov r9, rbx
mov r8, rbp
xor edx, edx
mov rcx, r12
call fcn.140bf4050
test eax, eax
jne 0x140bf3c78
lea rax, [rsi + 0xf]
cmp rbx, rax
ja 0x140bf3bb2
lea rax, [rbx + 0xf]
cmp rax, rsi
jb 0x140bf3bb2
mov rax, rbx
mov edx, reloc.WS2_32.dll_recv
nop word [rax + rax]
movzx ecx, byte [rdi + rax]
xor byte [rax], cl
lea rax, [rax + 1]
sub rdx, 1
jne 0x140bf3ba0
jmp 0x140bf3bc1
movdqu xmm0, xmmword [rbx]
movdqu xmm1, xmmword [rsi]
xorps xmm1, xmm0
movdqu xmmword [rbx], xmm1
add rbx, 0x10
add rbp, 0x10
sub rdi, 0x10
movups xmmword [rsi], xmm6
sub r14, 0x10
jne 0x140bf3b60
jmp 0x140bf3c76
mov rdi, qword [rsp + 0x70]
mov rbp, rsi
sub rbp, rdi
nop word [rax + rax]
lea rax, [rdi + 0xf]
lea rcx, [rbx + 0xf]
cmp rbx, rax
ja 0x140bf3c02
cmp rcx, rdi
jae 0x140bf3c10
lea rax, [rsi + 0xf]
cmp rbx, rax
ja 0x140bf3c36
cmp rcx, rsi
jb 0x140bf3c36
mov r8, rbx
mov rcx, rdi
sub r8, rdi
mov edx, reloc.WS2_32.dll_recv
nop
movzx eax, byte [rcx + rbp]
xor al, byte [rcx]
mov byte [r8 + rcx], al
lea rcx, [rcx + 1]
sub rdx, 1
jne 0x140bf3c20
jmp 0x140bf3c45
movdqu xmm1, xmmword [rsi]
movdqu xmm0, xmmword [rdi]
xorps xmm1, xmm0
movdqu xmmword [rbx], xmm1
mov r9, rbx
mov r8, rbx
mov edx, r15d
mov rcx, r12
call fcn.140bf4050
test eax, eax
jne 0x140bf3c78
movups xmm0, xmmword [rbx]
add rbx, 0x10
add rdi, 0x10
sub rbp, 0x10
movups xmmword [rsi], xmm0
sub r14, 0x10
jne 0x140bf3bf0
xor eax, eax
movaps xmm6, xmmword [rsp + 0x20]
mov rdi, qword [rsp + 0x60]
mov rbp, qword [rsp + 0x58]
mov rbx, qword [rsp + 0x50]
mov rsi, qword [rsp + 0x68]
add rsp, 0x30
pop r15
pop r14
pop r12
ret
Function at 0x140bf4050
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.140bfaec0
test eax, eax
je 0x140bf40a1
mov rcx, rdi
shr rcx, 2
and ecx, 3
je 0x140bf40a1
mov eax, 4
sub eax, ecx
jmp 0x140bf40a3
xor eax, eax
cmp eax, esi
je 0x140bf40db
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.140c85940
mov qword [rdi + 8], rbx
mov rbx, qword [rsp + 0x40]
mov ecx, 0x2000000
call fcn.140bfaec0
mov rsi, qword [rsp + 0x48]
mov rcx, rdi
test eax, eax
je 0x140bf410d
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.140bfab50
mov r8, rbp
mov rdx, r14
cmp r15d, 1
jne 0x140bf412c
mov rbp, qword [rsp + 0x50]
add rsp, 0x20
pop r15
pop r14
pop rdi
jmp fcn.140bf5df0
mov rbp, qword [rsp + 0x50]
add rsp, 0x20
pop r15
pop r14
pop rdi
jmp fcn.140bf5610
Function at 0x140bf6970
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 [0x140db81c0]
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 0x140bf69d4
dec rax
test rax, rax
jg 0x140bf69c5
mov r9, r14
lea rcx, [rbx + 0x28]
mov r8, rbx
mov edx, 1
call fcn.140bf4050
mov edi, eax
test eax, eax
jne 0x140bf6a55
add r14, 0x10
add esi, 0x10
cmp esi, 0x30
jl 0x140bf69c0
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 0x140bf6a10
mov r8d, 0x100
lea rdx, [rsp + 0x20]
lea rcx, [rbx + 0x28]
call fcn.140bf4c50
mov edi, eax
test eax, eax
jne 0x140bf6a55
movups xmm0, xmmword [rsp + 0x40]
movups xmmword [rbx], xmm0
mov edx, gethostbyname
lea rcx, [rsp + 0x20]
call fcn.140bfa370
mov eax, edi
mov rcx, qword [rsp + 0x50]
xor rcx, rsp
call fcn.140c4bf60
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