joyce8/EMBER2024-capa huggingface dataset:
Function at 0x140083480
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.1400a06f0
sub rsp, rax
mov rdi, r8
mov r14, rdx
mov r8, qword [rsp + 0xa0]
mov r15, rcx
mov ebx, dword [r8]
mov dword [rsp + 0x80], ebx
test ebx, ebx
je 0x1400834f8
mov rdx, qword [rsp + 0x98]
nop dword [rax]
test rdi, rdi
je 0x1400834f1
mov eax, ebx
dec rdi
movzx ecx, byte [rax + rdx]
xor cl, byte [r15]
inc r15
mov byte [r14], cl
inc r14
inc ebx
and ebx, 0xf
jne 0x1400834d0
mov dword [rsp + 0x80], ebx
mov rcx, qword [rsp + 0x90]
mov esi, 0xc
movzx r13d, byte [rcx + 0xc]
lea r12, [rcx + 0xc]
mov r10, qword [rsp + 0xa8]
shl r13d, 8
movzx eax, byte [rcx + 0xd]
lea ebp, [rsi - 0xb]
or r13d, eax
movzx eax, byte [rcx + 0xe]
shl r13d, 8
or r13d, eax
movzx eax, byte [rcx + 0xf]
shl r13d, 8
or r13d, eax
cmp rdi, 0x10
jb 0x14008361d
mov eax, 0x10000000
mov ebx, esi
nop dword [rax + rax]
mov rsi, rdi
shr rsi, 4
cmp rsi, rax
cmova rsi, rax
add r13d, esi
mov eax, r13d
cmp rax, rsi
jae 0x14008356f
sub rsi, rax
xor r13d, r13d
mov qword [rsp + 0x20], rcx
mov r8, rsi
mov rcx, r15
mov rdx, r14
call r10
mov rcx, qword [rsp + 0x90]
mov eax, r13d
shr eax, 0x18
mov byte [r12], al
mov eax, r13d
shr eax, 0x10
mov byte [rcx + 0xd], al
mov eax, r13d
shr eax, 8
mov byte [rcx + 0xe], al
mov byte [rcx + 0xf], r13b
test r13d, r13d
jne 0x1400835dd
mov r8d, ebx
mov ecx, ebp
mov rdx, r12
nop word [rax + rax]
movzx eax, byte [rdx - 1]
lea rdx, [rdx - 1]
add ecx, eax
mov byte [rdx], cl
shr ecx, 8
add r8d, 0xffffffff
jne 0x1400835c0
mov rcx, qword [rsp + 0x90]
mov r9, qword [rsp + 0x88]
mov eax, 0x10000000
mov r10, qword [rsp + 0xa8]
shl rsi, 4
sub rdi, rsi
add r14, rsi
add r15, rsi
cmp rdi, 0x10
jae 0x140083550
mov ebx, dword [rsp + 0x80]
mov esi, 0xc
mov r8, qword [rsp + 0xa0]
test rdi, rdi
je 0x1400836d2
mov rax, qword [rsp + 0x98]
xor edx, edx
mov qword [rsp + 0x20], rcx
mov r8, rbp
mov rcx, rax
mov qword [rax], rdx
mov qword [rax + 8], rdx
mov rdx, rax
call r10
mov rcx, qword [rsp + 0x90]
inc r13d
mov eax, r13d
shr eax, 0x18
mov byte [r12], al
mov eax, r13d
shr eax, 0x10
mov byte [rcx + 0xd], al
mov eax, r13d
shr eax, 8
mov byte [rcx + 0xe], al
mov byte [rcx + 0xf], r13b
test r13d, r13d
jne 0x140083699
nop dword [rax + rax]
movzx eax, byte [r12 - 1]
lea r12, [r12 - 1]
add ebp, eax
mov byte [r12], bpl
shr ebp, 8
add esi, 0xffffffff
jne 0x140083680
mov rdx, qword [rsp + 0x98]
nop dword [rax]
nop word [rax + rax]
mov ecx, ebx
inc ebx
movzx eax, byte [rcx + r15]
xor al, byte [rcx + rdx]
mov byte [rcx + r14], al
sub rdi, 1
jne 0x1400836b0
mov rax, qword [rsp + 0xa0]
mov dword [rax], ebx
jmp 0x1400836d5
mov dword [r8], ebx
mov rbx, qword [rsp + 0x70]
add rsp, 0x30
pop r15
pop r14
pop r13
pop r12
pop rdi
pop rsi
pop rbp
ret
Function at 0x140083da0
Capabilities:
Encode data using xor

