joyce8/EMBER2024-capa huggingface dataset:
Function at 0xc5eac7
Capabilities:
Authenticate hmac

Disassembly:
ret
mov word [eax + edi - 0x4d01], cx
cdq
mov dword [esp + eax - 0x4cff], 0xbc8e860e
movsx ecx, dl
mov eax, dword [esi + eax*4 - 0x13401]
xor eax, ebx
pop ecx
bswap eax
shr dx, 0x21
dec eax
bswap eax
not eax
xor ebx, eax
add ebp, eax
shr edx, 0x7b
movzx ecx, byte [edx + esi - 6]
movsx eax, dx
xadd edx, eax
lea esi, [esi + eax - 6]
lea eax, [edx + edx*4 - 0x6e659ece]
xor cl, bl
inc edx
sub cl, dl
bt edx, 0x36
mul dl
and eax, edx
rol cl, 1
add cl, dl
dec ax
xor cl, 0xb8
sal dl, 0xe1
not al
xor bl, cl
lea eax, [edx*2 + 0x762b7582]
add ax, dx
adc ecx, esp
neg ax
shl al, 0xc3
movzx ax, byte [edx + ecx - 2]
movzx ax, al
imul edx, edx
movzx ecx, dl
and ecx, edx
mov cl, byte [edi + ecx*2 - 0xa]
jnp 0xc93041
sbb eax, eax
clc
cmc
neg eax
mov esp, ebp
pop ebp
jmp 0x773cfb
push edx
adc al, cl
not dx
imul edx, edx
lea ecx, [edx*2 - 0x6fc2efe0]
mov word [edi - 2], ax
setno byte [esp]
mov dword [esp], edx
sbb edi, 1
shl edx, cl
add ecx, 0xb9071aab
and dword [esp + edx - 0x640000], ecx
pop eax
jae fcn.0087275e

Function at 0xc5eef6
Capabilities:
Execute syscall

Disassembly:
mov dword [esp + eax - 0x6a989583], 0x331f984
or byte [esp + eax - 0x6a989581], ah
xor edx, ebx
not eax
and cx, 0xb38b
dec edx
xor dword [esp], 0x4614318d
mov dword [esp], eax
dec eax
xor edx, 0x4c9aac1b
cwde
and byte [esp + eax - 0x6a7b], 0x98
not edx
rol eax, cl
dec word [esp + eax*2 - 0x6a7af]
add al, 0x91
neg edx
rol edx, 2
jmp 0x904daa
Function at 0xc61f4b
Capabilities:
Encode data using base64

Disassembly:
lea edx, [eax*8 + 0x66815a38]
pop edi
dec eax
lea esp, [esp + 0x10]
jne 0xcaea1f
mov eax, 0xa9b679bd
jmp 0x78e484

Function at 0xc661a7
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
dec eax
adc edx, ecx
call fcn.0088560b
mov eax, 0xd8bd640d
lea ecx, [eax*2 - 0x1c7b0ee9]
mov edx, dword [esi]
shl al, 0x21
mov ecx, dword [esi + 4]
lea eax, [eax + eax*4 - 0x7df6cb54]
add eax, 0x950a311a
not edx
adc ax, 0xb17
bswap eax
not ecx
xadd al, ah
or edx, ecx
movzx ecx, ax
bt cx, 0x35
or al, ah
mov dword [eax + esi - 0x60655256], edx
push ecx
call fcn.00cb2f8c

