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

Disassembly:
push rbp
push r15
push r14
push r13
push r12
push rsi
push rdi
push rbx
sub rsp, 0x28
lea rbp, [rsp + 0x20]
mov qword [rbp], 0xfffffffffffffffe
mov rdi, rdx
mov rsi, rcx
lea rax, [r8 + 2]
movabs rcx, 0xaaaaaaaaaaaaaaab
mul rcx
mov r15, rdx
add r15, rdx
xorps xmm0, xmm0
movups xmmword [rsi + 0x10], xmm0
movups xmmword [rsi], xmm0
and r15, 0xfffffffffffffffc
js 0x1400533cb
mov ebx, r9d
mov r14, r8
cmp r15, 0xf
ja 0x1400532d5
mov qword [rsi + 0x10], r15
mov qword [rsi + 0x18], setsockopt
mov rcx, rsi
xor edx, edx
mov r8, r15
call fcn.1400c8de0
add r15, rsi
mov r12, r15
mov byte [r12], 0
cmp qword [rsi + 0x18], 0x10
mov rax, rsi
jb 0x1400531ef
mov rax, qword [rsi]
mov rcx, qword [rbp + 0x70]
cmp r14, 3
jb 0x14005330e
lea r8, [r14 - 2]
xor edx, edx
nop word cs:[rax + rax]
movzx r9d, byte [rdi + rdx]
shr r9d, 2
movzx r9d, byte [rcx + r9]
mov byte [rax], r9b
movzx r9d, byte [rdi + rdx]
shl r9d, 4
and r9d, 0x30
movzx r10d, byte [rdi + rdx + 1]
shr r10d, 4
or r10d, r9d
movzx r9d, byte [rcx + r10]
mov byte [rax + 1], r9b
movzx r9d, byte [rdi + rdx + 1]
and r9d, 0xf
movzx r10d, byte [rdi + rdx + 2]
shr r10d, 6
lea r9d, [r10 + r9*4]
movzx r9d, byte [rcx + r9]
mov byte [rax + 2], r9b
movzx r9d, byte [rdi + rdx + 2]
and r9d, 0x3f
movzx r9d, byte [rcx + r9]
mov byte [rax + 3], r9b
add rax, 4
add rdx, 3
cmp rdx, r8
jb 0x140053210
cmp rdx, r14
jae 0x140053319
movzx r8d, byte [rdi + rdx]
shr r8d, 2
movzx r8d, byte [rcx + r8]
mov byte [rax], r8b
dec r14
movzx r8d, byte [rdi + rdx]
shl r8d, 4
and r8d, 0x30
cmp rdx, r14
jne 0x140053361
movzx ecx, byte [rcx + r8]
mov byte [rax + 1], cl
test bl, bl
je 0x140053394
mov byte [rax + 2], 0x3d
mov byte [rax + 3], 0x3d
jmp 0x1400533b7
mov rax, r15
or rax, 0xf
cmp rax, 0x17
mov r13d, socket
cmovae r13, rax
cmp r13, 0xfff
jb 0x140053322
lea rcx, [r13 + 0x28]
call fcn.14009a7a0
mov r12, rax
add r12, 0x27
and r12, 0xffffffffffffffe0
mov qword [r12 - 8], rax
jmp 0x14005332e
xor edx, edx
cmp rdx, r14
jb 0x14005328e
test bl, bl
je 0x140053394
jmp 0x1400533b7
lea rcx, [r13 + 1]
call fcn.14009a7a0
mov r12, rax
mov qword [rsi], r12
mov qword [rsi + 0x10], r15
mov qword [rsi + 0x18], r13
mov rcx, r12
xor edx, edx
mov r8, r15
call fcn.1400c8de0
add r12, r15
mov byte [r12], 0
cmp qword [rsi + 0x18], 0x10
mov rax, rsi
jae 0x1400531ec
jmp 0x1400531ef
movzx r9d, byte [rdx + rdi + 1]
shr r9d, 4
movzx r8d, r8b
or r8, r9
movzx r8d, byte [rcx + r8]
mov byte [rax + 1], r8b
movzx edx, byte [rdx + rdi + 1]
and edx, 0xf
movzx ecx, byte [rcx + rdx*4]
mov byte [rax + 2], cl
test bl, bl
je 0x140053394
mov byte [rax + 3], 0x3d
jmp 0x1400533b7
cmp qword [rsi + 0x18], 0x10
mov rdi, rsi
jb 0x1400533a1
mov rdi, qword [rsi]
mov rcx, rdi
call fcn.1400a4440
cmp qword [rsi + 0x10], rax
jb 0x1400533d0
mov qword [rsi + 0x10], rax
mov byte [rdi + rax], 0
mov rax, rsi
add rsp, 0x28
pop rbx
pop rdi
pop rsi
pop r12
pop r13
pop r14
pop r15
pop rbp
ret
call fcn.140004740
call fcn.140007e60
int3
Function at 0x140053940
Capabilities:
Convert ip address from string

