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

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rsi
push rdi
sub rsp, 0x30
mov rdi, rcx
mov rbx, r8
mov rcx, rdx
mov rsi, rdx
call fcn.1400d6bf0
mov rcx, qword [rdi + 0x10]
test rcx, rcx
je 0x1401f1112
add rcx, 0xc8
mov r9b, 1
mov qword [rsp + 0x20], rbx
mov r8, rsi
xor edx, edx
call fcn.14015c030
mov rbx, qword [rsp + 0x40]
mov rsi, qword [rsp + 0x48]
add rsp, 0x30
pop rdi
ret
mov rcx, qword [rdi + 0x18]
test rcx, rcx
je 0x1401f1132
mov rdx, rsi
mov rbx, qword [rsp + 0x40]
mov rsi, qword [rsp + 0x48]
add rsp, 0x30
pop rdi
jmp fcn.1401ffb90
mov rcx, qword [rdi + 0x20]
test rcx, rcx
je 0x1401f116b
add rcx, 0x550
mov qword [rsp + 0x20], rbx
mov r9b, 1
mov r8, rsi
xor edx, edx
call fcn.14015c030
mov dl, 0x2c
mov rcx, rsi
call fcn.1400d4b00
mov rcx, qword [rdi + 0x20]
add rcx, 0x570
jmp 0x1401f10f0
mov rcx, qword [rdi + 0x28]
test rcx, rcx
je 0x1401f11ae
add rcx, 0xa0
call fcn.1400e6840
mov rcx, qword [rdi + 0x28]
mov ebx, eax
add rcx, 0xa0
call fcn.1400e6510
mov rcx, rax
mov r8, rsi
mov edx, ebx
mov rbx, qword [rsp + 0x40]
mov rsi, qword [rsp + 0x48]
add rsp, 0x30
pop rdi
jmp fcn.1400f32e0
mov rbx, qword [rsp + 0x40]
xor al, al
mov rsi, qword [rsp + 0x48]
add rsp, 0x30
pop rdi
ret
Function at 0x14022eaa0
Capabilities:
Encrypt data using curve25519