Function at 0xc6ab25
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
mov eax, dword [ebp + edx - 0x18b59c03]
sal ecx, 0xb7
xor eax, ebx
xor edx, ecx
jb 0xceedbf
bt ecx, edx
xor eax, 0x949d7f82
btc ecx, edx
btc cx, cx
or cx, dx
rol eax, 2
shl ecx, 0x8b
btc dx, dx
xchg ecx, edx
not eax
or ecx, ecx
xor ecx, ecx
ror eax, 2
jmp 0x92ee92
mov dword ss:[ecx], edx
mov ecx, 0x4ba3ac97
inc cl
lea ebp, [ebp + ecx - 0x4ba3ac9c]
sal ecx, 0x35
lea edx, [ecx - 0x7a4a63fd]
js 0x77f617
mov eax, 0x53a501a2
movzx edx, al
rol dx, 0x48
lea ebp, [eax + ebp - 0x53a501a6]
mov edx, dword [ebp + eax - 0x53a501a2]
ror eax, 0x1c
mov ecx, 0x631ca734
xor edx, ebx
push eax
shr eax, 0xeb
neg edx
lea edx, [eax + edx - 0x19bd358d]
add eax, dword [esp + eax - 0x74a03]
bts ecx, 0x1c
shl ecx, cl
neg edx
ror edx, 2
shl al, 0x85
sbb edx, 0xeb8d0db0
jmp 0xcaf4ac
sal edx, 0xba
bswap eax
lea edx, [edx + 0x71020428]
xor ebx, eax
add edi, eax
movsx eax, dx
add ecx, edi
jmp ecx
lea edx, [eax*2 - 0x5af396ef]
mov dword [esp + eax*4 - 0x3e5c5000], edx
mov word [esi + eax - 0xf971400], cx
call fcn.00cec468
mov ecx, 0xd498e608
mov ecx, dword [esi]
mov edx, 0x5e3dc0b0
mov edx, dword [esi + edx - 0x5e3dc0ac]
add esi, 8
jmp 0x8cac61
call fcn.009b3704
Function at 0xc7014d
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
inc ecx
push edx
inc ecx
xor esp, 0xadb75016
shr dl, 0xe5
jbe 0xc661f7
inc ecx
inc esp
rol word [esp + edx - 0x2775a9ed], 0x25
inc esp
xadd byte [esp + edx - 0x2775a9ec], dl
inc ecx
bswap esp
add edx, ecx
inc ecx
dec esp
inc esp
mov esi, ecx
dec eax
btc edx, edx
dec esp
mov dword [esp + edi + 0x616c000f], ecx
inc edx
mov eax, dword [esp + eax + 2]
inc ecx
pop edx
inc ecx
mov edi, 0x73a1a095
inc esp
xor dword [esp + edi + 0x616c0007], esp
ror dword [esp + edi + 0x616c0003], 0x9e
dec eax
add edx, edi
inc edx
sal byte [esp + eax], 0xa1
dec esp
mov ecx, dword [esp + edi + 0x616c0007]
dec ebp
arpl sp, sp
dec eax
lea ebx, [ecx*8 + 0x77082102]
dec ecx
adc ebp, esp
dec eax
and dword [esp + edx - 0x64a5aa02], 0xc2ba3b2b
inc esi
movzx esi, byte [edx + ebx - 0x64a5a9fc]
dec eax
cdq
dec ebx
lea ecx, [eax + edx*8 - 0x225511f0]
inc ecx
push eax
dec ebp
lea ebx, [ebx + edx + 7]
inc ebp
xor dh, cl
inc esp
or dword [esp + edx*8 + 0xa], eax
inc ecx
rol dh, 1
inc ecx
sal eax, 0x89
push edi
inc ecx
xor dh, 0x9e
shl dword [esp + edx], cl
dec ebx
inc ecx
adc dh, 0x83
dec ecx
mul edx
inc ecx
ror dh, 1
dec eax
not edx
inc ebp
xor cl, dh
dec esi
lea esi, [esp + esi + 0x20]
inc ebp
mov ebp, dword [esi + edx*2 + 2]
cdq
inc esp
mov dword [esi + edx - 2], ebp
sub dword [esp + edx + 9], 0x3a04b58d
dec eax
lea esi, [edx + esi - 2]
dec eax
cdq
inc ecx
pop edi
pop ebx
inc ecx
pop ebp
inc ecx
pop esi
jbe fcn.0073c0e6
inc ebp
xor cl, bh
dec esi
lea edi, [esp + edi + 0x10]
add dword [esp + ebx - 0x9e89], ecx
xadd dx, cx
inc ecx
adc edx, edx
inc dx
mov ebx, dword [edi + edi + 0x616baaee]
sar dl, 0x27
mov word [esi + edi + 0x616baaf0], bx
sbb word [esp + edx - 0x2775a9f7], 0xf938
dec byte [esp + edx - 0x2775a9f3]
dec eax
neg dword [esp + edx - 0x2775a9f8]
inc esi
mov esp, dword [edx + ebx - 0x2775a9fe]
inc ebp
xor esp, ecx
inc ebp
lea esp, [esp + edi*2 + 0x25b77eab]
inc ecx
xor esp, 0x7f9e49b8
dec esp
mov dword [esp + edx - 0x2775aa00], eax
sar di, 0x8e
dec esp
and eax, dword [esp + edx - 0x2775a9fc]
inc edi
lea esp, [esp + edx*2 - 0x5d16801a]
jge 0x975f1d
je 0xc70177
mov ebx, 0x55a12e01
stc
add byte [ecx], dl
pushal
push esi
sbb dword [ebp - 7], edx
add byte [ecx + 0x558926ab], dl
stc
add byte [0x55e90603], cl
stc
add byte [ecx - 8], al
xchg al, bh
stosb byte es:[edi], al
enter 0x13cf, 0xffffffffffffff84
cmp eax, 0xb1a4480f
adc byte [esi], bl
lodsd eax, dword [esi]
adc byte [edi], bh
mov dword gs:[0xc424fe06], eax
xchg ebp, eax
adc edi, esp
cld
ret
Function at 0xc73a2e
Capabilities:
Encode data using base64