Disassembly:
mov qword [rsp + 0x18], rbx
mov qword [rsp + 0x20], rsi
push r14
mov eax, 0x20
call fcn.1400a06f0
sub rsp, rax
cmp qword [rcx + 0x38], 0
mov rbx, r8
mov r14, rdx
mov rsi, rcx
je 0x140083ddf
mov eax, 0xfffffffe
mov rbx, qword [rsp + 0x40]
mov rsi, qword [rsp + 0x48]
add rsp, 0x20
pop r14
ret
mov rcx, qword [rcx + 0x30]
movabs rax, 0x2000000000000000
add rcx, rbx
cmp rcx, rax
ja 0x140083eb0
cmp rcx, rbx
jb 0x140083eb0
mov qword [rsp + 0x38], rdi
mov edi, dword [rsi + 0x174]
mov qword [rsi + 0x30], rcx
test edi, edi
je 0x140083e44
test rbx, rbx
je 0x140083e33
movzx eax, byte [r14]
dec rbx
mov ecx, edi
inc r14
xor byte [rcx + rsi + 0x40], al
inc edi
and edi, 0xf
jne 0x140083e15
jmp 0x140083e37
test edi, edi
jne 0x140083e92
lea rdx, [rsi + 0x60]
lea rcx, [rsi + 0x40]
call fcn.140085200
mov qword [rsp + 0x30], rbp
mov rbp, rbx
and rbp, 0xfffffffffffffff0
je 0x140083e6b
lea rdx, [rsi + 0x60]
mov r9, rbp
lea rcx, [rsi + 0x40]
mov r8, r14
call fcn.140085030
add r14, rbp
sub rbx, rbp
mov rbp, qword [rsp + 0x30]
test rbx, rbx
je 0x140083e92
mov edi, ebx
lea rcx, [rsi + 0x40]
sub r14, rsi
nop
movzx eax, byte [r14 + rcx - 0x40]
xor byte [rcx], al
lea rcx, [rcx + 1]
sub rbx, 1
jne 0x140083e80
mov dword [rsi + 0x174], edi
xor eax, eax
mov rdi, qword [rsp + 0x38]
mov rbx, qword [rsp + 0x40]
mov rsi, qword [rsp + 0x48]
add rsp, 0x20
pop r14
ret
mov rbx, qword [rsp + 0x40]
or eax, 0xffffffff
mov rsi, qword [rsp + 0x48]
add rsp, 0x20
pop r14
ret
Function at 0x140085030
Capabilities:
Encode data using add xor sub operations
Encode data using xor

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rbp
mov qword [rsp + 0x18], rsi
mov qword [rsp + 0x20], rdi
push r12
push r13
push r14
push r15
mov rsi, rcx
lea r14, [r8 + 0xe]
sub rsi, r8
lea r13, [0x1400e6f60]
mov r12, r9
mov rbp, rdx
mov r11, rcx
nop word [rax + rax]
movzx eax, byte [r11 + 0xf]
mov rdi, r14
movzx ecx, byte [r14 + 1]
mov r15d, 0xf
xor rcx, rax
mov r9, rcx
and ecx, 0xf
add rcx, rcx
and r9, 0xfffffffffffffff0
mov r8, qword [rbp + rcx*8]
mov rcx, qword [rbp + rcx*8 + 8]
mov rax, r8
mov rdx, rcx
shr r8, 4
and edx, 0xf
shl rax, 0x3c
shr rcx, 4
or rax, rcx
mov rbx, qword [r13 + rdx*8]
xor rbx, r8
xor rbx, qword [r9 + rbp]
xor rax, qword [r9 + rbp + 8]
nop word [rax + rax]
movzx ecx, byte [rdi]
mov r9, rbx
movzx edx, byte [rsi + rdi]
lea rdi, [rdi - 1]
xor rdx, rcx
shr rbx, 4
mov rcx, rax
shl r9, 0x3c
shr rax, 4
and ecx, 0xf
or r9, rax
mov r10, rdx
and r10, 0xfffffffffffffff0
and edx, 0xf
add rdx, rdx
mov r8, qword [r13 + rcx*8]
xor r8, rbx
xor r9, qword [rbp + rdx*8 + 8]
xor r8, qword [rbp + rdx*8]
mov rcx, r9
and ecx, 0xf
shr r9, 4
mov rax, r8
shr r8, 4
shl rax, 0x3c
or rax, r9
mov rbx, qword [r13 + rcx*8]
xor rax, qword [r10 + rbp + 8]
xor rbx, r8
xor rbx, qword [r10 + rbp]
sub r15, 1
jne 0x1400850d0
mov rdx, rbx
mov byte [r11 + 7], bl
shr rdx, 0x20
add r14, 0x10
mov ecx, edx
mov byte [r11 + 3], dl
shr ecx, 0x18
sub rsi, 0x10
mov byte [r11], cl
mov ecx, edx
shr ecx, 0x10
mov byte [r11 + 1], cl
mov ecx, edx
shr ecx, 8
mov rdx, rax
mov byte [r11 + 2], cl
mov ecx, ebx
shr ecx, 0x18
mov byte [r11 + 4], cl
mov ecx, ebx
shr ecx, 0x10
mov byte [r11 + 5], cl
mov ecx, ebx
shr ecx, 8
mov byte [r11 + 6], cl
shr rdx, 0x20
mov ecx, edx
mov byte [r11 + 0xb], dl
shr ecx, 0x18
mov byte [r11 + 8], cl
mov ecx, edx
shr ecx, 0x10
mov byte [r11 + 9], cl
mov ecx, edx
shr ecx, 8
mov byte [r11 + 0xa], cl
mov ecx, eax
shr ecx, 0x18
mov byte [r11 + 0xc], cl
mov ecx, eax
shr ecx, 0x10
mov byte [r11 + 0xd], cl
mov ecx, eax
shr ecx, 8
mov byte [r11 + 0xe], cl
mov byte [r11 + 0xf], al
sub r12, 0x10
jne 0x140085070
mov rbx, qword [rsp + 0x28]
mov rbp, qword [rsp + 0x30]
mov rsi, qword [rsp + 0x38]
mov rdi, qword [rsp + 0x40]
pop r15
pop r14
pop r13
pop r12
ret
Function at 0x140085200
Capabilities:
Encode data using add xor sub operations
Encode data using xor

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rsi
mov qword [rsp + 0x18], rdi
mov qword [rsp + 0x20], r14
movzx eax, byte [rcx + 0xf]
lea r14, [0x1400e6f60]
mov r10d, eax
mov rdi, rdx
and eax, 0xf
and r10, 0xfffffffffffffff0
add rax, rax
mov esi, 0xe
mov r9, qword [rdx + rax*8]
mov r8, qword [rdx + rax*8 + 8]
mov r11, r9
mov rax, r8
shr r9, 4
and eax, 0xf
shl r11, 0x3c
shr r8, 4
or r11, r8
mov rbx, qword [r14 + rax*8]
xor rbx, r9
xor rbx, qword [r10 + rdx]
xor r11, qword [r10 + rdx + 8]
nop word [rax + rax]
movzx edx, byte [rsi + rcx]
mov rax, r11
shr r11, 4
mov r9, rbx
shr rbx, 4
and eax, 0xf
shl r9, 0x3c
mov r10d, edx
or r9, r11
and r10, 0xfffffffffffffff0
and edx, 0xf
mov r8, qword [r14 + rax*8]
add rdx, rdx
xor r8, rbx
xor r9, qword [rdi + rdx*8 + 8]
xor r8, qword [rdi + rdx*8]
mov rax, r9
and eax, 0xf
shr r9, 4
mov r11, r8
shr r8, 4
shl r11, 0x3c
or r11, r9
mov rbx, qword [r14 + rax*8]
xor r11, qword [r10 + rdi + 8]
xor rbx, r8
xor rbx, qword [r10 + rdi]
sub rsi, 1
jns 0x140085270
mov rsi, qword [rsp + 0x10]
mov rdx, rbx
mov rdi, qword [rsp + 0x18]
mov r14, qword [rsp + 0x20]
shr rdx, 0x20
mov eax, edx
mov byte [rcx + 3], dl
shr eax, 0x18
mov byte [rcx], al
mov eax, edx
shr eax, 0x10
mov byte [rcx + 1], al
mov eax, edx
shr eax, 8
mov rdx, r11
mov byte [rcx + 2], al
mov eax, ebx
shr eax, 0x18
mov byte [rcx + 4], al
mov eax, ebx
shr eax, 0x10
mov byte [rcx + 5], al
mov eax, ebx
shr eax, 8
mov byte [rcx + 6], al
shr rdx, 0x20
mov eax, edx
mov byte [rcx + 7], bl
mov rbx, qword [rsp + 8]
shr eax, 0x18
mov byte [rcx + 8], al
mov eax, edx
shr eax, 0x10
mov byte [rcx + 9], al
mov eax, edx
shr eax, 8
mov byte [rcx + 0xa], al
mov eax, r11d
shr eax, 0x18
mov byte [rcx + 0xc], al
mov eax, r11d
shr eax, 0x10
mov byte [rcx + 0xd], al
mov eax, r11d
shr eax, 8
mov byte [rcx + 0xe], al
mov byte [rcx + 0xb], dl
mov byte [rcx + 0xf], r11b
ret
Function at 0x140087a00
Capabilities:
Contain obfuscated stackstrings
Encode data using xor
Encrypt data using salsa20 or chacha

