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

Disassembly:
mov qword [rsp + 0x10], rbx
mov qword [rsp + 0x18], rbp
mov qword [rsp + 0x20], rsi
push rdi
push r12
push r13
push r14
push r15
sub rsp, 0x70
mov rax, qword [0x140546618]
xor rax, rsp
mov qword [rsp + 0x60], rax
mov rax, qword [r9]
xor ebp, ebp
mov r14, r9
mov r13d, edx
mov qword [rsp + 0x38], rcx
mov rsi, rcx
mov qword [rsp + 0x30], rax
mov rbx, rax
lea edi, [rbp + 4]
mov eax, dword [r14 + 0x1c]
mov r8, r13
mov cl, byte [r14 + 0x24]
add r8, rbp
mov edx, dword [r14 + 0x20]
mov r9d, 0x40
add rdx, r8
mov dword [rsp + 0x28], 0x40
imul rdx, rax
mov qword [rsp + 0x20], rsi
shr rdx, cl
mov ecx, 0x200
imul edx, dword [r14 + 0x18]
sub r8d, edx
lea edx, [r9 - 0x3f]
mov eax, r8d
mov r8, rsi
shl rax, 6
movups xmm0, xmmword [rax + rbx]
movups xmmword [rsi], xmm0
movups xmm1, xmmword [rax + rbx + 0x10]
movups xmmword [rsi + 0x10], xmm1
movups xmm0, xmmword [rax + rbx + 0x20]
movups xmmword [rsi + 0x20], xmm0
movups xmm1, xmmword [rax + rbx + 0x30]
mov eax, ebp
add eax, r13d
movups xmmword [rsi + 0x30], xmm1
xor dword [rsi], eax
call fcn.1400167b0
inc rbp
add rsi, 0x40
cmp rbp, rdi
jb 0x1401c0539
mov rbx, qword [rsp + 0x38]
xor r10d, r10d
xor r11d, r11d
mov ebp, dword [r14 + 0x24]
lea r9, [rsp + 0x40]
mov r15d, dword [r14 + 0x20]
mov rax, r11
mov r12d, dword [r14 + 0x1c]
xor r8d, r8d
and eax, 0xf
lea rsi, [rbx + rax*4]
mov rbx, qword [rsp + 0x30]
lea eax, [r8 + r13]
xor eax, r10d
imul ecx, eax, 0x1000193
xor ecx, dword [rsi]
mov edx, ecx
lea rax, [r15 + rcx]
mov rcx, rbp
imul rax, r12
shr rax, cl
imul eax, dword [r14 + 0x18]
sub edx, eax
mov ecx, edx
shl rcx, 6
add rcx, rbx
mov qword [r9], rcx
prefetcht0 byte [rcx]
inc r8d
lea rsi, [rsi + 0x40]
lea r9, [r9 + 8]
cmp r8d, edi
jb 0x1401c05ef
mov rbx, qword [rsp + 0x38]
mov ebp, 0x10
mov r8, qword [rsp + 0x40]
mov rdx, rbx
sub r8, rbx
mov r9d, ebp
lea esi, [rbp - 0xf]
imul eax, dword [rdx], 0x1000193
mov ecx, dword [r8 + rdx]
xor ecx, eax
mov dword [rdx], ecx
add rdx, rdi
sub r9, rsi
jne 0x1401c064f
mov r8, qword [rsp + 0x48]
lea rdx, [rbx + 0x40]
sub r8, rbx
mov r9, rbp
imul eax, dword [rdx], 0x1000193
mov ecx, dword [r8 + rdx - 0x40]
xor ecx, eax
mov dword [rdx], ecx
add rdx, rdi
sub r9, rsi
jne 0x1401c0674
mov r8, qword [rsp + 0x50]
lea rdx, [rbx + 0x80]
sub r8, rbx
mov r9, rbp
imul eax, dword [rdx], 0x1000193
mov ecx, dword [r8 + rdx - 0x80]
xor ecx, eax
mov dword [rdx], ecx
add rdx, rdi
sub r9, rsi
jne 0x1401c069d
mov r8, qword [rsp + 0x58]
lea rdx, [rbx + 0xc0]
sub r8, rbx
mov r9, rbp
imul eax, dword [rdx], 0x1000193
mov ecx, dword [r8 + rdx - 0xc0]
xor ecx, eax
mov dword [rdx], ecx
add rdx, rdi
sub r9, rsi
jne 0x1401c06c6
add r10d, esi
add r11, rsi
cmp r10d, 0x200
jne 0x1401c05cc
mov dword [rsp + 0x28], 0x40
mov r9d, 0x40
mov r8, rbx
mov qword [rsp + 0x20], rbx
mov edx, esi
mov ecx, 0x200
call fcn.1400167b0
add rbx, 0x40
sub rdi, rsi
jne 0x1401c06f3
mov rcx, qword [rsp + 0x60]
xor rcx, rsp
call fcn.14036fcc0
lea r11, [rsp + 0x70]
mov rbx, qword [r11 + 0x38]
mov rbp, qword [r11 + 0x40]
mov rsi, qword [r11 + 0x48]
mov rsp, r11
pop r15
pop r14
pop r13
pop r12
pop rdi
ret
Function at 0x1401c37ec
Capabilities:
Encode data using xor

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rsi
push rdi
sub rsp, 0x20
mov edx, dword [rcx + 0x60]
mov rbx, rcx
and edx, 0x3f
mov eax, 0x38
mov rsi, r9
lea rdi, [rbx + 0x40]
mov byte [rdx + rcx], 0x80
inc edx
mov ecx, edx
add rcx, rbx
cmp edx, eax
jbe 0x1401c384e
lea r8d, [rax + 8]
sub r8d, edx
xor edx, edx
call fcn.14038ebe0
mov rdx, rdi
mov rcx, rbx
call fcn.1401c0f00
xorps xmm0, xmm0
xor eax, eax
movups xmmword [rbx], xmm0
movups xmmword [rbx + 0x10], xmm0
movups xmmword [rbx + 0x20], xmm0
mov qword [rbx + 0x30], rax
jmp 0x1401c385a
sub eax, edx
xor edx, edx
mov r8d, eax
call fcn.14038ebe0
mov rcx, qword [rbx + 0x60]
shl rcx, 3
rol rcx, 0x20
mov rdx, rcx
mov rax, rcx
shl rcx, 0x10
shr rdx, 0x10
shl rax, 0x10
xor rdx, rax
movabs rax, 0xffff0000ffff
and rdx, rax
xor rdx, rcx
mov rcx, rdx
mov rax, rdx
shr rcx, 8
shl rax, 8
xor rcx, rax
shl rdx, 8
movabs rax, 0xff00ff00ff00ff
and rcx, rax
xor rcx, rdx
mov rdx, rdi
mov qword [rbx + 0x38], rcx
mov rcx, rbx
call fcn.1401c0f00
xor r8d, r8d
mov ecx, dword [rdi]
lea rdi, [rdi + 4]
rol ecx, 0x10
mov eax, ecx
mov edx, ecx
shr edx, 8
shl eax, 8
xor edx, eax
shl ecx, 8
and edx, 0xff00ff
lea eax, [r8*4]
xor edx, ecx
inc r8d
mov dword [rax + rsi], edx
cmp r8d, 8
jb 0x1401c38c2
mov rbx, qword [rsp + 0x30]
mov rsi, qword [rsp + 0x38]
add rsp, 0x20
pop rdi
ret