Disassembly:
dec edx
mov dword [esp + ecx - 0x793f7a42], 0x99b4843d
add ecx, 0xfc3e728a
ror edx, 1
push ecx
lea edx, [edx + ecx - 0x6ee6c927]
mov eax, ecx
rol edx, 1
push eax
neg ax
xor edx, 0x9928a71c
lea ecx, [ecx + 0x2028b73f]
btr eax, 0x36
inc eax
xor ebx, edx
not al
dec ax
btr dx, dx
jae 0x97b233
neg al
pop edx
mov edx, 0x93ac6da1
sub al, 0xa5
call fcn.0073e07d
call dword [edx - 0x159afe45]
outsb dx, byte [esi]
stc
add byte [esi], bl
loop 0xc73a88
lcall 0x57a, 0x1a00f96e
mov ch, byte [esi - 7]
add byte [edx], bh
imul ebp, dword [0xf96e82], 0x46
enter 0x5b65, 0xffffffffffffff91
enter 0xffffffffffffa8cf, 0xfffffffffffffff5
xchg edx, eax
jl 0xc73ae3
aad 0xf2
dec esp
add byte [edi], 0xff
invalid
scasd eax, dword es:[edi]
lds edi, [esi]
ret 0x41b7
cld
inc ebp
xchg ebp, eax
jns 0xc73afc
add al, 0xe4
xor edx, dword [ebx]
jecxz 0xc73a78
xor cl, byte [edx - 0x169c314a]
ficom dword [edx + edx*2 - 0x1d3886c4]
imul ecx, dword [esi - 0x569d9ecd], 0x211efaeb
pop edi
int3
mov byte [0x81521ed0], al
ja 0xc73aaf
xchg ebp, eax
jnp 0xc73aae
mov ah, byte [edx - 0x11368955]
mov ch, 0xae
dec ecx
aad 0
push cs
or byte [edx], bl
mov ebp, ebp
in eax, dx
mov byte [esi], bl
or byte [edx], bl
mov ecx, esp
pop esp
out dx, al
or byte [edx], bl
mov dword [ebp - 0x10], ebp
scasb al, byte es:[edi]
or byte [edx], bl
mov dword [0x1a08c6e4], edx
mov dword [ecx], ebp
jl 0xc73afd
or byte [edx], bl
mov dword [0x1a088640], ebp
mov dword [0x20f7eeec], ebx
mov dword [ecx], edx
mov edi, 0xb18654c3
sbb byte [ebp - 0x4e5f9b53], bl
xchg edx, eax
and ah, ah
int3

Function at 0xc769b6
Capabilities:
Encode data using base64

Disassembly:
xor dl, 0x14
ror cx, 0x8f
rol dl, 1
lea eax, [ecx + ecx + 0x27137506]
neg dl
ror dl, 1
sal cl, 0xe7
xor bl, dl
lea edx, [esp + edx + 0xc]
mov dword [esp + eax*2 - 0x4c26ea0c], 0x17b948ae
sub ecx, 0xfe3fed0a
movzx ax, byte [edx + ecx*2 - 0x28025ec]
sub ecx, 0x94025fa1
mov dword [esp + ecx - 0x6d3db351], 0x5db3d011
jno 0x8ff6c9

