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

Disassembly:
push rbx
cmp qword [rcx + 0x10], 0
mov rbx, rcx
je 0x180111e22
mov r10d, dword [rdx]
mov r11d, dword [rbx + 0x18]
mov edx, r10d
mov r8d, r10d
shr edx, 0x18
mov ecx, r10d
shr r8d, 0x10
shr ecx, 8
cmp r10d, r11d
je 0x180111e22
mov r9, qword [rbx + 8]
mov rbx, qword [rbx]
dec r9
movzx ecx, cl
mov qword [rsp + 0x10], rdi
movabs rdi, 0xcbf29ce484222325
movzx eax, r10b
xor rax, rdi
movabs rdi, 0x100000001b3
imul rax, rdi
xor rax, rcx
movzx ecx, r8b
imul rax, rdi
xor rax, rcx
mov ecx, edx
imul rax, rdi
xor rax, rcx
imul rax, rdi
mov rdi, qword [rsp + 0x10]
and rax, r9
xor ecx, ecx
nop dword [rax]
mov edx, dword [rbx + rax*8]
lea r8, [rbx + rax*8]
cmp edx, r10d
je 0x180111e26
cmp edx, r11d
je 0x180111e22
inc rax
add rax, rcx
inc rcx
and rax, r9
cmp rcx, r9
jbe 0x180111e00
xor eax, eax
pop rbx
ret
mov rax, r8
pop rbx
ret

Function at 0x180112060
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
mov qword [rsp + 0x10], rbx
push rbp
push rsi
push rdi
push r12
push r13
push r14
push r15
sub rsp, 0x20
cmp qword [rcx + 0x10], 0
mov r13, rdx
mov rdi, rcx
je 0x180112167
mov r12d, dword [rdx + 0x80]
lea rax, [rcx + 0x18]
mov ecx, dword [rax + 0x80]
mov qword [rsp + 0x70], rax
mov dword [rsp + 0x60], ecx
cmp r12d, ecx
jne 0x1801120bf
lea r8, [r12*4]
mov rdx, rax
mov rcx, r13
call fcn.1803bbe20
test eax, eax
je 0x180112167
mov r15, qword [rdi + 8]
xor ebp, ebp
dec r15
mov eax, 0x811c9dc5
mov ecx, ebp
test r12, r12
je 0x1801120f3
nop dword [rax]
nop dword [rax + rax]
xor eax, dword [r13 + rcx*4]
inc rcx
imul eax, eax, 0x1000193
cmp rcx, r12
jb 0x1801120e0
mov ebx, eax
mov rax, qword [rdi]
and rbx, r15
mov qword [rsp + 0x78], rax
imul rsi, rbx, 0x88
add rsi, rax
mov r14d, dword [rsi + 0x80]
mov edi, r14d
shl rdi, 2
cmp r14d, r12d
jne 0x18011212f
mov r8, rdi
mov rdx, r13
mov rcx, rsi
call fcn.1803bbe20
test eax, eax
je 0x180112162
cmp r14d, dword [rsp + 0x60]
jne 0x18011214a
mov rdx, qword [rsp + 0x70]
mov r8, rdi
mov rcx, rsi
call fcn.1803bbe20
test eax, eax
je 0x180112167
inc rbx
add rbx, rbp
inc rbp
and rbx, r15
cmp rbp, r15
ja 0x180112167
mov rax, qword [rsp + 0x78]
jmp 0x180112100
mov rax, rsi
jmp 0x180112169
xor eax, eax
mov rbx, qword [rsp + 0x68]
add rsp, 0x20
pop r15
pop r14
pop r13
pop r12
pop rdi
pop rsi
pop rbp
ret

Function at 0x180112330
Capabilities:
Encode data using xor

Disassembly:
mov rax, qword [rcx + 8]
mov r9, qword [rcx]
mov r8, rax
test rax, rax
je 0x18011235c
nop
movzx edx, byte [r9 + r8 - 1]
mov ecx, eax
shl ecx, 5
add edx, ecx
mov ecx, eax
shr ecx, 2
add edx, ecx
xor eax, edx
sub r8, 1
jne 0x180112340
ret
Function at 0x180112360
Capabilities:
Hash data using fnv

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rsi
mov qword [rsp + 0x18], rdi
mov r10, qword [rcx + 8]
mov rsi, rcx
movzx eax, byte [rdx]
mov r11, rdx
movabs rdx, 0x100000001b3
movabs rcx, 0xcbf29ce484222325
xor rax, rcx
dec r10
mov rbx, qword [rsi]
movzx ecx, byte [r11 + 2]
movzx r8d, byte [r11 + 1]
mov edi, dword [rsi + 0x18]
imul rax, rdx
xor rax, r8
imul rax, rdx
xor rax, rcx
movzx ecx, byte [r11 + 3]
imul rax, rdx
xor rax, rcx
imul rax, rdx
and rax, r10
xor ecx, ecx
nop dword [rax]
mov edx, dword [rbx + rax*8]
lea r8, [rbx + rax*8]
mov r9d, dword [r11]
cmp edx, edi
je 0x180112406
cmp edx, r9d
je 0x18011240d
inc rax
add rax, rcx
inc rcx
and rax, r10
cmp rcx, r10
jbe 0x1801123d0
xor eax, eax
mov rbx, qword [rsp + 8]
mov rsi, qword [rsp + 0x10]
mov rdi, qword [rsp + 0x18]
ret
mov dword [r8], r9d
inc qword [rsi + 0x10]
mov rbx, qword [rsp + 8]
mov rax, r8
mov rsi, qword [rsp + 0x10]
mov rdi, qword [rsp + 0x18]
ret