Function at 0x1401c3908
Capabilities:
Hash data using sha256

Disassembly:
mov r11, rsp
push rbx
push rbp
push rsi
push rdi
push r14
sub rsp, 0xb0
mov rax, qword [0x140546618]
xor rax, rsp
mov qword [rsp + 0xa0], rax
movups xmm0, xmmword [0x1404b80c8]
mov rdi, r8
mov rsi, rdx
movups xmm1, xmmword [0x1404b80d8]
mov r14, rcx
movaps xmmword [rsp + 0x70], xmm0
and qword [r11 - 0x48], 0
movaps xmmword [r11 - 0x58], xmm1
cmp r8, 0x80
jae 0x1401c3965
lea rcx, [rsp + 0x30]
call fcn.1401c3758
jmp 0x1401c39a7
mov rbx, rdi
shr rbx, 6
imul rbp, rbx, 0xffffffffffffffc0
add rbp, rdi
lea rdx, [rsp + 0x70]
mov rcx, rsi
call fcn.1401c0f00
add rsi, 0x40
sub rbx, 1
jne 0x1401c3973
test rbp, rbp
je 0x1401c399f
mov r8, rbp
lea rcx, [rsp + 0x30]
mov rdx, rsi
call fcn.14038e7d0
add qword [rsp + 0x90], rdi
mov r9, r14
lea rcx, [rsp + 0x30]
call fcn.1401c37ec
mov rcx, qword [rsp + 0xa0]
xor rcx, rsp
call fcn.14036fcc0
add rsp, 0xb0
pop r14
pop rdi
pop rsi
pop rbp
pop rbx
ret
Function at 0x1401c4c70
Capabilities:
Create thread

