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

Disassembly:
test r8d, r8d
jle 0x1400d660e
mov r11, rsp
push r15
sub rsp, 0x150
mov rax, qword [0x140320c20]
xor rax, rsp
mov qword [rsp + 0x120], rax
mov qword [r11 + 0x10], rbx
mov r10, rcx
mov qword [r11 + 0x18], rbp
xor r15d, r15d
mov qword [r11 + 0x20], rsi
mov qword [r11 - 0x10], rdi
mov qword [r11 - 0x18], r12
mov qword [r11 - 0x20], r13
mov qword [r11 - 0x28], r14
mov dword [rsp + 4], r8d
mov qword [rsp + 0x10], rdx
mov qword [rsp + 8], rcx
nop dword [rax + rax]
mov eax, r15d
lea r9, [rsp + 0x20]
shl eax, 6
movsxd r11, eax
add r11, rdx
xor r8d, r8d
nop dword [rax]
nop dword [rax + rax]
lea eax, [r8*4]
inc r8d
movsxd rcx, eax
lea r9, [r9 + 4]
movzx eax, byte [r11 + rcx + 1]
movzx edx, byte [rcx + r11]
shl edx, 8
or edx, eax
movzx eax, byte [r11 + rcx + 2]
shl edx, 8
or edx, eax
movzx eax, byte [r11 + rcx + 3]
shl edx, 8
or edx, eax
mov dword [r9 - 4], edx
cmp r8d, 0x10
jl 0x1400d6400
lea rax, [rsp + 0x58]
mov r11d, gethostbyname
nop dword [rax]
mov edx, dword [rax]
mov r9d, edx
mov r8d, dword [rax - 0x34]
lea rax, [rax + 4]
mov ecx, edx
rol r9d, 0xf
shr edx, 0xa
rol ecx, 0xd
xor r9d, ecx
mov ecx, r8d
xor r9d, edx
ror ecx, 7
mov edx, r8d
shr r8d, 3
rol edx, 0xe
xor edx, ecx
xor edx, r8d
add r9d, edx
add r9d, dword [rax - 0x3c]
add r9d, dword [rax - 0x18]
mov dword [rax + 4], r9d
sub r11, 1
jne 0x1400d6450
mov r11d, dword [r10 + 0x88]
xor ebx, ebx
mov edi, dword [r10 + 0x8c]
mov esi, dword [r10 + 0x90]
mov r13d, dword [r10 + 0x94]
mov r9d, dword [r10 + 0x98]
mov ebp, dword [r10 + 0x9c]
mov r14d, dword [r10 + 0xa0]
mov r12d, dword [r10 + 0xa4]
lea r10, [0x140290d10]
nop word [rax + rax]
mov r8d, r9d
mov eax, r9d
rol eax, 7
mov ecx, r9d
ror r8d, 0xb
not ecx
xor r8d, eax
and ecx, r14d
mov eax, r9d
mov edx, r11d
ror eax, 6
xor r8d, eax
ror edx, 0xd
mov eax, ebp
and eax, r9d
xor ecx, eax
mov eax, r11d
add r8d, ecx
rol eax, 0xa
add r8d, dword [rbx + r10]
xor edx, eax
add r8d, dword [rsp + rbx + 0x20]
mov eax, r11d
ror eax, 2
add r8d, r12d
xor edx, eax
mov ecx, edi
xor ecx, esi
mov eax, edi
and eax, esi
and ecx, r11d
xor ecx, eax
mov r12d, r14d
add edx, ecx
mov r14d, ebp
mov ebp, r9d
add rbx, 4
lea r9d, [r8 + r13]
mov r13d, esi
mov esi, edi
mov edi, r11d
lea r11d, [rdx + r8]
cmp rbx, 0x100
jl 0x1400d64e0
mov r10, qword [rsp + 8]
mov eax, r12d
mov rdx, qword [rsp + 0x10]
inc r15d
mov dword [rsp], r12d
add dword [r10 + 0x88], r11d
add dword [r10 + 0x8c], edi
add dword [r10 + 0x90], esi
add dword [r10 + 0x94], r13d
add dword [r10 + 0x98], r9d
add dword [r10 + 0x9c], ebp
add dword [r10 + 0xa0], r14d
add dword [r10 + 0xa4], eax
cmp r15d, dword [rsp + 4]
jl 0x1400d63e0
mov r14, qword [rsp + 0x130]
mov r13, qword [rsp + 0x138]
mov r12, qword [rsp + 0x140]
mov rdi, qword [rsp + 0x148]
mov rsi, qword [rsp + 0x178]
mov rbp, qword [rsp + 0x170]
mov rbx, qword [rsp + 0x168]
mov rcx, qword [rsp + 0x120]
xor rcx, rsp
call fcn.140215090
add rsp, 0x150
pop r15
ret
Function at 0x1400d6610
Capabilities:
Hash data using sha256