Function at 0x180112600
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
mov qword [rsp + 0x20], rbx
mov qword [rsp + 8], rcx
push rbp
push rsi
push rdi
push r12
push r13
push r14
push r15
sub rsp, 0x20
mov r12, qword [rcx + 8]
xor ebp, ebp
mov r13d, dword [rdx + 0x80]
dec r12
mov r14, rdx
mov eax, 0x811c9dc5
mov r8d, ebp
test r13, r13
je 0x180112652
nop dword [rax]
xor eax, dword [rdx + r8*4]
inc r8
imul eax, eax, 0x1000193
cmp r8, r13
jb 0x180112640
mov edi, eax
mov rax, qword [rcx]
and rdi, r12
add rcx, 0x18
mov qword [rsp + 0x68], rax
mov qword [rsp + 0x70], rcx
nop dword [rax + rax]
imul rbx, rdi, 0x88
add rbx, rax
mov r15d, dword [rbx + 0x80]
mov esi, r15d
shl rsi, 2
cmp r15d, dword [rcx + 0x80]
jne 0x1801126a3
mov rdx, rcx
mov r8, rsi
mov rcx, rbx
call fcn.1803bbe20
test eax, eax
je 0x1801126d7
cmp r15d, r13d
jne 0x1801126ba
mov r8, rsi
mov rdx, r14
mov rcx, rbx
call fcn.1803bbe20
test eax, eax
je 0x180112733
inc rdi
add rdi, rbp
inc rbp
and rdi, r12
cmp rbp, r12
ja 0x180112738
mov rax, qword [rsp + 0x68]
mov rcx, qword [rsp + 0x70]
jmp 0x180112670
movups xmm0, xmmword [r14]
mov rax, qword [rsp + 0x60]
movups xmmword [rbx], xmm0
movups xmm1, xmmword [r14 + 0x10]
movups xmmword [rbx + 0x10], xmm1
movups xmm0, xmmword [r14 + 0x20]
movups xmmword [rbx + 0x20], xmm0
movups xmm1, xmmword [r14 + 0x30]
movups xmmword [rbx + 0x30], xmm1
movups xmm0, xmmword [r14 + 0x40]
movups xmmword [rbx + 0x40], xmm0
movups xmm1, xmmword [r14 + 0x50]
movups xmmword [rbx + 0x50], xmm1
movups xmm0, xmmword [r14 + 0x60]
movups xmmword [rbx + 0x60], xmm0
movups xmm1, xmmword [r14 + 0x70]
movups xmmword [rbx + 0x70], xmm1
mov ecx, dword [r14 + 0x80]
mov dword [rbx + 0x80], ecx
inc qword [rax + 0x10]
mov rax, rbx
jmp 0x18011273a
xor eax, eax
mov rbx, qword [rsp + 0x78]
add rsp, 0x20
pop r15
pop r14
pop r13
pop r12
pop rdi
pop rsi
pop rbp
ret
Function at 0x1801129e0
Capabilities:
Hash data using fnv

