joyce8/EMBER2024-capa huggingface dataset:
Function at 0x8e7e30
Capabilities:
Execute syscall

Disassembly:
add dl, 0xb2
neg eax
neg dl
sal ecx, cl
mov dword [esp], eax
rol dl, 1
shl dword [esp], 0x36
xor bl, dl
sub eax, dword [esp]
ror ax, 0x2e
lea edx, [esp + edx + 4]
rol byte [esp + eax - 0x38d228e2], 0xa3
btc ax, ax
mov eax, dword [edx + eax*2 - 0x71a451d6]
mov dword [esi - 4], eax
mov edx, dword [esp]
adc esi, 0xfffffffc
mov eax, ecx
push eax
add ecx, edx
pop ecx
pop eax
js fcn.00909547
mov ecx, 0x25936e39
sal ecx, 0xac
mov eax, dword [esi + ecx - 0x36e39000]
movzx edx, cl
bts edx, 0x83
mov ecx, dword [esi + edx*2 - 0xc]
sbb edx, edx
add edx, edx
adc eax, ecx
movzx ecx, dx
mov dword [esi + edx + 4], eax
add ecx, dword [edx + ebp]
lea eax, [edx - 0x2e7fe0d8]
bts edx, edx
xor ecx, ebx
shl al, 0xe1
not ecx
sbb al, al
neg ax
add ecx, edx
call fcn.00ca95e8
sysenter
push edi
mov dword [esp], 0xb57f93c0
call fcn.00912a97

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

Disassembly:
mov dword [esp + eax - 2], eax
xor edx, ebx
movzx ecx, byte [esp + eax*4 - 8]
mov dword [esp + eax + 2], eax
shr ecx, 0x21
adc edx, ecx
xor edx, 0x4821d916
add edx, 0xfa816b99
and ecx, 0x9d2b6c26
jb 0x8bb6c1
push ecx
not edx
sub byte [esp + eax + 3], 5
inc cx
bswap edx
setae cl
xchg word [esp + ecx + 4], ax
xor ebx, edx
add edi, edx
mov edx, 0x420e2c32
pop eax
pop edx
pop eax
jmp fcn.007ab5dc

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

Disassembly:
lea esp, [esp + 8]
ja 0xc8bb1b
mov ecx, 0x46a2cd80
xor ecx, 0xaac3a98
sub ecx, 0xb9a9161c
mov edx, esp
mov ecx, 0x4c
mov eax, 0xe2b435b6
lea eax, [esi - 0x80]
push 0xd0b49a2b
js 0xcc9182

Function at 0x8f47ba
Capabilities:
Encode data using base64

Disassembly:
adc ebp, 6
xor dl, bl
sar ax, 1
ror eax, 0xcf
not dl
neg al
ror al, 0x41
sbb ax, 0x1589
neg dl
shr eax, 0xe1
adc dl, 0x31
xor ax, 0x3383
ror dl, 1
lea eax, [eax*4 + 0x3834ec3b]
or eax, 0xa89e7421
xor bl, dl
add ax, ax
add ax, 0x18bb
add eax, 0xcc300020
add edx, esp
mov dword [edx], ecx
movzx edx, ax
jmp edi
sub cl, byte [esp + 6]
dec al
dec ecx
jge 0x920e3c
xor bl, al
lea eax, [esp + eax + 8]
shl ecx, cl
pop ecx
mov dword [eax], edx
mov eax, 0xd318e133
add dword [esp], eax
mov ecx, dword [ebp + 1]
movsx edx, ax
cdq
xor ecx, ebx
or edx, 0x2218d8b7
sar dword [esp], 0xbc
ror edx, 0x46
ror ecx, 1
xadd dl, al
pop eax
bt eax, edx
neg ecx
cbw
rol eax, 0x4c
adc dx, ax
ror ecx, 3
btc edx, 0x1b
sar eax, 0x9b
add ecx, eax
xor ebx, ecx
bts eax, 0x88
ror edx, 0xad
neg dx
add edi, ecx
movzx ecx, dx
xor cx, ax
mov ecx, dword [esi + ecx*2 - 0x17ff2]
adc dx, 0x162c
adc eax, eax
sbb esi, 0xfffffff3
movzx edx, byte [ebp + 5]
btc eax, eax
sub ax, ax
jbe 0x7684b8

Function at 0x8f67bb
Capabilities:
Encode data using base64