Disassembly:
push rbp
push rsi
push rdi
push rbx
sub rsp, 0x28
lea rbp, [rsp + 0x20]
mov qword [rbp], 0xfffffffffffffffe
mov rdi, rdx
mov rsi, rcx
mov r8, qword [rdx + 0x10]
test r8, r8
je 0x14005399f
cmp qword [rdi + 0x18], 0x10
mov rbx, rdi
jb 0x140053971
mov rbx, qword [rdi]
mov rcx, rbx
mov edx, 0x3a
call fcn.1400c9900
test rax, rax
je 0x14005399f
sub rax, rbx
cmp rax, 0xffffffffffffffff
je 0x14005399f
mov ecx, reloc.WS2_32.dll_socket
mov rdx, rbx
mov r8, rsi
call qword [sym.imp.WS2_32.dll_inet_pton]
jmp 0x1400539cc
mov qword [rsi], 0
mov dword [rsi + 8], 0xffff0000
add rsi, 0xc
cmp qword [rdi + 0x18], 0x10
jb 0x1400539bb
mov rdi, qword [rdi]
mov ecx, 2
mov rdx, rdi
mov r8, rsi
call qword [sym.imp.WS2_32.dll_inet_pton]
cmp eax, 1
sete al
add rsp, 0x28
pop rbx
pop rdi
pop rsi
pop rbp
ret
Function at 0x140057640
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbp
push r15
push r14
push r13
push r12
push rsi
push rdi
push rbx
sub rsp, 0x58
lea rbp, [rsp + 0x50]
mov qword [rbp], 0xfffffffffffffffe
mov rsi, rdx
mov r15, rcx
lea rcx, [rdx + 0x68]
lea r8, [0x14013cd30]
lea rbx, [rbp - 0x28]
mov rdx, rbx
call fcn.1400581a0
mov rdi, qword [rbp - 0x28]
mov r14, qword [rbp - 0x18]
mov r12, qword [rbp - 0x10]
cmp r12, 0x10
cmovae rbx, rdi
test r14, r14
je 0x1400576b7
mov eax, r14d
and eax, 3
movabs rcx, 0x100000001b3
cmp r14, 4
jae 0x1400576c6
movabs r8, 0xcbf29ce484222325
xor edx, edx
jmp 0x14005771c
movabs r9, 0xcbf29ce484222325
jmp 0x140057747
mov r9, r14
and r9, 0xfffffffffffffffc
movabs r8, 0xcbf29ce484222325
xor edx, edx
nop dword [rax]
movzx r10d, byte [rbx + rdx]
xor r10, r8
imul r10, rcx
movzx r8d, byte [rbx + rdx + 1]
xor r8, r10
imul r8, rcx
movzx r10d, byte [rbx + rdx + 2]
xor r10, r8
imul r10, rcx
movzx r8d, byte [rbx + rdx + 3]
xor r8, r10
imul r8, rcx
add rdx, 4
cmp r9, rdx
jne 0x1400576e0
mov r9, r8
test rax, rax
je 0x140057747
add rdx, rbx
xor r10d, r10d
nop word [rax + rax]
movzx r9d, byte [rdx + r10]
xor r9, r8
imul r9, rcx
inc r10
mov r8, r9
cmp rax, r10
jne 0x140057730
and r9, qword [r15 + 0x30]
mov r13, qword [r15 + 8]
mov rax, qword [r15 + 0x18]
mov rcx, r9
shl rcx, 4
mov r15, qword [rax + rcx + 8]
cmp r15, r13
je 0x1400577d2
mov qword [rbp - 8], rsi
add r9, r9
mov rsi, qword [rax + r9*8]
cmp r14, qword [r15 + 0x20]
jne 0x1400577a3
nop word cs:[rax + rax]
cmp qword [r15 + 0x28], 0x10
jb 0x140057790
mov rdx, qword [r15 + 0x10]
jmp 0x140057794
lea rdx, [r15 + 0x10]
mov rcx, rbx
mov r8, r14
call fcn.1400c9820
test eax, eax
je 0x1400577b7
cmp r15, rsi
je 0x1400577b4
mov r15, qword [r15 + 8]
cmp r14, qword [r15 + 0x20]
je 0x140057780
jmp 0x1400577a3
xor r15d, r15d
mov rsi, qword [rbp - 8]
test r15, r15
cmove r15, r13
cmp r12, 0x10
jae 0x1400577e2
cmp r15, r13
jne 0x140057818
jmp 0x140057869
xor r15d, r15d
test r15, r15
cmove r15, r13
cmp r12, 0x10
jb 0x1400577c8
lea rdx, [r12 + 1]
cmp rdx, 0x1000
jb 0x14005780b
mov rax, qword [rdi - 8]
add rdi, 0xfffffffffffffff8
sub rdi, rax
cmp rdi, 0x20
jae 0x14005787c
add r12, 0x28
mov rdx, r12
mov rdi, rax
mov rcx, rdi
call fcn.14009a7e4
cmp r15, r13
je 0x140057869
cmp byte [r15 + 0xc9], 0
setne al
cmp byte [rsi + 0x99], 0
setne cl
xor cl, al
jne 0x140057869
lea rcx, [r15 + 0xd0]
lea rdx, [rsi + 0xa0]
call fcn.140065b10
test al, al
je 0x140057869
add r15, 0xf0
add rsi, 0xc0
mov rcx, r15
mov rdx, rsi
call fcn.140065b10
mov ecx, eax
mov al, 1
test cl, cl
jne 0x14005786b
xor eax, eax
add rsp, 0x58
pop rbx
pop rdi
pop rsi
pop r12
pop r13
pop r14
pop r15
pop rbp
ret
call fcn.1400a4324
int3
Function at 0x1400578b0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push r15
push r14
push rsi
push rdi
push rbx
sub rsp, 0x20
mov rsi, rdx
mov rdi, qword [rdx + 0x10]
cmp qword [rdx + 0x18], 0x10
jb 0x1400578cc
mov rsi, qword [rsi]
test rdi, rdi
je 0x1400578f5
mov eax, edi
and eax, 3
movabs rdx, 0x100000001b3
cmp rdi, 4
jae 0x140057904
movabs r9, 0xcbf29ce484222325
xor r8d, r8d
jmp 0x14005795c
movabs r10, 0xcbf29ce484222325
jmp 0x140057987
mov r10, rdi
and r10, 0xfffffffffffffffc
movabs r9, 0xcbf29ce484222325
xor r8d, r8d
nop dword [rax + rax]
movzx r11d, byte [rsi + r8]
xor r11, r9
imul r11, rdx
movzx r9d, byte [rsi + r8 + 1]
xor r9, r11
imul r9, rdx
movzx r11d, byte [rsi + r8 + 2]
xor r11, r9
imul r11, rdx
movzx r9d, byte [rsi + r8 + 3]
xor r9, r11
imul r9, rdx
add r8, 4
cmp r10, r8
jne 0x140057920
mov r10, r9
test rax, rax
je 0x140057987
add r8, rsi
xor r11d, r11d
nop word [rax + rax]
movzx r10d, byte [r8 + r11]
xor r10, r9
imul r10, rdx
inc r11
mov r9, r10
cmp rax, r11
jne 0x140057970
and r10, qword [rcx + 0x30]
mov rbx, qword [rcx + 8]
mov rax, qword [rcx + 0x18]
mov rcx, r10
shl rcx, 4
mov r14, qword [rax + rcx + 8]
cmp r14, rbx
je 0x1400579f4
add r10, r10
mov r15, qword [rax + r10*8]
cmp rdi, qword [r14 + 0x20]
jne 0x1400579e3
nop word cs:[rax + rax]
cmp qword [r14 + 0x28], 0x10
jb 0x1400579d0
mov rdx, qword [r14 + 0x10]
jmp 0x1400579d4
lea rdx, [r14 + 0x10]
mov rcx, rsi
mov r8, rdi
call fcn.1400c9820
test eax, eax
je 0x1400579f7
cmp r14, r15
je 0x1400579f4
mov r14, qword [r14 + 8]
cmp rdi, qword [r14 + 0x20]
je 0x1400579c0
jmp 0x1400579e3
xor r14d, r14d
test r14, r14
cmove r14, rbx
lea rcx, [r14 + 0x30]
xor eax, eax
cmp r14, rbx
cmovne rax, rcx
add rsp, 0x20
pop rbx
pop rdi
pop rsi
pop r14
pop r15
ret
Function at 0x140058c60
Capabilities:
Hash data using fnv

