joyce8/EMBER2024-capa huggingface dataset:
Function at 0x97ed69
Capabilities:
Encode data using xor

Disassembly:
inc sp
btc ebx, edi
inc ecx
movsx edx, ax
inc cx
rol edx, 1
inc cx
sub edx, 0x5e41eb1a
shr edi, 2
inc cx
xor edx, 0x4166dc11
not edx
inc bp
xor ecx, edx
btc ebx, edi
inc ecx
sal bh, 0x22
not bx
inc sp
mov dword [esi + ebx*2 - 0x1befe], edx
inc ecx
push esi
pop ecx
inc ecx
not bh
inc ecx
mov eax, dword [ebx + ebx*2 - 0x1befc]
js 0x8abf14
pop edx
mov dword [esp], 0x388cee31
xor ebx, ecx
sar dx, 8
sbb ax, ax
sbb eax, eax
sar byte [esp + 3], 0x67
adc edi, ecx
sub word [esp + 2], ax
and al, 2
ror byte [esp], 0xe3
ja 0x7b11cd
adc bl, byte fs:[eax - 0x79804680]
pushal
add al, 0x82
xor eax, 0x9896fff9
sub al, 0xee
xor eax, 0xe0f2fff9
in al, dx
fisubr dword gs:[ebx]
cmp dh, 0x1d
idiv dword [ebx]
inc esi
adc eax, 0x5ef8938d
xchg ebx, eax
xchg dword [esi - 0x79], eax
arpl word [edx - 0x3d], sp
loope 0x777d6b
clc
xchg dword [edx], ebx
fdisi8087_nop
mov eax, 0xeb62a7f8
loope 0x777d77
clc
aas
insb byte es:[edi], dx
rcl byte [edx]
jmp dword [esp + eax*2]
inc esp
mov esp, edx
dec ebp
lea ebx, [ebx + ebx*8 - 0x6fbf2]
inc esp
xadd ebx, eax
inc ecx
xor eax, ecx
inc eax
inc ecx
not dh
dec esi
lea esp, [ebp*2 - 0x135011c8]
dec eax
bts ebx, 0x2f
neg eax
dec cx
shr edx, cl
rol eax, 1
inc ecx
ror dh, 0xe1
bswap eax
rol dx, 0x23
jae 0xc3b5f0
dec esp
mov dword [ebx + esi + 2], esp
dec eax
mov dword [esp + ebx], 0xd0b32819
inc esi
movzx edx, word [ebx + ebx]
dec esp
lea ebp, [edi + ebx*2 + 0x180e99b1]
inc bp
xor edx, ecx
jmp 0x777d0e
inc ecx
ror ebp, cl
inc ecx
push ecx
inc cx
bts esp, 0x92
inc edx
xor dword [esp + eax*8 - 0x6fbf8], eax
inc ecx
pop ecx
jmp fcn.00c4b175

Function at 0x981ef1
Capabilities:
Encode data using base64

Disassembly:
neg eax
ror cx, 0xa
neg dword [esp + 4]
lea ecx, [ecx + ecx*4 - 0x48f605dd]
lea eax, [eax + ecx - 0x68a6c365]
bswap eax
not eax
xor dl, byte [esp + 5]
mov dword [esp], edx
xor ebx, eax
sub cx, dx
add edi, eax
ror byte [esp + 2], 0x21
pop ecx
pop edx
jb fcn.00cfe987

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

Disassembly:
xor eax, ebx
lea eax, [eax + edx*2 - 0x665be701]
dec dx
mov dword [esp + edx - 0x723ffa58], edx
xchg dword [esp + edx - 0x723ffa58], edx
not eax
js 0x786b89

Function at 0x98789b
Capabilities:
Encode data using xor