Disassembly:
push rbx
sub rsp, 0xe0
mov rax, qword [0x140320c20]
xor rax, rsp
mov qword [rsp + 0xd0], rax
movups xmm0, xmmword [0x140292578]
mov rbx, r8
mov r8d, edx
movups xmm1, xmmword [0x140292588]
mov rdx, rcx
xor eax, eax
lea rcx, [rsp + 0x20]
mov qword [rsp + 0x20], rax
movups xmmword [rsp + 0xa8], xmm0
movups xmmword [rsp + 0xb8], xmm1
call fcn.1400d6690
mov rdx, rbx
lea rcx, [rsp + 0x20]
call fcn.1400d6750
mov rcx, qword [rsp + 0xd0]
xor rcx, rsp
call fcn.140215090
add rsp, 0xe0
pop rbx
ret

Function at 0x1400d6a60
Capabilities:
Reference sql statements

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rsi
push rdi
sub rsp, 0x30
mov rbx, r8
mov byte [r8], 0
mov rdi, rdx
mov rsi, rcx
call fcn.1400d6910
test eax, eax
jne 0x1400d6a98
mov byte [rbx], 3
mov rbx, qword [rsp + 0x40]
mov rsi, qword [rsp + 0x48]
add rsp, 0x30
pop rdi
ret
cmp qword [rsi + 0x340], 0
jne 0x1400d6ab7
mov byte [rbx], 1
xor eax, eax
mov rbx, qword [rsp + 0x40]
mov rsi, qword [rsp + 0x48]
add rsp, 0x30
pop rdi
ret
mov r8, rdi
lea rdx, str.SELECT_pwsqlite_crypt__1_pw___isAdmin_FROM___w_.sqlite_user_WHERE_uname_2
mov rcx, rsi
call fcn.1400d6850
mov rdi, rax
test rax, rax
jne 0x1400d6ae4
lea eax, [rdi + 7]
mov rbx, qword [rsp + 0x40]
mov rsi, qword [rsp + 0x48]
add rsp, 0x30
pop rdi
ret
mov r9d, dword [rsi + 0x334]
mov edx, 1
mov r8, qword [rsi + 0x338]
mov rcx, rdi
mov byte [rsp + 0x28], 0
mov qword [rsp + 0x20], 0
call fcn.14005cf40
mov r8, qword [rsi + 0x340]
or r9d, 0xffffffff
mov byte [rsp + 0x28], 1
mov rcx, rdi
mov qword [rsp + 0x20], 0
lea edx, [r9 + 3]
call fcn.14005cf40
mov rcx, rdi
call fcn.14005b950
cmp eax, 0x64
jne 0x1400d6b60
xor edx, edx
mov rcx, rdi
call fcn.14005c1f0
test eax, eax
je 0x1400d6b60
mov edx, 1
mov rcx, rdi
call fcn.14005c1f0
add al, 2
mov byte [rbx], al
jmp 0x1400d6b63
mov byte [rbx], 1
mov rcx, rdi
mov rbx, qword [rsp + 0x40]
mov rsi, qword [rsp + 0x48]
add rsp, 0x30
pop rdi
jmp fcn.14005ab60
Function at 0x1400d7640
Capabilities:
Encode data using xor
Encrypt data using aes
Reference aes constants