Disassembly:
push rbp
push r15
push r14
push r13
push r12
push rsi
push rdi
push rbx
sub rsp, 0x88
lea rbp, [rsp + 0x80]
mov qword [rbp], 0xfffffffffffffffe
mov r13, rcx
mov dword [rbp - 0x20], 0
lea rcx, [rbp - 0x60]
lea rdx, [rbp - 0x20]
lea r8, [rbp - 1]
call fcn.14005a240
mov rdi, qword [r13]
movabs r12, 0xcbf29ce484222325
movabs rsi, 0x100000001b3
nop word cs:[rax + rax]
lea rbx, [rdi + 0x48]
lea r14, [rdi + 0xf8]
mov qword [rbp - 0x10], rbx
mov r15, qword [r13 + 8]
cmp rdi, r15
je 0x140058df8
movzx eax, byte [rdi + 0x48]
xor rax, r12
imul rax, rsi
movzx ecx, byte [rdi + 0x49]
xor rcx, rax
imul rcx, rsi
movzx eax, byte [rdi + 0x4a]
xor rax, rcx
imul rax, rsi
movzx ecx, byte [rdi + 0x4b]
xor rcx, rax
imul rcx, rsi
and rcx, qword [rbp - 0x30]
mov r8, qword [rbp - 0x48]
mov rax, rcx
shl rax, 4
mov rax, qword [r8 + rax + 8]
cmp rax, qword [rbp - 0x58]
je 0x140058de0
mov edx, dword [rbx]
cmp edx, dword [rax + 0x10]
je 0x140058d52
add rcx, rcx
mov rcx, qword [r8 + rcx*8]
nop word cs:[rax + rax]
cmp rax, rcx
je 0x140058de0
mov rax, qword [rax + 8]
cmp edx, dword [rax + 0x10]
jne 0x140058d40
cmp r14, r15
je 0x140058dad
mov rsi, r13
mov rbx, r14
mov r14, r12
mov r12, rdi
nop word cs:[rax + rax]
lea r13, [r12 + 0xf8]
mov rcx, r12
mov rdx, r13
call fcn.140059e50
add r12, 0x1f0
cmp r12, r15
mov r12, r13
jne 0x140058d70
mov r13, rsi
mov r15, qword [rsi + 8]
mov r12, r14
mov r14, rbx
movabs rsi, 0x100000001b3
mov rbx, qword [rbp - 0x10]
add r15, 0xffffffffffffff08
mov rcx, r15
call fcn.140044d50
add qword [r13 + 8], 0xffffffffffffff08
mov r15, qword [r13 + 8]
cmp rdi, r15
jne 0x140058cdc
jmp 0x140058df8
lea rcx, [rbp - 0x60]
lea rdx, [rbp - 0x20]
mov r8, rbx
call fcn.140059410
mov rdi, r14
jmp 0x140058cc0
mov rcx, qword [rbp - 0x48]
test rcx, rcx
je 0x140058e40
mov rdx, qword [rbp - 0x38]
sub rdx, rcx
cmp rdx, 0x1000
jb 0x140058e29
mov rax, qword [rcx - 8]
add rcx, 0xfffffffffffffff8
sub rcx, rax
cmp rcx, 0x20
jae 0x140058e9b
add rdx, 0x27
mov rcx, rax
call fcn.14009a7e4
xorps xmm0, xmm0
lea rax, [rbp - 0x48]
movups xmmword [rax], xmm0
mov qword [rax + 0x10], 0
mov rax, qword [rbp - 0x58]
mov rcx, qword [rax + 8]
mov qword [rcx], 0
mov rcx, qword [rax]
test rcx, rcx
je 0x140058e79
nop word [rax + rax]
mov rsi, qword [rcx]
mov edx, 0x18
call fcn.14009a7e4
mov rcx, rsi
test rsi, rsi
jne 0x140058e60
mov rax, qword [rbp - 0x58]
mov edx, 0x18
mov rcx, rax
call fcn.14009a7e4
nop
add rsp, 0x88
pop rbx
pop rdi
pop rsi
pop r12
pop r13
pop r14
pop r15
pop rbp
ret
call fcn.1400a4324
int3
Function at 0x14005a3c0
Capabilities:
Hash data using fnv