Disassembly:
mov qword [rsp + 0x18], rbx
push rbp
push rsi
push rdi
sub rsp, 0x30
movzx esi, r8b
mov rdi, rdx
mov rbx, rcx
add rcx, 0x70
xor edx, edx
mov r8d, 0x200
call fcn.14038ebe0
xor ebp, ebp
mov dword [rbx + 0x270], ebp
mov byte [rbx + 0x274], bpl
mov byte [rbx + 0x275], bpl
mov qword [rbx + 0x278], rdi
mov byte [rbx + 0x280], sil
mov qword [rbx + 0x288], rbp
mov rcx, rbx
call fcn.14034a6a0
lea rcx, [rbx + 0x28]
call fcn.14034a5f0
lea ecx, [rbp + 0x10]
call fcn.14036fce4
mov rdi, rax
mov qword [rsp + 0x50], rax
lea ecx, [rbp + 0x10]
call fcn.14036fce4
mov qword [rax], rbx
lea rcx, [0x1401c4d70]
mov qword [rax + 8], rcx
mov qword [rsp + 0x58], rax
lea rsi, [rdi + 8]
mov qword [rsp + 0x28], rsi
mov dword [rsp + 0x20], ebp
mov r9, rax
lea r8, [0x140075e80]
xor edx, edx
xor ecx, ecx
call fcn.14039a510
mov qword [rdi], rax
test rax, rax
je 0x1401c4d5b
mov qword [rbx + 0x288], rdi
mov qword [rsp + 0x50], 1
lea rcx, [rsp + 0x50]
call fcn.140087ee0
movzx eax, byte [rbx + 0x274]
test al, al
je 0x1401c4d36
mov rax, rbx
mov rbx, qword [rsp + 0x60]
add rsp, 0x30
pop rdi
pop rsi
pop rbp
ret
mov dword [rsi], ebp
mov ecx, 6
call fcn.14036d01c
int3
Function at 0x1401c4ec0
Capabilities:
Create thread

Disassembly:
mov qword [rsp + 0x10], rbx
push rdi
sub rsp, 0x50
mov eax, 1
xchg dword [0x1407f3250], eax
test eax, eax
jne 0x1401c5061
lea ecx, [rax + 1]
call fcn.14036fce4
mov qword [rsp + 0x60], rax
lea rcx, [rsp + 0x38]
mov qword [rsp + 0x28], rcx
xor ebx, ebx
mov dword [rsp + 0x20], ebx
mov r9, rax
lea r8, [0x1401c74f0]
xor edx, edx
xor ecx, ecx
call fcn.14039a510
mov qword [rsp + 0x30], rax
test rax, rax
je 0x1401c506c
cmp dword [rsp + 0x38], ebx
je 0x1401c507b
call sub.KERNEL32.dll_GetCurrentThreadId
cmp dword [rsp + 0x38], eax
je 0x1401c5086
movaps xmm0, xmmword [rsp + 0x30]
movdqa xmmword [rsp + 0x40], xmm0
xor edx, edx
lea rcx, [rsp + 0x40]
call fcn.14036d7a8
test eax, eax
jne 0x1401c5091
xorps xmm0, xmm0
movdqa xmmword [rsp + 0x30], xmm0
cmp dword [0x1407e16c0], eax
jbe 0x1401c4f9b
lea rdx, str._____________________________________________
lea ecx, [rbx + 6]
call fcn.140027890
cmp dword [0x1407e16c0], eax
jbe 0x1401c4f9b
lea rdx, str._________GhostRider_tuning_results_________
call fcn.140027890
cmp dword [0x1407e16c0], eax
jbe 0x1401c4f9b
lea rdx, str._____________________________________________
call fcn.140027890
lea r10, str.cn_dark__512_KB_
mov r11d, 6
lea rdi, [0x140000000]
nop
cmp dword [0x1407e16c0], 0
jbe 0x1401c4fef
movsd xmm0, qword [rbx + rdi + 0x54d390]
movsd qword [rsp + 0x28], xmm0
mov eax, dword [rbx + rdi + 0x54d39c]
mov dword [rsp + 0x20], eax
mov r9d, dword [rbx + rdi + 0x54d398]
mov r8, qword [r10]
lea rdx, str._24s___ux_u___.2f_h_s
mov ecx, 6
call fcn.140027890
mov r9d, dword [rbx + rdi + 0x54d338]
cmp r9d, dword [rbx + rdi + 0x54d398]
jne 0x1401c5011
mov eax, dword [rbx + rdi + 0x54d39c]
cmp dword [rbx + rdi + 0x54d33c], eax
je 0x1401c5048
cmp dword [0x1407e16c0], 0
jbe 0x1401c5048
movsd xmm0, qword [rbx + rdi + 0x54d330]
movsd qword [rsp + 0x28], xmm0
mov eax, dword [rbx + rdi + 0x54d33c]
mov dword [rsp + 0x20], eax
mov r8, qword [r10]
lea rdx, str._24s___ux_u___.2f_h_s
mov ecx, 6
call fcn.140027890
add rbx, 0x10
add r10, 8
sub r11, 1
jne 0x1401c4fb0
cmp dword [rsp + 0x38], r11d
jne 0x1401c509c
mov rbx, qword [rsp + 0x68]
add rsp, 0x50
pop rdi
ret
mov dword [rsp + 0x38], ebx
mov ecx, 6
call fcn.14036d01c
nop
mov ecx, 1
call fcn.14036d01c
int3
mov ecx, 5
call fcn.14036d01c
int3
mov ecx, 2
call fcn.14036d01c
nop
call fcn.1403978dc
int3
Function at 0x1401dec48
Capabilities:
Encode data using xor