Disassembly:
lea ebp, [ebp + ecx - 0x532bd7ff]
mov dword [esp + ecx - 0x532bd800], ecx
shr cl, 6
xor dl, bl
not dl
sal cl, 0xc1
ror dl, 1
imul ecx, ecx
push ecx
sbb ecx, ecx
xor dl, cl
not word [esp + 9]
btr ecx, 0x94
xor dl, 0x89
add cl, cl
ror dl, 1
pop ecx
xor bl, dl
lea edx, [esp + edx + 8]
xor ecx, 0x18041f26
inc ecx
jg 0xc8dffe
Function at 0x8f8ed6
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
rol eax, 3
push ecx
pop ecx
shr cx, 0x8b
dec eax
not eax
add ecx, ecx
lea eax, [eax + ecx*2 + 0x4f25423c]
xor ebx, eax
add edi, eax
push ecx
rol edx, 0x2e
adc dword [esp + ecx*4], edi
ret 4
lea ebp, [ebp + edx*4 - 0x12a]
mov word [ecx + ebp - 0x7f4800b4], ax
pop edx
ja fcn.00754c95
mov dx, word [ebp]
jmp 0xc83908
mov ecx, 0xfe31a0a1
movsx eax, cl
mov cx, word [ebp + 2]
add ebp, 2
or dx, cx
movsx ecx, ax
not dx
push ecx
sub ecx, eax
mov word [ebp + ecx], dx
setno cl
sar dword [esp + ecx - 1], cl
lea esi, [esi + ecx*2 - 6]
adc al, 0xb7
or ecx, 0xee335712
lea edx, [ecx + eax*4 - 0x24f881d9]
mov eax, dword [esi]
xor eax, ebx
sub ecx, ecx
jns 0x81b8ae

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

Disassembly:
jle 0x89990a
add edx, ecx
mov dword [eax + edi - 0x2a157d9b], edx
movzx eax, word [esi + eax*2 - 0x542afb40]
mov edx, dword [esp]
dec word [esp]
not dl
xor ax, bx
and byte [esp + 2], 0xac
xchg dword [esp], edx
ror ax, 1
sub dword [esp], edx
movsx ecx, dx
call fcn.00cb2f9f
mov eax, 0x3427331e
mov cx, word [eax + edi - 0x3427331e]
mov dx, word [edi + eax*2 - 0x684e663a]
neg ax
lea edi, [edi + eax*2 - 0x684f99c2]
not cx
add al, ah
shl eax, 0x61
call fcn.00c805a4
bswap eax
btr edx, ecx
ror eax, 1
xor eax, 0x528dbb98
lea edx, [ecx*8 - 0x48d8b9e3]
lea eax, [edx + eax - 0x5686f910]
or edx, 0xf6873687
sbb edx, edx
xor ebx, eax
add dl, dh
neg dword [esp + edx*2 + 0xc]
lea ecx, [edx + ecx*4 + 0x1025d908]
add esi, eax
neg edx
movsx eax, byte [esp + ecx - 0x7399d594]
cdq
mov ecx, dword [ebp + edx*8 + 4]
dec dl
btr eax, eax
mov eax, dword [ebp + edx - 0xf7]
or byte [esp + edx - 0xf8], dl
mov dword [esp + edx - 0xff], edx
xadd byte [esp + edx - 0xf8], dh
adc ecx, eax
mov dword [edx + ebp - 0xfff7], ecx
push edx
movzx ecx, dl
call fcn.008f6c00
push 0x2a157d9f
mov eax, dword [esp]
mov edx, dword [eax + edi - 0x2a157d9f]
not dword [esp + eax - 0x2a157d9f]
dec byte [esp + eax*2 - 0x542afb3b]
mov ecx, dword [edi + eax*2 - 0x542afb3a]
jl 0xce455c
jno 0x879b98

Function at 0x9004c9
Capabilities:
Encode data using base64

Disassembly:
call fcn.008488a1
mov edx, dword [edi - 4]
push 0xc53aba8a
xor edx, ebx
jmp 0xc8df23
inc edx
xor edx, 0xde0ed6a4
mov ecx, dword [esp]
inc edx
xadd cl, ch
xor edx, 0xd489e7bb
rol edx, 2
movzx eax, cl
xor ebx, edx
add ebp, edx
xadd byte [esp + eax*2 - 0x86], ah
mov edx, dword [edi + eax*2 - 0x7490]
div al
xor edx, ebx
sal al, 0xa5
shl ax, cl
dec edx
not cl
dec dword [esp + eax*4 - 0x21800]
ror edx, 1
call fcn.00802023

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