Function at 0xc76c05
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
xor ebx, eax
add esi, eax
lea edx, [esp + ecx - 0x3f6bffdb]
sar cx, 0x4b
movzx cx, byte [edx + ecx*2 - 0x7ed7fffe]
push 0x5a0f5e9c
mov edx, dword [esp + 4]
mov word [edi - 4], cx
adc edi, 0xfffffffb
mov eax, edx
jmp 0xcccd10
push ecx
bt edx, ecx
bswap eax
ror eax, 2
xor eax, 0x551ea6bc
pop edx
sub eax, 0x803c2d2a
mov dword [esp + edx - 0x3f6bffff], 0x8f99d4b3
btc dx, 0x9d
jb 0x7888af
pop ecx
pop edx
jmp fcn.00c9bff2
Function at 0xc79c0c
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
bswap eax
ror eax, 3
lea eax, [eax + edx*2 - 0x45b979f3]
inc edx
mov dword [esp + edx - 0x119b8], 0x9c39db90
pop edx
not eax
or edx, ecx
inc eax
rol edx, cl
bts ecx, 0xc
jb 0xc87151
add cl, 0x84
xchg byte [esp + edx - 0x62d6e74c], dl
ror cl, 1
xadd eax, edx
call fcn.009bea3d
mov edx, 0x21857811
dec edx
mov edx, dword [ebp + edx*2 - 0x430af020]
mov ecx, 0xac970fad
mov eax, dword [ebp + 4]
mov cl, byte [ebp + 8]
jns 0xce6124
xor cx, 0xc209
lea ebp, [ebp + ecx*2 - 0x18448]
sal byte [esp + ecx - 0xc224], cl
cbw
xor edx, ebx
not edx
call fcn.0089280e
cpuid
sbb edi, 8
mov dword [edi + 0xc], eax
mov eax, 0xfba7938b
or al, ah
xadd al, ah
mov dword [edi + 8], ebx
lea eax, [eax*4 + 0x718d781f]
jl 0xcf4b38
xor ebx, eax
inc dx
add edi, eax
lea eax, [ecx + edx*4 + 0x909ba8f]
neg edx
movzx ecx, byte [edx + ebp - 0x1258f184]
xor cl, bl
cwd
neg cl
bts dx, dx
idiv al
lea edx, [edx - 0x29c0cee3]
not cl
rol eax, 0x1f
sub edx, eax
ror edx, 0xa6
adc cl, 0x17
add edx, eax
not cl
xor bl, cl
shl eax, 3
adc ecx, esp
movzx dx, byte [edx + ecx - 0x7ff698d1]
mov word [esi], dx
lea ecx, [eax - 0x34ce8b66]
xadd eax, ecx
movzx edx, cx
movzx ecx, byte [ebp + edx*4 - 0x146ba]
lea edx, [eax*4 - 0x72641674]
neg al
sbb ebp, 0xfffffff8
neg dx
sar edx, 0xff
idiv ax
xor cl, bl
cdq
push eax
neg dl
not cl
xor cl, 0xa4
add cl, 7
sal word [esp], 0xc2
cwd
xor cl, dl
sar edx, 0x94
xor bl, cl
mul dword [esp]
bswap eax
inc dword [esp]
lea ecx, [esp + ecx + 4]
movzx ax, byte [ecx]
call fcn.009a8722
call fcn.00868d48
mov eax, 0xf1b6610b
lea ecx, [eax + eax*4 + 0x44a3f8ad]
sub ebp, 4
imul cx, cx
movsx edx, cl
sal dl, 0xe7
add edx, dword [edx + ebp]
btc cx, 0xb4
sal al, 0xe5
xor edx, ebx
ror edx, 1
cwde
sar ecx, 0xe6
inc eax
xor edx, 0x3cb6240c
sar cx, cl
sub cx, 0xb197
sar ax, 0xc2
inc edx
bswap edx
shr ax, cl
xor ecx, ecx
ror ecx, 0x42
xor ebx, edx
sal ax, 0xe9
dec eax
add esi, edx
movsx edx, al
shl cx, 0x61
mov eax, dword [eax + edi - 0x83ff]
btc ecx, edx
btr cx, 0x97
mov ecx, dword [edi + ecx - 0x7ffffffc]
sub edx, edx
imul dx, dx
push ebx
jno 0xc86c0b
mov dword [edi + eax - 0x602be4d3], ecx
movsx ecx, ax
cwde
mov dword [edi], edx
call fcn.0086750f
Function at 0xc85a01
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
xor al, 0x3e
not cx
sub ecx, 0xa70a5125
neg dword [esp + edx - 0x3a10d218]
xor bl, al
inc ecx
and dword [esp + edx*2 - 0x7421a434], 0x850a2519
shr word [esp + edx - 0x3a10d216], 5
lea eax, [esp + eax + 8]
pop ecx
dec dx
pop ecx
mov ecx, dword [edx + eax - 0x3a10d21b]
jp 0xce3d78
xor al, bl
rol al, 1
or dx, dx
adc al, 4
neg al
bswap edx
sub al, 0xa5
dec dl
ror al, 1
call fcn.008af206
mov ecx, 0x5d89b933
lea ebp, [ecx + ebp - 0x5d89b937]
btr ecx, 0xbe
movsx edx, cx
call fcn.008fdf3f
rol ecx, 3
bswap ecx
rol ecx, 1
xor ebx, ecx
add esi, ecx
movzx ecx, al
and word [esp + edx - 0x3d3adb00], 0x4a83
lea ecx, [edi + edx - 0x3d3adb04]
mul word [esp + edx - 0x3d3adafe]
and dword [esp + edx - 0x3d3a0000], 0x989e1c9b
mov dword [edi + edx*2 - 0x7a740008], ecx
lea edi, [edi + edx - 0x3d3a0008]
dec edx
pop ecx
jne fcn.00c9bff2
mov dword [esp + edx - 0x3a10d21c], edx
push edx
sub al, 0x22
jmp 0x86c5b4
movzx eax, dx
mov edx, ecx
movsx ecx, al
xadd ax, cx
mov ecx, dword [esi + eax - 0xd236]
adc edx, ecx
movsx ecx, ax
mov dword [esi + eax*2 - 0x1a46c], edx
shl cx, 0xac
add ax, 0xe52f
mov edx, eax
movzx ecx, byte [ebp + eax*4 - 0x2dd96]
shr eax, 0x43
ror dl, 0x21
xor cl, bl
push edx
xadd word [esp + eax - 0x16eb], ax
cwd
xor cl, 0x9c
cwde
neg dword [esp + eax - 0xb7]
ror cl, 1
neg cl
inc ax
call fcn.0091a1e1
neg ecx
sub word [esp + eax*2 + 2], 0x352a
jno 0x9a8fdf
mov dword [esp + 0xc], 0xc294bdab
sub edi, 4
mov edx, dword [esp + 0xc]
movzx eax, byte [esp + 0xc]
mov ecx, eax
mov ecx, dword [edi + eax - 0xab]
xchg word [esp + eax - 0xab], dx
xor ecx, ebx
idiv al
dec ecx
cbw
sub dl, 0x11
not ecx
neg ecx
lea ecx, [ecx + eax*2 + 0x21b69736]
xor ebx, ecx
inc al
and eax, dword [esp + eax - 0xfff3]
imul ax
add ebp, ecx
mov dword [esp + eax - 0xf039], ebp
ret 0x10