Disassembly:
mov qword [rsp + 0x10], rbx
push rdi
sub rsp, 0x30
mov rax, qword [0x140546618]
xor rax, rsp
mov qword [rsp + 0x28], rax
mov r10, qword [rcx + 8]
mov rbx, rcx
mov rax, qword [rcx + 0x50]
mov rdi, r9
mov byte [rbx + r10], 0x80
lea rdx, [rax + r10*8]
rol rdx, 0x20
mov r8, rdx
mov rax, rdx
shr r8, 0x10
shl rax, 0x10
xor r8, rax
shl rdx, 0x10
movabs rax, 0xffff0000ffff
and r8, rax
xor r8, rdx
mov rcx, r8
mov rax, r8
shr rcx, 8
shl rax, 8
xor rcx, rax
shl r8, 8
movabs rax, 0xff00ff00ff00ff
and rcx, rax
xor rcx, r8
mov r8d, 8
inc r10
mov qword [rsp + 0x20], rcx
cmp r10, r8
jae 0x1401dece7
sub r8, r10
lea rcx, [rbx + r10]
xor edx, edx
call fcn.14038ebe0
mov r8d, 1
mov rdx, rbx
mov rcx, rbx
call fcn.1401d5b00
lea rdx, [rsp + 0x20]
mov rcx, rbx
call fcn.1401d8db0
xor r8d, r8d
add rbx, 0x10
mov edx, dword [rbx]
lea rbx, [rbx + 4]
rol edx, 0x10
mov ecx, edx
mov eax, edx
shr ecx, 8
shl eax, 8
xor ecx, eax
shl edx, 8
and ecx, 0xff00ff
xor ecx, edx
mov dword [rdi + r8*4], ecx
inc r8
cmp r8, 0x10
jb 0x1401ded0c
mov rcx, qword [rsp + 0x28]
xor rcx, rsp
call fcn.14036fcc0
mov rbx, qword [rsp + 0x48]
add rsp, 0x30
pop rdi
ret
Function at 0x140205e68
Capabilities:
Encode data using xor

Disassembly:
mov qword [rsp + 0x10], rbx
push rbp
push rsi
push rdi
push r12
push r13
push r14
push r15
sub rsp, 0xc0
mov rax, qword [0x140546618]
xor rax, rsp
mov qword [rsp + 0xb0], rax
mov rbp, qword [rcx + 0x80]
lea r12, [rsp + 0x30]
mov rdx, qword [rcx + 0xe8]
add r12, rbp
mov rsi, qword [rcx + 0xf0]
or r13, 0xffffffffffffffff
xor edi, edi
mov qword [rsp + 0x20], r9
lea r8d, [rbp*8]
mov r15d, 0x80
mov byte [r12], r15b
lea r14, [rdx + r8]
mov rbx, rcx
test rbp, rbp
jne 0x140205ee7
mov qword [rcx + 0xf0], r13
mov rdx, 0xfffffffffffffc00
jmp 0x140205f0b
test rdx, rdx
jne 0x140205f00
lea rax, [rsi - 1]
mov qword [rcx + 0xf0], rax
lea rdx, [r8 - 0x400]
jmp 0x140205f0b
mov ecx, 0x400
sub ecx, r8d
sub rdx, rcx
lea rcx, [rsp + 0x31]
mov qword [rbx + 0xe8], rdx
add rcx, rbp
rol rsi, 0x20
rol r14, 0x20
xor edx, edx
cmp r8d, 0x37e
ja 0x140205fd5
lea r8d, [rdx + 0x6f]
sub r8, rbp
call fcn.14038ebe0
or byte [rsp + 0x9f], 1
mov rdx, rsi
shr rdx, 0x10
mov rax, rsi
shl rax, 0x10
movabs r13, 0xffff0000ffff
xor rdx, rax
shl rsi, 0x10
and rdx, r13
xor rdx, rsi
movabs rsi, 0xff00ff00ff00ff
mov rcx, rdx
mov rax, rdx
shr rcx, 8
shl rdx, 8
shl rax, 8
xor rcx, rax
mov rax, r14
and rcx, rsi
shl rax, 0x10
xor rcx, rdx
mov rdx, r14
shr rdx, 0x10
xor rdx, rax
mov qword [rsp + 0xa0], rcx
and rdx, r13
shl r14, 0x10
xor rdx, r14
mov rcx, rdx
mov rax, rdx
shr rcx, 8
shl rax, 8
xor rcx, rax
shl rdx, 8
and rcx, rsi
xor rcx, rdx
sub r15, rbp
jmp 0x1402060ab
mov r8d, 0x7f
sub r8, rbp
call fcn.14038ebe0
mov r8, r15
mov rdx, r12
sub r8, rbp
mov rcx, rbx
call fcn.140201a14
xor edx, edx
mov qword [rbx + 0xe8], 0xfffffffffffffc00
lea rcx, [rsp + 0x30]
mov qword [rbx + 0xf0], r13
lea r8d, [rdx + 0x6f]
call fcn.14038ebe0
mov rdx, rsi
mov byte [rsp + 0x9f], 1
shr rdx, 0x10
lea r12, [rsp + 0x30]
mov rax, rsi
movabs r13, 0xffff0000ffff
shl rax, 0x10
xor rdx, rax
shl rsi, 0x10
and rdx, r13
xor rdx, rsi
movabs rsi, 0xff00ff00ff00ff
mov rcx, rdx
mov rax, rdx
shr rcx, 8
shl rdx, 8
shl rax, 8
xor rcx, rax
mov rax, r14
and rcx, rsi
shl rax, 0x10
xor rcx, rdx
mov rdx, r14
shr rdx, 0x10
xor rdx, rax
mov qword [rsp + 0xa0], rcx
and rdx, r13
shl r14, 0x10
xor rdx, r14
mov rcx, rdx
mov rax, rdx
shr rcx, 8
shl rax, 8
xor rcx, rax
shl rdx, 8
and rcx, rsi
xor rcx, rdx
mov qword [rsp + 0xa8], rcx
mov r8, r15
mov rcx, rbx
mov rdx, r12
call fcn.140201a14
mov r8, qword [rsp + 0x20]
add rbx, 0x88
mov rcx, qword [rbx]
lea rbx, [rbx + 8]
rol rcx, 0x20
mov rdx, rcx
mov rax, rcx
shl rcx, 0x10
shr rdx, 0x10
shl rax, 0x10
xor rdx, rax
and rdx, r13
xor rdx, rcx
mov rcx, rdx
mov rax, rdx
shr rcx, 8
shl rax, 8
xor rcx, rax
shl rdx, 8
and rcx, rsi
xor rcx, rdx
mov qword [r8 + rdi*8], rcx
inc rdi
cmp rdi, 8
jb 0x1402060cd
mov rcx, qword [rsp + 0xb0]
xor rcx, rsp
call fcn.14036fcc0
mov rbx, qword [rsp + 0x108]
add rsp, 0xc0
pop r15
pop r14
pop r13
pop r12
pop rdi
pop rsi
pop rbp
ret
Function at 0x140256fd0
Capabilities:
Encode data using xor