Disassembly:
lea esp, [esp + 4]
jne 0x7ae09a
Function at 0x98aad0
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
mov eax, 0xd3147e92
btc ax, ax
div al
mov eax, dword [ebp + ebx*4]
call fcn.00cd93ef
add edi, edx
sar dword [esp + ecx - 0x1364b5a2], cl
adc dword [esp + ecx - 0x1364b5a2], eax
dec ecx
movzx edx, byte [ebp + ecx - 0x1364b5a1]
lea ebp, [ebp + ecx*2 - 0x26c96b41]
xor dl, bl
xor ecx, ecx
not dl
rol dword [esp + ecx], 0xc3
shr byte [esp + ecx + 2], 0xa1
xor dl, 0xa4
add dl, 7
cbw
sar cl, 0x87
add ecx, ecx
not dl
jge 0x8a5131
xor al, 0x3b
sub cx, ax
xor bl, dl
inc ecx
pop eax
xor cx, cx
adc edx, esp
bt cx, ax
mov dword [esp], eax
push 0x788cf3a8
dec ebx
push 0x6cad2ab6
call fcn.008e05ab
mov eax, 0x3c991684
movsx ecx, al
mov ecx, dword [ebp + eax*2 - 0x79322d08]
lea ebp, [eax + ebp - 0x3c991680]
movsx edx, al
cbw
call fcn.0094702a
mov dword [esp + 4], eax
push 0x8e3dbc04
dec ebx
lea esp, [esp + 8]
jne 0x7baada
mov eax, dword [ebp]
push 0x4c03533a
lea esp, [esp + 4]
call eax
mov edi, 0x343173a5
mov ebx, edi
mov ebp, dword [ebp + edi - 0x343173a9]
movsx esi, bx
mov dword [edi + ebp - 0x343173a5], eax
bt esi, ebx
mov ecx, 0x2ebc5b16
mov esi, ebp
pop ebx
movzx eax, cl
pop edi
movzx edx, al
pop ebp
mov edx, dword [ebp + ecx - 0x2ebc5b16]
shl ax, 0x43
jae 0x9b433d
mov ecx, 0xbf3ed5ae
movzx eax, cl
mov eax, dword [ebp + eax*4 - 0x2b8]
mov ecx, dword [ebp + 4]
mov edx, 0xf923fb8a
lea edx, [edx + edx*8 - 0x38d60fd9]
or eax, ecx
movzx ecx, dx
or edx, 0xd5a30cab
not eax
or dl, 0x3e
sal edx, 0xd0
mov dword [ebp + ecx*4 - 0x32000], eax
inc edx
mov eax, dword [ecx + esi - 0xc805]
rol ecx, 0xec
lea esi, [ecx + esi - 0xc801004]
xor eax, ebx
bswap eax
rol edx, 0x15
not eax
and ecx, ecx
bt ecx, edx
btc ecx, ecx
bswap eax
jb 0x80bc43
sar dx, cl
sub ecx, 0xc9371139
dec eax
imul ecx, edx
ror eax, 2
and ecx, ecx
push ecx
imul ecx, ecx
xor ebx, eax
add edi, eax
mov ecx, dword [edx + ebp - 0x39cbec]
lea eax, [edx*4 + 0x1ca22933]
inc byte [esp + edx*8 - 0x1ce5f7d]
mov eax, dword [ebp + edx - 0x39cbe8]
lea edx, [edx - 0x29d500f4]
sar byte [esp + 3], 0x85
add ecx, eax
dec dx
movzx eax, word [esp]
mov dword [ebp + eax - 0x7378], ecx
setp al
lea ebp, [ebp + eax*2 - 0xe5f8]
mov dword [esp + eax*4 - 0x1cc00], edi
ret

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

Disassembly:
not eax
and dx, cx
lea eax, [ecx + eax + 0x2b7027f8]
btr edx, 0xa3
neg eax
sal edx, 5
mov dword [esp + ecx - 0x649765b8], 0x4da646a0
neg cx
inc eax
bswap eax
sub word [esp + ecx - 0x64979a48], cx
sub cx, word [esp + ecx - 0x64979a47]
neg eax
shl edx, 0xe6
sub dx, cx
xor ebx, eax
call fcn.007e2081
call fcn.008b2a43

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

Disassembly:
inc ecx
mov edx, 0x1f136fb6
inc edi
mov edx, dword [ebx + edx - 0x1f136fb6]
dec eax
mov dword [esp], 0x60ae9c99
dec ecx
add ebx, 4
inc ebp
xor edx, ecx
rol word [esp + 2], 0xa6
inc dword [esp + 4]
shr word [esp + 2], 0x41
inc ecx
inc edx
dec eax
rol dword [esp], 0xe8
inc ecx
xor edx, 0xa59032bf
inc ecx
add edx, 0xa4902ba5
inc ecx
neg edx
call fcn.00c68baa
Function at 0x99040a
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
xor al, 0xb5
not al
not dx
xor bl, al
lea eax, [esp + eax + 8]
xor dx, 0x988
mov ecx, dword [edx + eax - 0xbde]
and dword [esp + edx*4 - 0x2f74], 0x4a02b09c
shr edx, 0xd5
push edx
mov dword [edx + ebp - 8], ecx
lea ebp, [ebp + edx*8 - 8]
movzx ecx, dx
sub edx, 0xbe0d0fb0
pop ecx
pop edx
pop ecx
jns fcn.00754c95

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