Function at 0xc85e24
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
not ecx
mov cx, word [edi]
neg eax
jl 0x8d8f64
mov ax, word [edi + eax*2 - 0x4594e29c]
mov edx, 0xe53fc53a
adc edi, 1
shl edx, 0x3d
sal dl, 0xc5
or edx, edx
and cx, ax
call fcn.007b4318
mov dword [esp + edx - 0x74baf9a8], edx
movzx ecx, byte [ebp + edx - 0x74baf9a9]
mov eax, 0x2299200d
btc edx, eax
jae 0x76026c
xor cl, bl
add cl, 0x3d
not cl
neg dword [esp + eax - 0x2299200d]
sbb cl, 0xa9
cwd
neg cl
xor dl, al
xor bl, cl
sub edx, dword [esp + edx - 0x74ba000d]
lea ecx, [esp + ecx + 4]
push eax
xor eax, 0x73aa10b8
call fcn.00c85a9c
Function at 0xc86522
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
push 0x5219712b
lea esp, [esp + 0x10]
jne 0xd0c69f
mov eax, 0x230fe22d
mov edi, eax
movsx ecx, al
pop edi
mov dword [esp + ecx - 0x5a7981c1], eax
mov ecx, dword [eax + edi - 0x34c58105]
inc edx
xor ecx, ebx
cdq
xor ax, word [esp + edx*2 + 1]
cdq
bswap ecx
xor ecx, 0x419b0037
rol dl, 0xa7
mul eax
shr word [esp + edx - 0xae0bbd5], 0x28
dec ecx
and eax, 0x33114589
adc ax, 0xdfbb
btr eax, eax
neg ecx
btc ax, 0xb2
or dword [esp + edx - 0xae0bbd6], eax
btc eax, eax
xor ebx, ecx
sal dword [esp + edx*8 - 0x5705deb0], 0xa8
cbw
sal al, 0xe2
mov dword [esi + edx*4 - 0x2b82ef60], ecx
call fcn.00ce15e8
mov ecx, 0xfacc798
lea edx, [ecx + ecx*4 + 0x4a0c3a27]
lea ebp, [ebp + ecx*2 - 0x1f598f34]
shl cl, 0xe5
mov ecx, dword [ecx + ebp - 0xfacc700]
xor ecx, ebx
add dx, dx
mov eax, 0xd09101ad
neg ecx
xchg ah, dl
xor eax, eax
rol ecx, 3
shr al, 0x41
bswap ecx
rol eax, 0xd8
neg eax
rol dl, 0xa5
rol ecx, 1
bt eax, 0x26
sal dx, 0x43
bswap edx
xor ebx, ecx
or ax, 0x8798
add eax, edx
cwde
adc esi, ecx
movsx ecx, al
ror eax, cl
sal dx, 0xaf
mov ecx, edi
setb dl
push edx
lea edi, [edi + edx*4 - 0x40004]
mov dword [edi + edx - 0x10000], ecx
pop edx
jp fcn.00c9bff2
jmp 0x95db47