Disassembly:
sal bx, 0xec
neg esi
ror word [esp + esi - 0x416daf68], 0x4b
rol ebp, 1
add ebp, edx
mov ecx, 0x12e460d
bts cx, cx
mov dword [esp + ecx*4 - 0x4b99810], edi
mov edx, 0x36af8c3a
push ecx
mov dword [esp + edx - 0x36af8c0e], eax
or al, dl
dec cx
not al
mov dword [esp], ecx
lea edx, [ecx + ecx*8 - 0x417cdae2]
pop ecx
mov word [esi + 2], ax
jns 0x8d789d
mov dword [esp], 0x4e29a78b
sub esi, 0xfffffffe
lea eax, [edx*4 - 0x3adb937b]
imul cl
mov dword [esp + eax - 0x43312208], edi
ret 4
Function at 0x903b2c
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
lea ebp, [ebp + eax*4 + 2]
shl eax, 0x35
mov edx, 0x8429b91c
mov word [ebp + eax], cx
add dx, dx
or dword [esp + eax], edx
cwde
mov dword [esp + eax*4], esi
ret
push 0x58f9d2d
setb byte [esp]
adc eax, edx
mov dword [ebp - 4], eax
test ebx, ebx
lea esp, [esp + 4]
je 0x821909
mov eax, dword [ebp + ebx*4]
push eax
push 0xff8d4d8b
dec ebx
push 0x4228a6a8
lea esp, [esp + 8]
jne 0x8218ef
mov eax, 0x76b82d32
cwde
mov eax, dword [ebp + eax*2 - 0x5a64]
jmp 0x85e92b
mov dword [esp + eax - 0x7012ae07], edi
sbb al, ah
push ebx
and ax, 0xf082
or eax, 0x5f839739
movzx ebx, ax
mov ebx, edx
movsx edx, ax
mov edx, ebx
shl edx, 2
shr eax, 0xa
shl eax, 0x5f
inc eax
mov eax, ebp
jno 0x8218d3
or al, byte [esp + eax + 2]
jle 0x786f29

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

Disassembly:
mov dword [esp], ecx
adc al, 0x96
rol al, 1
rol ecx, cl
dec ecx
sub ecx, dword [esp]
xor al, 0x28
neg ecx
neg al
call fcn.0093afcb
mov ebx, 0x3591ab2f
dec eax
lea ecx, [ebx + ebx*4 + 0x711a072a]
dec eax
sal ecx, 0x3e
dec eax
mov edx, dword [esi + ebx - 0x3591ab2f]
movzx edi, cl
inc ebp
movzx eax, byte [ebx + ecx*4]
inc ebp
xor al, cl
call fcn.007b94c6
and ecx, ecx
mov dword [esp + ecx*2 - 0x6403fe26], ecx
not ax
btr ecx, 0x38
and dx, ax
lea eax, [ecx + ecx + 0x18bfc016]
mov word [ebp + eax - 0x7cc3be40], dx
add byte [esp + eax - 0x7cc3be3b], 0x8f
lea esi, [ecx + esi - 0x3201ff19]
mov eax, dword [esi + eax - 0x7cc3be40]
or cl, 0x1f
mov dword [esp + ecx*2 - 0x6403fe3e], ecx
xchg dword [esp + ecx - 0x3201ff1d], ecx
xor eax, ebx
call fcn.00c4396e

Function at 0x90603d
Capabilities:
Encode data using base64

Disassembly:
not dl
bswap eax
neg eax
mov dword [esp + ecx - 0x6c48edcb], edx
mov byte [esp + edx - 0x62b50047], 0x85
xor ebx, eax
dec dword [esp + ecx - 0x6c48edcb]
neg dword [esp + edx - 0x62b50049]
sbb dword [esp + edx - 0x62b50049], edx
adc edi, eax
bts cx, 0xaf
inc dx
movzx cx, byte [ecx + esi - 0x6c48edcb]
lea eax, [edx + 0x21c7490]
call fcn.0093046c

Function at 0x908103
Capabilities:
Encode data using base64

