joyce8/EMBER2024-capa huggingface dataset:
Function at 0x140013ce0
Capabilities:
Get thread local storage value
Set thread local storage value

Disassembly:
sub rsp, 0x28
xor r9d, r9d
xor edx, edx
xor ecx, ecx
mov dword [0x140898060], 0xffffffff
mov r8d, 0xffff
call qword [sym.imp.KERNEL32.dll_CreateSemaphoreW]
mov qword [0x140898068], rax
call qword [sym.imp.KERNEL32.dll_TlsAlloc]
cmp eax, 0xffffffff
je 0x140013cd0
lea rdx, [0x140013b90]
mov ecx, eax
mov dword [0x140898058], eax
call fcn.14001b590
test eax, eax
jne 0x140013cd8
add rsp, 0x28
ret
call qword [0x1408992c4]
jmp 0x140013cc7
call fcn.14001b3c0
nop
nop
push r13
push r12
push rbp
push rdi
push rsi
push rbx
sub rsp, 0x28
mov rsi, qword [0x14088a620]
mov r11d, dword [rsi]
mov rbx, rcx
test r11d, r11d
jne 0x140013d18
mov rax, qword [rcx + 0x10]
test rax, rax
je 0x140013d80
mov r12, qword [rcx + 0x10]
test r12, r12
je 0x140013d90
call fcn.140013be0
mov qword [rbx + 0x10], rax
jmp 0x140013d07
mov r10d, dword [rsi]
test r10d, r10d
je 0x140013eaa
mov r9d, dword [0x140880400]
test r9d, r9d
je 0x140013ed8
lock add dword [0x140898060], 1
jne 0x140013f0c
mov r12, qword [rbx + 0x10]
test r12, r12
je 0x140013eb7
mov eax, dword [rsi]
test eax, eax
je 0x140013d21
lock sub dword [0x140898060], 1
js 0x140013d21
mov rcx, qword [0x140898068]
xor r8d, r8d
mov edx, 1
call qword [sym.imp.KERNEL32.dll_ReleaseSemaphore]
call fcn.140013c80
mov dword [0x140880400], 1
mov edx, dword [rsi]
test edx, edx
jne 0x140013dac
mov r12, qword [rbx + 0x10]
test r12, r12
jne 0x140013d21
mov rax, qword [0x140898050]
lea r12, [rax + 1]
mov qword [0x140898050], r12
mov qword [rbx + 0x10], r12
jmp 0x140013dc7
lock add dword [0x140880404], 1
je 0x140013e91
mov r8d, dword [0x140880400]
lea rdi, [0x140880400]
mov rbp, qword [0x140899334]
test r8d, r8d
jne 0x140013ea0
nop dword [rax]
xor ecx, ecx
call rbp
mov ecx, dword [rdi]
test ecx, ecx
je 0x140013f00
jmp 0x140013ea0
mov rcx, qword [0x140898068]
mov edx, 0xffffffff
call qword [sym.imp.KERNEL32.dll_WaitForSingleObject]
test eax, eax
je 0x140013dba
lock sub dword [0x140898060], 1
jmp 0x140013dba

Function at 0x14001d3c0
Capabilities:
Get thread local storage value
Set thread local storage value

Disassembly:
lea rcx, [0x140880560]
jmp 0x140013ce0

Function at 0x14001d3d0
Capabilities:
Get thread local storage value
Set thread local storage value

Disassembly:
lea rcx, [0x140880560]
jmp 0x140013ce0
Function at 0x1408adca6
Capabilities:
Resolve function by parsing pe exports

Disassembly:
jns 0x1408b9c9c
add r9w, r9w
mov rdx, qword [rsp + r9 - 0x676d0dea]
mov r9d, dword [rsp + r9 - 0x676d0def]
mov r9, qword [rsp + r9 - 0x57]
test dword [rsp + r9 - 0x676d0719], 0x5a2e1420
jle 0x1408b8038
call fcn.1408a4040
call fcn.140998529
movsxd rbp, eax
test eax, eax
jle 0x1408b807c
lea rcx, [rbp + 1]
mov eax, 2
mov qword [rbx + 8], rbp
mul rcx
cmovo rax, r13
mov rcx, rax
call fcn.1408c02e8
mov r9d, edi
mov r8, rsi
xor edx, edx
xor ecx, ecx
mov dword [rsp + 0x28], ebp
mov qword [rbx], rax
mov qword [rsp + 0x20], rax
call fcn.1408b23e0
sbb eax, 0x246c8b48
push rax
mov rbp, qword [rsp + 0x50]
cmp qword [rbx], r12
jne 0x1408b80a4
mov rcx, qword [rbx + 8]
mov eax, 2
inc rcx
mul rcx
cmovo rax, r13
mov rcx, rax
call fcn.1408c02e8
mov qword [rbx], rax
mov rax, qword [rbx]
mov rcx, qword [rbx + 8]
mov rsi, qword [rsp + 0x60]
mov word [rax + rcx*2], r12w
mov rax, rbx
mov rbx, qword [rsp + 0x58]
add rsp, 0x30
pop r13
pop r12
pop rdi
ret
setns byte [rsp + 0x30]
mov qword [rsp + 0x40], 0xffffffffe5821c35
neg word [rsp + 0x30]
jle 0x140985293
mov r9, qword [rsp + 0x10]
jg 0x140980459