Disassembly:
mov qword [rsp + 0x18], rsi
push rbp
push rdi
push r14
lea rbp, [rsp - 0x3f]
mov eax, 0xb0
call fcn.1400a06f0
sub rsp, rax
mov rax, qword [0x1400fb010]
xor rax, rsp
mov qword [rbp + 0x2f], rax
mov rax, qword [rbp + 0x7f]
mov r14, r8
mov dword [rbp - 0x11], 0x61707865
mov rsi, rdx
mov dword [rbp - 0xd], 0x3320646e
mov rdi, rcx
mov dword [rbp - 9], 0x79622d32
mov dword [rbp - 5], 0x6b206574
movups xmm0, xmmword [r9]
movups xmm1, xmmword [r9 + 0x10]
movups xmmword [rbp - 1], xmm0
movups xmm0, xmmword [rax]
movups xmmword [rbp + 0xf], xmm1
movups xmmword [rbp + 0x1f], xmm0
test r8, r8
je 0x140087b94
mov qword [rsp + 0xd8], rbx
nop dword [rax + rax]
mov ebx, 0x40
lea rdx, [rbp - 0x11]
cmp r14, rbx
lea rcx, [rbp - 0x51]
cmovb rbx, r14
call fcn.140087bc0
xor eax, eax
test rbx, rbx
je 0x140087b7a
cmp rbx, 0x20
jb 0x140087b45
lea rdx, [rdi - 1]
add rdx, rbx
lea rcx, [rbp + rbx - 0x52]
cmp rdi, rcx
ja 0x140087ac8
lea rcx, [rbp - 0x51]
cmp rdx, rcx
jae 0x140087b45
lea rcx, [rsi - 1]
add rcx, rbx
cmp rdi, rcx
ja 0x140087ad9
cmp rdx, rsi
jae 0x140087b45
lea rcx, [rbp - 0x51]
mov rdx, rsi
sub rdx, rcx
mov r9, rbx
lea rcx, [rbp - 0x51]
and r9, 0xffffffffffffffe0
mov r8, rdi
sub r8, rcx
nop dword [rax]
nop dword [rax + rax]
movdqu xmm0, xmmword [rbp + rax - 0x51]
lea rcx, [rdx + rax]
movdqu xmm1, xmmword [rbp + rcx - 0x51]
lea rcx, [r8 + rax]
pxor xmm1, xmm0
movdqu xmm0, xmmword [rbp + rax - 0x41]
movdqu xmmword [rbp + rcx - 0x51], xmm1
lea rcx, [rdx + rax]
movdqu xmm1, xmmword [rbp + rcx - 0x41]
lea rcx, [r8 + rax]
add rax, 0x20
pxor xmm1, xmm0
movdqu xmmword [rbp + rcx - 0x41], xmm1
cmp rax, r9
jb 0x140087b00
cmp rax, rbx
jae 0x140087b7a
lea rcx, [rbp - 0x51]
mov r8, rsi
sub r8, rcx
mov r9, rdi
lea rcx, [rbp - 0x51]
sub r9, rcx
nop
lea rdx, [rbp - 0x51]
add rdx, rax
inc rax
movzx ecx, byte [r8 + rdx]
xor cl, byte [rdx]
mov byte [r9 + rdx], cl
cmp rax, rbx
jb 0x140087b60
inc dword [rbp + 0x1f]
add rdi, rbx
add rsi, rbx
sub r14, rbx
jne 0x140087a80
mov rbx, qword [rsp + 0xd8]
mov rcx, qword [rbp + 0x2f]
xor rcx, rsp
call fcn.140002dc0
mov rsi, qword [rsp + 0xe0]
add rsp, 0xb0
pop r14
pop rdi
pop rbp
ret
Function at 0x14008af80
Capabilities:
Encode data using xor