Disassembly:
mov qword [rsp + 0x10], rbx
push rbp
lea rbp, [rsp - 0xd0]
sub rsp, 0x1d0
mov rax, qword [0x1403dd7c0]
xor rax, rsp
mov qword [rbp + 0xc0], rax
movups xmm0, xmmword [rdx]
mov rbx, rcx
mov ecx, 2
movups xmm1, xmmword [rdx + 0x10]
movd eax, xmm0
movups xmmword [rbp + 0xb0], xmm1
and al, 0xf8
psrldq xmm1, 0xf
movups xmmword [rbp + 0xa0], xmm0
mov byte [rbp + 0xa0], al
movd eax, xmm1
and al, 0x3f
or al, 0x40
mov byte [rbp + 0xbf], al
add r8, 8
lea rax, [rsp + 0x40]
nop dword [rax + rax]
movd xmm1, dword [r8 - 8]
xorps xmm0, xmm0
movd xmm2, dword [r8 - 4]
lea rax, [rax + 0x40]
punpcklbw xmm1, xmm0
lea r8, [r8 + 0x10]
punpcklbw xmm2, xmm0
punpcklwd xmm1, xmm0
punpcklwd xmm2, xmm0
movdqu xmmword [rax - 0x60], xmm1
movd xmm1, dword [r8 - 0x10]
punpcklbw xmm1, xmm0
punpcklwd xmm1, xmm0
movdqu xmmword [rax - 0x50], xmm2
movd xmm2, dword [r8 - 0xc]
punpcklbw xmm2, xmm0
punpcklwd xmm2, xmm0
movdqu xmmword [rax - 0x40], xmm1
movdqu xmmword [rax - 0x30], xmm2
sub rcx, 1
jne 0x14022eb10
lea rdx, [rbp + 0xa0]
lea rcx, [rsp + 0x20]
call fcn.14022ecc0
lea rdx, [rbp - 0x60]
lea rcx, [rbp - 0x60]
call fcn.14022e6f0
lea r8, [rbp - 0x60]
lea rdx, [rsp + 0x20]
lea rcx, [rbp + 0x20]
call fcn.14022dc10
lea rcx, [rbp + 0x20]
call fcn.14022d810
movzx eax, byte [rbp + 0x20]
mov byte [rbx], al
movzx eax, byte [rbp + 0x24]
mov byte [rbx + 1], al
movzx eax, byte [rbp + 0x28]
mov byte [rbx + 2], al
movzx eax, byte [rbp + 0x2c]
mov byte [rbx + 3], al
movzx eax, byte [rbp + 0x30]
mov byte [rbx + 4], al
movzx eax, byte [rbp + 0x34]
mov byte [rbx + 5], al
movzx eax, byte [rbp + 0x38]
mov byte [rbx + 6], al
movzx eax, byte [rbp + 0x3c]
mov byte [rbx + 7], al
movzx eax, byte [rbp + 0x40]
mov byte [rbx + 8], al
movzx eax, byte [rbp + 0x44]
mov byte [rbx + 9], al
movzx eax, byte [rbp + 0x48]
mov byte [rbx + 0xa], al
movzx eax, byte [rbp + 0x4c]
mov byte [rbx + 0xb], al
movzx eax, byte [rbp + 0x50]
mov byte [rbx + 0xc], al
movzx eax, byte [rbp + 0x54]
mov byte [rbx + 0xd], al
movzx eax, byte [rbp + 0x58]
mov byte [rbx + 0xe], al
movzx eax, byte [rbp + 0x5c]
mov byte [rbx + 0xf], al
movzx eax, byte [rbp + 0x60]
mov byte [rbx + 0x10], al
movzx eax, byte [rbp + 0x64]
mov byte [rbx + 0x11], al
movzx eax, byte [rbp + 0x68]
mov byte [rbx + 0x12], al
movzx eax, byte [rbp + 0x6c]
mov byte [rbx + 0x13], al
movzx eax, byte [rbp + 0x70]
mov byte [rbx + 0x14], al
movzx eax, byte [rbp + 0x74]
mov byte [rbx + 0x15], al
movzx eax, byte [rbp + 0x78]
mov byte [rbx + 0x16], al
movzx eax, byte [rbp + 0x7c]
mov byte [rbx + 0x17], al
movzx eax, byte [rbp + 0x80]
mov byte [rbx + 0x18], al
movzx eax, byte [rbp + 0x84]
mov byte [rbx + 0x19], al
movzx eax, byte [rbp + 0x88]
mov byte [rbx + 0x1a], al
movzx eax, byte [rbp + 0x8c]
mov byte [rbx + 0x1b], al
movzx eax, byte [rbp + 0x90]
mov byte [rbx + 0x1c], al
movzx eax, byte [rbp + 0x94]
mov byte [rbx + 0x1d], al
movzx eax, byte [rbp + 0x98]
mov byte [rbx + 0x1e], al
movzx eax, byte [rbp + 0x9c]
mov byte [rbx + 0x1f], al
xor eax, eax
mov rcx, qword [rbp + 0xc0]
xor rcx, rsp
call fcn.140278f40
mov rbx, qword [rsp + 0x1e8]
add rsp, 0x1d0
pop rbp
ret
Function at 0x140230e80
Capabilities:
Encode data using xor

Disassembly:
mov r9, rdx
movzx r10d, r8b
neg r10d
lea rdx, [rcx + 0x7c]
lea rax, [r9 + 0x7c]
movd xmm2, r10d
pshufd xmm2, xmm2, 0
cmp rcx, rax
ja 0x140230ec7
cmp rdx, r9
jb 0x140230ec7
sub r9, rcx
mov r8d, 0x20
nop
mov edx, dword [rcx]
xor edx, dword [rcx + r9]
lea rcx, [rcx + 4]
and edx, r10d
xor dword [rcx - 4], edx
sub r8, 1
jne 0x140230eb0
ret
lea rax, [rcx + 0x10]
sub r9, rcx
mov ecx, 4
nop dword [rax]
nop word [rax + rax]
movdqu xmm0, xmmword [rax - 0x10]
movdqu xmm1, xmmword [r9 + rax - 0x10]
lea rax, [rax + 0x20]
pxor xmm1, xmm0
pand xmm1, xmm2
pxor xmm1, xmm0
movdqu xmmword [rax - 0x30], xmm1
movdqu xmm0, xmmword [rax - 0x20]
movdqu xmm1, xmmword [r9 + rax - 0x20]
pxor xmm1, xmm0
pand xmm1, xmm2
pxor xmm1, xmm0
movdqu xmmword [rax - 0x20], xmm1
sub rcx, 1
jne 0x140230ee0
ret
Function at 0x140233970
Capabilities:
Encrypt data using curve25519