Disassembly:
mov qword [rsp + 0x10], rbx
mov qword [rsp + 0x18], rsi
mov qword [rsp + 0x20], rdi
push rbp
push r14
push r15
mov rbp, rsp
sub rsp, 0x50
mov rax, qword [0x140320c20]
xor rax, rsp
mov qword [rbp - 0x10], rax
mov r15d, dword [rcx + 0x1c]
xor edi, edi
sub r15d, 6
xor r14d, r14d
movsxd rbx, r15d
mov rsi, rcx
test r15d, r15d
jle 0x1400d76d7
mov r8, rbx
lea rcx, [rbp - 0x30]
shl r8, 2
call fcn.140218780
xor r8d, r8d
xor edx, edx
cmp edi, dword [rsi + 0x1c]
ja 0x1400d7818
cmp r8, rbx
jge 0x1400d76c5
cmp rdx, 4
jge 0x1400d76c9
mov eax, dword [rbp + r8*4 - 0x30]
lea rcx, [rdx + rdi*4]
inc r8
mov dword [rsi + rcx*4 + 0x20], eax
inc rdx
inc r14d
cmp r8, rbx
jl 0x1400d76a4
cmp rdx, 4
jne 0x1400d76d2
inc edi
xor r14d, r14d
xor edx, edx
cmp r8, rbx
jl 0x1400d7696
cmp edi, dword [rsi + 0x1c]
ja 0x1400d7818
movsxd rax, r14d
lea r9, [0x1402928e0]
lea r10, [0x140294d70]
movzx edx, byte [rbp + rbx*4 - 0x33]
lea r9, [r9 + 4]
movzx ecx, byte [rbp - 0x30]
xor cl, byte [rdx + r10]
mov edx, 1
mov byte [rbp - 0x30], cl
movzx ecx, byte [rbp + rbx*4 - 0x32]
movzx ecx, byte [rcx + r10]
xor byte [rbp - 0x2f], cl
movzx ecx, byte [rbp + rbx*4 - 0x31]
movzx ecx, byte [rcx + r10]
xor byte [rbp - 0x2e], cl
movzx ecx, byte [rbp + rbx*4 - 0x34]
movzx ecx, byte [rcx + r10]
xor byte [rbp - 0x2d], cl
movzx ecx, byte [r9 - 4]
xor byte [rbp - 0x30], cl
cmp r15d, 8
je 0x1400d7770
cmp rdx, rbx
jge 0x1400d77d0
nop dword [rax + rax]
mov ecx, dword [rbp + rdx*4 - 0x34]
xor dword [rbp + rdx*4 - 0x30], ecx
inc rdx
cmp rdx, rbx
jl 0x1400d7750
jmp 0x1400d77d0
mov ecx, dword [rbp + rdx*4 - 0x34]
xor dword [rbp + rdx*4 - 0x30], ecx
inc rdx
cmp rdx, 4
jl 0x1400d7770
movzx ecx, byte [rbp - 0x24]
mov edx, 5
movzx ecx, byte [rcx + r10]
xor byte [rbp - 0x20], cl
movzx ecx, byte [rbp - 0x23]
movzx ecx, byte [rcx + r10]
xor byte [rbp - 0x1f], cl
movzx ecx, byte [rbp - 0x22]
movzx ecx, byte [rcx + r10]
xor byte [rbp - 0x1e], cl
movzx ecx, byte [rbp - 0x21]
movzx ecx, byte [rcx + r10]
xor byte [rbp - 0x1d], cl
cmp rdx, rbx
jge 0x1400d77d0
nop dword [rax + rax]
mov ecx, dword [rbp + rdx*4 - 0x34]
xor dword [rbp + rdx*4 - 0x30], ecx
inc rdx
cmp rdx, rbx
jl 0x1400d77c0
xor r8d, r8d
test r15d, r15d
jle 0x1400d780f
cmp edi, dword [rsi + 0x1c]
ja 0x1400d7818
cmp r8, rbx
jge 0x1400d7800
cmp rax, 4
jge 0x1400d7804
mov ecx, dword [rbp + r8*4 - 0x30]
lea rdx, [rax + rdi*4]
inc r8
mov dword [rsi + rdx*4 + 0x20], ecx
inc rax
cmp r8, rbx
jl 0x1400d77e2
cmp rax, 4
jne 0x1400d780a
inc edi
xor eax, eax
cmp r8, rbx
jl 0x1400d77d8
cmp edi, dword [rsi + 0x1c]
jbe 0x1400d76f1
mov rcx, qword [rbp - 0x10]
xor rcx, rsp
call fcn.140215090
lea r11, [rsp + 0x50]
mov rbx, qword [r11 + 0x28]
mov rsi, qword [r11 + 0x30]
mov rdi, qword [r11 + 0x38]
mov rsp, r11
pop r15
pop r14
pop rbp
ret
Function at 0x1400d7840
Capabilities:
Encode data using xor