Disassembly:
mov eax, 0x38
call fcn.1400a06f0
sub rsp, rax
cmp dword [rsp + 0x68], 0
je 0x14008afa9
lea rax, [0x140089550]
mov qword [rsp + 0x68], rax
add rsp, 0x38
jmp fcn.1400830b0
lea rax, [0x1400886b0]
mov qword [rsp + 0x68], rax
add rsp, 0x38
jmp fcn.140082de0

Function at 0x140090149
Capabilities:
Encode data using xor

Disassembly:
test r8, r8
je 0x14009033a
push rbx
mov eax, 0xd0
call fcn.1400a06f0
sub rsp, rax
mov rax, qword [0x1400fb010]
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.14007c0e0
lea rdx, [rsp + 0x30]
mov rcx, r14
call fcn.14007be30
mov r8d, 1
lea rdx, [rsp + 0x30]
lea rcx, [rsp + 0x28]
call fcn.1400788e0
mov rcx, r15
call fcn.14007c0e0
lea rdx, [rsp + 0x30]
mov rcx, r15
call fcn.14007be30
mov r8d, 1
lea rdx, [rsp + 0x30]
lea rcx, [rsp + 0x20]
call fcn.1400788e0
mov r8d, dword [rsp + 0x20]
mov edx, dword [rsp + 0x24]
xor r8d, edi
xor edi, dword [rsp + 0x28]
xor edx, esi
xor esi, dword [rsp + 0x2c]
mov eax, edi
mov byte [r14], dil
shr eax, 8
mov byte [r14 + 1], al
mov eax, edi
shr eax, 0x10
mov byte [r14 + 2], al
mov eax, edx
shr eax, 8
shr edi, 0x18
mov byte [r14 + 3], dil
mov byte [r14 + 4], dl
mov byte [r14 + 5], al
mov eax, edx
shr eax, 0x10
mov byte [r14 + 6], al
mov eax, r8d
shr eax, 8
shr edx, 0x18
mov byte [r14 + 7], dl
mov byte [r15], r8b
mov byte [r15 + 1], al
mov eax, r8d
shr eax, 0x10
mov byte [r15 + 2], al
shr r8d, 0x18
mov byte [r15 + 3], r8b
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 0x1400901b0
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.140002dc0
add rsp, 0xd0
pop rbx
ret
Function at 0x14009d3f0
Capabilities:
Encode data using xor