Disassembly:
call fcn.00874442
push 0xf705b586
mov eax, dword [edi]
shr dword [esp], 0xa4
mov edx, 0x553c1a1e
mov ecx, dword [edi + edx - 0x553c1a1a]
btc edx, edx
or dl, 0x35
not eax
neg byte [esp + edx - 0x153c1a3c]
lea edx, [edx + edx - 0x40cb43dd]
lea edx, [edx + edx + 0x4e10a506]
not ecx
shl dl, 7
bts edx, 6
or eax, ecx
movsx ecx, byte [esp + edx*2 - 0x42d50c80]
or ecx, 0x829b49a3
mov dword [esp + edx*2 - 0x42d50c80], edx
mov dword [edi + edx*2 - 0x42d50c7c], eax
sub edx, 0x1b87713b
adc dl, dl
movsx eax, dx
mov eax, dword [edx + ebp - 0x5e3150e]
xor eax, ebx
call fcn.007e0c2c
Function at 0x9128a3
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
add cx, ax
sal eax, 0x57
xor bl, dl
shr dword [esp + ecx - 0x848c64], cl
ror word [esp + ecx - 0x848c62], cl
jnp 0x848aa1
inc ecx
rcr dword [ecx*4 + 0x29081454], 0x44
add al, 2
rol ecx, 0x1c
lea edx, [esp + edx + 8]
sub dword [esp + eax + 2], eax
bt ecx, 0xa0
sub ecx, eax
adc ax, word [eax + edx]
xor word [esp], cx
ror dword [esp + 3], 0x3d
ror ecx, 0xf9
lea esi, [esi + ecx - 0x4246342]
setb cl
js 0xd08ff5
cmp eax, 0x8df9c9c1
mov ah, 0xe
mov esi, 0xffbdb9c
xchg edx, eax
ror dword [edi], 0x88
and dword [0x226c004c], eax
clc
insb byte es:[edi], dx
and bh, al
add esi, edi
push ecx
fidivr word [edx + 0x3e53d100]
jno 0x848ac0
mov edx, 0x16dbf500
cdq
fidivr word [edx + 0x46136d00]
sub esi, ebx
mov edx, 0xd6d9c100
sub byte [ecx], ah
mov ecx, edi
jmp 0x848aa0
lea esp, [esp + 8]
call eax
mov edx, 0x49b0e38e
mov ebp, dword [edx + ebp - 0x49b0e392]
lea esi, [edx + 0x7e0e0824]
call fcn.00cfb6df
sub ebp, 4
mov edx, 0x7a161128
xor dl, dl
movzx eax, dl
xor eax, dword [ebp + eax*8]
neg dl
movzx ecx, dx
not dl
xor eax, ebx
rol eax, 1
xor edx, 0xcf1abb92
xadd dx, cx
dec eax
neg dl
xor dx, dx
not eax
lea eax, [eax + ecx*4 - 0x5d335338]
and dl, dl
xor eax, 0x4d88458b
inc cx
lea edx, [edx*4 - 0x54efd360]
btr ecx, edx
xor ebx, eax
add edi, eax
movsx eax, cl
lea ecx, [ecx - 0x4fcd9168]
rol dl, 0x27
mov eax, dword [edx + esi - 0x7f402c50]
jb 0x94ac5c
mov ecx, dword [esi + edx - 0x7f402c4c]
jb 0x848a8b
push ebx
sal dx, 4
add dx, 0xebac
not edx
cpuid
jle 0xc898d0
sub esi, 4
mov ecx, 0xd2aeb116
movsx edx, cx
mov edx, dword [esi]
xor edx, ebx
lea eax, [ecx + ecx*4 + 0x3b940ca4]
cwde
lea edx, [edx + eax - 0x2e5d2f7f]
shl cl, 0x26
ror edx, 1
shr eax, 0x3b
call fcn.009415f8
sbb esi, 7
call fcn.0077e8de
mov word [esi + ecx*2 - 0x848c600], ax
movzx edx, cx
pop ecx
pop ecx
jne fcn.00cfe987
Function at 0x913e2f
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
cdq
adc ecx, 0xa091b026
mov dword [esp + eax], 0xe6018b80
rol ecx, 2
not ecx
add byte [esp + eax*2 + 1], 0x82
xadd byte [esp + eax*4], dh
sbb ecx, 0xb20e8383
xor ebx, ecx
add edi, ecx
shl al, 0x41
mov ecx, dword [eax + esi + 4]
jbe 0x9c2169
add word [esp + edi*4 - 0x3a77d86b], bx
dec eax
add ebp, eax
or byte [esp + edi - 0xe9df612], 0xa8
dec esp
mov esp, dword [esi + edi*4 - 0x3a77d874]
inc ecx
pop edx
dec eax
not edi
dec esp
mov edi, dword [esi + edi*2 + 0x1d3bec44]
inc ecx
pop ebp
dec esp
lea ebp, [ebx*4 + 0x7272a1b]
dec ebp
lea esi, [ebp + edi - 0xc674e4f]
dec eax
lea esi, [esi + edi*2 + 0x1d3bec4c]
jne 0xc76e4c
inc ecx
mov edi, 0xbc313416
inc ecx
movsx edx, di
inc sp
mov eax, dword [esi + edx*2 - 0x682c]
shr dx, 0xec
movsx ebx, dl
dec eax
lea esi, [edx + esi - 1]
dec ecx
lea eax, [edi - 0x4b498ad7]
inc ecx
movzx ecx, word [ebx + edx - 3]
adc al, bh
dec eax
lea eax, [eax + eax*8 + 0x1c956c10]
dec esi
lea ebx, [edx + ebx - 1]
inc cx
xor ecx, ecx
dec eax
shr eax, 0x41
inc esp
movzx esi, bx
dec eax
idiv eax
rol cx, 1
sub cx, 0x96b2
rol cx, 1
inc ecx
mov edx, 0xc9a1d720
not cx
sub cx, 0x2f
mul ebx
dec eax
cdq
rol cx, 1
dec esp
lea esp, [edx*4 - 0x336ba677]
inc ebp
movsx ebp, dx
dec ecx
lea eax, [ebp + ebx*2 - 0x72fd93f5]
inc cx
dec ecx
shl esi, 0x16
mov edi, 0x87b77308
inc sp
xor ecx, ecx
inc cx
sal esp, 0x2e
inc ebp
xchg dl, ah
cwd
dec eax
adc ecx, esp
inc esp
mov byte [ecx + edx], al
dec ebp
xchg esi, ebp
inc bp
xor ebp, ebp
inc edx
mov ebx, dword [edx + ebx]
neg di
dec esi
lea ebx, [edx + ebx + 4]
dec ecx
rol ebp, 0xfa
inc esp
mov eax, edi
inc ecx
xor ebx, ecx
dec ecx
rol esi, 0xad
dec esi
lea edx, [edx + ebp*2 - 0x6e4d1ff2]
ror ebx, 1
dec ebx
neg ebx
not ebx
dec eax
cdq
inc ecx
mov ecx, esp
shl di, 0xce
inc ecx
push ecx
inc ecx
sar al, 0xe6
xor dword [esp + edx*8], ebx
inc ecx
pop ecx
inc ecx
sal ch, 0x26
dec eax
arpl bx, bx
dec eax
adc ebp, ebx
dec eax
or edx, ebp
jmp edx
sar al, 0x63
lea esi, [esi + eax*2 + 8]
sub edx, 0xd5aa68b1
movzx edx, byte [ebp + eax + 4]
bts eax, 0x9a
lea eax, [eax + eax*4 + 0x343dd021]
lea ebp, [eax + ebp - 0x483dd01c]
jae 0x886308

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