Disassembly:
push rbx
sub rsp, 0x2f0
mov rax, qword [0x1403dd7c0]
xor rax, rsp
mov qword [rsp + 0x2e0], rax
mov rbx, rdx
test rcx, rcx
je 0x140233ace
test rdx, rdx
je 0x140233ace
test r8, r8
je 0x140233ace
movups xmm0, xmmword [rcx]
mov edx, 0x20
movups xmmword [r8], xmm0
movups xmm1, xmmword [rcx + 0x10]
movups xmmword [r8 + 0x10], xmm1
lea r8, [rsp + 0x2a0]
call fcn.1401b2260
movzx eax, byte [rsp + 0x2bf]
and byte [rsp + 0x2a0], 0xf8
and al, 0x3f
or al, 0x40
mov byte [rsp + 0x2bf], al
xor ecx, ecx
lea rax, [rsp + 0x40]
nop dword [rax]
movd xmm1, dword [rsp + rcx + 0x2a0]
lea rax, [rax + 0x40]
movd xmm2, dword [rsp + rcx + 0x2a4]
xorps xmm0, xmm0
punpcklbw xmm1, xmm0
punpcklbw xmm2, xmm0
punpcklwd xmm1, xmm0
movdqu xmmword [rax - 0x60], xmm1
movd xmm1, dword [rsp + rcx + 0x2a8]
punpcklwd xmm2, xmm0
movdqu xmmword [rax - 0x50], xmm2
movd xmm2, dword [rsp + rcx + 0x2ac]
add rcx, 0x10
punpcklbw xmm1, xmm0
punpcklbw xmm2, xmm0
punpcklwd xmm1, xmm0
punpcklwd xmm2, xmm0
movdqu xmmword [rax - 0x40], xmm1
movdqu xmmword [rax - 0x30], xmm2
cmp rcx, 0x20
jl 0x1402339f0
lea rdx, [rsp + 0x20]
lea rcx, [rsp + 0x220]
movups xmmword [rsp + 0xa0], xmm0
movups xmmword [rsp + 0xb0], xmm0
movups xmmword [rsp + 0xc0], xmm0
movups xmmword [rsp + 0xd0], xmm0
movups xmmword [rsp + 0xe0], xmm0
movups xmmword [rsp + 0xf0], xmm0
movups xmmword [rsp + 0x100], xmm0
movups xmmword [rsp + 0x110], xmm0
call fcn.14022f580
lea rdx, [rsp + 0x220]
lea rcx, [rsp + 0x20]
call fcn.140233250
lea rdx, [rsp + 0x20]
mov rcx, rbx
call fcn.140233020
mov al, 1
jmp 0x140233ad0
xor al, al
mov rcx, qword [rsp + 0x2e0]
xor rcx, rsp
call fcn.140278f40
add rsp, 0x2f0
pop rbx
ret
Function at 0x1402394b0
Capabilities:
Encode data using xor

Disassembly:
mov qword [rsp + 8], rbx
push rdi
mov r11, rdx
mov edi, r9d
mov r9d, dword [rsp + 0x30]
xor edx, edx
mov eax, r9d
mov rbx, r8
shr eax, 8
mov r8d, edi
movzx r10d, al
movzx eax, r9b
shl eax, 8
or r10d, eax
mov qword [r11 + 0x30], rdx
shl r10d, 8
mov eax, r9d
shr eax, 0x10
movzx ecx, al
or r10d, ecx
shr r9d, 0x18
shl r10d, 8
mov rcx, r11
or r10d, r9d
mov dword [r11 + 0x38], edx
mov qword [r11 + 0xb8], rdx
mov rdx, rbx
mov dword [r11 + 0x3c], r10d
mov dword [r11 + 0xc0], r10d
mov dword [r11 + 0x40], 0x40
mov dword [r11 + 0xc4], 0x40
mov dword [r11 + 0xb4], 1
mov rbx, qword [rsp + 0x10]
pop rdi
jmp fcn.1402390e0
Function at 0x140239550
Capabilities:
Encrypt data using salsa20 or chacha