Disassembly:
xor eax, ebx
mov dword [esp + edx*2 - 0x6e32f044], 0x9394bea3
lea ecx, [edx + edx*4 + 0x491e20b5]
rol eax, 3
imul cx, word [esp + edx - 0x37197820]
or ecx, 0x59ae4c34
sub cx, 0x9393
xor eax, 0xb09d0ca7
shr cx, 0xe7
lea eax, [eax + ecx*2 + 0x3a147a6a]
push ecx
sub dword [esp + edx - 0x3719781e], 0xa21c7f87
neg eax
inc cx
bts dx, 0x8d
xor ebx, eax
xchg edx, ecx
add ebp, eax
xchg byte [esp + edx - 0x5dbf00d8], cl
xor dx, dx
mov edx, dword [edi + edx - 0x5dbf0000]
mov ecx, dword [edi + ecx*2 - 0x6e32effc]
jns 0xd08a95
jae 0x880702
mov eax, 0xa7aa7f1b
bt eax, 0x34
sbb ebp, 4
mov edx, dword [ebp]
call fcn.00cc364e
call fcn.008fa1b4

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

Disassembly:
neg edx
and al, 0xa3
or eax, 0xae96c316
mov dword [esp], eax
not edx
sal ax, 0xec
xor edx, 0x46b3173e
call fcn.007bc9c9
sub esi, 1
mov eax, 0x510d62ab
movzx edx, byte [eax + esi - 0x510d62ab]
xor dl, bl
lea ecx, [eax*4 - 0xbf88479]
sar cl, 0x21
cwde
xor dl, 0x8d
xor eax, ecx
or ecx, eax
ror dl, 1
xadd al, cl
inc eax
adc dl, 0x83
inc cx
xor dl, 3
bt eax, eax
btc ax, cx
ror dl, 1
and cl, ah
not cl
sbb dl, 0xa
bswap ecx
xor bl, dl
xor cx, ax
xadd eax, ecx
add edx, esp
mov ax, word [edx + eax*2 - 0x2f477b88]
sal cx, cl
movsx edx, cl
bt edx, 0x25
lea ebp, [ecx + ebp - 0x383d1982]
call fcn.00c684dc

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

Disassembly:
inc ebp
xor dh, cl
dec ebx
lea ecx, [esp + eax*2 - 0x776f46]
inc ecx
sub dh, 0xb9
dec esp
lea edi, [edi + ecx*8 + 0x10035e01]
dec esi
mov dword [esp + eax - 0x6c2ab133], eax
push eax
inc ecx
xor dh, 0x85
inc edx
movsx ebx, byte [esp - 0x159cb9fd]
dec eax
add ecx, 0x56155d95
cbw
inc ecx
neg dh
push edi
dec eax
rol eax, cl
inc esi
xchg dword [esp + eax - 0x6c2ab125], eax
inc ecx
sbb dh, 0x92
dec edx
lea edx, [ebx + eax + 0x7bb1cd1b]
inc bp
and edi, edi
inc ecx
imul edi, edi
inc ebp
xor cl, dh
inc esp
mov edx, dword [esp + ebx*8 - 0x193]
dec eax
bt ecx, 0xac
dec eax
btc ecx, ebx
dec esi
lea esi, [esp + esi + 0x18]
inc edx
not byte [esp + edx - 0x32fffff2]
dec eax
shr eax, 0xb
inc bx
movzx ecx, byte [esi - 0x2b39740a]
inc edx
sal dword [esp - 0x5672e808], 0x75
inc edx
sal byte [esp - 0x159cb9ee], 0xe4
dec ecx
mul edx
inc sp
mov edi, ecx
inc bp
movzx edi, bh
dec eax
bswap eax
div edi
sar byte [esp + eax - 0x92217], 0xc7
inc eax
mov bh, byte [esi + eax*2 - 0x124434]
bts ax, 0xa8
inc esp
adc bh, bh
dec ecx
shr eax, 0x48
call fcn.008343de
Function at 0x996a1c
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
dec esi
mov dword [esp + ebp*2 - 0x10824], ecx
dec ecx
bts esi, eax
inc esi
xor dword [esp + ebp - 0x8412], eax
push edx
movzx ebx, dl
dec eax
cwde
dec esi
mov ecx, dword [esp + ebp - 0x840a]
inc esi
movzx edi, byte [esp + ebp - 0x8411]
inc ecx
dec dh
dec ecx
sal edx, cl
dec ebp
arpl ax, ax
inc ecx
ror ebp, cl
dec eax
mov dword [esp + eax + 0x10008], 0x399c432a
dec ecx
adc ebp, eax
inc ecx
rol esi, 0x22
inc cx
neg ebp
dec ecx
sub ebx, ebp
dec esi
lea eax, [esp + ebp*2 - 0x3eed8]
inc ebx
add al, byte [ebp + eax - 0x1f7dc]
inc cx
sar esi, 0x2a
dec esi
lea edx, [edi + edi*4 + 0x79882c15]
inc dx
mov dword [esi + ebp - 0x1f7e2], eax
inc ecx
pop eax
inc edx
shl byte [esp + ebp*2 - 0x3efb2], 0x81
inc ecx
not bh
dec ecx
lea esi, [ebp + esi - 0x1f7e2]
mov eax, 0x9d87c514
inc ecx
pop ebp
jae fcn.0073c0e6
cwde
inc ecx
push ecx
dec eax
not edi
inc esp
adc esi, edi
inc esp
xor dword [esp + edx + 1], esp
dec ecx
dec edx
inc ecx
shr dl, 0xe1
inc esp
or eax, edi
inc ecx
pop ecx
inc ecx
neg eax
dec ecx
not ebp
call fcn.0073a09f

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