Disassembly:
inc dx
dec ebp
lea edx, [esi + 0x5896cd21]
inc esp
sub byte [esp + ebx - 0x1926], dl
inc sp
xor ecx, edx
dec eax
lea edx, [esp + edx + 0x18]
pop edi
dec eax
lea edi, [eax + eax*8 + 0x6721fe08]
inc esp
mov byte [edx + ebx*4 - 0x64dc], al
shl word [esp + ebx - 0x192d], 0xd
inc cx
adc eax, edx
inc esi
mov esp, dword [ebx + ebx - 0x1937]
dec ebp
lea ebx, [ebx + ebx*4 - 0x64d8]
dec ecx
lea edx, [ebp + 0x20806c19]
not di
inc ebp
xor esp, ecx
inc ecx
ror esp, 1
inc ebp
bt esi, ebp
dec eax
sal dword [esp + ebx - 0x192f], 0xfe
dec eax
adc dword [esp + ebx - 0x192f], 0x318708a3
inc ecx
dec esp
call fcn.00834a2c

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

Disassembly:
push 0x37862900
mov dword [esp], esi
push 0x9e107eb0
lea esp, [esp + 0x18]
je 0x8b50bb
jmp 0x86e8bb
Function at 0x915780
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
sub edx, 0xfe2a3e9b
add ecx, eax
adc eax, eax
xor ebx, edx
lea ecx, [eax + eax*8 - 0x1151bece]
neg eax
add esi, edx
dec eax
jmp esi
dec ebx
jmp 0x9b5e48
jb 0x83a869
mov dword [esp + eax - 1], eax
mov eax, dword [eax + ebp - 1]
add ecx, 0xa91ba413
call fcn.00cc2aa0
jb 0x8d66a1
sub dl, cl
neg eax
bswap edx
inc eax
xor eax, 0x458a060c
mov dword [esp + edx*4 - 0x563fffc], 0x20a6a688
or cx, dx
pop edx
xor ebx, eax
xadd cx, dx
imul cx, word [esp + edx - 0x20a6fffd]
dec dx
add edi, eax
movsx eax, byte [esp + edx*2 - 0x414dfffc]
mov dword [esp + edx*2 - 0x414dfffc], edi
ret
lea esp, [esp + 4]
jne 0xc94a03
mov eax, 0x53c6e06
bswap eax
lea eax, [eax + eax*4 + 0x199c4821]
mov eax, dword [ebp + eax*2 - 0x7386e874]
jmp fcn.00978654
mov eax, 0x673d6023
sal ax, 0x21
bts eax, 0xf
mov eax, dword [ebp + ebx*4]
push eax
call 0x915793
mov eax, 0x1535331d
and eax, eax
movzx ecx, ax
mov eax, dword [edi + eax - 0x1535331d]
mov cl, byte [edi + ecx*2 - 0x6636]
mov edx, 0xb883f414
adc edx, edx
lea edi, [edi + edx - 0x7107e826]
bt dx, dx
setb dl
xor edx, edx
shr eax, cl
movsx ecx, dl
mov dword [edi + edx*2], eax
and cl, dl
lea ebp, [ebp + edx*4 - 4]
not ecx
rol edx, cl
add edx, dword [ebp + edx*8]
and cx, cx
lea eax, [ecx + 0x53a9be07]
xor edx, ebx
or eax, 0x46004729
idiv al
ror eax, 7
ror edx, 3
add edx, 0x3299b4a3
inc cl
xadd ecx, eax
add ax, 0x7d23
rol edx, 1
jmp 0x788201