Disassembly:
push r15
push r14
push rsi
push rdi
push rbp
push rbx
sub rsp, 0x28
movabs rax, 0x800000000000001
cmp rdx, rax
jae 0x14005a56f
mov rsi, rcx
dec rdx
or rdx, 1
bsr rcx, rdx
xor ecx, 0x3f
neg cl
mov ebx, 1
shl rbx, cl
lea rax, [rsi + 0x18]
mov rdi, qword [rsi + 8]
mov edx, 2
shl rdx, cl
mov rcx, rax
mov r8, rdi
call fcn.140019520
lea rax, [rbx - 1]
mov qword [rsi + 0x30], rax
mov qword [rsi + 0x38], rbx
mov rax, qword [rsi + 8]
mov rax, qword [rax]
cmp rax, rdi
je 0x14005a562
movabs rcx, 0xcbf29ce484222325
movabs rdx, 0x100000001b3
jmp 0x14005a461
mov qword [r9 + r10*8], r8
mov qword [r9 + rbx*8], r8
cmp rax, rdi
je 0x14005a562
mov r8, rax
mov rax, qword [rax]
movzx r9d, byte [r8 + 0x10]
xor r9, rcx
imul r9, rdx
movzx r10d, byte [r8 + 0x11]
xor r10, r9
imul r10, rdx
movzx r9d, byte [r8 + 0x12]
xor r9, r10
imul r9, rdx
movzx r11d, byte [r8 + 0x13]
xor r11, r9
imul r11, rdx
and r11, qword [rsi + 0x30]
mov r9, qword [rsi + 0x18]
lea r10, [r11 + r11]
lea rbx, [r11*2 + 1]
shl r11, 4
mov r11, qword [r9 + r11]
cmp r11, rdi
je 0x14005a450
mov r14, qword [r9 + rbx*8]
mov ebp, dword [r8 + 0x10]
cmp ebp, dword [r14 + 0x10]
jne 0x14005a500
mov r10, qword [r14]
cmp r10, r8
je 0x14005a454
mov r11, qword [r8 + 8]
mov qword [r11], rax
mov r14, qword [rax + 8]
mov qword [r14], r10
mov r15, qword [r10 + 8]
mov qword [r15], r8
mov qword [r10 + 8], r14
mov qword [rax + 8], r11
mov qword [r8 + 8], r15
jmp 0x14005a454
cmp r11, r14
je 0x14005a538
mov r14, qword [r14 + 8]
cmp ebp, dword [r14 + 0x10]
jne 0x14005a500
mov r9, qword [r14]
mov r10, qword [r8 + 8]
mov qword [r10], rax
mov r11, qword [rax + 8]
mov qword [r11], r9
mov rbx, qword [r9 + 8]
mov qword [rbx], r8
mov qword [r9 + 8], r11
mov qword [rax + 8], r10
mov qword [r8 + 8], rbx
jmp 0x14005a458
mov rbx, qword [r8 + 8]
mov qword [rbx], rax
mov r14, qword [rax + 8]
mov qword [r14], r11
mov r15, qword [r11 + 8]
mov qword [r15], r8
mov qword [r11 + 8], r14
mov qword [rax + 8], rbx
mov qword [r8 + 8], r15
mov qword [r9 + r10*8], r8
jmp 0x14005a458
add rsp, 0x28
pop rbx
pop rbp
pop rdi
pop rsi
pop r14
pop r15
ret
lea rcx, str.invalid_hash_bucket_count
call fcn.14009bac8
int3
Function at 0x1400627e0
Capabilities:
Encrypt data using curve25519