Disassembly:
sub rsp, 8
mov r11d, 1
mov r10, rcx
cmp dword [rcx + 0x1c], r11d
jbe 0x1400d7961
mov qword [rsp], rbx
lea rbx, [0x140000000]
mov r9d, r11d
inc r11d
lea r8, [r9 + 2]
add r9, r9
shl r8, 4
add r8, r10
movzx ecx, byte [r8 + 3]
movzx eax, byte [r8 + 2]
mov edx, dword [rbx + rcx*4 + 0x326300]
xor edx, dword [rbx + rax*4 + 0x322710]
movzx eax, byte [r8 + 1]
xor edx, dword [rbx + rax*4 + 0x3253d0]
movzx eax, byte [r8]
xor edx, dword [rbx + rax*4 + 0x326700]
mov dword [r8], edx
movzx ecx, byte [r10 + r9*8 + 0x27]
movzx eax, byte [r10 + r9*8 + 0x26]
mov edx, dword [rbx + rcx*4 + 0x326300]
xor edx, dword [rbx + rax*4 + 0x322710]
movzx eax, byte [r10 + r9*8 + 0x25]
xor edx, dword [rbx + rax*4 + 0x3253d0]
movzx eax, byte [r10 + r9*8 + 0x24]
xor edx, dword [rbx + rax*4 + 0x326700]
mov dword [r10 + r9*8 + 0x24], edx
movzx ecx, byte [r10 + r9*8 + 0x2b]
movzx eax, byte [r10 + r9*8 + 0x2a]
mov edx, dword [rbx + rcx*4 + 0x326300]
xor edx, dword [rbx + rax*4 + 0x322710]
movzx eax, byte [r10 + r9*8 + 0x29]
xor edx, dword [rbx + rax*4 + 0x3253d0]
movzx eax, byte [r10 + r9*8 + 0x28]
xor edx, dword [rbx + rax*4 + 0x326700]
mov dword [r10 + r9*8 + 0x28], edx
movzx eax, byte [r10 + r9*8 + 0x2e]
movzx ecx, byte [r10 + r9*8 + 0x2f]
mov edx, dword [rbx + rcx*4 + 0x326300]
xor edx, dword [rbx + rax*4 + 0x322710]
movzx eax, byte [r10 + r9*8 + 0x2d]
xor edx, dword [rbx + rax*4 + 0x3253d0]
movzx eax, byte [r10 + r9*8 + 0x2c]
xor edx, dword [rbx + rax*4 + 0x326700]
mov dword [r10 + r9*8 + 0x2c], edx
cmp r11d, dword [r10 + 0x1c]
jb 0x1400d7862
mov rbx, qword [rsp]
add rsp, 8
ret
Function at 0x1400d8dd0
Capabilities:
Encrypt data using rc4 prga

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x18], rbp
mov qword [rsp + 0x20], rsi
push rdi
sub rsp, 0x110
mov rax, qword [0x140320c20]
xor rax, rsp
mov qword [rsp + 0x100], rax
mov rdi, qword [rsp + 0x148]
lea r10, [rsp]
xor eax, eax
mov rbp, r9
mov r8d, eax
mov ecx, eax
mov rsi, rdx
nop dword [rax]
nop word [rax + rax]
mov byte [r10], cl
lea r10, [r10 + 1]
inc ecx
cmp ecx, 0x100
jl 0x1400d8e20
mov r9d, eax
lea r11, [rsp]
mov r10d, eax
nop dword [rax + rax]
movzx ebx, byte [r11]
mov ecx, r10d
and ecx, 0x8000000f
jge 0x1400d8e56
dec ecx
or ecx, 0xfffffff0
inc ecx
movsxd rcx, ecx
movzx edx, byte [rcx + rsi]
add edx, ebx
add r9d, edx
and r9d, 0x800000ff
jge 0x1400d8e78
dec r9d
or r9d, 0xffffff00
inc r9d
movsxd rcx, r9d
lea rdx, [rsp]
add rdx, rcx
inc r10d
movzx ecx, byte [rdx]
mov byte [r11], cl
inc r11
mov byte [rdx], bl
cmp r10d, 0x100
jl 0x1400d8e40
sub rbp, rdi
mov r11d, reloc.WLDAP32.dll_Ordinal_32
inc eax
and eax, 0x800000ff
jge 0x1400d8eb4
dec eax
or eax, 0xffffff00
inc eax
movsxd rcx, eax
lea r9, [rsp]
add r9, rcx
movzx r10d, byte [r9]
add r8d, r10d
and r8d, 0x800000ff
jge 0x1400d8edb
dec r8d
or r8d, 0xffffff00
inc r8d
movsxd rcx, r8d
lea rdx, [rsp]
add rdx, rcx
movzx ecx, byte [rdx]
mov byte [r9], cl
mov byte [rdx], r10b
movzx edx, byte [r9]
add rdx, r10
movzx ecx, dl
movzx edx, byte [rsp + rcx]
xor dl, byte [rdi + rbp]
mov byte [rdi], dl
inc rdi
sub r11, 1
jne 0x1400d8ea2
mov rcx, qword [rsp + 0x100]
xor rcx, rsp
call fcn.140215090
lea r11, [rsp + 0x110]
mov rbx, qword [r11 + 0x10]
mov rbp, qword [r11 + 0x20]
mov rsi, qword [r11 + 0x28]
mov rsp, r11
pop rdi
ret
Function at 0x1400d8f40
Capabilities:
Hash data with md5