Disassembly:
mov r10, rcx
mov r9, qword [str.expand_32_byte_k]
movzx eax, byte [r9 + 2]
movzx r8d, byte [r9 + 3]
shl r8d, 8
or r8d, eax
movzx eax, byte [r9 + 1]
shl r8d, 8
or r8d, eax
movzx eax, byte [r9]
shl r8d, 8
or r8d, eax
mov dword [rcx], r8d
movzx eax, byte [r9 + 6]
movzx ecx, byte [r9 + 7]
shl ecx, 8
or ecx, eax
movzx eax, byte [r9 + 5]
shl ecx, 8
or ecx, eax
movzx eax, byte [r9 + 4]
shl ecx, 8
or ecx, eax
mov dword [r10 + 4], ecx
movzx eax, byte [r9 + 0xa]
movzx ecx, byte [r9 + 0xb]
shl ecx, 8
or ecx, eax
movzx eax, byte [r9 + 9]
shl ecx, 8
or ecx, eax
movzx eax, byte [r9 + 8]
shl ecx, 8
or ecx, eax
mov dword [r10 + 8], ecx
movzx eax, byte [r9 + 0xe]
movzx ecx, byte [r9 + 0xf]
shl ecx, 8
or ecx, eax
movzx eax, byte [r9 + 0xd]
shl ecx, 8
or ecx, eax
movzx eax, byte [r9 + 0xc]
shl ecx, 8
or ecx, eax
mov dword [r10 + 0xc], ecx
movzx eax, byte [rdx + 2]
movzx ecx, byte [rdx + 3]
shl ecx, 8
or ecx, eax
movzx eax, byte [rdx + 1]
shl ecx, 8
or ecx, eax
movzx eax, byte [rdx]
shl ecx, 8
or ecx, eax
mov dword [r10 + 0x10], ecx
movzx eax, byte [rdx + 6]
movzx ecx, byte [rdx + 7]
shl ecx, 8
or ecx, eax
movzx eax, byte [rdx + 5]
shl ecx, 8
or ecx, eax
movzx eax, byte [rdx + 4]
shl ecx, 8
or ecx, eax
mov dword [r10 + 0x14], ecx
movzx eax, byte [rdx + 0xa]
movzx ecx, byte [rdx + 0xb]
shl ecx, 8
or ecx, eax
movzx eax, byte [rdx + 9]
shl ecx, 8
or ecx, eax
movzx eax, byte [rdx + 8]
shl ecx, 8
or ecx, eax
mov dword [r10 + 0x18], ecx
movzx ecx, byte [rdx + 0xf]
shl ecx, 8
movzx eax, byte [rdx + 0xe]
or ecx, eax
movzx eax, byte [rdx + 0xd]
shl ecx, 8
or ecx, eax
movzx eax, byte [rdx + 0xc]
shl ecx, 8
or ecx, eax
mov dword [r10 + 0x1c], ecx
movzx eax, byte [rdx + 0x12]
movzx ecx, byte [rdx + 0x13]
shl ecx, 8
or ecx, eax
movzx eax, byte [rdx + 0x11]
shl ecx, 8
or ecx, eax
movzx eax, byte [rdx + 0x10]
shl ecx, 8
or ecx, eax
mov dword [r10 + 0x20], ecx
movzx eax, byte [rdx + 0x16]
movzx ecx, byte [rdx + 0x17]
shl ecx, 8
or ecx, eax
movzx eax, byte [rdx + 0x15]
shl ecx, 8
or ecx, eax
movzx eax, byte [rdx + 0x14]
shl ecx, 8
or ecx, eax
mov dword [r10 + 0x24], ecx
movzx eax, byte [rdx + 0x1a]
movzx ecx, byte [rdx + 0x1b]
shl ecx, 8
or ecx, eax
movzx eax, byte [rdx + 0x19]
shl ecx, 8
or ecx, eax
movzx eax, byte [rdx + 0x18]
shl ecx, 8
or ecx, eax
mov dword [r10 + 0x28], ecx
movzx eax, byte [rdx + 0x1e]
movzx ecx, byte [rdx + 0x1f]
shl ecx, 8
or ecx, eax
movzx eax, byte [rdx + 0x1d]
shl ecx, 8
or ecx, eax
movzx eax, byte [rdx + 0x1c]
shl ecx, 8
or ecx, eax
mov dword [r10 + 0x40], 0x40
mov dword [r10 + 0x2c], ecx
ret
Function at 0x1402421b0
Capabilities:
Check for time delay via gettickcount