Disassembly:
mov ecx, edx
not dword [esp + 0x10]
rol ax, 1
lea ecx, [edx + ecx - 0x6c7e27cd]
xor bx, ax
pop ecx
bt edx, 0x36
mov word [esi - 4], ax
sbb dword [esp + 0xc], edx
lea ecx, [esi - 4]
xadd dword [esp + 0xc], edx
imul edx, edx
mov dword [esi + edx*2 - 0x198a23da], ecx
push edx
or dx, dx
lea ecx, [edx*4 - 0x85867e1]
lea esi, [esi + edx - 0xcc511f1]
sub dx, 0x7a5
lea edx, [ecx + ecx*4 + 0x3690343a]
and edx, dword [esp + edx*4 - 0x30ee4c17]
pop eax
pop edx
pop ecx
pop eax
pop ecx
ja fcn.007ab5dc

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

Disassembly:
mov dword [esp], 0xfd33f290
mov dword [esp], ebx

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

Disassembly:
movzx edx, byte [ebp + eax*2 - 0x422]
xor dl, bl
xor dl, 0x95
mov dword [esp + eax - 0x211], 0x1e90bbae
sub dl, cl
neg eax
xchg dword [esp], ecx
rol byte [esp + ecx - 0x1e90bbab], 6
neg dl
xchg cx, ax
and dword [esp + ecx - 0x1e90fdef], 0x1b15a926
or eax, 0xb13ac032
adc dl, 0x9f
mov dword [esp + ecx*2 - 0x3d21fbde], 0x442d6333
bt ecx, eax
jae 0xcb3529

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

Disassembly:
add esi, 6
mov dword [esp], 0x87b126a8
sar byte [esp + 3], 0xc7
shld edx, eax, cl
mov dword [esi], edx
mov ecx, dword [esp + 6]
call fcn.0097d089
Function at 0x9aaf50
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
push 0x560ddf83
dec ebx
lea esp, [esp + 8]
jne 0x89d795

Function at 0x9acde7
Capabilities:
Encode data using base64

Disassembly:
add al, 0x15
neg al
dec dx
mov dword [esp + edx*2 - 0x44691a5a], edx
call fcn.0089ae59

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

Disassembly:
sub dl, 0xbb
add ecx, 0x2eb5949b
neg dl
sar ecx, cl
xor dl, 0x12
pop eax
inc ecx
movsx eax, cx
inc dl
rol dl, 1
shl cx, cl
xadd al, cl
dec dl
bts ax, ax
or cl, al
xor bl, dl
btc ax, cx
jb 0x9a1def

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