Disassembly:
mov qword [rsp + 8], rbx
push rbp
lea rbp, [rsp - 0x57]
sub rsp, 0xa0
mov rax, qword [0x140320c20]
xor rax, rsp
mov qword [rbp + 0x47], rax
lea ecx, [rdx + 1]
mov rbx, r8
mov eax, 0x4f7a09cd
imul r8d, ecx, 0x9ef4
imul ecx
sar edx, 0xe
mov eax, edx
shr eax, 0x1f
add edx, eax
imul eax, edx, 0x7fffff07
sub r8d, eax
jns 0x1400d8f90
add r8d, 0x7fffff07
mov eax, r8d
imul ecx, r8d, 0x9ef4
sar eax, 8
mov byte [rbp + 0x38], al
mov eax, r8d
sar eax, 0x10
mov byte [rbp + 0x39], al
mov eax, r8d
sar eax, 0x18
mov byte [rbp + 0x3a], al
mov eax, 0x4f7a09cd
imul r8d
mov byte [rbp + 0x37], r8b
sar edx, 0xe
mov eax, edx
shr eax, 0x1f
add edx, eax
imul eax, edx, 0x7fffff07
sub ecx, eax
jns 0x1400d8fd8
add ecx, 0x7fffff07
mov eax, ecx
imul r8d, ecx, 0x9ef4
sar eax, 8
mov byte [rbp + 0x3c], al
mov eax, ecx
sar eax, 0x10
mov byte [rbp + 0x3d], al
mov eax, ecx
sar eax, 0x18
mov byte [rbp + 0x3e], al
mov eax, 0x4f7a09cd
imul ecx
mov byte [rbp + 0x3b], cl
sar edx, 0xe
mov eax, edx
shr eax, 0x1f
add edx, eax
imul eax, edx, 0x7fffff07
sub r8d, eax
jns 0x1400d901d
add r8d, 0x7fffff07
mov eax, 0x4f7a09cd
mov byte [rbp + 0x3f], r8b
imul r8d
mov ecx, r8d
sar ecx, 8
sar edx, 0xe
mov eax, edx
mov byte [rbp + 0x40], cl
shr eax, 0x1f
mov ecx, r8d
sar ecx, 0x10
add edx, eax
imul eax, edx, 0x7fffff07
mov byte [rbp + 0x41], cl
mov ecx, r8d
sar ecx, 0x18
imul edx, r8d, 0x9ef4
mov byte [rbp + 0x42], cl
sub edx, eax
jns 0x1400d9065
add edx, 0x7fffff07
mov eax, edx
mov byte [rbp + 0x43], dl
sar eax, 8
lea rcx, [rbp - 0x29]
mov byte [rbp + 0x44], al
mov eax, edx
sar eax, 0x10
sar edx, 0x18
mov byte [rbp + 0x45], al
xor eax, eax
mov byte [rbp + 0x46], dl
lea rdx, [rbp + 0x37]
mov dword [rbp - 0x29], 0x67452301
mov dword [rbp - 0x25], 0xefcdab89
lea r8d, [rax + 0x10]
mov dword [rbp - 0x21], 0x98badcfe
mov qword [rbp - 0x1d], 0x10325476
mov dword [rbp - 0x15], eax
call fcn.1400d8480
lea rdx, [rbp - 0x29]
mov rcx, rbx
call fcn.1400d82b0
mov rcx, qword [rbp + 0x47]
xor rcx, rsp
call fcn.140215090
mov rbx, qword [rsp + 0xb0]
add rsp, 0xa0
pop rbp
ret
Function at 0x1400d90e0
Capabilities:
Hash data with md5

Disassembly:
mov qword [rsp + 0x18], rbx
mov qword [rsp + 0x20], rsi
push rbp
push rdi
push r12
push r14
push r15
lea rbp, [rsp - 0x1f]
sub rsp, 0xd0
mov rax, qword [0x140320c20]
xor rax, rsp
mov qword [rbp + 0xf], rax
movups xmm0, xmmword [r9]
mov r14, qword [rbp + 0x6f]
mov eax, edx
mov r15, qword [rbp + 0x7f]
mov edi, edx
xor ebx, ebx
mov byte [rbp - 0x21], dil
test r8d, r8d
mov dword [rbp - 0x1d], 0x546c4173
mov r12d, r8d
mov dword [rsp + 0x20], 0x67452301
sete bl
mov dword [rsp + 0x24], 0xefcdab89
sar eax, 8
mov rsi, rcx
mov byte [rbp - 0x20], al
lea rcx, [rsp + 0x20]
mov eax, edx
mov dword [rsp + 0x28], 0x98badcfe
sar eax, 0x10
mov r8d, Ordinal_27
mov byte [rbp - 0x1f], al
mov eax, edx
sar eax, 0x18
lea rdx, [rbp - 0x31]
mov byte [rbp - 0x1e], al
movups xmmword [rbp - 0x31], xmm0
mov qword [rsp + 0x2c], 0x10325476
mov dword [rbp - 0x7d], 0
call fcn.1400d8480
lea rdx, [rsp + 0x20]
lea rcx, [rbp - 0x31]
call fcn.1400d82b0
lea r8, [rbp - 0x11]
mov edx, edi
call fcn.1400d8f40
mov rdi, qword [rsi + 0x30]
lea r9, [rbp - 0x31]
movups xmm0, xmmword [rbp - 0x11]
xor eax, eax
mov dword [rdi], 1
mov dword [rdi + 4], 1
mov dword [rdi + 8], ebx
lea r10d, [rax + 0x10]
movups xmmword [rdi + 0xc], xmm0
mov dword [rdi + 0x1c], 0xa
mov rcx, rax
lea rdx, [rbp - 0x11]
and ecx, 3
lea r9, [r9 + 1]
add rdx, rcx
mov r8, rax
movzx ecx, byte [r9 - 1]
inc rax
shr r8, 2
mov byte [rdx + r8*4], cl
sub r10, 1
jne 0x1400d91d1
lea rdx, [rbp - 0x11]
mov rcx, rdi
call fcn.1400d7640
cmp dword [rdi + 8], 1
jne 0x1400d9215
mov rcx, rdi
call fcn.1400d7840
mov r8d, dword [rbp + 0x77]
mov r9, r15
mov dword [rdi], 0
mov rdx, r14
mov rcx, qword [rsi + 0x30]
lea r8d, [r8*8]
test r12d, r12d
je 0x1400d923d
call fcn.1400d6da0
jmp 0x1400d9242
call fcn.1400d71f0
mov rcx, qword [rbp + 0xf]
xor rcx, rsp
call fcn.140215090
lea r11, [rsp + 0xd0]
mov rbx, qword [r11 + 0x40]
mov rsi, qword [r11 + 0x48]
mov rsp, r11
pop r15
pop r14
pop r12
pop rdi
pop rbp
ret
Function at 0x1400d9db0
Capabilities:
Initialize winsock library