Disassembly:
push rbx
movsxd rbx, r9d
mov r10, r8
mov r11, rdx
cmp rdx, r8
je 0x140257132
mov qword [rsp + 0x10], rsi
lea rsi, [rcx - 1]
not rcx
shr rsi, 0x3f
shr rcx, 0x3f
and rsi, rcx
mov ecx, dword [rdx + 8]
xor ecx, dword [r8 + 8]
dec rsi
and ecx, esi
xor dword [rdx + 8], ecx
xor dword [r8 + 8], ecx
mov edx, dword [r8 + 0x10]
movq xmm4, rsi
xor edx, dword [r11 + 0x10]
and edx, esi
punpcklqdq xmm4, xmm4
xor dword [r11 + 0x10], edx
xor dword [r8 + 0x10], edx
mov ecx, dword [r11 + 0x14]
mov edx, dword [r8 + 0x14]
xor rdx, rcx
and edx, 4
and rdx, rsi
mov eax, edx
xor eax, ecx
xor ecx, ecx
mov dword [r11 + 0x14], eax
xor dword [r8 + 0x14], edx
mov edx, ecx
test r9d, r9d
jle 0x1402570f2
cmp ebx, 2
jb 0x1402570f2
mov r9, qword [r8]
lea rax, [rbx - 1]
mov r8, qword [r11]
mov qword [rsp + 0x18], rdi
lea rdi, [rbx - 1]
lea rdi, [r9 + rdi*8]
lea rax, [r8 + rax*8]
cmp r9, rax
ja 0x140257081
cmp rdi, r8
jae 0x1402570ed
cmp r9, r10
ja 0x14025708b
cmp rdi, r10
jae 0x1402570ed
cmp r9, r11
ja 0x140257095
cmp rdi, r11
jae 0x1402570ed
cmp r8, r10
ja 0x14025709f
cmp rax, r10
jae 0x1402570ed
cmp r8, r11
ja 0x1402570a9
cmp rax, r11
jae 0x1402570ed
mov eax, ebx
and eax, 0xfffffffe
nop
movdqu xmm2, xmmword [rcx + r9]
add edx, 2
movdqu xmm1, xmmword [rcx + r8]
lea rcx, [rcx + 0x10]
movdqa xmm3, xmm2
pxor xmm3, xmm1
pand xmm3, xmm4
movdqa xmm0, xmm3
pxor xmm3, xmm2
pxor xmm0, xmm1
movdqu xmmword [rcx + r8 - 0x10], xmm0
movdqu xmmword [rcx + r9 - 0x10], xmm3
cmp edx, eax
jl 0x1402570b0
mov rdi, qword [rsp + 0x18]
movsxd rax, edx
cmp rax, rbx
jge 0x14025712d
nop word [rax + rax]
mov rcx, qword [r11]
mov rdx, qword [rcx + rax*8]
lea r8, [rcx + rax*8]
mov rcx, qword [r10]
mov r9, qword [rcx + rax*8]
xor r9, rdx
and r9, rsi
xor rdx, r9
mov qword [r8], rdx
mov rcx, qword [r10]
xor qword [rcx + rax*8], r9
inc rax
cmp rax, rbx
jl 0x140257100
mov rsi, qword [rsp + 0x10]
pop rbx
ret
Function at 0x14025dda0
Capabilities:
Encode data using xor
Encrypt data using rc4 prga