Function at 0x1409141b2
Capabilities:
Encode data using xor

Disassembly:
push qword [rsp + 8]
popfq
lea rsp, [rsp + 0x18]
ret 8
hlt
movabs r14, 0xb9a7dcbd2092e912
ja 0x14091b336
jl 0x140941295
sub r14, 0x1e8f4d37
lea rax, [rax + 0x5bbc51b7]
jne 0x14096dba2
lea edi, [rbp - 0x4b4773d6]
adc eax, dword [rbx]
outsb dx, byte [rsi]
xor qword [r8 - 0x305790dd], rdx
popfq
sbb eax, 0xa378c372
jl 0x14091419b
shl dword [rcx - 0x1faf4490], 1
ja 0x14091425a
sbb dl, byte [rdx + 0x14]
mov al, 0x9b
test dword [rdi - 0x38f43ae9], edx
or eax, edi
movabs byte [0x38f00ca644c8e316], al
push 0x31
invalid
cli
mov dil, 0x92
cmc
lodsd eax, dword [rsi]
outsd dx, dword [rsi]
test al, 0xe5
push rdx
ficomp dword [rax - 0x65]
fidivr dword [rcx]
cmp al, 0xfb
jae 0x140914206
shr dword [rbp + 0x3a], 0x3d
fisttp word [rax - 0x58]
test eax, 0x99d931ea
pushfq
sub al, 0x7b
int 0xf1
insd dword [rdi], dx
and ah, dl
invalid
shr r15b, 0x58
jne 0x1408a4401
mov r15, qword [rsp + r15*2 - 0x69cf55d0]
call fcn.140992e3c

Function at 0x14093b265
Capabilities:
Encode data using base64

Disassembly:
mov r9, rbp
and r9, 0xffffffff89a1073f
test rbp, 0x7b3d9f8e

Function at 0x140952ca3
Capabilities:
Encode data using base64

Disassembly:
push rdi
push rbp
pushfq
movabs rbp, 0x9b2672c3d8e731b

Function at 0x1409559d2
Capabilities:
Encode data using base64

Disassembly:
jns fcn.1409c7e97
jb 0x140984810
push qword [rsp + 0x18]
popfq
lea rsp, [rsp + 0x28]
ret
xor r14, r14
shl r14b, 0x93
sub r14w, 0x92b1
je 0x1409d9c03
call fcn.1409442f3

Function at 0x140960af1
Capabilities:
Encode data using base64

Disassembly:
not r9
sub byte [rsp + 0x30], 0x80
jbe fcn.140963fb0
call fcn.1408a67cf
and r11w, word [rsp + 0x34]
mov r8, qword [rsp + 0x38]
jae 0x1408afe53

Function at 0x1409791d2
Capabilities:
Encode data using base64

Disassembly:
lea r8, [rcx + r8*8 - 0x6ef2ef6a]
add bp, word [rsp + 0x3d]
Function at 0x1409847f2
Capabilities:
Encode data using base64

Disassembly:
push r14
movabs r14, 0x250c3c8a599d638e
add r14d, 0x122ed22
neg r14b
xchg qword [rsp + r14 - 0x5ac05038], rcx

Function at 0x14098cbc2
Capabilities:
Encode data using xor

Disassembly:
mov word [rsp + r12 + 0x4ae5550c], r12w
add r14w, word [rsp + r12 + 0x4ae55530]
cmp r12b, 0x10
not qword [rsp + r12 + 0x4ae5552c]
call fcn.14091f557
shl dword [rsp + 0x68], 0x37
mov r10, qword [rsp + r10*2 + 0x80]
xor word [rsp + 0x68], 0x33bc
jl 0x1409523ac
not qword [rsp + r12 + 0x4ae55534]
ja 0x1409273e8

Function at 0x14098e9e9
Capabilities:
Encode data using xor

Disassembly:
mov rcx, qword [rsp]
call fcn.14095728b
sets bl
setae bl
mov rcx, qword [rsp + 0x70]
or qword [rsp + 0x58], r12
movsx r12w, r12b
neg r12w
or rbx, r12
mov r9, qword [rsp + 0x20]
add qword [rsp + 0x60], 0xffffffffbf74dcc4
shr r12b, 0x12
lea r12, [r12 + r12*8 - 0x28da4fd9]
js 0x1408a9fbc

Function at 0x1409d66de
Capabilities:
Encode data using xor