Disassembly:
push rbx
push rbp
push rsi
push rdi
push r14
sub rsp, 0x40
mov rax, qword [0x1403dd7c0]
xor rax, rsp
mov qword [rsp + 0x38], rax
mov rsi, r9
movzx ebp, r8b
mov rbx, rdx
mov r14, rcx
mov rdi, qword [rsp + 0x90]
xorps xmm0, xmm0
xor eax, eax
movups xmmword [rsp + 0x20], xmm0
mov qword [rsp + 0x30], rax
movzx r9d, byte [rdx + 0x38]
lea r8, str.readExpectedMessage
mov rdx, rdi
lea rcx, [rsp + 0x20]
call fcn.1400f65b0
nop
cmp byte [rbx + 0x38], 0
je 0x140242225
cmp qword [rbx + 0x40], 0
jne 0x140242225
mov rax, qword [rdi]
lea rdx, str.No_m_pHandler.
mov rcx, rdi
call qword [rax + 0x28]
mov dword [rbx + 0x58], 0
cmp dword [rbx + 8], 0
jne 0x140242240
call sub.KERNEL32.dll_GetTickCount
mov dword [rbx + 8], eax
nop word [rax + rax]
mov eax, dword [rbx + 0x14]
cmp eax, 5
jne 0x140242270
cmp dword [0x14047ac50], 0xa
jge 0x140242267
mov rax, qword [rdi]
lea rdx, str.sshRp.m_totalTimeoutMs_wf_is_too_small__2_
mov rcx, rdi
call qword [rax + 0x28]
inc dword [0x14047ac50]
mov dword [rbx + 0x14], 0x7530
jmp 0x140242274
test eax, eax
je 0x1402422a5
cmp dword [rbx + 8], 0
jne 0x140242282
call sub.KERNEL32.dll_GetTickCount
mov dword [rbx + 8], eax
cmp dword [rbx + 0x14], 0x3e8
jae 0x140242292
mov dword [rbx + 0x14], 0x7530
call sub.KERNEL32.dll_GetTickCount
mov ecx, dword [rbx + 8]
cmp eax, ecx
jbe 0x1402422a5
sub eax, ecx
cmp eax, dword [rbx + 0x14]
ja 0x1402422d9
mov r9, rdi
mov r8, rsi
mov rdx, rbx
mov rcx, r14
call fcn.140245d20
test al, al
je 0x140242311
mov rcx, rsi
call fcn.14011eb90
test al, al
jne 0x140242311
test bpl, bpl
je 0x1402422d5
cmp dword [rbx + 0x58], 0x5d
je 0x140242240
mov bl, 1
jmp 0x140242313
mov rcx, rsi
call fcn.14011ec10
mov byte [rsi + 0x28], 1
cmp byte [rdi + 0x169], 0
je 0x140242311
mov rax, qword [rdi]
lea rdx, str.Too_much_time_elapsed_waiting_for_response.
mov rcx, rdi
call qword [rax + 0x28]
mov r8d, dword [rbx + 0x14]
lea rdx, str.totalTimeoutMs
mov rcx, rdi
call fcn.1400f6d60
xor bl, bl
lea rcx, [rsp + 0x20]
call fcn.1400f6680
movzx eax, bl
mov rcx, qword [rsp + 0x38]
xor rcx, rsp
call fcn.140278f40
add rsp, 0x40
pop r14
pop rdi
pop rsi
pop rbp
pop rbx
ret
Function at 0x140246300
Capabilities:
Check for time delay via gettickcount

Disassembly:
mov qword [rsp + 8], rbx
push rdi
sub rsp, 0x20
cmp dword [rdx + 0x14], 0
mov rdi, r8
mov rbx, rdx
je 0x140246360
cmp dword [rdx + 8], 0
jne 0x140246324
call sub.KERNEL32.dll_GetTickCount
mov dword [rbx + 8], eax
cmp dword [rbx + 0x14], 0x3e8
jae 0x140246334
mov dword [rbx + 0x14], 0x7530
call sub.KERNEL32.dll_GetTickCount
mov ecx, dword [rbx + 8]
cmp eax, ecx
jbe 0x140246360
sub eax, ecx
cmp eax, dword [rbx + 0x14]
jbe 0x140246360
mov rcx, rdi
call fcn.14011ec10
mov al, 1
mov byte [rdi + 0x28], 1
mov rbx, qword [rsp + 0x30]
add rsp, 0x20
pop rdi
ret
mov rbx, qword [rsp + 0x30]
xor al, al
add rsp, 0x20
pop rdi
ret
Function at 0x14025a0a0
Capabilities:
Encode data using xor