Disassembly:
mov qword [rsp + 0x10], rbx
push rsi
mov r10, rdx
xor r11b, r11b
xor edx, edx
mov rsi, r9
mov rbx, rcx
test rcx, rcx
je 0x14025deb4
test r10, r10
je 0x14025deb4
movzx eax, byte [rcx]
test r8d, r8d
jne 0x14025dde5
cmp al, 0x7f
jbe 0x14025dead
mov edx, 1
mov eax, edx
add rax, r10
jmp 0x14025debc
mov r11b, 0xff
cmp al, 0x80
jbe 0x14025ddfb
mov edx, 1
mov eax, edx
add rax, r10
jmp 0x14025debc
jne 0x14025dead
mov eax, 1
lea rcx, [r10 - 1]
cmp r10, rax
jbe 0x14025de9e
cmp rcx, 8
jb 0x14025de90
and ecx, 7
mov rdx, r10
sub rdx, rcx
xorps xmm3, xmm3
xorps xmm2, xmm2
nop dword [rax + rax]
movd xmm1, dword [rax + rbx]
xorps xmm0, xmm0
punpcklbw xmm1, xmm0
punpcklwd xmm1, xmm0
por xmm1, xmm3
movdqa xmm3, xmm1
movd xmm1, dword [rax + rbx + 4]
punpcklbw xmm1, xmm0
add rax, 8
punpcklwd xmm1, xmm0
por xmm1, xmm2
movdqa xmm2, xmm1
cmp rax, rdx
jb 0x14025de30
por xmm2, xmm3
movdqa xmm0, xmm2
psrldq xmm0, 8
por xmm2, xmm0
movdqa xmm0, xmm2
psrldq xmm0, 4
por xmm2, xmm0
movd edx, xmm2
cmp rax, r10
jae 0x14025de9e
nop
movzx ecx, byte [rax + rbx]
inc rax
or edx, ecx
cmp rax, r10
jb 0x14025de90
neg edx
sbb r11b, r11b
movzx r11d, r11b
mov edx, r11d
and edx, 1
mov eax, edx
add rax, r10
jmp 0x14025debc
mov eax, 1
mov r10, rdx
mov qword [rsp + 0x10], rdi
test rsi, rsi
je 0x14025df15
mov rdi, qword [r9]
test rdi, rdi
je 0x14025df15
movzx r8d, r11b
lea r9, [rbx + r10]
and r8d, 1
mov byte [rdi], r11b
test r10, r10
je 0x14025df12
mov ebx, edx
add rbx, rdi
nop word [rax + rax]
movzx edx, byte [r9 - 1]
lea r9, [r9 - 1]
dec r10
movzx ecx, r11b
xor edx, ecx
add r8d, edx
mov byte [rbx + r10], r8b
shr r8d, 8
test r10, r10
jne 0x14025def0
add qword [rsi], rax
mov rdi, qword [rsp + 0x10]
mov rbx, qword [rsp + 0x18]
pop rsi
ret

Function at 0x140260610
Capabilities:
Set thread local storage value

Disassembly:
mov eax, 0x28
call fcn.1403706b0
sub rsp, rax
mov ecx, dword [rcx]
call qword [sym.imp.KERNEL32.dll_TlsSetValue]
xor ecx, ecx
test eax, eax
setne cl
mov eax, ecx
add rsp, 0x28
ret
Function at 0x140274790
Capabilities:
Get thread local storage value

Disassembly:
mov eax, 0x28
call fcn.1403706b0
sub rsp, rax
lea rcx, [0x140555ac8]
add rsp, 0x28
jmp fcn.140260470

Function at 0x14027f590
Capabilities:
Encode data using xor