Disassembly:
test dl, r14b
cmovne r14d, dword [rsp + 0x11]
or rbx, qword [rsp + 0x10]
lea rdi, [rdi + r14*4 - 0x2928899f]
xor dword [rsp + 0x10], 0x4c042a15
cmp r11, 0x51b6751f
not r11d
mov qword [rsp + 0x48], rdx
not rbx
push r14
xchg qword [rsp + r11 - 0x6b99ce87], rdi
mov rcx, qword [rsp + 0x48]
jle 0x1409523e5
not qword [rsp + r14*4 - 0x162f338]
lea rdx, [rdx + r11*2 + 0x1c9d92a2]
movsx r11w, byte [rsp + r14*2 - 0xb1798b]
not dl
shr dword [rsp + r14*2 - 0xb17958], 0x18
mov r11, qword [rsp + 0x58]
call fcn.1408b9c59
push qword [rsp]

Function at 0x1409d967b
Capabilities:
Encode data using xor

Disassembly:
cmp dword [rsp + 0x48], 0x922d6b97
call fcn.14096e59c

Function at 0x141425858
Capabilities:
Encrypt data using rc4 prga

Disassembly:
mov qword [rsp + 8], rbx
sub r10w, r14w
mov qword [rsp + 0x10], rdi
shr bh, 6
xor edi, edi
mov bh, 0x2a
movzx ebx, r8b
movzx r10w, spl
mov r11, rcx
movsx r10d, ax
movzx r8w, spl
mov r8, rdi
movsx r9, r15w
nop
movzx r9d, byte [r11]
jmp 0x14142589b
movzx r10d, byte [rdx]
jmp 0x1414258a4
inc r11
jmp 0x1414258ac
inc rdx
cmc
clc
jmp 0x1414258b6
test bl, bl
jmp 0x1414258bd
je 0x1414258ee
mov ecx, r8d
bts ax, cx
mov eax, 0x2c01480d
rol eax, cl
test rbx, 0x20308b07
add al, r8b
clc
xor r9b, al
jmp 0x1414258e4
inc r8
cmp r14b, r10b
clc
test r10b, r12b
test r9b, r9b
jmp 0x1414258f6
je 0x141425905
cmp r9b, r10b
je 0x14142588b
cmp r9b, r10b
jmp 0x14142590d
jae 0x14142592d
or eax, 0xffffffff
mov rbx, qword [rsp + 8]
movzx rdi, dx
movzx edi, dx
mov rdi, qword [rsp + 0x10]
jmp 0x14142592c
ret
mov rbx, qword [rsp + 8]
mov dil, 0xa5
movzx rax, r8w
seta dil
bswap ax
cwde
mov eax, edi
mov di, 0xae33
movsx di, r10b
cmovl di, r15w
mov rdi, qword [rsp + 0x10]
ret
Function at 0x140011778
Capabilities:
Encode data using xor

Disassembly:
push rbx
push rbp
push rsi
push rdi
push r12
push r13
push r14
push r15
sub rsp, 0x1a8
mov rax, qword [0x1404e8f18]
xor rax, rsp
mov qword [rsp + 0x190], rax
mov eax, 0x88
movsxd r13, r9d
mov qword [rsp + 0x20], r8
mov ebp, edx
mov r12, rcx
mov esi, 0x64
sub esi, r13d
lea rcx, [rsp + 0x30]
lea r8d, [rax + 0x40]
add esi, esi
cmp r13d, r8d
cmove esi, eax
xor edx, edx
call fcn.140337250
mov eax, esi
movsxd r14, esi
cdq
and edx, 7
add eax, edx
sar eax, 3
movsxd r15, eax
xor edi, edi
cmp ebp, esi
jl 0x140011816
mov rcx, rdi
test r15, r15
jle 0x140011800
mov rax, qword [r12 + rcx*8]
xor qword [rsp + rcx*8 + 0x30], rax
inc rcx
cmp rcx, r15
jl 0x1400117ef
mov edx, 0x18
lea rcx, [rsp + 0x30]
call fcn.1400118b8
sub ebp, esi
add r12, r14
jmp 0x1400117e3
movsxd rbx, ebp
lea rcx, [rsp + 0x100]
mov r8, rbx
mov rdx, r12
call fcn.1403367f0
inc ebp
mov byte [rsp + rbx + 0x100], 1
movsxd rax, ebp
lea rcx, [rsp + 0x100]
sub esi, ebp
add rcx, rax
movsxd r8, esi
xor edx, edx
call fcn.140337250
or byte [rsp + r14 + 0xff], 0x80
test r15, r15
jle 0x140011873
mov rax, qword [rsp + rdi*8 + 0x100]
xor qword [rsp + rdi*8 + 0x30], rax
inc rdi
cmp rdi, r15
jl 0x14001185e
mov edx, 0x18
lea rcx, [rsp + 0x30]
call fcn.1400118b8
mov rcx, qword [rsp + 0x20]
lea rdx, [rsp + 0x30]
mov r8, r13
call fcn.1403367f0
mov rcx, qword [rsp + 0x190]
xor rcx, rsp
call fcn.1403354e0
add rsp, 0x1a8
pop r15
pop r14
pop r13
pop r12
pop rdi
pop rsi
pop rbp
pop rbx
ret
Function at 0x1400165f8
Capabilities:
Parse credit card information