Function at 0xc8722f
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
xor ebx, edx
call fcn.0093b2d1
dec al
inc edx

Function at 0xc88f27
Capabilities:
Encode data using xor

Disassembly:
call fcn.007c1a39
mov edx, 0x39a0c21b
movzx ecx, dl
bt edx, ecx
mov edx, dword [ebp + edx - 0x39a0c21b]
call fcn.00c3923a
mov ax, word [esi]
mov edx, 0xbd32f292
and dx, 0x59b7
mov cl, byte [esi + 2]
rol edx, 0xed
lea edx, [edx + edx*4 + 0x3f01f928]
adc esi, 2
btr edx, edx
shl ax, cl
mov ecx, edx
bt edx, 0x8d
sbb edx, ecx
mov word [esi], ax
btc dx, cx
add edx, ecx
jno 0xc98422
cmp esp, dword [edi]
mov ah, 1
mov ecx, 0xf6db76
not dh
loope 0xc88fbe
fcomi st(6)
add byte [edx - 0x2451de9b], ch
test byte [eax], 0x7e
mov ss, word [ecx + 0x3e]
fcomi st(6)
add byte [esi + 0x248f912d], dh
invalid
adc dword [edi], 0x98f40ca9
sbb ah, ch
leave
or al, byte [eax]
lds ebx, [esi + 0x14bedfa]
cmp byte [edi + edx*2 - 0x1f], 0xd9
adc cl, 0xe9
mov byte [ebx], ch
popfd
cmp eax, 0x6a35dcba
pop ebp
mov ah, 0xb6
invalid
mov edx, dword [ebp]
adc cl, ch
adc ebp, 4
xor edx, ebx
lea eax, [ecx + ecx*2 - 0x2244704f]
and eax, 0x3daeaa82
dec eax
not edx
bt eax, eax
rol edx, 1
lea ecx, [ecx + ecx*8 - 0x17f22649]
dec edx
bswap edx
cbw
shr cl, 0x67
xor ebx, edx
div al
neg eax
call fcn.008813b2

Function at 0xc8bb1d
Capabilities:
Encode data using base64

Disassembly:
not dl
xor bl, dl
lea edx, [esp + edx + 8]
cwde
shr dword [esp + 4], cl
movzx cx, byte [edx]
sub ax, ax
movzx edx, ax
mov word [edx + ebp - 2], cx
add ax, dx
adc dl, ah
lea ebp, [edx + ebp - 2]
cdq
pop edx
pop edx
jno fcn.00754c95
mov edx, 0x5605cca3
mov ecx, dword [ebp + edx - 0x5605cca3]
jmp 0x9740a8
Function at 0xc8ca97
Capabilities:
Encode data using xor