Disassembly:
mov qword [rsp + 8], rbx
push rbp
push rsi
push rdi
push r14
push r15
sub rsp, 0x1b0
mov rax, qword [0x1403dd7c0]
xor rax, rsp
mov qword [rsp + 0x1a0], rax
mov rdi, r9
mov rbx, r8
mov rsi, qword [rsp + 0x200]
xor edx, edx
mov r8d, 0x178
lea rcx, [rsp + 0x20]
call sub.VCRUNTIME140.dll_memset
lea rcx, [rsp + 0x20]
call fcn.1400f8050
nop
lea r14, [rdi + 0x48]
lea rcx, [rdi + 0x50]
call fcn.1400e6840
test eax, eax
jne 0x14025a117
xor edx, edx
lea r8d, [rax + 0x10]
lea rcx, [rdi + 0x50]
call fcn.1400e2640
mov dword [r14], reloc.WS2_32.dll_inet_ntoa
cmp dword [rbx + 0x554], 0
je 0x14025a12c
lea rdx, str.Not_in_IV_mode.
jmp 0x14025a2ef
mov ecx, dword [rbx + 0x558]
cmp ecx, 0xf
ja 0x14025a2e8
mov edx, dword [r14]
add edx, ecx
cmp edx, 0xc
jbe 0x14025a14c
or dword [rbx + 0x550], 1
lea rcx, [rdi + 0x50]
call fcn.1400e6510
mov rsi, rax
xor r15d, r15d
mov edi, r15d
cmp dword [rbx + 0x558], r15d
jne 0x14025a1b9
test dword [r14], 0xfffffff0
jbe 0x14025a1b4
mov eax, edi
mov rcx, qword [rax + rsi]
xor qword [rbx + 0x510], rcx
lea eax, [rdi + 8]
mov rax, qword [rax + rsi]
xor qword [rbx + 0x518], rax
lea r8, [rsp + 0x20]
lea rdx, [rbx + 0x510]
mov rcx, rbx
call fcn.14025ba90
sub qword [rbx + 0x560], 0xffffffffffffff80
add edi, 0x10
mov eax, dword [r14]
and eax, 0xfffffff0
cmp edi, eax
jb 0x14025a170
mov eax, edi
add rsi, rax
cmp edi, dword [r14]
jae 0x14025a2e4
movsxd rcx, dword [rbx + 0x558]
movzx eax, byte [rsi]
mov byte [rcx + rbx + 0x540], al
inc dword [rbx + 0x558]
lea rsi, [rsi + 1]
cmp dword [rbx + 0x558], 0x10
jne 0x14025a2d9
lea rdx, [rbx + 0x510]
movzx eax, byte [rbx + 0x540]
xor byte [rdx], al
movzx eax, byte [rbx + 0x541]
xor byte [rbx + 0x511], al
movzx eax, byte [rbx + 0x542]
xor byte [rbx + 0x512], al
movzx eax, byte [rbx + 0x543]
xor byte [rbx + 0x513], al
movzx eax, byte [rbx + 0x544]
xor byte [rbx + 0x514], al
movzx eax, byte [rbx + 0x545]
xor byte [rbx + 0x515], al
movzx eax, byte [rbx + 0x546]
xor byte [rbx + 0x516], al
movzx eax, byte [rbx + 0x547]
xor byte [rbx + 0x517], al
movzx eax, byte [rbx + 0x548]
xor byte [rbx + 0x518], al
movzx eax, byte [rbx + 0x549]
xor byte [rbx + 0x519], al
movzx eax, byte [rbx + 0x54a]
xor byte [rbx + 0x51a], al
movzx eax, byte [rbx + 0x54b]
xor byte [rbx + 0x51b], al
movzx eax, byte [rbx + 0x54c]
xor byte [rbx + 0x51c], al
movzx eax, byte [rbx + 0x54d]
xor byte [rbx + 0x51d], al
movzx eax, byte [rbx + 0x54e]
xor byte [rbx + 0x51e], al
movzx eax, byte [rbx + 0x54f]
xor byte [rbx + 0x51f], al
lea r8, [rsp + 0x20]
mov rcx, rbx
call fcn.14025ba90
mov dword [rbx + 0x558], r15d
sub qword [rbx + 0x560], 0xffffffffffffff80
inc edi
cmp edi, dword [r14]
jb 0x14025a1c2
mov bl, 1
jmp 0x14025a2fa
lea rdx, str.buflen_error.
mov rax, qword [rsi]
mov rcx, rsi
call qword [rax + 0x28]
xor bl, bl
lea rcx, [rsp + 0x20]
call fcn.1400f8080
movzx eax, bl
mov rcx, qword [rsp + 0x1a0]
xor rcx, rsp
call fcn.140278f40
mov rbx, qword [rsp + 0x1e0]
add rsp, 0x1b0
pop r15
pop r14
pop rdi
pop rsi
pop rbp
ret
Function at 0x14025b840
Capabilities:
Encode data using xor
Encrypt data using rc4 prga