Disassembly:
sub rsp, 0x1d8
mov rax, qword [0x140320c20]
xor rax, rsp
mov qword [rsp + 0x1c0], rax
mov ecx, 0x202
mov byte [0x14033061c], 0
lea rdx, [rsp + 0x20]
call qword [sym.imp.WS2_32.dll_WSAStartup]
test eax, eax
jne 0x1400d9e0a
movzx ecx, word [rsp + 0x20]
cmp cl, 2
jne 0x1400d9e0a
movzx eax, byte [0x14033061c]
mov edx, 1
shr cx, 8
cmp cl, 2
cmove eax, edx
mov byte [0x14033061c], al
lea rax, [0x14033061c]
mov rcx, qword [rsp + 0x1c0]
xor rcx, rsp
call fcn.140215090
add rsp, 0x1d8
ret
Function at 0x1400d9eb0
Capabilities:
Resolve dns

Disassembly:
mov rax, rsp
push rbp
push rdi
push r14
lea rbp, [rax - 0x5f]
sub rsp, 0xc0
mov qword [rbp - 1], 0xfffffffffffffffe
mov qword [rax + 0x18], rbx
mov qword [rax + 0x20], rsi
mov rax, qword [0x140320c20]
xor rax, rsp
mov qword [rbp + 0x3f], rax
mov rbx, rcx
mov qword [rbp + 0x37], reloc.WS2_32.dll_ntohs
xor r14d, r14d
mov qword [rbp + 0x2f], r14
mov byte [rbp + 0x1f], r14b
cmp byte [rdx], r14b
jne 0x1400d9f00
mov r8d, r14d
jmp 0x1400d9f0d
or r8, 0xffffffffffffffff
inc r8
cmp byte [rdx + r8], r14b
jne 0x1400d9f04
lea rcx, [rbp + 0x1f]
call fcn.1400044f0
nop
xorps xmm0, xmm0
movdqu xmmword [rbp - 0x51], xmm0
mov qword [rbp - 0x41], r14
mov esi, r14d
mov dword [rbp - 0x39], r14d
mov dword [rbp - 0x31], 2
xor eax, eax
mov qword [rbp - 0x2d], rax
mov qword [rbp - 0x25], rax
mov qword [rbp - 0x1d], rax
mov qword [rbp - 0x15], rax
mov qword [rbp - 0xd], rax
mov dword [rbp - 5], eax
mov qword [rbp - 0x59], r14
lea rcx, [rbp + 0x1f]
cmp qword [rbp + 0x37], 0x10
cmovae rcx, qword [rbp + 0x1f]
lea r9, [rbp - 0x59]
lea r8, [rbp - 0x31]
xor edx, edx
call qword [sym.imp.WS2_32.dll_getaddrinfo]
test eax, eax
je 0x1400d9f7a
mov esi, 1
mov dword [rbp - 0x39], esi
jmp 0x1400d9fc2
mov rdi, qword [rbp - 0x59]
test rdi, rdi
je 0x1400d9fb8
nop dword [rax]
nop word [rax + rax]
mov rax, qword [rdi + 0x20]
movups xmm0, xmmword [rax]
movups xmmword [rbp + 7], xmm0
lea rdx, [rbp + 7]
lea rcx, [rbp - 0x51]
call fcn.1400da8b0
mov rdi, qword [rdi + 0x28]
test rdi, rdi
jne 0x1400d9f90
mov esi, dword [rbp - 0x39]
mov rdi, qword [rbp - 0x59]
mov rcx, rdi
call qword [sym.imp.WS2_32.dll_freeaddrinfo]
nop
mov rax, qword [rbp + 0x37]
cmp rax, 0x10
jb 0x1400da018
inc rax
mov rcx, qword [rbp + 0x1f]
cmp rax, 0x1000
jb 0x1400da013
test cl, 0x1f
je 0x1400d9fe6
call fcn.1402226ac
int3
mov rax, qword [rcx - 8]
cmp rax, rcx
jb 0x1400d9ff5
call fcn.1402226ac
int3
sub rcx, rax
cmp rcx, 8
jae 0x1400da004
call fcn.1402226ac
int3
cmp rcx, 0x27
jbe 0x1400da010
call fcn.1402226ac
int3
mov rcx, rax
call fcn.1402150bc
test esi, esi
je 0x1400da023
xor bl, bl
jmp 0x1400da0ba
mov qword [rbx + 0x470], r14
lea rcx, [rbx + 0x6e]
xor edx, edx
mov r8d, 0x400
call fcn.140218bd0
xorps xmm0, xmm0
movdqu xmmword [rbp + 7], xmm0
mov qword [rbp + 0x17], r14
lea rdx, [rbp - 0x51]
lea rcx, [rbp + 7]
call fcn.1400da750
mov r9, qword [rbp + 7]
mov rax, r9
mov rdx, qword [rbp + 0xf]
cmp r9, rdx
je 0x1400da096
cmp word [rax], 2
jne 0x1400da083
mov rcx, qword [rbx + 0x470]
add rcx, rcx
movups xmm0, xmmword [rax]
movups xmmword [rbx + rcx*8 + 0x6e], xmm0
inc qword [rbx + 0x470]
cmp qword [rbx + 0x470], 0x40
jae 0x1400da096
add rax, 0x10
cmp rax, rdx
jne 0x1400da064
cmp qword [rbx + 0x470], 0
setne bl
test r9, r9
je 0x1400da0ba
mov r8, qword [rbp + 0x17]
sub r8, r9
sar r8, 4
mov rdx, r9
call fcn.14002bc90
nop
mov rdx, qword [rbp - 0x51]
test rdx, rdx
je 0x1400da0d3
mov r8, qword [rbp - 0x41]
sub r8, rdx
sar r8, 4
call fcn.14002bc90
movzx eax, bl
mov rcx, qword [rbp + 0x3f]
xor rcx, rsp
call fcn.140215090
lea r11, [rsp + 0xc0]
mov rbx, qword [r11 + 0x30]
mov rsi, qword [r11 + 0x38]
mov rsp, r11
pop r14
pop rdi
pop rbp
ret
Function at 0x1400da610
Capabilities:
Check mutex on windows
Send data
Send data on socket