Disassembly:
mov qword [rsp + 8], rbx
push rdi
sub rsp, 0x20
mov rdi, rcx
xor al, al
mov ecx, dword [rcx + 0x7c]
cmp ecx, 0xffffffff
je 0x140016785
cmp ecx, 0x7c
je 0x140016785
cmp ecx, 0x29
jne 0x140016672
cmp dword [rdi + 0x1c], 0
jne 0x140016785
lea rbx, [rdi + 0x80]
test dword [rbx], 0x10000000
je 0x14001679e
cmp ecx, 0x5d
jne 0x14001664f
test dword [rbx], 0x10000000
je 0x1400167ac
mov dl, byte [rdi + 0x78]
lea rcx, [rdi + 0x40]
call fcn.140015bf4
mov rcx, rdi
call fcn.140018c68
mov rcx, rdi
call fcn.140018cdc
mov ecx, dword [rdi + 0x7c]
mov al, 1
jmp 0x14001660a
lea rbx, [rdi + 0x80]
cmp ecx, 0x2e
jne 0x140016689
lea rcx, [rdi + 0x40]
call fcn.140015e78
jmp 0x14001665b
cmp ecx, 0x5c
jne 0x1400166d7
mov rcx, rdi
call fcn.140018c68
test byte [rbx], 0x80
je 0x1400166cd
mov al, byte [rdi + 0x78]
cmp al, 0x62
jne 0x1400166b5
lea rcx, [rdi + 0x40]
call fcn.1400165ec
mov rcx, rdi
call fcn.140018c68
jmp 0x14001666b
cmp al, 0x42
jne 0x1400166cd
lea rcx, [rdi + 0x40]
call fcn.1400165ec
lea rcx, [rdi + 0x40]
call fcn.140018c04
jmp 0x1400166ab
mov rcx, rdi
call fcn.1400167c8
jmp 0x140016663
cmp ecx, 0x5b
jne 0x140016702
mov rcx, rdi
call fcn.140018c68
mov rcx, rdi
call fcn.140016e4c
mov edx, 0x5d
mov rcx, rdi
lea r8d, [rdx - 0x59]
call fcn.140018054
jmp 0x140016663
cmp ecx, 0x28
jne 0x140016737
mov rcx, rdi
call fcn.140018c68
mov rcx, rdi
call fcn.140019310
mov edx, 0x29
mov rcx, rdi
mov bl, al
lea r8d, [rdx - 0x24]
call fcn.140018054
test bl, bl
je 0x14001666b
jmp 0x140016663
cmp ecx, 0x5e
jne 0x14001674a
lea rcx, [rdi + 0x40]
call fcn.140015be8
jmp 0x1400166ab
cmp ecx, 0x24
jne 0x14001675d
lea rcx, [rdi + 0x40]
call fcn.140015f78
jmp 0x1400166ab
lea eax, [rcx - 0x2a]
cmp eax, 1
jbe 0x1400167ba
cmp ecx, 0x3f
je 0x1400167ba
cmp ecx, 0x7b
je 0x1400167ba
cmp ecx, 0x7d
jne 0x14001663e
test dword [rbx], 0x10000000
je 0x140016790
jmp 0x14001664f
mov rbx, qword [rsp + 0x30]
add rsp, 0x20
pop rdi
ret
mov edx, 6
mov rcx, rdi
call fcn.140018048
int3
mov edx, 5
mov rcx, rdi
call fcn.140018048
int3
mov edx, 4
mov rcx, rdi
call fcn.140018048
int3
mov edx, 0xa
mov rcx, rdi
call fcn.140018048
int3
Function at 0x14003fb70
Capabilities:
Encode data using xor
Generate random numbers using a mersenne twister

Disassembly:
push rbx
sub rsp, 0x20
mov r9d, 0x270
mov rbx, rcx
cmp dword [rcx], r9d
jne 0x14003fbc3
lea r8, [rcx + 8]
mov edx, dword [r8 - 4]
xor edx, dword [r8]
lea r8, [r8 + 4]
btr edx, 0x1f
xor edx, dword [r8 - 8]
mov eax, edx
and al, 1
neg al
sbb ecx, ecx
shr edx, 1
and ecx, 0x9908b0df
xor ecx, dword [r8 + 0x62c]
xor ecx, edx
mov dword [r8 + 0x9b8], ecx
sub r9, 1
jne 0x14003fb88
jmp 0x14003fbd0
cmp dword [rcx], 0x4e0
jb 0x14003fbd0
call fcn.14003fc10
mov eax, dword [rbx]
mov edx, dword [rbx + rax*4 + 4]
inc eax
mov dword [rbx], eax
mov ecx, edx
mov eax, dword [rbx + 0x1384]
shr ecx, 0xb
and eax, ecx
xor edx, eax
mov eax, edx
and eax, 0xff3a58ad
shl eax, 7
xor edx, eax
mov eax, edx
and eax, 0xffffdf8c
shl eax, 0xf
xor edx, eax
mov eax, edx
shr eax, 0x12
xor eax, edx
add rsp, 0x20
pop rbx
ret