Disassembly:
mov qword [rsp + 8], rcx
push rbp
push rsi
push rdi
push r14
mov eax, 0x28
call fcn.1400a06f0
sub rsp, rax
mov qword [rsp + 0x58], rbx
mov rsi, rdx
mov rbx, qword [rsp + 0x78]
mov r14, r9
mov qword [rsp + 0x60], r12
mov rdi, rcx
shl rsi, 5
mov r12, rdx
mov qword [rsp + 0x68], r13
mov r13, r8
test rsi, rsi
je 0x14009d46e
mov r9, rsi
nop word [rax + rax]
movzx eax, byte [rcx]
lea rcx, [rcx + 4]
mov dword [rbx], eax
movzx eax, byte [rcx - 3]
shl eax, 8
or dword [rbx], eax
movzx eax, byte [rcx - 2]
shl eax, 0x10
or dword [rbx], eax
movzx eax, byte [rcx - 1]
shl eax, 0x18
or dword [rbx], eax
add rbx, 4
sub r9, 1
jne 0x14009d440
mov qword [rsp + 0x20], r15
cmp r13, 1
jbe 0x14009d49e
mov rbp, r12
lea r15, [r8 - 1]
shl rbp, 7
mov rdx, rbx
mov r8, r12
sub rdx, rbp
mov rcx, rbx
call fcn.14009cf80
add rbx, rbp
sub r15, 1
jne 0x14009d484
mov rdx, r13
mov r8, r12
shl rdx, 7
mov rcx, r14
add rdx, 0xffffffffffffff80
imul rdx, r12
add rdx, qword [rsp + 0x78]
call fcn.14009cf80
xor ebp, ebp
test r13, r13
je 0x14009d5c4
mov rbx, qword [rsp + 0x70]
mov rdi, r12
shl rdi, 7
mov r15, r13
nop word [rax + rax]
mov eax, dword [rdi + r14 - 0x40]
xor edx, edx
div r13
mov eax, edx
imul rax, r12
shl rax, 7
add rax, qword [rsp + 0x78]
test rsi, rsi
je 0x14009d5a7
cmp rsi, 8
jb 0x14009d57b
lea rcx, [rsi - 1]
mov r8, rbp
lea rcx, [rax + rcx*4]
lea rdx, [rbx - 4]
lea rdx, [rdx + rsi*4]
cmp rbx, rcx
ja 0x14009d525
cmp rdx, rax
jae 0x14009d57b
lea rcx, [r14 - 4]
lea rcx, [rcx + rsi*4]
cmp rbx, rcx
ja 0x14009d537
cmp rdx, r14
jae 0x14009d57b
mov rdx, r14
lea rcx, [rbx + 0x10]
sub rdx, rbx
movdqu xmm0, xmmword [rax]
add r8, 8
lea rax, [rax + 0x20]
movdqu xmm1, xmmword [rdx + rcx - 0x10]
lea rcx, [rcx + 0x20]
pxor xmm1, xmm0
movdqu xmmword [rcx - 0x30], xmm1
movdqu xmm1, xmmword [rdx + rcx - 0x20]
movdqu xmm0, xmmword [rax - 0x10]
pxor xmm1, xmm0
movdqu xmmword [rcx - 0x20], xmm1
cmp r8, rsi
jb 0x14009d541
jmp 0x14009d5a7
mov r9, r14
mov rdx, rbx
sub r9, rbx
mov r8, rsi
nop word [rax + rax]
mov ecx, dword [rdx + r9]
lea rdx, [rdx + 4]
xor ecx, dword [rax]
lea rax, [rax + 4]
mov dword [rdx - 4], ecx
sub r8, 1
jne 0x14009d590
mov r8, r12
mov rdx, rbx
mov rcx, r14
call fcn.14009cf80
sub r15, 1
jne 0x14009d4e0
mov rdi, qword [rsp + 0x50]
mov r15, qword [rsp + 0x20]
mov r13, qword [rsp + 0x68]
mov r12, qword [rsp + 0x60]
mov rbx, qword [rsp + 0x58]
test rsi, rsi
je 0x14009d608
nop dword [rax]
mov ecx, dword [r14 + rbp*4]
mov eax, ecx
mov byte [rdi], cl
lea rdi, [rdi + 4]
shr eax, 8
inc rbp
mov byte [rdi - 3], al
mov eax, ecx
shr eax, 0x10
shr ecx, 0x18
mov byte [rdi - 2], al
mov byte [rdi - 1], cl
cmp rbp, rsi
jb 0x14009d5e0
add rsp, 0x28
pop r14
pop rdi
pop rsi
pop rbp
ret
Function at 0x14009ffe0
Capabilities:
Encode data using base64