Disassembly:
mov qword [rsp + 0x10], rbx
push rbp
push rsi
push rdi
sub rsp, 0x40
mov rax, qword [0x1403dd7c0]
xor rax, rsp
mov qword [rsp + 0x30], rax
mov rax, qword [rcx]
lea rdx, [rsp + 0x20]
mov rbx, r8
xorps xmm0, xmm0
add r8, 0x500
movups xmmword [rsp + 0x20], xmm0
call qword [rax + 0x20]
xor edi, edi
xorps xmm0, xmm0
movups xmmword [rbx + 0x540], xmm0
mov esi, edi
xorps xmm1, xmm1
movups xmmword [rbx + 0x510], xmm1
mov qword [rbx + 0x550], rdi
mov dword [rbx + 0x558], edi
mov qword [rbx + 0x560], rdi
mov qword [rbx + 0x568], rdi
movups xmmword [rsp + 0x20], xmm0
mov r8, qword [rbx + 0x570]
lea rdx, [rsp + 0x20]
add r8, 8
mov byte [rsp + 0x20], dil
add r8, rsi
lea rcx, [rbx + 0x500]
call fcn.14025aa30
inc edi
add rsi, 0x10
cmp edi, 0x100
jl 0x14025b8b0
mov eax, 0x1000
lea r11, [0x140314170]
nop
mov r10d, 0x100
nop word [rax + rax]
mov rdx, qword [rbx + 0x570]
movzx ecx, byte [rdx + rax - 0xfea]
movzx r9d, byte [rdx + rax - 0xfe9]
mov byte [rdx + rax + 0x17], cl
mov rdx, qword [rbx + 0x570]
movzx ecx, byte [rdx + rax - 0xfeb]
mov byte [rdx + rax + 0x16], cl
mov rdx, qword [rbx + 0x570]
movzx ecx, byte [rdx + rax - 0xfec]
mov byte [rdx + rax + 0x15], cl
mov rdx, qword [rbx + 0x570]
movzx ecx, byte [rdx + rax - 0xfed]
mov byte [rdx + rax + 0x14], cl
mov rdx, qword [rbx + 0x570]
movzx ecx, byte [rdx + rax - 0xfee]
mov byte [rdx + rax + 0x13], cl
mov rdx, qword [rbx + 0x570]
movzx ecx, byte [rdx + rax - 0xfef]
mov byte [rdx + rax + 0x12], cl
mov rdx, qword [rbx + 0x570]
movzx ecx, byte [rdx + rax - 0xff0]
mov byte [rdx + rax + 0x11], cl
mov rdx, qword [rbx + 0x570]
movzx ecx, byte [rdx + rax - 0xff1]
mov byte [rdx + rax + 0x10], cl
mov rdx, qword [rbx + 0x570]
movzx ecx, byte [rdx + rax - 0xff2]
mov byte [rdx + rax + 0xf], cl
mov rdx, qword [rbx + 0x570]
movzx ecx, byte [rdx + rax - 0xff3]
mov byte [rdx + rax + 0xe], cl
mov rdx, qword [rbx + 0x570]
movzx ecx, byte [rdx + rax - 0xff4]
mov byte [rdx + rax + 0xd], cl
mov rdx, qword [rbx + 0x570]
movzx ecx, byte [rdx + rax - 0xff5]
mov byte [rdx + rax + 0xc], cl
mov rdx, qword [rbx + 0x570]
movzx ecx, byte [rdx + rax - 0xff6]
mov byte [rdx + rax + 0xb], cl
mov rdx, qword [rbx + 0x570]
movzx ecx, byte [rdx + rax - 0xff7]
mov byte [rdx + rax + 0xa], cl
mov rdx, qword [rbx + 0x570]
movzx ecx, byte [rdx + rax - 0xff8]
mov byte [rdx + rax + 9], cl
lea ecx, [r9 + r9]
mov rdx, qword [rbx + 0x570]
movzx ecx, byte [rcx + r11]
mov byte [rax + rdx + 8], cl
lea ecx, [r9 + r9]
mov r8, qword [rbx + 0x570]
movzx ecx, byte [rcx + r11 + 1]
xor byte [r8 + rax + 9], cl
add rax, 0x10
sub r10, 1
jne 0x14025b900
cmp rax, 0x10000
jl 0x14025b8f0
mov al, 1
mov rcx, qword [rsp + 0x30]
xor rcx, rsp
call fcn.140278f40
mov rbx, qword [rsp + 0x68]
add rsp, 0x40
pop rdi
pop rsi
pop rbp
ret
Function at 0x14025f710
Capabilities:
Encrypt data using blowfish

Disassembly:
lea rax, [0x1403dc000]
ret

Function at 0x14025f720
Capabilities:
Encrypt data using blowfish

Disassembly:
lea rax, [0x1403dc050]
ret
Function at 0x1402659f0
Capabilities:
Encrypt data using des
Resolve function by parsing pe exports

Disassembly:
cmp byte [rcx + 0x3b0], 0
mov r9, r8
mov r8, rdx
lea rdx, [rcx + 0xb0]
jne 0x140262a00
jmp 0x140264820

Function at 0x1402664c0
Capabilities:
Encrypt data using rc4 prga