Disassembly:
bswap ecx
add eax, 0xb513451c
pop edx
xor ebx, ecx
add edi, ecx
neg ax
shr byte [esp + 1], 0x64
movsx edx, al
mov edx, dword [ebp + edx*2 - 0xd0]
mov dword [esp + 4], eax
neg eax
lea ebp, [ebp + eax - 0x4af07e94]
cwde
jle fcn.00996adb
xor edx, ebx
call fcn.0094fe72
mov ecx, dword [esi + ecx - 0x4319a688]
mov eax, dword [esi + 4]
mov edx, 0x5f1cbd22
not ecx
and dx, dx
not eax
jle 0xc9a0b4
mov dx, word [esi]
mov eax, 0x23b8fe1b
call fcn.0098f71e
or ecx, eax
movzx eax, dx
mov dword [edx + esi - 0x5f1cbd1e], ecx
movzx eax, byte [eax + ebp - 0xbd22]
movzx ecx, dx
imul ecx, edx
xor al, bl
rol dx, 0xe6
inc ecx
lea ecx, [edx + ecx*4 - 0x6a4aa7e0]
not al
dec al
sar dx, 0x89
xor al, 0xf
btc dx, dx
ror al, 1
bts edx, edx
call fcn.0090954c
Function at 0x9b6c2b
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
dec eax
cdq
dec ebp
arpl bp, bp
neg dl
dec ecx
adc ebp, ebp
dec eax
ror ecx, cl
inc ebp
movsx edx, di
dec esp
lea ebp, [edx*8 - 0x6cc5f6ec]
dec esi
mov esp, dword [esi + edi*2 - 0x122]
inc ecx
or cl, al
jg 0xccab5f
dec ebx
mov eax, dword [esp + edi*2 - 0x122]
inc ecx
setbe bh
imul ecx, edx
dec ecx
sal edx, 0xde
dec eax
mov dword [ecx + esi], eax
dec eax
or ecx, ebp
jmp ecx
inc ebp
lea ebp, [ebp + ecx*2 - 0x537ad7b8]
inc ecx
rol ebp, 2
inc ecx
pop edx
dec eax
xor edi, eax
inc ecx
dec ebp
inc ecx
not ebp
inc sp
btr eax, esi
inc esp
xchg ebx, esi
inc ecx
imul eax
inc ecx
push ecx
inc esp
xor dword [esp + ecx*2 - 0x4373d122], ebp
inc ecx
xchg bh, bl
rol dl, 0x41
inc ecx
pop ecx
inc sp
bts edx, eax
jae 0x7c5067
or eax, 0xfdb78871
jg 0x9b6cb5
push edx
in al, 0x1e
enter 0xffffffffffffe8ff, 0x3a
test dword [edi + 5], eax
adc al, 0xa5
call 0xf5998a1b
int 0x3a
xchg edi, eax
mov edi, ebx
xchg dword [esi - 0x34e574f9], ebp
invalid
and byte [esi], al
cmpsb byte [esi], byte es:[edi]
insd dword es:[edi], dx
aam 0x3a
sbb byte [esi], al
cmpsb byte [esi], byte es:[edi]
insd dword es:[edi], dx
mov esp, 0x5a0eff32
xchg edx, eax
jno 0x9b6d27
sbb eax, 0x88b4a97f
popfd
mov ah, 8
or byte [edx], 0x51
scasb al, byte es:[edi]
les esi, [edx + ebx*4 - 0x66]
jmp 0x9b6cd8
invalid
movsb byte es:[edi], byte [esi]
sbb esi, dword [ebp + 0x44e89d50]
mov esp, dword [esi + 4]
dec eax
add esi, 4
movsx edx, di
inc ebp
and edi, esp
mov ecx, edi
inc ecx
not edi
xadd bx, di
jle 0x97eae6
inc esp
mov dword [esi], edi
xchg dx, cx
mov eax, ebx
inc esp
mov eax, ecx
inc ecx
mov edi, dword [ebx + eax - 0x1aae3df7]
cwd
dec ebp
lea edi, [eax + ebx*4 + 0x6e93d8a5]
dec eax
or ecx, 0xcdace1be
dec esi
lea ebx, [ecx + ebx + 0x46]
call fcn.00c805dc
not eax
inc ebp
movzx edi, dl
inc ecx
xor ecx, ecx
xor ecx, 0x76131780
inc ecx
dec eax
sub eax, 0x7e3e642e
inc ebp
xadd dh, bh
inc ecx
bswap edi
ror ecx, 3
inc ebp
movsx eax, si
not ecx
inc ebp
mov ebp, edx
inc ecx
push ecx
xor dword [esp + eax*2 + 0x2e9dadcc], ecx
inc ecx
pop ecx
inc ecx
movsx edx, bp
inc cx
mul edi
dec eax
arpl cx, cx
dec esp
xor ebp, eax
dec eax
adc ebp, ecx
inc ecx
sal edi, 0xd8
dec esp
lea ebp, [eax*8 + 0x582c9e2d]
inc ecx
imul esi
inc ecx
movzx ecx, byte [ebx + eax*2 - 0x2e080000]
movzx edi, dl
inc ecx
sal bh, 2
movsx ebx, dx
dec ebp
lea ebx, [ebx + eax*2 - 0x2e07ffff]

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