Disassembly:
mov qword [rsp + 0x20], rbx
push rbp
push rsi
push rdi
sub rsp, 0x50
mov rax, qword [0x140320c20]
xor rax, rsp
mov qword [rsp + 0x40], rax
cmp qword [rcx], 0xffffffffffffffff
mov edi, r9d
mov ebp, r8d
mov rsi, rdx
mov rbx, rcx
je 0x1400da726
cmp qword [rcx + 0x470], 0
je 0x1400da726
xor ecx, ecx
call fcn.140224720
xor edx, edx
div qword [rbx + 0x470]
add rdx, rdx
movups xmm0, xmmword [rbx + rdx*8 + 0x6e]
movups xmmword [rsp + 0x30], xmm0
test dil, 8
jne 0x1400da68d
cmp edi, 4
je 0x1400da68d
movzx eax, word [rsp + 0x30]
cmp eax, 2
je 0x1400da686
cmp eax, 0x17
jne 0x1400da6ac
mov ecx, 0x1f90
jmp 0x1400da6a1
movzx eax, word [rsp + 0x30]
cmp eax, 2
je 0x1400da69c
cmp eax, 0x17
jne 0x1400da6ac
mov ecx, 0x1f91
call qword [sym.imp.WS2_32.dll_htons]
mov word [rsp + 0x32], ax
mov eax, dword [0x140330608]
test al, 1
jne 0x1400da6df
or eax, 1
xor r8d, r8d
xor edx, edx
mov dword [0x140330608], eax
xor ecx, ecx
call qword [sym.imp.KERNEL32.dll_CreateMutexA]
lea rcx, [0x140246a10]
mov qword [0x140330600], rax
call fcn.14021505c
mov rcx, qword [0x140330600]
or edx, 0xffffffff
call qword [sym.imp.KERNEL32.dll_WaitForSingleObject]
mov rcx, qword [rbx]
lea rax, [rsp + 0x30]
mov dword [rsp + 0x28], reloc.WS2_32.dll_recv
xor r9d, r9d
mov r8d, ebp
mov qword [rsp + 0x20], rax
mov rdx, rsi
call qword [sym.imp.WS2_32.dll_sendto]
mov rcx, qword [0x140330600]
mov ebx, eax
call qword [sym.imp.KERNEL32.dll_ReleaseMutex]
mov eax, ebx
jmp 0x1400da728
xor eax, eax
mov rcx, qword [rsp + 0x40]
xor rcx, rsp
call fcn.140215090
mov rbx, qword [rsp + 0x88]
add rsp, 0x50
pop rdi
pop rsi
pop rbp
ret
Function at 0x1400daed0
Capabilities:
Encode data using xor
Encrypt data using aes
Reference aes constants