Disassembly:
sub rsp, 0x48
mov qword [rsp + 0x58], rbx
mov rbx, rcx
mov qword [rsp + 0x60], rbp
mov qword [rsp + 0x40], rsi
mov rsi, qword [rcx + 8]
mov qword [rsp + 0x38], rdi
mov edi, dword [rcx + 0x18]
mov qword [rsp + 0x28], r14
mov qword [rsp + 0x20], r15
lea r15, [rcx + 0x18]
mov r14, r15
test rsi, rsi
jne 0x180112a2e
mov esi, 0x10
lea ecx, [rsi + 0x70]
call fcn.180313d50
mov r11, rax
xor ecx, ecx
mov ebp, esi
jmp 0x180112a60
xor r11d, r11d
xor ebp, ebp
add rsi, rsi
je 0x180112a77
lea rcx, [rsi*8]
call fcn.180313d50
xor ecx, ecx
mov r11, rax
mov rbp, rsi
test rsi, rsi
je 0x180112a77
nop dword [rax]
nop word [rax + rax]
mov eax, dword [r14]
mov dword [r11 + rcx*8], eax
xor eax, eax
mov word [r11 + rcx*8 + 4], ax
inc rcx
cmp rcx, rsi
jb 0x180112a60
xor esi, esi
cmp qword [rbx + 8], rsi
jbe 0x180112b41
mov qword [rsp + 0x30], r12
movabs r14, 0x100000001b3
movabs r12, 0xcbf29ce484222325
nop dword [rax]
mov rax, qword [rbx]
mov r9d, dword [rax + rsi*8]
mov edx, r9d
mov r8d, r9d
mov ecx, r9d
shr edx, 0x18
shr r8d, 0x10
shr ecx, 8
cmp r9d, dword [r15]
je 0x180112b2f
movzx ecx, cl
lea r10, [rbp - 1]
movzx eax, r9b
xor rax, r12
imul rax, r14
xor rax, rcx
movzx ecx, r8b
imul rax, r14
xor rax, rcx
mov ecx, edx
imul rax, r14
xor rax, rcx
imul rax, r14
and rax, r10
xor ecx, ecx
mov r8d, dword [r11 + rax*8]
lea rdx, [r11 + rax*8]
cmp r8d, edi
je 0x180112b18
cmp r8d, r9d
je 0x180112b1b
inc rax
add rax, rcx
inc rcx
and rax, r10
cmp rcx, r10
jbe 0x180112af1
xor edx, edx
jmp 0x180112b1b
mov dword [rdx], r9d
mov rax, qword [rbx]
lea rcx, [rax + rsi*8]
mov eax, dword [rax + rsi*8]
mov dword [rdx], eax
movzx eax, word [rcx + 4]
mov word [rdx + 4], ax
inc rsi
cmp rsi, qword [rbx + 8]
jb 0x180112aa0
mov r12, qword [rsp + 0x30]
mov rcx, qword [rbx]
mov r15, qword [rsp + 0x20]
mov r14, qword [rsp + 0x28]
mov rdi, qword [rsp + 0x38]
mov rsi, qword [rsp + 0x40]
mov qword [rbx + 8], rbp
mov rbp, qword [rsp + 0x60]
mov qword [rbx], r11
mov rbx, qword [rsp + 0x58]
test rcx, rcx
je 0x180112b77
add rsp, 0x48
jmp fcn.1803141cc
add rsp, 0x48
ret
Function at 0x18013c770
Capabilities:
Encode data using xor

Disassembly:
xor r9b, r9b
mov r10, rdx
test r8, r8
je 0x18013c797
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 0x18013c780
movzx eax, r9b
ret
Function at 0x18013d380
Capabilities:
Encode data using xor