Disassembly:
push rsi
sub rsp, 0x20
mov rsi, rcx
call fcn.140063550
and byte [rsi], 0xf8
movzx eax, byte [rsi + 0x1f]
and al, 0x3f
or al, 0x40
mov byte [rsi + 0x1f], al
add rsp, 0x20
pop rsi
ret

Function at 0x140062810
Capabilities:
Enumerate pe sections

Disassembly:
mov r8, rdx
lea rdx, [0x1400fefb0]
jmp fcn.140061870

Function at 0x140062820
Capabilities:
Encrypt data using curve25519

Disassembly:
sub rsp, 0x48
mov rax, r8
movups xmm0, xmmword [rdx]
movups xmm1, xmmword [rdx + 0x10]
movaps xmmword [rsp + 0x20], xmm0
movaps xmmword [rsp + 0x30], xmm1
and byte [rsp + 0x20], 0xf8
movzx edx, byte [rsp + 0x3f]
and dl, 0x3f
or dl, 0x40
mov byte [rsp + 0x3f], dl
lea r8, [rsp + 0x20]
mov rdx, rax
call fcn.140061870
nop
add rsp, 0x48
ret
Function at 0x14007fdf0
Capabilities:
Encode data using xor
Hash data using murmur3
Resolve function by parsing pe exports

Disassembly:
push rsi
push rdi
sub rsp, 0x28
mov rdi, rcx
mov rsi, qword [rcx + 0x60]
mov dl, 0x80
call fcn.14007f890
cmp byte [rdi + 0x68], 0x38
je 0x14007fe20
nop word [rax + rax]
mov rcx, rdi
xor edx, edx
call fcn.14007f890
cmp byte [rdi + 0x68], 0x38
jne 0x14007fe10
mov rdx, rsi
shr rdx, 0x38
mov rcx, rdi
call fcn.14007f890
mov rdx, rsi
shr rdx, 0x30
mov rcx, rdi
call fcn.14007f890
mov rdx, rsi
shr rdx, 0x28
mov rcx, rdi
call fcn.14007f890
mov rdx, rsi
shr rdx, 0x20
mov rcx, rdi
call fcn.14007f890
mov edx, esi
shr edx, 0x18
mov rcx, rdi
call fcn.14007f890
mov edx, esi
shr edx, 0x10
mov rcx, rdi
call fcn.14007f890
mov edx, esi
shr edx, 8
mov rcx, rdi
call fcn.14007f890
mov rcx, rdi
mov edx, esi
add rsp, 0x28
pop rdi
pop rsi
jmp fcn.14007f890