Disassembly:
mov qword [rsp + 0x18], rbx
mov qword [rsp + 0x20], rbp
push rsi
push rdi
push r14
sub rsp, 0x20
mov ebx, 0x80
mov qword [rsp + 0x40], r12
mov r14d, r9d
mov esi, r8d
mov r12, rdx
mov rdi, rcx
cmp r8d, ebx
jbe 0x1402664f1
mov esi, ebx
jmp 0x1402664fb
mov eax, 1
cmp esi, eax
cmovb esi, eax
mov qword [rsp + 0x48], r15
mov r15d, 0x400
test r14d, r14d
jne 0x140266510
mov r14d, r15d
jmp 0x140266517
cmp r14d, r15d
cmova r14d, r15d
mov edx, esi
mov rcx, r12
call fcn.1400e6020
mov rcx, r12
mov ebp, esi
call fcn.1400e6510
mov r12, qword [rsp + 0x40]
cmp esi, ebx
jbe 0x14026653b
xor al, al
jmp 0x140266665
test r14d, r14d
mov r8d, esi
lea rcx, [rdi + 0xb0]
mov rdx, rax
cmove r14d, r15d
mov r15d, esi
call sub.VCRUNTIME140.dll_memcpy
lea r11, [0x140318730]
cmp esi, ebx
jae 0x1402665a9
lea eax, [rsi - 1]
movzx r8d, byte [rax + rdi + 0xb0]
lea rdx, [rdi + 0xb0]
add rdx, r15
nop dword [rax + rax]
mov eax, ebp
lea rdx, [rdx + 1]
sub eax, esi
inc ebp
movzx ecx, byte [rax + rdi + 0xb0]
movzx eax, r8b
add rcx, rax
movzx eax, cl
movzx r8d, byte [rax + r11]
mov byte [rdx - 1], r8b
cmp ebp, ebx
jb 0x140266580
lea eax, [r14 + 7]
mov r8d, ebx
shr eax, 3
lea r9, [rdi + 0xb0]
sub r8d, eax
neg r14d
mov eax, r8d
movzx ecx, r14b
add r9, rax
and cl, 7
mov edx, 0xff
sar rdx, cl
movzx eax, byte [r9]
and rdx, rax
movzx r10d, byte [rdx + r11]
mov byte [r9], r10b
test r8d, r8d
je 0x140266614
nop dword [rax]
movzx eax, r10b
lea ebx, [rbx - 1]
movzx ecx, byte [rbx + rdi + 0xb0]
lea r9, [r9 - 1]
xor rcx, rax
movzx r10d, byte [rcx + r11]
mov byte [r9], r10b
add r8d, 0xffffffff
jne 0x1402665f0
mov r9d, 0x3f
lea r10, [rdi + 0x12e]
mov r11d, 0x100
nop word [rax + rax]
lea r8d, [r9 + r9]
movzx ecx, byte [r8 + rdi + 0xb0]
lea eax, [r8 + 1]
movzx edx, byte [rax + rdi + 0xb0]
lea r10, [r10 - 2]
imul edx, r11d
mov eax, r9d
dec r9d
add dx, cx
mov word [r10 + 2], dx
test eax, eax
jne 0x140266630
mov al, 1
mov r15, qword [rsp + 0x48]
mov rbx, qword [rsp + 0x50]
mov rbp, qword [rsp + 0x58]
add rsp, 0x20
pop r14
pop rdi
pop rsi
ret

Function at 0x1402671f0
Capabilities:
Encode data using add xor sub operations
Encode data using xor
Encrypt data using rc4 prga

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rdi
mov r10d, dword [rdx + 0x458]
mov rbx, r8
mov r11d, dword [rdx + 0x45c]
movsxd rdi, r9d
test r9d, r9d
jle 0x14026725f
nop dword [rax]
nop word [rax + rax]
inc r10b
lea rbx, [rbx + 1]
movzx r10d, r10b
mov r9d, dword [rdx + r10*4 + 0x58]
lea r8, [rdx + r10*4]
lea eax, [r11 + r9]
movzx r11d, al
mov ecx, dword [rdx + r11*4 + 0x58]
mov dword [r8 + 0x58], ecx
mov dword [rdx + r11*4 + 0x58], r9d
add r9b, cl
movzx eax, r9b
movzx ecx, byte [rdx + rax*4 + 0x58]
xor byte [rbx - 1], cl
sub rdi, 1
jne 0x140267220
mov rbx, qword [rsp + 8]
mov rdi, qword [rsp + 0x10]
mov dword [rdx + 0x45c], r11d
mov dword [rdx + 0x458], r10d
ret