Disassembly:
xor r9b, r9b
mov r10, rdx
test r8, r8
je 0x14027f5b7
sub r10, rcx
nop
movzx edx, byte [r10 + rcx]
movzx eax, byte [rcx]
lea rcx, [rcx + 1]
xor dl, al
or r9b, dl
sub r8, 1
jne 0x14027f5a0
movzx eax, r9b
ret
Function at 0x1402b68b0
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, 0x30
call fcn.1403706b0
sub rsp, rax
mov r10, r9
mov rbx, r8
mov r9, qword [rsp + 0xa0]
mov r14, rdx
mov rbp, rcx
mov edi, dword [r9]
mov dword [rsp + 0x80], edi
test edi, edi
je 0x1402b6928
mov rdx, qword [rsp + 0x98]
nop dword [rax]
test rbx, rbx
je 0x1402b6921
mov eax, edi
dec rbx
movzx ecx, byte [rax + rdx]
xor cl, byte [rbp]
inc rbp
mov byte [r14], cl
inc r14
inc edi
and edi, 0xf
jne 0x1402b6900
mov dword [rsp + 0x80], edi
mov r8, qword [rsp + 0x90]
mov esi, 1
movzx r12d, byte [r8 + 0xc]
lea r15, [r8 + 0xc]
mov r11, qword [rsp + 0xa8]
shl r12d, 8
movzx eax, byte [r8 + 0xd]
lea r13d, [rsi + 0xb]
or r12d, eax
movzx eax, byte [r8 + 0xe]
shl r12d, 8
or r12d, eax
movzx eax, byte [r8 + 0xf]
shl r12d, 8
or r12d, eax
cmp rbx, 0x10
jb 0x1402b6a5e
mov eax, 0x10000000
mov edi, r13d
mov qword [rsp + 0x20], r8
mov rdx, rbx
shr rdx, 4
mov r9, r10
cmp rdx, rax
cmova rdx, rax
add r12d, edx
mov r13, rdx
mov eax, r12d
mov ecx, r12d
sub r13, rax
cmp rax, rdx
cmovae r13, rdx
xor r12d, r12d
cmp rax, rdx
mov r8, r13
mov rdx, r14
cmovae r12d, ecx
mov rcx, rbp
call r11
mov r8, qword [rsp + 0x90]
mov eax, r12d
shr eax, 0x18
mov byte [r15], al
mov eax, r12d
shr eax, 0x10
mov byte [r8 + 0xd], al
mov eax, r12d
shr eax, 8
mov byte [r8 + 0xe], al
mov byte [r8 + 0xf], r12b
test r12d, r12d
jne 0x1402b6a1d
mov r8d, edi
mov eax, esi
mov rdx, r15
nop dword [rax + rax]
movzx ecx, byte [rdx - 1]
lea rdx, [rdx - 1]
add eax, ecx
mov byte [rdx], al
shr eax, 8
add r8d, 0xffffffff
jne 0x1402b6a00
mov r8, qword [rsp + 0x90]
mov r10, qword [rsp + 0x88]
mov eax, 0x10000000
mov r11, qword [rsp + 0xa8]
shl r13, 4
sub rbx, r13
add r14, r13
add rbp, r13
cmp rbx, 0x10
jae 0x1402b6980
mov edi, dword [rsp + 0x80]
mov r13d, 0xc
mov r9, qword [rsp + 0xa0]
test rbx, rbx
je 0x1402b6b01
mov rax, qword [rsp + 0x98]
xorps xmm0, xmm0
mov qword [rsp + 0x20], r8
mov r9, r10
mov r8, rsi
mov rdx, rax
mov rcx, rax
movups xmmword [rax], xmm0
call r11
mov rcx, qword [rsp + 0x90]
inc r12d
mov eax, r12d
shr eax, 0x18
mov byte [r15], al
mov eax, r12d
shr eax, 0x10
mov byte [rcx + 0xd], al
mov eax, r12d
shr eax, 8
mov byte [rcx + 0xe], al
mov byte [rcx + 0xf], r12b
test r12d, r12d
jne 0x1402b6ad7
nop dword [rax + rax]
movzx eax, byte [r15 - 1]
lea r15, [r15 - 1]
add esi, eax
mov byte [r15], sil
shr esi, 8
add r13d, 0xffffffff
jne 0x1402b6ac0
mov rdx, qword [rsp + 0x98]
nop
mov ecx, edi
inc edi
movzx eax, byte [rcx + rbp]
xor al, byte [rcx + rdx]
mov byte [rcx + r14], al
sub rbx, 1
jne 0x1402b6ae0
mov rax, qword [rsp + 0xa0]
mov dword [rax], edi
jmp 0x1402b6b04
mov dword [r9], edi
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 0x1402b7290
Capabilities:
Encode data using xor