Function at 0x919151
Capabilities:
Encode data using xor

Disassembly:
mov dword [esp], 0x90553bb8
call fcn.00c68497
movzx dx, byte [esi]
mov ecx, 0x9292b03f
movsx eax, cl
mov al, byte [esi + eax*4 - 0xfa]
ror cx, 0x2f
xor cx, 0xba87
or dl, al
movsx eax, cx
shl ecx, 0xd0
not dl
mov word [esi + 2], dx
movzx eax, word [ebp]
xor ax, bx
rol ax, 1
sub ax, 0xd936
lea edx, [ecx + ecx*8 + 0x4f221781]
sub ecx, 0xa19d3aa1
ror ax, 1
call fcn.00caa2fd
sti
invalid

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

Disassembly:
or cl, al
dec dl
movzx eax, word [esp + 4]
not cl
mov word [eax + ebp - 0x89b2], cx
mov edx, dword [edi + eax*8 - 0x44d90]
mov dword [esp + eax - 0x89b2], eax
and eax, 0x77bf4028
jb 0xc872a0
lea edi, [eax + edi - 0x1c]
xor byte [esp + eax*8 - 0xfc], al
movzx ecx, al
bswap eax
xor edx, ebx
xor edx, 0xf121f685
inc eax
not al
not edx
lea eax, [eax*2 + 0x25a06a98]
cmovo cx, word [esp + ecx*2 - 0x3b]
inc ecx
dec edx
rol ax, 0xc2
sbb eax, 0xc5191b1c
xor ax, cx
neg edx
lea edx, [edx + eax + 0x36fd1275]
rol ax, cl
cwde
xor ebx, edx
sar word [esp + eax - 0x2e2b], 0xe9
add esi, edx
div byte [esp + eax - 0x2e26]
rol ecx, 0x61
movzx edx, byte [esp + eax*2 - 0x4aa8]
mov dword [esp + eax*4 - 0x9558], esi
ret 4
Function at 0x91f2b2
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
adc ebp, 2
xchg word [esp + 1], dx
pop edx
push edx
shr ax, cl
mov word [ebp + edx - 0x6f732e2e], ax
movsx ecx, dx
not edx
or word [esp + ecx*4 - 0xb8b6], cx
mov dword [esp + ecx - 0x2e2e], esi
ret
xor ebx, eax
xor cx, cx
adc esi, eax
btr edx, edx
shl edx, 0x36
imul dx, cx
mov ax, word [ebp + edx*4 - 0x1000000]
neg ecx
pop edx
or cl, byte [ebp + ecx - 0x7bd6fffe]
mov edx, dword [esp]
sub word [esp + 2], dx
jae 0x89fb23
mov eax, 0xab0192bb
mul eax
movzx eax, byte [eax + edi - 0x4b8fd499]
movzx ecx, dx
xor al, bl
call fcn.008417e0
mov eax, dword [ebp - 4]
mov ecx, 0x3f08151e
inc cl
xor eax, ebx
shr cl, 0x42
rol eax, 1
shr cl, 0x22
movzx edx, cl
xor eax, 0xfebdb588
add eax, edx
bt ecx, edx
rol eax, cl
imul edx, edx
sub ecx, 0x7119b2b7
bswap ecx
xor ebx, eax
ror cl, 0x65
mov dword [esi + edx - 5], eax
neg dl
mov ecx, dword [ebp + edx - 0x107]
lea ebp, [edx + ebp - 0x107]
xor ecx, ebx
xor edx, edx
shr dl, 0xc7
jbe 0xc74344
rol ecx, 3
movzx eax, dx
xor eax, edx
and eax, edx
sbb ecx, 0x8f1f902b
bt ax, dx
imul ax
and dx, ax
neg ecx
call fcn.00c9a6b8
movsx ebx, word [esp + eax*2 - 0x17e]
inc ebp
xor edx, ecx
inc ecx
xor edx, 0x76131780
inc esp
mov ebp, dword [esp + eax*8 - 0x5f4]
shl word [esp + eax - 0xbe], 0x28
dec esp
btr ebx, esp
inc ecx
inc edx
dec eax
not eax
dec eax
cwde
dec esi
lea edi, [eax*8 + 0x33106b30]
inc ecx
ror edx, 3
dec esp
bts ebx, esp
xadd byte [esp + eax + 0xc2], ch
xchg word [esp + edx - 0x2e13f791], cx
inc ecx
not edx
dec esp
mov dword [esp + eax*4 + 0x300], ecx
inc esp
xor dword [esp + eax + 0xc0], edx
inc ecx
movzx edi, ch
inc ecx
mov esi, 0x532c02aa
inc ecx
pop ecx
dec ecx
div edi
inc cx
ror edi, 0xe5
sar ax, 0xc9
dec ebp
arpl dx, dx
inc ecx
sal esi, 2
or ebx, ecx
dec ecx
adc ebp, edx
shr di, 0xa7
dec ebx
xor edi, dword [ebx + ebp*4 + 4]
dec ecx
xor ecx, eax
inc cx
mul esp
dec esi
lea ebx, [ecx + ebx - 0xfeb3]
sal bx, 0x28
inc cx
sub ebp, 0x8d4d8134
test ah, cl
pop es
les eax, [edx - 0x6ccb68f]
push ecx
dec eax
ror edi, 4
dec esp
add dword [esp + ecx*8 - 0x7f5f8], esp
xchg byte [esp + ecx*2 - 0x1fd79], cl
dec eax
lea edi, [edi + ecx - 0x7fb606b9]
ror dl, 0x42
inc ecx
not bh
dec eax
sub eax, dword [esp + ecx*4 - 0x3f800]
dec eax
neg edi
or word [esp + ecx - 0xfdfc], dx
dec eax
lea edi, [edi + ecx*4 + 0x5bd736ef]
sar dword [esp + ecx*2 - 0x1fc00], 0xc6
dec esp
xor ecx, edi
dec eax
xadd dword [esp + ecx - 0xfe00], edx
dec eax
mov dword [esi + ecx*2 - 0x1fc10], edi
dec eax
lea esi, [esi + ecx*2 - 0x1fc10]
inc sp
xchg dword [esp + ecx - 0xfdfa], edi
cbw
inc ecx
bts ebp, edx
inc ecx
pop esp
jb fcn.0073c0e6