Disassembly:
push rbx
mov eax, 0x20
call fcn.1803146e0
sub rsp, rax
mov rbx, r8
call fcn.18013d5e0
test eax, eax
js 0x18013d5d5
mov eax, dword [rbx + 0xf0]
shl eax, 2
movsxd r9, eax
test eax, eax
jle 0x18013d40d
lea r8, [rbx + 8]
xor r10d, r10d
lea r8, [r8 + r9*4]
lea rax, [rbx + 8]
nop
mov edx, dword [rax - 8]
add r10, 4
mov ecx, dword [r8 - 8]
lea r8, [r8 - 0x10]
mov dword [rax - 8], ecx
lea rax, [rax + 0x10]
mov ecx, dword [r8 + 0xc]
sub r9, 4
mov dword [r8 + 8], edx
mov edx, dword [rax - 0x14]
mov dword [rax - 0x14], ecx
mov ecx, dword [r8 + 0x10]
mov dword [r8 + 0xc], edx
mov edx, dword [rax - 0x10]
mov dword [rax - 0x10], ecx
mov ecx, dword [r8 + 0x14]
mov dword [r8 + 0x10], edx
mov edx, dword [rax - 0xc]
mov dword [rax - 0xc], ecx
mov dword [r8 + 0x14], edx
cmp r10, r9
jl 0x18013d3c0
mov r11d, 1
cmp dword [rbx + 0xf0], r11d
jle 0x18013d5d3
mov qword [rsp + 0x30], rdi
lea r10, [rbx + 4]
lea rdi, [0x180000000]
mov r9d, dword [r10 + 0xc]
lea r10, [r10 + 0x10]
movzx eax, byte [r10 - 3]
inc r11d
movzx edx, byte [rdi + rax*4 + 0x3eddb0]
movzx eax, byte [r10 - 2]
mov r8d, dword [rdi + rdx*4 + 0x3ef1b0]
movzx ecx, byte [rdi + rax*4 + 0x3eddb0]
mov eax, r9d
shr rax, 0x18
xor r8d, dword [rdi + rcx*4 + 0x3eedb0]
movzx ecx, byte [rdi + rax*4 + 0x3eddb0]
movzx eax, r9b
mov r9d, dword [r10]
xor r8d, dword [rdi + rcx*4 + 0x3ee9b0]
movzx ecx, byte [rdi + rax*4 + 0x3eddb0]
mov eax, r9d
shr eax, 0x10
xor r8d, dword [rdi + rcx*4 + 0x3ef5b0]
movzx ecx, al
mov eax, r9d
shr eax, 8
mov dword [r10 - 4], r8d
movzx edx, byte [rdi + rcx*4 + 0x3eddb0]
movzx ecx, al
mov r8d, dword [rdi + rdx*4 + 0x3eedb0]
movzx eax, byte [rdi + rcx*4 + 0x3eddb0]
xor r8d, dword [rdi + rax*4 + 0x3ef1b0]
mov eax, r9d
shr rax, 0x18
movzx ecx, byte [rdi + rax*4 + 0x3eddb0]
movzx eax, r9b
mov r9d, dword [r10 + 4]
xor r8d, dword [rdi + rcx*4 + 0x3ee9b0]
movzx ecx, byte [rdi + rax*4 + 0x3eddb0]
mov eax, r9d
shr eax, 0x10
xor r8d, dword [rdi + rcx*4 + 0x3ef5b0]
movzx ecx, al
mov eax, r9d
shr eax, 8
mov dword [r10], r8d
movzx edx, byte [rdi + rcx*4 + 0x3eddb0]
movzx ecx, al
mov r8d, dword [rdi + rdx*4 + 0x3eedb0]
movzx eax, byte [rdi + rcx*4 + 0x3eddb0]
xor r8d, dword [rdi + rax*4 + 0x3ef1b0]
mov eax, r9d
shr rax, 0x18
movzx ecx, byte [rdi + rax*4 + 0x3eddb0]
movzx eax, r9b
mov r9d, dword [r10 + 8]
xor r8d, dword [rdi + rcx*4 + 0x3ee9b0]
movzx ecx, byte [rdi + rax*4 + 0x3eddb0]
mov eax, r9d
shr eax, 0x10
xor r8d, dword [rdi + rcx*4 + 0x3ef5b0]
movzx ecx, al
mov eax, r9d
shr eax, 8
mov dword [r10 + 4], r8d
movzx edx, byte [rdi + rcx*4 + 0x3eddb0]
movzx ecx, al
mov r8d, dword [rdi + rdx*4 + 0x3eedb0]
movzx eax, byte [rdi + rcx*4 + 0x3eddb0]
xor r8d, dword [rdi + rax*4 + 0x3ef1b0]
mov eax, r9d
shr rax, 0x18
movzx ecx, byte [rdi + rax*4 + 0x3eddb0]
movzx eax, r9b
xor r8d, dword [rdi + rcx*4 + 0x3ee9b0]
movzx ecx, byte [rdi + rax*4 + 0x3eddb0]
xor r8d, dword [rdi + rcx*4 + 0x3ef5b0]
mov dword [r10 + 8], r8d
cmp r11d, dword [rbx + 0xf0]
jl 0x18013d430
mov rdi, qword [rsp + 0x30]
xor eax, eax
add rsp, 0x20
pop rbx
ret
Function at 0x18013e9f0
Capabilities:
Encode data using xor