Function at 0x14003fc10
Capabilities:
Encode data using xor
Generate random numbers using a mersenne twister

Disassembly:
mov qword [rsp + 8], rbx
lea r10, [rcx + 0x9c4]
mov r9, rcx
mov r11d, dword [r10]
mov ebx, 0xe3
mov eax, r11d
mov r11d, dword [r10 + 4]
mov edx, eax
lea r10, [r10 + 4]
xor edx, r11d
btr edx, 0x1f
xor edx, eax
mov eax, edx
and al, 1
neg al
sbb ecx, ecx
shr edx, 1
and ecx, 0x9908b0df
xor ecx, dword [r10 + 0x630]
xor ecx, edx
mov dword [r10 - 0x9c4], ecx
sub rbx, 1
jne 0x14003fc27
lea r10, [r9 + 0xd50]
mov ebx, 0x18c
mov r11d, dword [r10]
mov eax, r11d
mov r11d, dword [r10 + 4]
mov edx, eax
lea r10, [r10 + 4]
xor edx, r11d
btr edx, 0x1f
xor edx, eax
mov eax, edx
and al, 1
neg al
sbb ecx, ecx
shr edx, 1
and ecx, 0x9908b0df
xor ecx, dword [r10 - 0xd50]
xor ecx, edx
mov dword [r10 - 0x9c4], ecx
sub rbx, 1
jne 0x14003fc72
mov eax, dword [r9 + 0x1380]
mov edx, eax
xor edx, dword [r9 + 4]
btr edx, 0x1f
xor edx, eax
mov eax, edx
and al, 1
neg al
sbb ecx, ecx
and dword [r9], ebx
mov rbx, qword [rsp + 8]
and ecx, 0x9908b0df
xor ecx, dword [r9 + 0x634]
shr edx, 1
xor ecx, edx
mov dword [r9 + 0x9c0], ecx
ret
Function at 0x14007ce7c
Capabilities:
Hash data using murmur3

Disassembly:
mov r8d, dword [rcx]
mov r10, rcx
movzx eax, r8w
imul r11d, eax, 0x9069
shr r8d, 0x10
add r11d, r8d
mov r8d, dword [rcx + 4]
mov dword [rcx], r11d
movzx eax, r8w
imul r9d, eax, 0x4650
mov eax, dword [rcx + 8]
shl eax, 0x11
xor eax, dword [rcx + 8]
shr r8d, 0x10
add r9d, r8d
shl r11d, 0x10
mov dword [rcx + 4], r9d
mov ecx, eax
shr ecx, 0xd
xor ecx, eax
mov edx, ecx
lea eax, [r9 + r11]
shl edx, 5
xor edx, ecx
imul ecx, dword [r10 + 0xc], 0x10dcd
mov dword [r10 + 8], edx
add ecx, 0x12d687
xor eax, ecx
mov dword [r10 + 0xc], ecx
add eax, edx
ret

Function at 0x140084f98
Capabilities:
Encode data using xor

Disassembly:
mov qword [rsp + 0x10], rbx
push rdi
sub rsp, 0x1c0
mov rax, qword [0x1404e8f18]
xor rax, rsp
mov qword [rsp + 0x1b0], rax
mov rbx, rcx
and dword [rsp + 0x30], 0
cmp byte [0x1404efec8], 0
jne 0x14008514f
mov edi, 1
mov byte [0x1404efec8], dil
call fcn.1400adc6c
neg al
sbb edx, edx
and edx, 0xc
add edx, 0x1a
lea rax, [rsp + 0xa0]
mov qword [rsp + 0x20], rax
xor r9d, r9d
xor r8d, r8d
xor ecx, ecx
call qword [0x14036f940]
movdqa xmm0, xmmword [0x1403c40d0]
movdqu xmmword [rsp + 0x40], xmm0
mov dword [rsp + 0x50], 0x7a606236
mov dword [rsp + 0x54], 0x383830
xor ecx, ecx
mov al, byte [rsp + 0x40]
xor byte [rsp + rcx + 0x41], al
add rcx, rdi
cmp rcx, 0x16
jb 0x140085022
mov byte [rsp + 0x57], 0
lea rdx, [rsp + 0x41]
lea rcx, [rsp + 0xa0]
call fcn.140347350
test rbx, rbx
jne 0x140085080
lea rax, [rsp + 0xa0]
mov qword [rsp + 0x80], rax
lea rcx, [rsp + 0xa0]
call fcn.14033cd00
mov qword [rsp + 0x88], rax
lea rax, [rsp + 0x80]
mov ebx, edi
jmp 0x1400850c8
xorps xmm0, xmm0
movdqu xmmword [rsp + 0x60], xmm0
mov ecx, 0x40
call fcn.140335358
mov qword [rax], rax
mov qword [rax + 8], rax
mov qword [rax + 0x10], rax
mov word [rax + 0x18], 0x101
mov qword [rsp + 0x60], rax
mov dword [rsp + 0x30], 2
lea r8, [rsp + 0x60]
mov rdx, rbx
lea rcx, [rsp + 0x40]
call fcn.140019d24
mov ebx, 6
mov dword [rsp + 0x30], ebx
mov rdx, rax
lea rcx, [0x1404efee0]
call fcn.1400406a0
nop
test bl, 4
je 0x1400850ef
and ebx, 0xfffffffb
mov rcx, qword [rsp + 0x40]
call fcn.140335394
nop
test bl, 2
je 0x14008511f
and ebx, 0xfffffffd
mov r8, qword [rsp + 0x60]
mov r8, qword [r8 + 8]
lea rdx, [rsp + 0x60]
lea rcx, [rsp + 0x60]
call fcn.1400133cc
mov edx, 0x40
mov rcx, qword [rsp + 0x60]
call fcn.140335394
nop
test dil, bl
je 0x140085131
mov rcx, qword [rsp + 0x80]
call fcn.140335394
call fcn.140085b18
test al, al
jne 0x14008513e
xor al, al
jmp 0x140085159
call fcn.1400851f8
nop
mov byte [0x1404efec9], dil
jmp 0x140085156
mov dil, byte [0x1404efec9]
mov al, dil
mov rcx, qword [rsp + 0x1b0]
xor rcx, rsp
call fcn.1403354e0
mov rbx, qword [rsp + 0x1d8]
add rsp, 0x1c0
pop rdi
ret
Function at 0x1400b2708
Capabilities:
Validate payment card number using luhn algorithm