Disassembly:
lea esi, [ecx + esi - 0x12f7e92]
pop edx
jno fcn.00c67487
Function at 0x9c20d8
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
mov dword [esi + edx*2 - 0x1c], eax
dec esp
mov dword [esp + edx - 8], eax
inc ecx
movzx edi, byte [ebx + edx*4 - 0x10]
dec eax
inc dword [esp + edx*2 - 0x10]
shr dx, 0x61
sets byte [esp + edx - 4]
dec esi
lea ebx, [edx + ebx + 0xd]
mov eax, dword [esp + edx - 2]
inc ecx
xor bh, cl
inc cx
not esi
inc esp
add dl, al
adc word [esp + edx*2 - 7], 0x6633
inc ecx
sbb bh, ah
and byte [esp + ecx*2 - 0x1fff7], 0x81
inc esp
add byte [esp + edx - 1], al
inc eax
ror bh, 1
inc ecx
idiv eax
inc ecx
xor bh, ah
inc cx
shl edi, 0x84
dec eax
idiv dword [esp + edx - 0x40]
inc eax
rol bh, 1
dec dword [esp + edx*2 - 0x1b84443c]
inc eax
xor bh, 0x92
inc eax
ror bh, 1
add word [esp + edx - 0xdc2221e], 0xe6b2
shr word [esp + edx - 0xdc2221d], 0x62
inc eax
sbb bh, 0xa5
not al
dec ebp
bt esi, esi
inc eax
xor bh, 0x9b
call fcn.00769f94
Function at 0xc3c3d3
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
ror dx, 0xe8
movzx edx, byte [ebp + ecx - 0x40000000]
dec ecx
xor dl, bl
btr ecx, ecx
ror cl, 0xc3
neg byte [esp + ecx - 0x3ffffffc]
sbb dl, 0x8a
xchg dword [esp + ecx - 0x3fffffff], ecx
ror dl, 1
pop ecx
not cl
ror byte [esp + ecx - 0x3ffffeff], 0xa6
sbb dl, cl
rol dword [esp + ecx - 0x3fffff00], 0x78
lea esi, [edx + esi - 0xfe84]
ror dx, 0x49
mov dword [esp + edx*8 - 0x223f8], edi
ret
bts ecx, 0x27
mov word [esi + ecx*8 - 0x18d6ac1e], ax
push edx
mov edx, dword [ebp + ecx - 0x31ad584]
not cl
movsx eax, cx
lea ebp, [ecx + ebp - 0x31ad577]
not eax
xor edx, ebx
sar ecx, 0x81
ror al, 0x27
bswap edx
cwde
lea edx, [edx + ecx*2 + 0x7282f53a]
neg edx
dec edx
pop eax
push ecx
rol dword [esp + ecx*8 - 0xc6b55e8], 0x95
ror edx, 1
shr cx, 0xea
btr cx, cx
lea edx, [edx + eax - 0x1255d06c]
jb 0x8defea
xor ebx, edx
xchg dword [esp + ecx - 0x18d001a], ecx
and cl, 0x86
adc edi, edx
idiv cl
movzx cx, byte [esi + ecx - 0x57a03182]
pop edx
sub edx, edx
sbb eax, eax
xor al, byte [esi + eax + 4]
jmp 0xcc8560
add esi, ecx
movsx ecx, byte [esp + eax*2 - 0x5dc0ea3]
neg ax
bts ax, dx
pop ecx
pop edx
pop edx
pop ecx
jb fcn.00882a69
movzx ax, byte [esi]
mov edx, 0x32b6d2a4
mov cl, byte [edx + esi - 0x32b6d2a2]
shl edx, 0xd6
shr dl, 0x22
shl dx, 0xef
not al
not cl
or al, cl
lea ecx, [edx + edx*8 + 0x121ad504]
jmp 0x941e6e
or dl, 0x3c
and cl, al
lea eax, [edx + edx*4 - 0x15fb02fb]
rol al, 6
not cl
push eax
add dx, ax
setp byte [esp + edx*4 - 0x3fa20]
mov word [esi + edx*4 - 0x3fa1c], cx
jns 0x8137df
jp 0x90ba52
mov edx, 0x93a48601
mov eax, edx
lea edx, [eax*2 - 0x51f4a1c9]
mov ecx, dword [ebp]
btr eax, eax
adc ebp, 4
idiv eax
imul edx, edx
and edx, eax
xor ecx, ebx
inc eax
not ecx
btc eax, eax
and ax, ax
neg al
neg ecx
sub ecx, 0xba994ab3
rol al, 0x27
lea eax, [eax - 0x6856d778]
rol ecx, 1
not edx
xor ebx, ecx
add edi, ecx
xchg al, dl
rol edx, 0xb2
jae 0x753157
mov eax, esi
sbb esi, 3
movzx ecx, dl
sar edx, cl
jno 0x8f988d