Function at 0x929e19
Capabilities:
Encode data using base64

Disassembly:
mov eax, dword [eax + esi - 0xf]
mov dword [esp], ecx
call fcn.00821f6a
pop eax
mov eax, dword [edi]
mov edx, 0x70b1d11a
lea edi, [edi + edx - 0x70b1d116]
movsx ecx, dl
xor eax, ebx
inc ecx
shr edx, 0x9d
shl dx, 5
not eax
bts ecx, ecx
sar edx, 0x3f
call fcn.0074aa48
xor ecx, 0xef29d3b3
bswap edx
dec ecx
lea edx, [eax*2 + 0x74370790]
shl edx, 0x32
xor ebx, ecx
call fcn.009b996b
syscall
call fcn.00820156
Function at 0x92d66a
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
mov cl, byte [ebp + 4]
mov edx, 0xf402bf2c
mov dword [esp], 0x4893b28c
mov dword [esp + 4], edx
add ebp, 2
xor dword [esp + 4], 0x9b07dc9a

Function at 0x92da4a
Capabilities:
Authenticate hmac

Disassembly:
sar byte [esp + eax - 0x400efffa], 0x83
lea eax, [esp + eax - 0x400effed]
shr ecx, 0xe7
mov dword [eax + ecx - 0x1f2b9bf], edx
movzx ecx, byte [ecx + ebp - 0x1f2b9c4]
shr dword [esp + 8], 0x9f
mov eax, 0x47889693
lea ebp, [ebp + eax - 0x47889698]
movzx edx, ax
not dword [esp + edx - 0x968b]
xor cl, bl
rol word [esp + edx*2 - 0x12d22], 0x4c
bts eax, eax
lea edx, [eax*8 - 0x6663f4d7]
xor cl, 0x16
xchg dword [esp + eax - 0x4788968c], edx
sar al, 0xc1
push eax
rol cl, 1
inc word [esp + eax - 0x478896c8]
sal ax, 1
xor cl, 0xb1
bt edx, eax
bt edx, edx
bts ax, 0x2a
ror cl, 1
lea edx, [eax + eax*2 + 0x3695a289]
mov dword [esp + eax - 0x47882d8e], edx
sub ax, word [esp + eax - 0x47882d8c]
xor bl, cl
and byte [esp + eax - 0x47882064], 0xb8
lea ecx, [esp + ecx + 0x10]
mov edx, dword [eax + ecx - 0x47882064]
jp 0xc41fab
mov dword [edi + eax - 0x47882060], edx
cwde
lea ecx, [eax + eax*2 - 0x7db9956]
lea edi, [edi + eax - 0x2060]
sar al, 0x66
cbw
mov dword [esp + eax*8 - 8], esi
ret 0xc
Function at 0x92dd50
Capabilities:
Hash data using murmur3