Function at 0x140080120
Capabilities:
Hash data using sha256

Disassembly:
push rbp
push r15
push r14
push r12
push rsi
push rdi
push rbx
sub rsp, 0xa0
lea rbp, [rsp + 0x80]
mov qword [rbp + 0x18], 0xfffffffffffffffe
mov rsi, rcx
cmp qword [rdx + 0x18], 0x10
mov r14, rdx
jb 0x140080151
mov r14, qword [rdx]
mov r15, qword [rdx + 0x10]
mov qword [rsi + 8], 0
mov ecx, 0x30
call fcn.14009a7a0
mov rdi, rax
mov qword [rsi], rax
mov qword [rsi + 0x10], 0x20
mov qword [rsi + 0x18], 0x2f
xorps xmm0, xmm0
movups xmmword [rax + 0x10], xmm0
movups xmmword [rax], xmm0
mov byte [rax + 0x20], 0
movaps xmm0, xmmword [0x1400ff250]
movaps xmmword [rbp - 0x60], xmm0
movaps xmm0, xmmword [0x1400ff260]
movaps xmmword [rbp - 0x50], xmm0
mov qword [rbp], 0
mov byte [rbp + 8], 0
test r15, r15
je 0x1400801d5
xor r12d, r12d
lea rbx, [rbp - 0x60]
nop dword [rax]
movzx edx, byte [r14 + r12]
mov rcx, rbx
call fcn.14007f890
inc r12
cmp r15, r12
jne 0x1400801c0
lea rcx, [rbp - 0x60]
mov rdx, rdi
call fcn.14007fea0
mov rax, rsi
add rsp, 0xa0
pop rbx
pop rdi
pop rsi
pop r12
pop r14
pop r15
pop rbp
ret
Function at 0x1400889c0
Capabilities:
Encode data using xor

Disassembly:
push r15
push r14
push r13
push r12
push rsi
push rdi
push rbp
push rbx
sub rsp, 0x2c8
movups xmm0, xmmword [rcx]
movups xmm1, xmmword [rcx + 0x10]
movups xmm2, xmmword [rcx + 0x20]
movups xmm3, xmmword [rcx + 0x30]
movaps xmmword [rsp + 0x40], xmm0
movups xmm0, xmmword [rcx + 0x70]
movaps xmmword [rsp + 0xb0], xmm0
movups xmm0, xmmword [rcx + 0x60]
movaps xmmword [rsp + 0xa0], xmm0
movups xmm0, xmmword [rcx + 0x50]
movaps xmmword [rsp + 0x90], xmm0
movups xmm0, xmmword [rcx + 0x40]
movaps xmmword [rsp + 0x80], xmm0
movaps xmmword [rsp + 0x70], xmm3
movaps xmmword [rsp + 0x60], xmm2
movaps xmmword [rsp + 0x50], xmm1
mov eax, reloc.WS2_32.dll_recv
mov rcx, qword [rsp + 0x40]
mov r8, qword [rsp + rax*8 - 0x38]
mov r9, qword [rsp + rax*8 + 0x30]
mov r10, r8
ror r10, 1
mov r11, r8
rol r11, 0x38
xor r11, r10
mov r10, r8
mov rsi, r9
rol rsi, 0x2d
shr r10, 7
mov rdi, r9
rol rdi, 3
xor r10, r11
xor rdi, rsi
shr r9, 6
xor r9, rdi
add rcx, qword [rsp + rax*8 + 8]
add rcx, r10
add rcx, r9
mov qword [rsp + rax*8 + 0x40], rcx
inc rax
mov rcx, r8
cmp rax, 0x50
jne 0x140088a30
mov rax, qword [rdx]
mov rbp, qword [rdx + 8]
mov rsi, qword [rdx + 0x10]
mov rcx, qword [rdx + 0x18]
mov r14, qword [rdx + 0x20]
mov r9, qword [rdx + 0x28]
mov r10, qword [rdx + 0x30]
mov r8, qword [rdx + 0x38]
xor r12d, r12d
lea r13, [0x1401006c0]
mov qword [rsp + 0x38], r8
mov qword [rsp + 0x20], r14
mov qword [rsp + 0x28], r9
mov qword [rsp + 0x30], r10
mov rbx, rax
mov qword [rsp + 8], rbp
mov qword [rsp + 0x10], rsi
mov qword [rsp + 0x18], rcx
nop word [rax + rax]
mov r15, r10
mov r10, r9
mov r9, r14
mov r14, rcx
mov rcx, rsi
mov rsi, rbp
mov rbp, r9
rol rbp, 0x32
mov rdi, r9
rol rdi, 0x2e
xor rdi, rbp
mov rbp, r9
rol rbp, 0x17
xor rbp, rdi
mov rdi, r10
and rdi, r9
add rdi, r8
mov r8, r9
not r8
and r8, r15
add r8, rdi
add r8, rbp
add r8, qword [r12 + r13]
add r8, qword [rsp + r12 + 0x40]
mov rbp, rbx
mov rdi, rbx
rol rdi, 0x24
rol rbx, 0x1e
xor rbx, rdi
mov rdi, rbp
rol rdi, 0x19
xor rdi, rbx
mov r11, rcx
xor r11, rsi
and r11, rbp
mov rbx, rcx
and rbx, rsi
xor rbx, r11
add rbx, rdi
add r14, r8
add rbx, r8
add r12, 8
mov r8, r15
cmp r12, 0x280
jne 0x140088ae0
add rax, rbx
mov qword [rdx], rax
mov rax, qword [rsp + 8]
add rax, rbp
mov qword [rdx + 8], rax
mov rax, qword [rsp + 0x10]
add rax, rsi
mov qword [rdx + 0x10], rax
mov rax, qword [rsp + 0x18]
add rax, rcx
mov qword [rdx + 0x18], rax
mov rax, qword [rsp + 0x20]
add rax, r14
mov qword [rdx + 0x20], rax
mov rax, qword [rsp + 0x28]
add rax, r9
mov qword [rdx + 0x28], rax
mov rax, qword [rsp + 0x30]
add rax, r10
mov qword [rdx + 0x30], rax
mov rax, qword [rsp + 0x38]
add rax, r15
mov qword [rdx + 0x38], rax
add rsp, 0x2c8
pop rbx
pop rbp
pop rdi
pop rsi
pop r12
pop r13
pop r14
pop r15
ret
Function at 0x140088f80
Capabilities:
Create thread