Disassembly:
mov qword [rsp + 0x10], rbx
mov qword [rsp + 0x18], rsi
mov qword [rsp + 0x20], rdi
push rbp
mov rbp, rsp
sub rsp, 0x50
mov rax, qword [0x140320c20]
xor rax, rsp
mov qword [rbp - 0x10], rax
mov esi, dword [rcx + 0x30]
mov rdi, rcx
sub esi, 6
movsxd rbx, esi
test esi, esi
jle 0x1400daf15
mov r8, rbx
lea rcx, [rbp - 0x30]
shl r8, 2
call fcn.140218780
xor r9d, r9d
xor r10d, r10d
test esi, esi
jle 0x1400daf67
xor r8d, r8d
xor edx, edx
cmp r9d, dword [rdi + 0x30]
ja 0x1400db0aa
cmp r8, rbx
jge 0x1400daf54
cmp rdx, 4
jge 0x1400daf58
mov eax, dword [rbp + r8*4 - 0x30]
lea rcx, [rdx + r9*4]
inc r8
mov dword [rdi + rcx*4 + 0x34], eax
inc rdx
inc r10d
cmp r8, rbx
jl 0x1400daf33
cmp rdx, 4
jne 0x1400daf62
inc r9d
xor r10d, r10d
xor edx, edx
cmp r8, rbx
jl 0x1400daf24
cmp r9d, dword [rdi + 0x30]
ja 0x1400db0aa
movsxd rax, r10d
lea r11, str.cw
lea r10, [0x140295950]
movzx edx, byte [rbp + rbx*4 - 0x33]
lea r10, [r10 + 4]
movzx ecx, byte [rbp - 0x30]
xor cl, byte [rdx + r11]
mov edx, 1
mov byte [rbp - 0x30], cl
movzx ecx, byte [rbp + rbx*4 - 0x32]
movzx ecx, byte [rcx + r11]
xor byte [rbp - 0x2f], cl
movzx ecx, byte [rbp + rbx*4 - 0x31]
movzx ecx, byte [rcx + r11]
xor byte [rbp - 0x2e], cl
movzx ecx, byte [rbp + rbx*4 - 0x34]
movzx ecx, byte [rcx + r11]
xor byte [rbp - 0x2d], cl
movzx ecx, byte [r10 - 4]
xor byte [rbp - 0x30], cl
cmp esi, 8
je 0x1400db000
cmp rdx, rbx
jge 0x1400db060
nop dword [rax + rax]
mov ecx, dword [rbp + rdx*4 - 0x34]
xor dword [rbp + rdx*4 - 0x30], ecx
inc rdx
cmp rdx, rbx
jl 0x1400dafe0
jmp 0x1400db060
mov ecx, dword [rbp + rdx*4 - 0x34]
xor dword [rbp + rdx*4 - 0x30], ecx
inc rdx
cmp rdx, 4
jl 0x1400db000
movzx ecx, byte [rbp - 0x24]
mov edx, 5
movzx ecx, byte [rcx + r11]
xor byte [rbp - 0x20], cl
movzx ecx, byte [rbp - 0x23]
movzx ecx, byte [rcx + r11]
xor byte [rbp - 0x1f], cl
movzx ecx, byte [rbp - 0x22]
movzx ecx, byte [rcx + r11]
xor byte [rbp - 0x1e], cl
movzx ecx, byte [rbp - 0x21]
movzx ecx, byte [rcx + r11]
xor byte [rbp - 0x1d], cl
cmp rdx, rbx
jge 0x1400db060
nop dword [rax + rax]
mov ecx, dword [rbp + rdx*4 - 0x34]
xor dword [rbp + rdx*4 - 0x30], ecx
inc rdx
cmp rdx, rbx
jl 0x1400db050
xor r8d, r8d
test esi, esi
jle 0x1400db0a0
cmp r9d, dword [rdi + 0x30]
ja 0x1400db0aa
cmp r8, rbx
jge 0x1400db090
cmp rax, 4
jge 0x1400db094
mov ecx, dword [rbp + r8*4 - 0x30]
lea rdx, [rax + r9*4]
inc r8
mov dword [rdi + rdx*4 + 0x34], ecx
inc rax
cmp r8, rbx
jl 0x1400db072
cmp rax, 4
jne 0x1400db09b
inc r9d
xor eax, eax
cmp r8, rbx
jl 0x1400db067
cmp r9d, dword [rdi + 0x30]
jbe 0x1400daf82
mov rcx, qword [rbp - 0x10]
xor rcx, rsp
call fcn.140215090
mov rbx, qword [rsp + 0x68]
mov rsi, qword [rsp + 0x70]
mov rdi, qword [rsp + 0x78]
add rsp, 0x50
pop rbp
ret