Disassembly:
mov qword [rsp + 0x20], r9
push rbx
push rbp
push rsi
push rdi
push r12
push r14
mov eax, 0x28
call fcn.1803146e0
sub rsp, rax
mov r14, qword [rsp + 0x90]
mov r10, r9
mov r12, qword [rsp + 0x88]
mov rdi, r8
mov rsi, rdx
mov rbp, rcx
mov ebx, dword [r14]
test ebx, ebx
je 0x18013ea51
nop dword [rax]
test rdi, rdi
je 0x18013ea51
mov eax, ebx
dec rdi
movzx ecx, byte [rax + r12]
xor cl, byte [rbp]
inc rbp
mov byte [rsi], cl
inc rsi
inc ebx
and ebx, 0xf
jne 0x18013ea30
mov r9, qword [rsp + 0x98]
mov rcx, qword [rsp + 0x80]
cmp rdi, 0x10
jb 0x18013eb1e
mov qword [rsp + 0x60], r13
xor ebx, ebx
mov r13, rdi
mov qword [rsp + 0x20], r15
shr r13, 4
mov r14, rsi
imul rax, r13, 0xfffffffffffffff0
mov r15, rbp
mov dword [rsp + 0x70], ebx
mov rbx, qword [rsp + 0x78]
add rdi, rax
mov rax, r13
sub r14, r12
shl rax, 4
sub r15, r12
add rsi, rax
add rbp, rax
mov r8, rbx
mov rdx, r12
call r9
mov rcx, qword [rsp + 0x80]
call fcn.18013ede0
mov edx, 2
mov rcx, r12
nop word [rax + rax]
mov rax, qword [r15 + rcx]
xor rax, qword [rcx]
mov qword [r14 + rcx], rax
lea rcx, [rcx + 8]
sub rdx, 1
jne 0x18013ead0
mov rcx, qword [rsp + 0x80]
add r14, 0x10
mov r9, qword [rsp + 0x98]
add r15, 0x10
sub r13, 1
jne 0x18013eaa7
mov r15, qword [rsp + 0x20]
mov r13, qword [rsp + 0x60]
mov ebx, dword [rsp + 0x70]
mov r14, qword [rsp + 0x90]
mov r10, qword [rsp + 0x78]
test rdi, rdi
je 0x18013eb55
mov r8, r10
mov rdx, r12
call r9
mov rcx, qword [rsp + 0x80]
call fcn.18013ede0
nop dword [rax]
mov ecx, ebx
inc ebx
movzx eax, byte [r12 + rcx]
xor al, byte [rcx + rbp]
mov byte [rsi + rcx], al
sub rdi, 1
jne 0x18013eb40
mov dword [r14], ebx
add rsp, 0x28
pop r14
pop r12
pop rdi
pop rsi
pop rbp
pop rbx
ret
Function at 0x18013eb70
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.1803146e0
sub rsp, rax
mov r10, r9
mov rbx, r8
mov r9, qword [rsp + 0xa0]
mov r14, rdx
mov r15, rcx
mov edi, dword [r9]
mov dword [rsp + 0x80], edi
test edi, edi
je 0x18013ebe8
mov rdx, qword [rsp + 0x98]
nop dword [rax]
test rbx, rbx
je 0x18013ebe1
mov eax, edi
dec rbx
movzx ecx, byte [rax + rdx]
xor cl, byte [r15]
inc r15
mov byte [r14], cl
inc r14
inc edi
and edi, 0xf
jne 0x18013ebc0
mov dword [rsp + 0x80], edi
mov r8, qword [rsp + 0x90]
mov esi, 1
movzx r13d, byte [r8 + 0xc]
lea rbp, [r8 + 0xc]
mov r11, qword [rsp + 0xa8]
shl r13d, 8
movzx eax, byte [r8 + 0xd]
lea r12d, [rsi + 0xb]
or r13d, eax
movzx eax, byte [r8 + 0xe]
shl r13d, 8
or r13d, eax
movzx eax, byte [r8 + 0xf]
shl r13d, 8
or r13d, eax
cmp rbx, 0x10
jb 0x18013ed1e
mov eax, 0x10000000
mov edi, r12d
mov qword [rsp + 0x20], r8
mov rdx, rbx
shr rdx, 4
mov r9, r10
cmp rdx, rax
cmova rdx, rax
mov r12, rdx
lea ecx, [rdx + r13]
mov eax, ecx
sub r12, rax
cmp rax, rdx
cmovae r12, rdx
xor r13d, r13d
cmp rax, rdx
mov r8, r12
mov rdx, r14
cmovae r13d, ecx
mov rcx, r15
call r11
mov r8, qword [rsp + 0x90]
mov eax, r13d
shr eax, 0x18
mov byte [rbp], al
mov eax, r13d
shr eax, 0x10
mov byte [r8 + 0xd], al
mov eax, r13d
shr eax, 8
mov byte [r8 + 0xe], al
mov byte [r8 + 0xf], r13b
test r13d, r13d
jne 0x18013ecdd
mov r8d, edi
mov eax, esi
mov rdx, rbp
nop word [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 0x18013ecc0
mov r8, qword [rsp + 0x90]
mov r10, qword [rsp + 0x88]
mov eax, 0x10000000
mov r11, qword [rsp + 0xa8]
shl r12, 4
sub rbx, r12
add r14, r12
add r15, r12
cmp rbx, 0x10
jae 0x18013ec40
mov edi, dword [rsp + 0x80]
mov r12d, 0xc
mov r9, qword [rsp + 0xa0]
test rbx, rbx
je 0x18013edc2
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 r13d
mov eax, r13d
shr eax, 0x18
mov byte [rbp], 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 0x18013ed97
nop dword [rax + rax]
movzx eax, byte [rbp - 1]
lea rbp, [rbp - 1]
add esi, eax
mov byte [rbp], sil
shr esi, 8
add r12d, 0xffffffff
jne 0x18013ed80
mov rdx, qword [rsp + 0x98]
nop
mov ecx, edi
inc edi
movzx eax, byte [r15 + rcx]
xor al, byte [rcx + rdx]
mov byte [r14 + rcx], al
sub rbx, 1
jne 0x18013eda0
mov rax, qword [rsp + 0xa0]
mov dword [rax], edi
jmp 0x18013edc5
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 0x18013eea0
Capabilities:
Encode data using xor

Disassembly:
mov qword [rsp + 0x20], r9
push rbx
push rbp
push rsi
push rdi
push r12
push r15
mov eax, 0x28
call fcn.1803146e0
sub rsp, rax
mov rsi, qword [rsp + 0x88]
mov r10, r9
mov r15, qword [rsp + 0x80]
mov rdi, r8
mov rbp, rdx
mov r12, rcx
mov ebx, dword [rsi]
test ebx, ebx
jns 0x18013eeef
mov dword [rsi], 0xffffffff
add rsp, 0x28
pop r15
pop r12
pop rdi
pop rsi
pop rbp
pop rbx
ret
je 0x18013ef14
test rdi, rdi
je 0x18013ef14
mov eax, ebx
dec rdi
movzx ecx, byte [rax + r15]
xor cl, byte [r12]
inc r12
mov byte [rbp], cl
inc rbp
inc ebx
and ebx, 0xf
jne 0x18013eef1
mov r9, qword [rsp + 0x90]
cmp rdi, 0x10
jb 0x18013efd9
mov qword [rsp + 0x60], r13
mov rsi, rbp
mov r13, rdi
mov qword [rsp + 0x20], r14
shr r13, 4
mov r14, r12
imul rax, r13, 0xfffffffffffffff0
sub rsi, r15
sub r14, r15
add rdi, rax
mov rax, r13
shl rax, 4
add rbp, rax
mov qword [rsp + 0x68], rbp
add r12, rax
mov rbp, qword [rsp + 0x78]
mov r8, rbp
mov rdx, r15
mov rcx, r15
call r9
cmp ebx, 0x10
jae 0x18013efa5
mov edx, 0xf
mov ecx, ebx
sub edx, ebx
add rcx, r15
shr edx, 3
inc edx
nop dword [rax]
nop word [rax + rax]
mov rax, qword [r14 + rcx]
xor rax, qword [rcx]
mov qword [rsi + rcx], rax
lea rcx, [rcx + 8]
sub rdx, 1
jne 0x18013ef90
mov r9, qword [rsp + 0x90]
add rsi, 0x10
add r14, 0x10
xor ebx, ebx
sub r13, 1
jne 0x18013ef61
mov r14, qword [rsp + 0x20]
mov r13, qword [rsp + 0x60]
mov rbp, qword [rsp + 0x68]
mov rsi, qword [rsp + 0x88]
mov r10, qword [rsp + 0x78]
test rdi, rdi
je 0x18013f006
mov r8, r10
mov rdx, r15
mov rcx, r15
call r9
nop word [rax + rax]
mov ecx, ebx
inc ebx
movzx eax, byte [r15 + rcx]
xor al, byte [rcx + r12]
mov byte [rcx + rbp], al
sub rdi, 1
jne 0x18013eff0
mov dword [rsi], ebx
add rsp, 0x28
pop r15
pop r12
pop rdi
pop rsi
pop rbp
pop rbx
ret
Function at 0x18013f9f0
Capabilities:
Encode data using xor

Disassembly:
push rbx
push rbp
push r14
mov eax, 0x20
call fcn.1803146e0
sub rsp, rax
cmp qword [rcx + 0x38], 0
mov rbx, r8
mov r14, rdx
mov rbp, rcx
je 0x18013fa20
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 0x18013fb12
cmp rcx, rbx
jb 0x18013fb12
mov qword [rsp + 0x40], rsi
mov esi, dword [rbp + 0x17c]
mov qword [rsp + 0x48], rdi
mov qword [rsp + 0x50], r12
mov qword [rbp + 0x30], rcx
test esi, esi
je 0x18013fa96
test rbx, rbx
je 0x18013faf2
movzx eax, byte [r14]
dec rbx
mov ecx, esi
inc r14
xor byte [rcx + rbp + 0x40], al
inc esi
and esi, 0xf
jne 0x18013fa60
lea r12, [rbp + 0x60]
lea rdi, [rbp + 0x40]
mov rdx, r12
mov rcx, rdi
call qword [rbp + 0x170]
jmp 0x18013fa9e
lea r12, [rbp + 0x60]
lea rdi, [rbp + 0x40]
mov qword [rsp + 0x58], r15
mov r15, rbx
and r15, 0xfffffffffffffff0
je 0x18013fac4
mov r9, r15
mov r8, r14
mov rdx, r12
mov rcx, rdi
call qword [rbp + 0x168]
add r14, r15
sub rbx, r15
mov r15, qword [rsp + 0x58]
test rbx, rbx
je 0x18013faf2
mov esi, ebx
sub r14, rbp
nop dword [rax]
nop word [rax + rax]
movzx eax, byte [rdi + r14 - 0x40]
xor byte [rdi], al
lea rdi, [rdi + 1]
sub rbx, 1
jne 0x18013fae0
mov rdi, qword [rsp + 0x48]
xor eax, eax
mov r12, qword [rsp + 0x50]
mov dword [rbp + 0x17c], 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 0x180140e30
Capabilities:
Encode data using xor

Disassembly:
push rbx
push rsi
push rdi
push r13
push r14
mov eax, 0x20
call fcn.1803146e0
sub rsp, rax
xor r13d, r13d
lea r14, [rcx + 0x40]
mov qword [rcx + 0x30], r13
mov rsi, r8
mov qword [rcx + 0x38], r13
mov rdi, rdx
mov qword [rcx + 0x178], r13
mov rbx, rcx
cmp r8, 0xc
jne 0x180140e88
movsd xmm0, qword [rdx]
lea edi, [r8 - 0xb]
movsd qword [rcx], xmm0
mov eax, dword [rdx + 8]
mov dword [rcx + 8], eax
mov dword [rcx + 0xc], 0x1000000
jmp 0x18014100e
mov qword [rsp + 0x58], r12
mov r12, rsi
mov qword [rsp + 0x60], r15
lea r15, [rcx + 0x60]
mov qword [r14], r13
mov qword [rcx + 0x48], r13
cmp rsi, 0x10
jb 0x180140f4e
mov qword [rsp + 0x50], rbp
mov rbp, rsi
shr rbp, 4
imul rax, rbp, 0xfffffffffffffff0
add rsi, rax
nop dword [rax]
movzx eax, byte [rdi]
mov rdx, r15
xor byte [r14], al
mov rcx, r14
movzx eax, byte [rdi + 1]
xor byte [rbx + 0x41], al
movzx eax, byte [rdi + 2]
xor byte [rbx + 0x42], al
movzx eax, byte [rdi + 3]
xor byte [rbx + 0x43], al
movzx eax, byte [rdi + 4]
xor byte [rbx + 0x44], al
movzx eax, byte [rdi + 5]
xor byte [rbx + 0x45], al
movzx eax, byte [rdi + 6]
xor byte [rbx + 0x46], al
movzx eax, byte [rdi + 7]
xor byte [rbx + 0x47], al
movzx eax, byte [rdi + 8]
xor byte [rbx + 0x48], al
movzx eax, byte [rdi + 9]
xor byte [rbx + 0x49], al
movzx eax, byte [rdi + 0xa]
xor byte [rbx + 0x4a], al
movzx eax, byte [rdi + 0xb]
xor byte [rbx + 0x4b], al
movzx eax, byte [rdi + 0xc]
xor byte [rbx + 0x4c], al
movzx eax, byte [rdi + 0xd]
xor byte [rbx + 0x4d], al
movzx eax, byte [rdi + 0xe]
xor byte [rbx + 0x4e], al
movzx eax, byte [rdi + 0xf]
xor byte [rbx + 0x4f], al
call qword [rbx + 0x170]
add rdi, 0x10
sub rbp, 1
jne 0x180140ec0
mov rbp, qword [rsp + 0x50]
test rsi, rsi
je 0x180140f7d
mov rcx, r14
sub rdi, rbx
nop dword [rax]
movzx eax, byte [rdi + rcx - 0x40]
xor byte [rcx], al
lea rcx, [rcx + 1]
sub rsi, 1
jne 0x180140f60
mov rdx, r15
mov rcx, r14
call qword [rbx + 0x170]
shl r12, 3
mov rdx, r15
xor byte [rbx + 0x4f], r12b
mov rax, r12
shr rax, 0x38
mov rcx, r14
xor byte [rbx + 0x48], al
mov rax, r12
shr rax, 0x30
xor byte [rbx + 0x49], al
mov rax, r12
shr rax, 0x28
xor byte [rbx + 0x4a], al
mov rax, r12
shr rax, 0x20
xor byte [rbx + 0x4b], al
mov rax, r12
shr rax, 0x18
xor byte [rbx + 0x4c], al
mov rax, r12
shr rax, 0x10
xor byte [rbx + 0x4d], al
mov rax, r12
shr rax, 8
xor byte [rbx + 0x4e], al
call qword [rbx + 0x170]
movzx eax, byte [rbx + 0x4d]
movzx edi, byte [rbx + 0x4c]
mov r15, qword [rsp + 0x60]
mov r12, qword [rsp + 0x58]
shl edi, 8
or edi, eax
movzx eax, byte [rbx + 0x4e]
shl edi, 8
or edi, eax
movzx eax, byte [rbx + 0x4f]
shl edi, 8
or edi, eax
mov rax, qword [r14]
mov qword [rbx], rax
mov rax, qword [rbx + 0x48]
mov qword [rbx + 8], rax
mov qword [r14], r13
lea rdx, [rbx + 0x20]
mov qword [rbx + 0x48], r13
mov rcx, rbx
mov r8, qword [rbx + 0x188]
call qword [rbx + 0x180]
inc edi
mov eax, edi
mov byte [rbx + 0xf], dil
shr eax, 0x18
mov byte [rbx + 0xc], al
mov eax, edi
shr eax, 0x10
mov byte [rbx + 0xd], al
mov eax, edi
shr eax, 8
mov byte [rbx + 0xe], al
add rsp, 0x20
pop r14
pop r13
pop rdi
pop rsi
pop rbx
ret
Function at 0x1801410c0
Capabilities:
Encode data using add xor sub operations

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rbp
mov qword [rsp + 0x18], rsi
mov qword [rsp + 0x20], rdi
push r12
push r14
push r15
mov rbx, rcx
lea rbp, [r8 + 0xe]
sub rbx, r8
lea r12, [0x1803efaf0]
mov r15, r9
mov rsi, rdx
mov r11, rcx
movzx eax, byte [r11 + 0xf]
mov rdi, rbp
movzx ecx, byte [rbp + 1]
mov r14d, 0xf
xor rcx, rax
mov rax, rcx
and rcx, 0xfffffffffffffff0
and eax, 0xf
lea rdx, [rcx + rsi]
add rax, rax
mov r10, qword [rsi + rax*8 + 8]
mov r8, qword [rsi + rax*8]
mov rcx, r10
and ecx, 0xf
shr r10, 4
mov rax, r8
shl r8, 0x3c
shr rax, 4
or r10, r8
xor rax, qword [r12 + rcx*8]
xor rax, qword [rdx]
xor r10, qword [rdx + 8]
nop word [rax + rax]
movzx ecx, byte [rdi]
mov r9, rax
movzx r8d, byte [rdi + rbx]
lea rdi, [rdi - 1]
xor r8, rcx
shl rax, 0x3c
mov rcx, r10
shr r9, 4
shr r10, 4
and ecx, 0xf
or rax, r10
mov rdx, r8
and edx, 0xf
and r8, 0xfffffffffffffff0
add rdx, rdx
xor r9, qword [r12 + rcx*8]
xor rax, qword [rsi + rdx*8 + 8]
xor r9, qword [rsi + rdx*8]
mov rcx, rax
mov rdx, rax
and ecx, 0xf
shr rdx, 4
mov rax, r9
shr rax, 4
mov r10, r9
shl r10, 0x3c
xor rax, qword [r12 + rcx*8]
or r10, rdx
xor rax, qword [r8 + rsi]
xor r10, qword [r8 + rsi + 8]
sub r14, 1
jne 0x180141150
mov rdx, rax
mov byte [r11 + 7], al
shr rdx, 0x20
add rbp, 0x10
mov ecx, edx
mov byte [r11 + 3], dl
shr ecx, 0x18
sub rbx, 0x10
mov byte [r11], cl
mov ecx, edx
shr ecx, 0x10
mov byte [r11 + 1], cl
mov ecx, edx
shr ecx, 8
mov byte [r11 + 2], cl
mov ecx, eax
shr ecx, 0x18
mov byte [r11 + 4], cl
mov ecx, eax
shr ecx, 0x10
mov byte [r11 + 5], cl
mov ecx, eax
shr ecx, 8
mov byte [r11 + 6], cl
mov rcx, r10
shr rcx, 0x20
mov eax, ecx
mov byte [r11 + 0xb], cl
shr eax, 0x18
mov byte [r11 + 8], al
mov eax, ecx
shr eax, 0x10
mov byte [r11 + 9], al
mov eax, ecx
shr eax, 8
mov byte [r11 + 0xa], al
mov eax, r10d
shr eax, 0x18
mov byte [r11 + 0xc], al
mov eax, r10d
shr eax, 0x10
mov byte [r11 + 0xd], al
mov eax, r10d
shr eax, 8
mov byte [r11 + 0xe], al
mov byte [r11 + 0xf], r10b
sub r15, 0x10
jne 0x1801410f4
mov rbx, qword [rsp + 0x20]
mov rbp, qword [rsp + 0x28]
mov rsi, qword [rsp + 0x30]
mov rdi, qword [rsp + 0x38]
pop r15
pop r14
pop r12
ret
mov eax, 0x28
call fcn.1803146e0
sub rsp, rax
add rsp, 0x28
jmp 0x1801410c0