Disassembly:
push rbp
push rsi
push rdi
sub rsp, 0xa0
lea rbp, [rsp + 0x80]
mov qword [rbp + 0x18], 0xfffffffffffffffe
cmp byte [rcx + 8], 0
jne 0x140089011
mov rdi, r8
mov rsi, rcx
mov qword [rcx + 0x10], rdx
mov rax, qword [rcx + 0x20]
test rax, rax
je 0x140088fb9
mov rcx, qword [rsi + 0x18]
call rax
movups xmm0, xmmword [rdi]
movups xmmword [rsi + 0x18], xmm0
xorps xmm0, xmm0
movups xmmword [rdi], xmm0
mov rcx, qword [rsi]
cmp rcx, 0xffffffffffffffff
je 0x140088fd5
call qword [sym.imp.KERNEL32.dll_CloseHandle]
mov qword [rsp + 0x28], 0
mov dword [rsp + 0x20], 0
lea r8, [0x1400890f0]
xor ecx, ecx
xor edx, edx
mov r9, rsi
call qword [sym.imp.KERNEL32.dll_CreateThread]
mov qword [rsi], rax
test rax, rax
je 0x140089016
mov byte [rsi + 8], 1
add rsp, 0xa0
pop rdi
pop rsi
pop rbp
ret
call fcn.14007a030
mov qword [rsi], 0xffffffffffffffff
call qword [sym.imp.KERNEL32.dll_GetLastError]
mov dword [rbp + 0x14], eax
lea rdx, [0x140100940]
lea rsi, [rbp - 0x48]
mov rcx, rsi
call fcn.140002830
lea rcx, [rbp - 0x10]
lea r8, [rbp + 0x14]
mov rdx, rsi
call fcn.1400894b0
lea rcx, [rbp - 0x28]
lea rdx, [rbp - 0x10]
call fcn.140029c20
lea rdx, [0x140117ba0]
lea rcx, [rbp - 0x28]
call fcn.14009ec98
int3
Function at 0x14008d330
Capabilities:
Hash data using sha1 via x86 extensions