Disassembly:
neg ax
bswap ecx
pop edx
xor ebx, ecx
add ebp, ecx
sub word [esp + edx - 0x15], ax
mov dword [esp + edx - 0x16], ebp
ret
sub dl, dh
setg dl
shr dl, 0x67
lea ecx, [ecx + edx + 0x5706ec34]
add eax, edx
bts edx, eax
neg ecx
xor ebx, ecx
mul edx
idiv eax
sar eax, 1
add ebp, ecx
call fcn.00c87eb1
push ecx
add edi, edx
mov ebp, dword [ecx + ebp - 0x2c0b]
imul eax, dword [esp + ecx*2 - 0x580e]
neg eax
cwde
pop eax
pop edx
pop ecx
jnp fcn.00754c95
mov edx, 0x617c825
movzx eax, dl
mov eax, dword [edi + edx - 0x617c825]
lea ecx, [edx + edx*8 - 0x2950d242]
shl edx, 0x62
sal cx, cl
mov edx, dword [edx + edi - 0x185f2090]
or cl, byte [edi + ecx*2 - 0x1b0aaff8]
push 0xf7b8ca04
jmp 0x9b85f4
rol dword [esp], 0xef
adc edi, 6
neg dword [esp]
jae 0xc51182
dec dword [esp]
shrd eax, edx, cl
and dword [esp], 0x9f39a996
mov dword [edi], eax
mov ecx, dword [esp]
lea eax, [ecx + ecx*2 + 0x7182fc1b]
lea esi, [esi + eax - 0x402f7c25]
mov ecx, dword [esi + eax - 0x402f7c21]
lea edx, [eax + eax*4 + 0x459308b9]
push eax
xor ecx, ebx
add word [esp + eax - 0x402f7c1f], dx
sete byte [esp + eax - 0x402f7c1b]
sbb ecx, 0xda355893
bswap edx
shr dword [esp + edx - 0x5e758086], 0x9b
xor ecx, 0x342ae08c
not ecx
cwd
not edx
ror ecx, 2
dec ecx
shl eax, 0xfa
jne 0x73c376
mov eax, 0x16016c34
mov edx, dword [esi + eax*4 - 0x5805b0d0]
movsx ecx, ax
mov eax, dword [eax + edx - 0x16016c34]
mov dword [esi + ecx - 0x6c34], eax
inc cx
movsx eax, cl
lea ebp, [ebp + ecx - 0x6c39]
or eax, ecx
sbb ecx, eax
mov edx, dword [ebp + ecx*2]
bt ax, cx
not al
xor edx, ebx
btr ecx, 0xd
not edx
neg ecx
dec al
rol edx, 3
sar ecx, 0xb3
not edx
and ecx, ecx
bswap edx
bt eax, ecx
lea edx, [eax + edx + 0x7a827fd0]
xor edx, 0xe42ef111
xchg ecx, eax
xadd cx, ax
rol edx, 1
xchg ch, al
shr ecx, cl
cmovb ax, cx
lea edx, [ecx + edx - 0x6c0bce7b]
js 0x8aba01
neg ecx
sar eax, cl
xor ebx, edx
add edi, edx
sal ecx, 0xf6
or eax, edi
jmp eax

Function at 0x9346f7
Capabilities:
Encode data using base64

Disassembly:
or cx, ax
mov dword [esp + eax*2 - 0x17e], eax
xor dl, cl
xor bl, dl
and word [esp + eax*8 - 0x5f6], cx
lea edx, [esp + edx + 4]
movzx cx, byte [edx + eax - 0xbf]
sbb dword [esp + eax - 0xbf], eax
mov dx, cx
mov al, byte [eax + ebp - 0xbe]
mov ecx, dword [esp]
adc word [esp + ecx], 0xb9bc
xor al, bl
not al
or cx, word [esp + ecx + 2]
ror al, 1
shl ecx, 0xd6
not al
rol ecx, 0x47
xor cx, cx
shl ecx, 0x44
xor al, 0x89
dec cl
sar ecx, 0x8a
ror al, 1
call fcn.008c9675