Disassembly:
xor r10d, r10d
test r8d, r8d
jle 0x1400a00d3
lea r9, [rdx + 1]
lea r11, str.ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_
cmp r8d, 3
jl 0x1400a005b
movzx eax, byte [r9]
movzx edx, byte [r9 - 1]
shl rdx, 8
or rdx, rax
movzx eax, byte [r9 + 1]
shl rdx, 8
or rdx, rax
mov rax, rdx
shr rax, 0x12
movzx eax, byte [rax + r11]
mov byte [rcx], al
mov rax, rdx
shr rax, 0xc
and eax, 0x3f
movzx eax, byte [rax + r11]
mov byte [rcx + 1], al
mov rax, rdx
shr rax, 6
and eax, 0x3f
movzx eax, byte [rax + r11]
mov byte [rcx + 2], al
add rcx, 3
and edx, 0x3f
movzx eax, byte [rdx + r11]
mov byte [rcx], al
jmp 0x1400a00b4
movzx edx, byte [r9 - 1]
shl edx, 0x10
cmp r8d, 2
jne 0x1400a0072
movzx eax, byte [r9]
shl eax, 8
or edx, eax
mov rax, rdx
shr rax, 0x12
movzx eax, byte [rax + r11]
mov byte [rcx], al
mov rax, rdx
shr rax, 0xc
and eax, 0x3f
movzx eax, byte [rax + r11]
mov byte [rcx + 1], al
cmp r8d, 1
jne 0x1400a009e
lea eax, [r8 + 0x3c]
jmp 0x1400a00aa
shr rdx, 6
and edx, 0x3f
movzx eax, byte [rdx + r11]
mov byte [rcx + 2], al
add rcx, 3
mov byte [rcx], 0x3d
add r10d, 4
add r9, 3
sub r8d, 3
inc rcx
test r8d, r8d
jg 0x14009fff7
mov byte [rcx], 0
mov eax, r10d
ret
mov byte [rcx], r10b
mov eax, r10d
ret
Function at 0x180003b90
Capabilities:
Get common file path