Disassembly:
sar edx, 0x36
bswap eax
neg ecx
ror ecx, 1
shr byte [esp + edx*2 + 4], 0x21
pop eax
adc ecx, 0xea11c581
xor ecx, 0x3f8b1913
xor ebx, ecx
add edi, ecx
movzx ax, byte [ebp + edx]
or edx, dword [esp + edx*2]
movzx ecx, dx
mov dl, byte [edx + ebp - 3]
inc dword [esp + ecx*4 - 0x14]
rol cl, 1
and al, dl
sar byte [esp + ecx - 8], 0x47
sete cl
xor dword [esp + ecx*8 - 8], 0x43013717
not al
ror dword [esp + ecx*2 - 2], cl
shl dword [esp + ecx*2 - 2], 0xb8
shl byte [esp + ecx + 2], 1
mov word [ecx + ebp + 1], ax
movzx edx, word [esp + ecx - 1]
or dl, byte [ecx + esi - 6]
xadd byte [esp + ecx*2 - 2], ch
xor dword [esp + ecx*2 - 2], ecx
shr ecx, 0xa9
lea esi, [esi + ecx*8 - 5]
mov eax, 0x4016e016
shr al, 0x47
xor dl, bl
dec dl
dec ecx
dec cx
ror dl, 1
xor dword [esp + eax - 0x4016e000], 0x20391b87
dec dl
bt eax, 0x1f
jae 0x79abd8
mov ecx, dword [edi]
mov edx, 0xdfad400b
lea eax, [edx*2 + 0x5d2bc790]
mov eax, dword ss:[ecx + eax*4 - 0x72191e98]
sub edx, edx
lea ecx, [edx + edx*4 + 0x4f0fa023]
xor edx, dword [edi + edx*2 + 4]
or eax, edx
call fcn.00ce9524
out 0x63, al
mov ah, 1
adc al, 0x7b
lahf
test byte [eax], 0xef
xchg ecx, eax
hlt

Function at 0xc8f89d
Capabilities:
Encode data using xor

Disassembly:
test ebx, ebx
jmp 0x940dba
jmp 0x8140ef

Function at 0xc958a4
Capabilities:
Encode data using xor

Disassembly:
and dl, byte [esp + 4]
lea ecx, [ecx*8 + 0x651c8f2a]
bswap eax
sub ecx, dword [esp + ecx - 0x78cc9133]
sub cl, byte [esp + ecx - 0x36ac906f]
call fcn.0086d5c6

Function at 0xc99dac
Capabilities:
Authenticate hmac

Disassembly:
btc edx, 0xb9
xor bl, cl
neg dx
lea ecx, [esp + ecx + 0x10]
mov edx, dword [ecx + eax - 0x4000c45a]
mov dword [esi + eax - 0x4000c458], edx
lea esi, [esi + eax - 0x4000c458]
mov dword [esp + eax - 0x4000c45a], edi
ret 0xc
add edi, eax
movzx ecx, byte [ebp + ecx - 0xef05]
movzx eax, dx
push edx
lea ebp, [ebp + eax - 0xc49a]
xor cl, bl
ror cl, 1
dec dl
mov dword [esp + eax*2 - 0x1893a], edx
bts eax, edx
dec cl
rol cl, 1
rol dword [esp + eax - 0x4000c497], 4
sbb cl, 0x30
xor cl, 0x2c
xchg byte [esp + eax - 0x4000c49d], al
dec edx
ror cl, 1
sub cl, 2
neg cl
add dx, word [esp + eax - 0x4000c4f8]
add cl, al
xor al, 0xa5
ja 0xc68edf
mov ecx, 0xef35ea95
lea eax, [ecx + ecx*2 - 0x607def50]
lea edi, [edi + eax - 0x6d23d073]
mov eax, dword [eax + edi - 0x6d23d06f]
rol cx, 0xcd
lea edx, [ecx*4 - 0x336b0851]
xor eax, ebx
dec edx
xor cl, 0xbb
dec cl
not eax
sub edx, 0x100ccc94
neg eax
bswap eax
and dx, dx
push ecx
dec eax
shl edx, 0xf7
push ecx
neg eax
ror ecx, 0xd9
ror eax, 3
and cl, ch
call fcn.009bb584
xor dl, bl
mov ecx, 0x7012923f
ror dl, 1
sar word [esp + ecx - 0x7012923d], 0xa1
adc dl, 0xb2
neg dl
ror cx, 0xe9
Function at 0xc99f22
Capabilities:
Authenticate hmac
Encode data using xor