Disassembly:
mov rax, qword [rdx + 0x28]
cmp byte [rax], 0x22
je 0x1400b2747
cmp byte [rax], 0x5b
je 0x1400b2742
cmp byte [rax], 0x66
je 0x1400b273d
cmp byte [rax], 0x6e
je 0x1400b2738
cmp byte [rax], 0x74
je 0x1400b2733
cmp byte [rax], 0x7b
jne fcn.1400b18f0
jmp fcn.1400b20f0
jmp fcn.1400b2658
jmp fcn.1400b1844
jmp fcn.1400b16ec
jmp fcn.1400b1548
xor r9d, r9d
jmp fcn.1400b23dc

Function at 0x1400b4e14
Capabilities:
Hash data using sha256

Disassembly:
xor eax, eax
mov dword [rcx], 0x6a09e667
mov qword [rcx + 0x38], rax
mov qword [rcx + 0x30], rax
mov qword [rcx + 0x28], rax
mov dword [rcx + 0x24], eax
mov dword [rcx + 4], 0xbb67ae85
mov dword [rcx + 8], 0x3c6ef372
mov dword [rcx + 0xc], 0xa54ff53a
mov dword [rcx + 0x10], 0x510e527f
mov dword [rcx + 0x14], 0x9b05688c
mov dword [rcx + 0x18], 0x1f83d9ab
mov qword [rcx + 0x1c], 0x5be0cd19
ret
Function at 0x1400b4f6c
Capabilities:
Encode data using xor