Disassembly:
push rbx
sub rsp, 0x70
lea rbx, [rcx + 0xc0]
lea r9, [rsp + 0x88]
xor r8d, r8d
xor edx, edx
lea rcx, [0x180062850]
call qword [sym.imp.SHELL32.dll_SHGetKnownFolderPath]
test eax, eax
js 0x180003ca6
mov rcx, qword [rsp + 0x88]
mov qword [rsp + 0x20], rcx
mov rax, 0xffffffffffffffff
inc rax
cmp word [rcx + rax*2], 0
jne 0x180003bd3
mov qword [rsp + 0x28], rax
lea rdx, [rsp + 0x20]
lea rcx, [rsp + 0x30]
call fcn.1800174c0
lea rax, [rsp + 0x30]
cmp rbx, rax
je 0x180003c53
mov rdx, qword [rbx + 0x18]
cmp rdx, 8
jb 0x180003c36
lea rdx, [rdx*2 + 2]
mov rcx, qword [rbx]
cmp rdx, 0x1000
jb 0x180003c31
add rdx, 0x27
mov r8, qword [rcx - 8]
sub rcx, r8
lea rax, [rcx - 8]
cmp rax, 0x1f
ja 0x180003c8c
mov rcx, r8
call fcn.18005b5e4
xor ecx, ecx
lea eax, [rcx + 7]
movups xmm0, xmmword [rsp + 0x30]
movups xmmword [rbx], xmm0
movups xmm1, xmmword [rsp + 0x40]
movups xmmword [rbx + 0x10], xmm1
mov word [rsp + 0x30], cx
jmp 0x180003c58
mov rax, qword [rsp + 0x48]
cmp rax, 8
jb 0x180003c98
lea rdx, [rax*2 + 2]
mov rcx, qword [rsp + 0x30]
mov rax, rcx
cmp rdx, 0x1000
jb 0x180003c93
add rdx, 0x27
mov rcx, qword [rcx - 8]
sub rax, rcx
add rax, 0xfffffffffffffff8
cmp rax, 0x1f
jbe 0x180003c93
call qword [sym.imp.api_ms_win_crt_runtime_l1_1_0.dll__invalid_parameter_noinfo_noreturn]
int3
call fcn.18005b5e4
mov rcx, qword [rsp + 0x88]
call qword [sym.imp.ole32.dll_CoTaskMemFree]
call fcn.18005b120
lea rcx, str.RSkinP
mov qword [rsp + 0x20], rcx
mov qword [rsp + 0x28], 6
lea r8, [rsp + 0x20]
mov edx, eax
lea rcx, [rsp + 0x50]
call fcn.180002b50
lea rdx, [rsp + 0x50]
mov rcx, rbx
call fcn.180002da0
mov rdx, qword [rsp + 0x68]
cmp rdx, 8
jb 0x180003d24
lea rdx, [rdx*2 + 2]
mov rcx, qword [rsp + 0x50]
mov rax, rcx
cmp rdx, 0x1000
jb 0x180003d1e
add rdx, 0x27
mov rcx, qword [rcx - 8]
sub rax, rcx
add rax, 0xfffffffffffffff8
cmp rax, 0x1f
jbe 0x180003d1e
call qword [sym.imp.api_ms_win_crt_runtime_l1_1_0.dll__invalid_parameter_noinfo_noreturn]
int3
call fcn.18005b5e4
nop
add rsp, 0x70
pop rbx
ret
Function at 0x1800076f0
Capabilities:
Write file on windows

Disassembly:
push rbx
sub rsp, 0x50
cmp qword [rcx + 0x68], 0
mov rbx, rcx
je 0x1800077b9
cmp byte [rcx + 0x71], 0
je 0x1800077b9
mov rax, qword [rcx]
mov edx, 0xffffffff
mov qword [rsp + 0x68], rdi
call qword [rax + 0x18]
cmp eax, 0xffffffff
je 0x1800077ac
mov rcx, qword [rbx + 0x68]
lea rax, [rsp + 0x60]
lea rdx, [rbx + 0x74]
mov qword [rsp + 0x20], rax
lea r9, [rsp + 0x50]
lea r8, [rsp + 0x30]
call qword [sym.imp.MSVCP140.dll_public:_int___cdecl_std::codecvt_char__char__struct__Mbstatet_::unshift_struct__Mbstatet____ptr64__char____ptr64__char____ptr64__char____ptr64____ptr64_const___ptr64]
test eax, eax
je 0x180007768
sub eax, 1
je 0x18000776c
cmp eax, 2
jne 0x1800077ac
mov rdi, qword [rsp + 0x68]
mov al, 1
mov byte [rbx + 0x71], 0
add rsp, 0x50
pop rbx
ret
mov byte [rbx + 0x71], 0
mov rdi, qword [rsp + 0x60]
lea rax, [rsp + 0x30]
sub rdi, rax
je 0x18000779a
mov r9, qword [rbx + 0x80]
lea rcx, [rsp + 0x30]
mov r8, rdi
mov edx, 1
call qword [sym.imp.api_ms_win_crt_stdio_l1_1_0.dll_fwrite]
cmp rdi, rax
jne 0x1800077ac
cmp byte [rbx + 0x71], 0
mov rdi, qword [rsp + 0x68]
sete al
add rsp, 0x50
pop rbx
ret
mov rdi, qword [rsp + 0x68]
xor al, al
add rsp, 0x50
pop rbx
ret
mov al, 1
add rsp, 0x50
pop rbx
ret
Function at 0x18001af70
Capabilities:
Hide thread from debugger

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
lea rcx, str.ntdll.dll
call qword [sym.imp.KERNEL32.dll_GetModuleHandleA]
mov rcx, rax
lea rdx, str.NtSetInformationThread
call qword [sym.imp.KERNEL32.dll_GetProcAddress]
test rax, rax
je 0x18001afb5
xor r9d, r9d
xor r8d, r8d
lea edx, [r9 + 0x11]
mov rcx, rbx
call rax
test eax, eax
sete al
add rsp, 0x20
pop rbx
ret
add rsp, 0x20
pop rbx
ret