Disassembly:
push rbx
push rbp
push r14
mov eax, 0x20
call fcn.1403706b0
sub rsp, rax
cmp qword [rcx + 0x38], 0
mov rbx, r8
mov r14, rdx
mov rbp, rcx
je 0x1402b72c0
mov eax, 0xfffffffe
add rsp, 0x20
pop r14
pop rbp
pop rbx
ret
mov rcx, qword [rcx + 0x30]
movabs rax, 0x2000000000000000
add rcx, rbx
cmp rcx, rax
ja 0x1402b73b2
cmp rcx, rbx
jb 0x1402b73b2
mov qword [rsp + 0x40], rsi
mov esi, dword [rbp + 0x174]
mov qword [rsp + 0x48], rdi
mov qword [rsp + 0x50], r12
mov qword [rbp + 0x30], rcx
test esi, esi
je 0x1402b7335
test rbx, rbx
je 0x1402b7392
movzx eax, byte [r14]
dec rbx
mov ecx, esi
inc r14
xor byte [rcx + rbp + 0x40], al
inc esi
and esi, 0xf
jne 0x1402b7300
lea r12, [rbp + 0x60]
lea rdi, [rbp + 0x40]
mov rdx, r12
mov rcx, rdi
call fcn.1402b8970
jmp 0x1402b733d
lea r12, [rbp + 0x60]
lea rdi, [rbp + 0x40]
mov qword [rsp + 0x58], r15
mov r15, rbx
and r15, 0xfffffffffffffff0
je 0x1402b7362
mov r9, r15
mov r8, r14
mov rdx, r12
mov rcx, rdi
call fcn.1402b8790
add r14, r15
sub rbx, r15
mov r15, qword [rsp + 0x58]
test rbx, rbx
je 0x1402b7392
mov esi, ebx
sub r14, rbp
nop dword [rax]
nop word [rax + rax]
movzx eax, byte [r14 + rdi - 0x40]
xor byte [rdi], al
lea rdi, [rdi + 1]
sub rbx, 1
jne 0x1402b7380
mov rdi, qword [rsp + 0x48]
xor eax, eax
mov r12, qword [rsp + 0x50]
mov dword [rbp + 0x174], esi
mov rsi, qword [rsp + 0x40]
add rsp, 0x20
pop r14
pop rbp
pop rbx
ret
mov eax, 0xffffffff
add rsp, 0x20
pop r14
pop rbp
pop rbx
ret
Function at 0x1402b8790
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
movzx eax, byte [rcx + 0xf]
lea r14, [r8 + 0xe]
mov rsi, rcx
lea r13, [0x14040b550]
sub rsi, r8
mov r12, r9
mov rbp, rdx
mov rbx, rcx
nop word [rax + rax]
movzx edx, byte [r14 + 1]
mov rdi, r14
movzx ecx, al
mov r15d, 0xf
xor rdx, rcx
mov r8, rdx
and edx, 0xf
add rdx, rdx
and r8, 0xfffffffffffffff0
mov r9, qword [rbp + rdx*8]
mov rax, qword [rbp + rdx*8 + 8]
mov rcx, r9
mov rdx, rax
shr rcx, 4
and edx, 0xf
shr rax, 4
shl r9, 0x3c
or rax, r9
mov r11, qword [r13 + rdx*8]
xor r11, rcx
xor r11, qword [r8 + rbp]
xor rax, qword [r8 + rbp + 8]
nop dword [rax]
nop dword [rax + rax]
movzx ecx, byte [rdi]
movzx edx, byte [rsi + rdi]
lea rdi, [rdi - 1]
xor rdx, rcx
mov rcx, r11
mov r9, rdx
shl r11, 0x3c
and edx, 0xf
shr rcx, 4
add rdx, rdx
and r9, 0xfffffffffffffff0
lea r8, [rdx*8]
mov rdx, rax
shr rax, 4
and edx, 0xf
or r11, rax
xor r11, qword [r8 + rbp + 8]
mov r10, qword [r13 + rdx*8]
mov rdx, r11
xor r10, rcx
shr rdx, 4
xor r10, qword [r8 + rbp]
mov rcx, r11
and ecx, 0xf
mov rax, r10
shr rax, 4
mov r11, qword [r13 + rcx*8]
xor r11, rax
mov rax, r10
xor r11, qword [r9 + rbp]
shl rax, 0x3c
or rax, rdx
xor rax, qword [r9 + rbp + 8]
sub r15, 1
jne 0x1402b8830
mov rdx, r11
mov byte [rbx + 7], r11b
shr rdx, 0x20
add r14, 0x10
mov ecx, edx
mov byte [rbx + 3], dl
shr ecx, 0x18
sub rsi, 0x10
mov byte [rbx], cl
mov ecx, edx
shr ecx, 0x10
mov byte [rbx + 1], cl
mov ecx, edx
shr ecx, 8
mov rdx, rax
mov byte [rbx + 2], cl
mov ecx, r11d
shr ecx, 0x18
mov byte [rbx + 4], cl
mov ecx, r11d
shr ecx, 0x10
mov byte [rbx + 5], cl
mov ecx, r11d
shr ecx, 8
mov byte [rbx + 6], cl
shr rdx, 0x20
mov ecx, edx
mov byte [rbx + 0xb], dl
shr ecx, 0x18
mov byte [rbx + 8], cl
mov ecx, edx
shr ecx, 0x10
mov byte [rbx + 9], cl
mov ecx, edx
shr ecx, 8
mov byte [rbx + 0xa], cl
mov ecx, eax
shr ecx, 0x18
mov byte [rbx + 0xc], cl
mov ecx, eax
shr ecx, 0x10
mov byte [rbx + 0xd], cl
mov ecx, eax
shr ecx, 8
mov byte [rbx + 0xe], cl
mov byte [rbx + 0xf], al
sub r12, 0x10
jne 0x1402b87d0
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