Disassembly:
mov qword [rsp + 0x10], rbx
mov qword [rsp + 0x18], rdi
push rbp
lea rbp, [rsp - 0x30]
sub rsp, 0x130
mov rax, qword [0x1404e8f18]
xor rax, rsp
mov qword [rbp + 0x20], rax
mov r8, rdx
lea rax, [rsp + 0x20]
sub r8, rax
mov r9, rcx
lea rax, [rsp + 0x20]
mov rdi, rcx
sub r9, rax
xor ebx, ebx
mov edx, ebx
lea r10d, [rbx + 0x10]
lea rcx, [rsp + 0x20]
add rcx, rdx
mov eax, dword [r8 + rcx]
mov dword [rcx], eax
xor eax, dword [rcx + r9]
mov dword [rbp + rdx - 0x60], eax
add rdx, 4
sub r10, 1
jne 0x1400b4fb2
xor r8d, r8d
lea rdx, [rsp + 0x60]
lea rcx, [rsp + 0x20]
call fcn.1400b5f30
mov r8d, 0x1000000
lea rdx, [rsp + 0x20]
lea rcx, [rsp + 0x60]
call fcn.1400b5f30
mov r8d, 0x2000000
lea rdx, [rsp + 0x60]
lea rcx, [rsp + 0x20]
call fcn.1400b5f30
mov r8d, 0x3000000
lea rdx, [rsp + 0x20]
lea rcx, [rsp + 0x60]
call fcn.1400b5f30
mov r8d, 0x4000000
lea rdx, [rsp + 0x60]
lea rcx, [rsp + 0x20]
call fcn.1400b5f30
mov r8d, 0x5000000
lea rdx, [rsp + 0x20]
lea rcx, [rsp + 0x60]
call fcn.1400b5f30
mov r8d, 0x6000000
lea rdx, [rsp + 0x60]
lea rcx, [rsp + 0x20]
call fcn.1400b5f30
mov r8d, 0x7000000
lea rdx, [rsp + 0x20]
lea rcx, [rsp + 0x60]
call fcn.1400b5f30
mov r8d, 0x8000000
lea rdx, [rsp + 0x60]
lea rcx, [rsp + 0x20]
call fcn.1400b5f30
mov r8d, 0x9000000
lea rdx, [rbp - 0x20]
lea rcx, [rsp + 0x60]
call fcn.1400b5f30
xor r8d, r8d
lea rdx, [rsp + 0x60]
lea rcx, [rbp - 0x60]
call fcn.1400b54c4
mov r8d, 1
lea rdx, [rsp + 0x20]
lea rcx, [rsp + 0x60]
call fcn.1400b54c4
mov r8d, 2
lea rdx, [rsp + 0x60]
lea rcx, [rsp + 0x20]
call fcn.1400b54c4
mov r8d, 3
lea rdx, [rsp + 0x20]
lea rcx, [rsp + 0x60]
call fcn.1400b54c4
mov r8d, 4
lea rdx, [rsp + 0x60]
lea rcx, [rsp + 0x20]
call fcn.1400b54c4
mov r8d, 5
lea rdx, [rsp + 0x20]
lea rcx, [rsp + 0x60]
call fcn.1400b54c4
mov r8d, 6
lea rdx, [rsp + 0x60]
lea rcx, [rsp + 0x20]
call fcn.1400b54c4
mov r8d, 7
lea rdx, [rsp + 0x20]
lea rcx, [rsp + 0x60]
call fcn.1400b54c4
mov r8d, 8
lea rdx, [rsp + 0x60]
lea rcx, [rsp + 0x20]
call fcn.1400b54c4
mov r8d, 9
lea rdx, [rbp - 0x60]
lea rcx, [rsp + 0x60]
call fcn.1400b54c4
mov eax, dword [rbp + rbx - 0x20]
xor eax, dword [rbp + rbx - 0x60]
xor dword [rbx + rdi], eax
add rbx, 4
cmp rbx, 0x40
jl 0x1400b516d
mov rcx, qword [rbp + 0x20]
xor rcx, rsp
call fcn.1403354e0
lea r11, [rsp + 0x130]
mov rbx, qword [r11 + 0x18]
mov rdi, qword [r11 + 0x20]
mov rsp, r11
pop rbp
ret
Function at 0x1400b5350
Capabilities:
Encode data using xor

Disassembly:
mov qword [rsp + 0x10], rbx
mov qword [rsp + 0x18], rdi
push rbp
lea rbp, [rsp - 0x57]
sub rsp, 0xf0
mov rax, qword [0x1404e8f18]
xor rax, rsp
mov qword [rbp + 0x47], rax
lea rax, [rcx + 0x3c]
mov rbx, rcx
lea rcx, [rbp - 0x39]
mov edi, 0x10
cmp rcx, rax
ja 0x1400b53b3
xor r9d, r9d
lea rax, [rbp + 3]
cmp rax, rbx
jb 0x1400b53b3
mov r8d, edi
lea rcx, [rbp - 0x39]
sub r8, r9
lea rcx, [rcx + r9*4]
shl r8, 2
lea rdx, [rbx + r9*4]
call fcn.1403367f0
jmp 0x1400b53d2
movups xmm0, xmmword [rbx]
movups xmm1, xmmword [rbx + 0x10]
movaps xmmword [rbp - 0x39], xmm0
movups xmm0, xmmword [rbx + 0x20]
movaps xmmword [rbp - 0x29], xmm1
movups xmm1, xmmword [rbx + 0x30]
movaps xmmword [rbp - 0x19], xmm0
movaps xmmword [rbp - 9], xmm1
xor r8d, r8d
lea rdx, [rbp - 0x79]
lea rcx, [rbp - 0x39]
call fcn.1400b54c4
mov r8d, 1
lea rdx, [rbp + 7]
lea rcx, [rbp - 0x79]
call fcn.1400b54c4
mov r8d, 2
lea rdx, [rbp - 0x79]
lea rcx, [rbp + 7]
call fcn.1400b54c4
mov r8d, 3
lea rdx, [rbp + 7]
lea rcx, [rbp - 0x79]
call fcn.1400b54c4
mov r8d, 4
lea rdx, [rbp - 0x79]
lea rcx, [rbp + 7]
call fcn.1400b54c4
mov r8d, 5
lea rdx, [rbp + 7]
lea rcx, [rbp - 0x79]
call fcn.1400b54c4
mov r8d, 6
lea rdx, [rbp - 0x79]
lea rcx, [rbp + 7]
call fcn.1400b54c4
mov r8d, 7
lea rdx, [rbp + 7]
lea rcx, [rbp - 0x79]
call fcn.1400b54c4
mov r8d, 8
lea rdx, [rbp - 0x79]
lea rcx, [rbp + 7]
call fcn.1400b54c4
mov r8d, 9
lea rdx, [rbp - 0x39]
lea rcx, [rbp - 0x79]
call fcn.1400b54c4
lea rcx, [rbp - 0x39]
sub rcx, rbx
mov eax, dword [rcx + rbx]
xor dword [rbx], eax
lea rbx, [rbx + 4]
sub rdi, 1
jne 0x1400b5494
mov rcx, qword [rbp + 0x47]
xor rcx, rsp
call fcn.1403354e0
lea r11, [rsp + 0xf0]
mov rbx, qword [r11 + 0x18]
mov rdi, qword [r11 + 0x20]
mov rsp, r11
pop rbp
ret
Function at 0x1400b9604
Capabilities:
Encrypt data using aes via x86 extensions