Function at 0x18001b100
Capabilities:
Create thread

Disassembly:
push rbx
sub rsp, 0x30
mov ebx, edx
call qword [sym.imp.KERNEL32.dll_DisableThreadLibraryCalls]
cmp ebx, 1
je 0x18001b11b
xor eax, eax
add rsp, 0x30
pop rbx
ret
xor eax, eax
lea r8, [0x18001afc0]
mov qword [rsp + 0x28], rax
xor r9d, r9d
xor edx, edx
mov dword [rsp + 0x20], eax
xor ecx, ecx
call qword [sym.imp.api_ms_win_crt_runtime_l1_1_0.dll__beginthreadex]
test rax, rax
je 0x18001b148
mov rcx, rax
call qword [sym.imp.KERNEL32.dll_CloseHandle]
mov eax, 1
add rsp, 0x30
pop rbx
ret

Function at 0x180020610
Capabilities:
Encrypt data using rc4 ksa
Encrypt data using rc4 prga

Disassembly:
mov qword [rsp + 0x18], rbp
mov qword [rsp + 0x20], rdi
push r12
push r14
push r15
sub rsp, 0x20
movsxd r12, edx
mov r15d, r9d
mov rbp, r8
mov r14, rcx
test rcx, rcx
je 0x180020770
test r8, r8
je 0x180020770
mov rdi, qword [rsp + 0x60]
test rdi, rdi
je 0x180020770
mov qword [rsp + 0x40], rbx
mov ecx, 0x100
mov qword [rsp + 0x48], rsi
call fcn.18005b6e8
xor ecx, ecx
mov r10, rax
mov edx, ecx
mov r8, rax
nop
mov byte [r8], dl
lea r8, [r8 + 1]
inc edx
cmp edx, 0x100
jl 0x180020670
mov r9d, ecx
mov r11d, ecx
mov rbx, r10
nop word [rax + rax]
movzx esi, byte [rbx]
mov eax, r11d
cdq
idiv r15d
movsxd rax, edx
movzx edx, byte [rax + rbp]
add r9d, edx
add r9d, esi
and r9d, 0x800000ff
jge 0x1800206bd
dec r9d
or r9d, 0xffffff00
inc r9d
movsxd rdx, r9d
inc r11d
movzx eax, byte [rdx + r10]
mov byte [rbx], al
inc rbx
mov byte [rdx + r10], sil
cmp r11d, 0x100
jl 0x180020690
mov rsi, qword [rsp + 0x48]
mov r8d, ecx
mov rbx, r12
test r12d, r12d
jle 0x180020754
sub r14, rdi
nop dword [rax]
inc ecx
and ecx, 0x800000ff
jge 0x180020704
dec ecx
or ecx, 0xffffff00
inc ecx
movsxd r9, ecx
movzx r11d, byte [r9 + r10]
add r8d, r11d
and r8d, 0x800000ff
jge 0x180020725
dec r8d
or r8d, 0xffffff00
inc r8d
movsxd rdx, r8d
movzx eax, byte [rdx + r10]
mov byte [r9 + r10], al
mov byte [rdx + r10], r11b
movzx eax, byte [r9 + r10]
add eax, r11d
movzx edx, al
movzx eax, byte [rdx + r10]
xor al, byte [r14 + rdi]
mov byte [rdi], al
inc rdi
sub rbx, 1
jne 0x1800206f0
mov rax, qword [rsp + 0x68]
mov rcx, r10
mov dword [rax], r12d
call fcn.18005b5e4
mov rbx, qword [rsp + 0x40]
mov eax, 0xffffffff
jmp 0x180020772
xor eax, eax
mov rbp, qword [rsp + 0x50]
mov rdi, qword [rsp + 0x58]
add rsp, 0x20
pop r15
pop r14
pop r12
ret