Function at 0xc3d9e0
Capabilities:
Encode data using base64

Disassembly:
adc cl, 0x92
mov dword [esp + edx*8], edx
push edx
ror cl, 1
neg cl

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

Disassembly:
xor ecx, 0x551ea6bc
sub ecx, 0x803c2d2a
btr edx, 0x1a
cwde
imul byte [esp + 9]
xor ebx, ecx
and edx, 0x21b1009
adc esi, ecx
pop ecx
pop eax
pop edx
jmp fcn.00c9bff2

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

Disassembly:
shl edx, 0x9e
ror ecx, 2
jmp 0xc78808
lea eax, [edx + edx - 0x1d780b61]
div eax
xor ecx, 0xe811a536
pop eax
sar dword [esp + edx*2], 0x17
setne byte [esp + edx]
inc ecx
jmp 0x90e3d4
lea ecx, [edx + ecx - 0x200e113a]
xor ebx, ecx
add esi, ecx
mov ecx, dword [esp + edx]
inc dl
xchg dword [esp + edx - 1], ecx
pop edx
jns fcn.00c9bff2
dec edi
lea ebx, [ebx + esi*2 - 0x40260c5e]
dec esp
xor eax, ebx
call fcn.00cfeb30
Function at 0xc4b7a1
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
mov cx, 2
lea eax, [edx*2 - 0x4cdf06cb]
mov word [edi - 2], cx
and dword [esp + 0x11], 0x50041f16
shl word [esp + 0xa], 0x6e
sbb edi, 1
pop edx
pop edx
pop eax
pop eax
pop ecx
pop ecx
jmp fcn.00c9bff2

Function at 0xc4d718
Capabilities:
Encode data using xor

Disassembly:
ror byte [esp + 0xb], 0xe3
pop eax
pop eax
pop eax
jmp esi
dec esp
lea edi, [eax*4 - 0x87e406f]
inc ecx
xor bh, cl
inc ebp
movsx esi, bp
inc eax
dec bh
movsx ecx, dl
inc esp
movsx eax, dl
call fcn.007b17a5
mov edx, 0x408d308a
movzx edx, byte [edx + ebp - 0x408d308a]
mov ecx, 0x793a2610
lea eax, [ecx*8 - 0x1d66ce55]
lea ebp, [ebp + ecx - 0x793a260f]
btr eax, eax
push eax
xor dl, bl
btc ecx, ecx
xchg ecx, eax
rol dl, 1
bswap ecx
xchg dword [esp + ecx - 0x2b626aac], eax
add dl, 0x25
shl al, 6
neg dl
xor dl, 0x33
neg dl
shr byte [esp + ecx - 0x2b626aaa], 0x83
bswap eax
not ax
not dl
pop eax
btc cx, 0x85
dec dl
rol dl, 1
and cl, 0xa
xor bl, dl
cbw
and cl, 2
lea ecx, [ecx + ecx - 0x5fdf447d]
adc edx, esp
mov ax, word [edx + eax - 0x79070010]
neg cx
sbb esi, 1
bt ecx, 0x3a
mov word [esi], ax
movzx edx, cx
mov eax, 0x38ba8819
mov ecx, dword [ebp + edx*2 - 0xe0fa]
not al
lea ebp, [ebp + edx - 0x7079]
call fcn.00c5f33f
inc ecx
mov edi, dword [ebx]
mov ecx, 0xc800ee93
dec ecx
add ebx, 4
inc esp
movsx eax, cl
inc ecx
mov edi, 0xb4ac3211
inc ecx
xor edi, ecx
inc esp
mov ebp, ecx
neg edi
inc ecx
push ebp
inc ebp
movzx esi, ch
inc ebp
movsx esp, ch
not edi
dec edi
lea edx, [eax + ebp*8 - 0x2c5ba75f]
xor edi, 0xcc8f3eb3
call fcn.008822ae
mov edx, 0x8c9d882c
movsx eax, dl
inc esp
movsx ebp, dl
inc edx
movzx edi, byte [eax + ebx - 0x2c]
jmp 0x996151
jp 0x7b4775
mov edx, dword [ebp + eax*8 - 0x27f0]
mov dword [esp + ecx - 0x388827e8], 0x8b108025
jne 0xcb4c4e
jmp 0xc3a6f4
sbb cx, cx
xor edx, ebx
shr dword [esp + ecx*2 - 0x7111fffc], 0x3d
xor eax, 0x7cbb113b
lea edx, [edx + eax - 0x46040029]
and eax, dword [esp + ecx*2 - 0x7111fffc]
bswap edx
add dword [esp + ecx*2 - 0x7111fffa], eax
ror edx, 3
sal word [esp + ecx - 0x3888fffd], 0xf
rol ecx, cl
neg edx
shr dword [esp + eax*2 + 4], 4
xor ebx, edx
pop eax
cwde
add esi, edx
sar byte [esp + 2], 1
not cx
call fcn.0075dd1b
in al, 0xb7
add dword [ebx + ebx - 0x1cff0ae8], esi
sub byte [ebx + ebx*8 + 0x18], dl
cmc
add byte [edi + 0x63], dl
add al, 0x8b
sbb ch, dh
add byte [ebx], ch
test eax, 0xf518034c
add byte [ebx - 0x18ad938d], bh
invalid