Disassembly:
mov ecx, dword [esi + edx - 0x50913a00]
or edx, edx
push edx
lea esi, [esi + edx - 0x509139fc]
mov ebp, ecx
pop eax
jns 0x804b0b
mov eax, 0xf98f231a
mov eax, dword [ebp]
mov ecx, 0xf63f6a1f
sub ebp, 0xfffffffc
bswap ecx
sar ecx, 0x36
movzx edx, cx
xor eax, ebx
or edx, 0xba868003
imul dx, cx
rol eax, 1
shr ecx, 0x91
dec eax
jmp 0x8f427c
lea ecx, [esp + ecx + 4]
xor byte [esp + eax + 3], dh
adc edx, edx
or dl, byte [ecx + eax*2]
call fcn.0099d32a
call fcn.00c7b5de
dec al
mov ecx, 0x21a05b3a
not cx
ror al, 1
mov edx, 0x8f902495
ror dword [esp + ecx*2 - 0x4341498a], cl
btr edx, 0x2e
dec al
sal dword [esp + ecx - 0x21a0a4c5], cl
call fcn.008c8a57
shl dx, 0x85
xor ax, dx
xor ecx, 0xb781383c
xor dx, dx
ror ecx, 2
ror al, 0xe3
mov dword [esp + eax - 0x348a2215], edx
btc eax, 0x9d
xor ebx, ecx
and byte [esp + eax*4 - 0x52288851], 0x23
adc edi, ecx
movzx ecx, ax
xchg dword [esp + eax - 0x148a2215], ecx
movzx ecx, byte [eax + ebp - 0x148a2210]
btr edx, 0x93
inc word [esp + eax - 0x148a2215]
dec eax
lea ebp, [ebp + eax*4 - 0x5228884a]
and byte [esp + eax - 0x148a2211], ah
ja 0x83c60d
xor cl, bl
dec cl
neg edx
pop eax
not cl
idiv ax
rol cl, 1
xor cl, 0xb9
push edx
or edx, edx
sbb eax, eax
xor bl, cl
rol word [esp + edx*2 - 0x11fffe], 0xe3
jae 0x85e47b

Function at 0xc9aded
Capabilities:
Encode data using base64

Disassembly:
mov dword [esp], 0x1464cb8
call fcn.00cb8079

Function at 0xc9ae12
Capabilities:
Encode data using base64

Disassembly:
rol dl, 0x26
xor ebx, eax
mov dword [esp], ecx
call fcn.00c994c8

Function at 0xc9b71f
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
movzx ecx, ax
lea eax, [esp + eax*2 - 0x1ffe2]
mov edx, dword [eax + edx - 0x27a2df94]
mov dword [edi + ecx*2 - 0x20006], edx
xchg dword [esp + ecx*2 - 0x1fffb], ecx
movsx edx, cl
mov eax, dword [ebp - 5]
and ecx, 0x518d69b6
xadd dword [esp + ecx - 0x508500b2], edx
lea ebp, [ebp + ecx - 0x508500bb]
or dl, byte [esp + ecx - 0x508500b6]
xor eax, ebx
rol eax, 2
imul ecx, dword [esp + ecx - 0x508500b5]
not eax
neg dword [esp + 4]
xor eax, 0x580e0f98
rol eax, 2
lea edx, [ecx + ecx*8 - 0x4d668e46]
xor ebx, eax
not cx
add ecx, 0xc284acab
add esi, eax
movsx eax, dx
mov eax, dword [edi + eax*8 - 0x35f28]
mov ecx, dword [edi + edx - 0x649b6be8]
rol dword [esp + edx - 0x649b6be0], 0x75
add eax, ecx
sar dx, 0xab
jae 0x974309
mov eax, 0x1b0514b4
movzx ecx, al
lea edx, [ecx*2 - 0x79c56554]
lea ebp, [ebp + eax*4 - 0x6c1452d1]
bt ax, 0xb1
xchg cl, al
cmovae eax, ecx
mov al, byte [eax + ebp - 0xb4]
jae 0xc90f69
mov dword [esp + edx*4 - 0x3fffc], eax
xor cl, 0x95
push eax
add cl, dl
xchg word [esp + edx - 0xfffb], ax
sal ax, 0x44
neg cl
sal eax, 0xff
adc cl, 0x9f
xadd ax, dx
xor bl, cl
lea ecx, [esp + ecx + 8]
add edx, dword [ecx + eax*4 - 0x3fffc]
mov dword [edi + eax*8 - 0x7fffc], edx
lea edx, [eax*8 + 0x279adf9c]
jmp 0x8c1fe6