Disassembly:
sub rsp, 0x48
movaps xmmword [rsp + 0x30], xmm9
movaps xmmword [rsp + 0x20], xmm8
movaps xmmword [rsp + 0x10], xmm7
movaps xmmword [rsp], xmm6
movdqu xmm1, xmmword [rcx]
movd xmm0, dword [rcx + 0x10]
pslldq xmm0, 0xc
pshufd xmm1, xmm1, 0x1b
movdqa xmm6, xmmword [0x140100b20]
movdqu xmm5, xmmword [rdx]
movdqu xmm4, xmmword [rdx + 0x10]
movdqu xmm3, xmmword [rdx + 0x20]
movdqu xmm2, xmmword [rdx + 0x30]
pshufb xmm5, xmm6
movdqa xmm7, xmm0
paddd xmm7, xmm5
movdqa xmm8, xmm1
sha1rnds4 xmm8, xmm7, 0
pshufb xmm4, xmm6
movdqa xmm7, xmm1
sha1nexte xmm7, xmm4
movaps xmm9, xmm8
sha1rnds4 xmm9, xmm7, 0
sha1msg1 xmm5, xmm4
pshufb xmm3, xmm6
sha1nexte xmm8, xmm3
movaps xmm7, xmm9
sha1rnds4 xmm7, xmm8, 0
sha1msg1 xmm4, xmm3
pshufb xmm2, xmm6
sha1nexte xmm9, xmm2
pxor xmm5, xmm3
sha1msg2 xmm5, xmm2
movaps xmm6, xmm7
sha1rnds4 xmm6, xmm9, 0
sha1msg1 xmm3, xmm2
sha1nexte xmm7, xmm5
pxor xmm4, xmm2
sha1msg2 xmm4, xmm5
movaps xmm8, xmm6
sha1rnds4 xmm8, xmm7, 0
sha1msg1 xmm2, xmm5
xorps xmm3, xmm5
sha1nexte xmm6, xmm4
sha1msg2 xmm3, xmm4
movaps xmm7, xmm8
sha1rnds4 xmm7, xmm6, 1
sha1msg1 xmm5, xmm4
xorps xmm2, xmm4
sha1nexte xmm8, xmm3
sha1msg2 xmm2, xmm3
movaps xmm6, xmm7
sha1rnds4 xmm6, xmm8, 1
sha1msg1 xmm4, xmm3
xorps xmm5, xmm3
sha1nexte xmm7, xmm2
sha1msg2 xmm5, xmm2
movaps xmm8, xmm6
sha1rnds4 xmm8, xmm7, 1
sha1msg1 xmm3, xmm2
xorps xmm4, xmm2
sha1nexte xmm6, xmm5
sha1msg2 xmm4, xmm5
movaps xmm7, xmm8
sha1rnds4 xmm7, xmm6, 1
sha1msg1 xmm2, xmm5
xorps xmm3, xmm5
sha1nexte xmm8, xmm4
sha1msg2 xmm3, xmm4
movaps xmm6, xmm7
sha1rnds4 xmm6, xmm8, 1
sha1msg1 xmm5, xmm4
xorps xmm2, xmm4
sha1nexte xmm7, xmm3
sha1msg2 xmm2, xmm3
movaps xmm8, xmm6
sha1rnds4 xmm8, xmm7, 2
sha1msg1 xmm4, xmm3
xorps xmm5, xmm3
sha1nexte xmm6, xmm2
sha1msg2 xmm5, xmm2
movaps xmm7, xmm8
sha1rnds4 xmm7, xmm6, 2
sha1msg1 xmm3, xmm2
xorps xmm4, xmm2
sha1nexte xmm8, xmm5
sha1msg2 xmm4, xmm5
movaps xmm6, xmm7
sha1rnds4 xmm6, xmm8, 2
sha1msg1 xmm2, xmm5
xorps xmm3, xmm5
sha1nexte xmm7, xmm4
sha1msg2 xmm3, xmm4
movaps xmm8, xmm6
sha1rnds4 xmm8, xmm7, 2
sha1msg1 xmm5, xmm4
xorps xmm2, xmm4
sha1nexte xmm6, xmm3
sha1msg2 xmm2, xmm3
movaps xmm7, xmm8
sha1rnds4 xmm7, xmm6, 2
sha1msg1 xmm4, xmm3
xorps xmm5, xmm3
sha1nexte xmm8, xmm2
sha1msg2 xmm5, xmm2
movaps xmm6, xmm7
sha1rnds4 xmm6, xmm8, 3
sha1msg1 xmm3, xmm2
xorps xmm4, xmm2
sha1nexte xmm7, xmm5
sha1msg2 xmm4, xmm5
movaps xmm8, xmm6
sha1rnds4 xmm8, xmm7, 3
sha1msg1 xmm2, xmm5
xorps xmm3, xmm5
sha1nexte xmm6, xmm4
sha1msg2 xmm3, xmm4
movaps xmm5, xmm8
sha1rnds4 xmm5, xmm6, 3
xorps xmm2, xmm4
sha1nexte xmm8, xmm3
sha1msg2 xmm2, xmm3
movaps xmm3, xmm5
sha1rnds4 xmm3, xmm8, 3
sha1nexte xmm5, xmm2
movaps xmm2, xmm3
sha1rnds4 xmm2, xmm5, 3
sha1nexte xmm3, xmm0
paddd xmm2, xmm1
pshufd xmm0, xmm2, 0x1b
movdqu xmmword [rcx], xmm0
extractps dword [rcx + 0x10], xmm3, 3
movaps xmm6, xmmword [rsp]
movaps xmm7, xmmword [rsp + 0x10]
movaps xmm8, xmmword [rsp + 0x20]
movaps xmm9, xmmword [rsp + 0x30]
add rsp, 0x48
ret