Function at 0xc5179c
Capabilities:
Encode data using base64

Disassembly:
mov dword [esp], 0x6cb1e400
call int.007ca602

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

Disassembly:
lea ecx, [ecx + edx*2 - 0x6945892a]
mov dword [esp + eax - 0x29], eax
cwd
call fcn.00947a9d
Function at 0xc59d76
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
mov dword [esp + eax], esi
ret
mov edx, dword [edx + edi - 0x3a9b4921]
shr cx, 0x47
bts ecx, 0xac
push ecx
lea edi, [edi + ecx*4 - 0x4244]
shr dword [esp + ecx*4 - 0x4248], 0xea
rol word [esp + ecx*2 - 0x2124], 0x41
xor edx, ebx
xor ecx, 0xfb95e08d
shl dword [esp + eax], cl
bswap edx
sar cx, 0xa2
sbb edx, eax
btc ecx, 0x99
neg al
bt eax, 0xba
not edx
dec eax
adc edx, eax
add cx, 0xf9f
jae 0xc948e6
bswap edx
neg edx
ror ecx, cl
xor ebx, edx
shr cl, 0xc7
adc esi, edx
xor eax, eax
not dword [esp + eax*4]
jno 0x8fcdbf
lea esp, [esp + 8]
call eax
mov edx, 0x3a9b491f
mov ebp, dword [ebp + edx*2 - 0x75369242]
movzx ecx, dx
and ecx, edx
mov dword [ebp + ecx - 0x491f], eax
inc dx
movsx edi, cl
pop ebx
pop esi
btc dx, dx
bt di, cx
movzx eax, cx
pop edi
xor ax, cx
je 0xcca2d8
je 0x986be7
inc eax
xor eax, 0xd7382c06
shr edx, cl
neg eax
bts dx, dx
jae 0xccb7c9
not eax
not edx
lea edx, [edx*2 + 0x5984d1ac]
or edx, edx
rol eax, 2
bswap ecx
bts edx, 8
xor ebx, eax
bts edx, edx
rol dx, 0xd
adc edi, eax
lea edx, [esp + edx - 0x57f48712]
mov eax, dword [edx + ecx - 0x24c10000]
lea ecx, [ecx*8 - 0x16d3d7ee]
xor cx, cx
lea edx, [ecx + ecx*2 + 0x4d1fcd2b]
mov dword [ebp + ecx - 0xf340004], eax
setnp dl
mov ecx, dword [ebp + ecx - 0xf340004]
mov eax, 0x923ebda0
seto al
mov eax, dword [ecx + edx - 0x7abbcd00]
jns 0x791126
lea esp, [esp + 8]
je 0xc5d582
push esi

Function at 0xc5ac9b
Capabilities:
Authenticate hmac
Encode data using base64
Encode data using xor
Execute syscall

Disassembly:
lea esp, [esp + 8]
ja 0x983a84
mov edx, 0x53cae2d
shl edx, 0x4f
mov edx, esp
mov eax, 0x8312f1b6
mov ecx, 0x4c
dec al
dec al
add eax, eax