Disassembly:
movdqu xmm3, xmmword [rcx + 0x10]
movdqu xmm0, xmmword [rcx]
mov rax, qword [rsp + 0x28]
movdqa xmm2, xmm0
movdqu xmmword [rdx], xmm0
pslldq xmm2, 4
movdqa xmm1, xmm2
movdqu xmmword [r8], xmm3
xorps xmm1, xmm0
pslldq xmm2, 4
movdqa xmm4, xmm2
pslldq xmm2, 4
xorps xmm4, xmm1
xorps xmm4, xmm2
aeskeygenassist xmm0, xmm3, 1
pshufd xmm1, xmm0, 0xff
xorps xmm4, xmm1
movdqa xmm1, xmm3
pslldq xmm1, 4
movdqa xmm0, xmm1
movdqu xmmword [r9], xmm4
pslldq xmm1, 4
xorps xmm0, xmm3
movdqa xmm2, xmm1
pslldq xmm1, 4
xorps xmm2, xmm0
xorps xmm2, xmm1
aeskeygenassist xmm0, xmm4, 0
pshufd xmm1, xmm0, 0xaa
xorps xmm2, xmm1
movdqa xmm1, xmm4
pslldq xmm1, 4
movdqa xmm0, xmm1
movdqu xmmword [rax], xmm2
mov rax, qword [rsp + 0x30]
xorps xmm0, xmm4
pslldq xmm1, 4
movdqa xmm3, xmm1
pslldq xmm1, 4
xorps xmm3, xmm0
xorps xmm3, xmm1
aeskeygenassist xmm0, xmm2, 2
pshufd xmm1, xmm0, 0xff
xorps xmm3, xmm1
movdqa xmm1, xmm2
pslldq xmm1, 4
movdqa xmm0, xmm1
movdqu xmmword [rax], xmm3
mov rax, qword [rsp + 0x38]
xorps xmm0, xmm2
pslldq xmm1, 4
movdqa xmm2, xmm1
pslldq xmm1, 4
xorps xmm2, xmm0
xorps xmm2, xmm1
aeskeygenassist xmm0, xmm3, 0
pshufd xmm1, xmm0, 0xaa
xorps xmm2, xmm1
movdqa xmm1, xmm3
pslldq xmm1, 4
movdqa xmm0, xmm1
movdqu xmmword [rax], xmm2
xorps xmm0, xmm3
pslldq xmm1, 4
movdqa xmm3, xmm1
pslldq xmm1, 4
xorps xmm3, xmm0
xorps xmm3, xmm1
aeskeygenassist xmm0, xmm2, 4
pshufd xmm1, xmm0, 0xff
xorps xmm3, xmm1
movdqa xmm1, xmm2
pslldq xmm1, 4
movdqa xmm0, xmm1
pslldq xmm1, 4
xorps xmm0, xmm2
movdqa xmm2, xmm1
xorps xmm2, xmm0
pslldq xmm1, 4
xorps xmm2, xmm1
aeskeygenassist xmm0, xmm3, 0
mov rax, qword [rsp + 0x40]
pshufd xmm1, xmm0, 0xaa
xorps xmm2, xmm1
movdqa xmm1, xmm3
pslldq xmm1, 4
movdqu xmmword [rax], xmm3
movdqa xmm0, xmm1
mov rax, qword [rsp + 0x48]
xorps xmm0, xmm3
pslldq xmm1, 4
movdqa xmm3, xmm1
pslldq xmm1, 4
xorps xmm3, xmm0
movdqu xmmword [rax], xmm2
xorps xmm3, xmm1
mov rax, qword [rsp + 0x50]
aeskeygenassist xmm0, xmm2, 8
pshufd xmm1, xmm0, 0xff
xorps xmm3, xmm1
movdqa xmm1, xmm2
pslldq xmm1, 4
movdqa xmm0, xmm1
movdqu xmmword [rax], xmm3
mov rax, qword [rsp + 0x58]
xorps xmm0, xmm2
pslldq xmm1, 4
movdqa xmm2, xmm1
pslldq xmm1, 4
xorps xmm2, xmm0
xorps xmm2, xmm1
aeskeygenassist xmm0, xmm3, 0
pshufd xmm1, xmm0, 0xaa
xorps xmm2, xmm1
movdqu xmmword [rax], xmm2
ret