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

Disassembly:
mov edx, 0x78215db3
lea edi, [edi + edx - 0x78215daf]
xor ecx, ebx
mov eax, 0x77a7ea35
mov dword [esp + eax - 0x77a7ea35], 0xb5362f9b
inc edx
dec ecx
not dl
sal eax, 0x10
idiv dl
bswap ecx
xchg dword [esp + edx - 0x78215d4b], eax
lea edx, [edx - 0x4d35cc5]
ror ecx, 1
btr edx, 4
sbb ecx, 0x213dfd25
idiv word [esp + edx - 0x734e0085]
mul dx
dec dword [esp + edx - 0x734e0013]
xor ecx, 0x92bfc508
neg ecx
rol eax, 0xdf
xadd dword [esp + eax - 0x5a9b202c], edx
inc eax
xor ecx, 0xe23c389c
shl al, 2
add eax, edx
xor ebx, ecx
or ax, 0xbd3b
push edx
adc esi, ecx
mov ecx, dword [esp + eax - 0x44d0bdb7]
call fcn.00d7cbc4
test ah, 0x94
cmc

Function at 0xfa9ca1
Capabilities:
Encode data using base64

Disassembly:
lea esp, [esp + 8]
jne 0xf44bb0

Function at 0xfacb66
Capabilities:
Encode data using base64

Disassembly:
lea esp, [esp + 4]
call eax
mov ebp, dword [ebp - 4]
mov ebx, 0x813c6282
movsx edx, bx
mov dword [edx + ebp - 0x6282], eax
mov edi, ebp
pop ebx
mov ecx, edx
mov esi, 0x6d0c609a
pop ebp
call fcn.01a24172
push ebp
or ecx, 0x7606c118
bts bp, dx
mov ebp, esp
lea esp, [esp - 0x48]
bsr ecx, ebp
mov ecx, dword [eax + 8]
test di, bp
xor dh, 0x9a
mov edx, dword [eax + 0xc]
cmp bp, 0x7ea3
push ebx
push esi
or esi, 0x639ffb5
push edi
test bp, 0x2c94
test ah, dl
mov edi, 1
mov esi, edi
shl esi, cl
add cx, di
mov ecx, dword [eax + 4]
xor ebx, ebx
cmc
mov dword [ebp - 0x20], edx
sub esi, edi
cmc
test ebp, 0x688ba0ae
test edi, ecx
mov dword [ebp - 0x44], esi
cmc
mov esi, edi
jmp 0x1ab05b2
mov dword [ebp - 0x10], edi
test dl, cl
add eax, 0x736
jmp 0xdaed8c
shl esi, cl
shl ch, cl
mov ecx, dword [ebp + 0xc]
test esi, 0x86b44b81
test cl, ch
cmc
mov dword [ebp - 0x18], ebx
cmp si, 0xcc28
mov byte [ebp - 1], bl
sub esi, edi
clc
test cl, dl
mov dword [ebp - 0x48], esi
mov esi, dword [eax]
mov dword [ecx], ebx
mov ecx, dword [ebp + 0x14]
mov dword [ecx], ebx
btc cx, 0x3e
mov ecx, dword [eax + 4]
cmovbe eax, esi
bsf eax, esp
lea ecx, [ecx + esi]
mov eax, 0x300
clc
shl eax, cl
cmp bp, 0xfa13
mov dword [ebp - 0x3c], esi
test bh, 0x84
mov dword [ebp - 0x14], ebx
jmp 0x17e0c70

Function at 0xfb3d02
Capabilities:
Encode data using xor

Disassembly:
lea edx, [edx + ecx*8 + 0x3586579a]
neg byte [esp + ecx + 6]
xor ebx, edx
push ecx
add edi, edx
push eax
bts cx, ax
pop edx
pop ecx
pop eax
pop edx
jae fcn.0182fdb4
Function at 0xfc269d
Capabilities:
Encode data using base64

Disassembly:
bts ecx, ecx
bswap edx
not edx
btc eax, ecx
ror cx, cl
lea edx, [edx + ecx - 0x6f6156b1]
btc ecx, 0x30
and eax, 0x69a7e787
not eax
rol edx, 1
xchg dword [esp + ecx - 0x16a4a48c], ecx
mov dword [esp + ecx - 0x7fa17a8a], ecx
sar byte [esp + ecx - 0x7fa17a84], 0x82
dec edx
inc cx
xor ebx, edx
rol dword [esp + ecx - 0x7fa17a87], 0x9a
sal dword [esp + ecx - 0x7fa17a87], cl
push eax
adc esi, edx
push ecx
movzx ax, byte [ebp + ecx - 0x7fa17a8b]
mov cl, byte [ebp + ecx - 0x7fa17a89]
add ebp, 2
not al
mov edx, 0x1bbb1400
and edx, dword [esp + edx*4 - 0x6eec4ff9]
not cl
sub dx, dx
and al, cl
call fcn.00f4168c
shl dword [esp + edi - 0x682e1f21], 0xad
movsx eax, di
mov edi, ecx
and dword [esp + eax*4 - 0x7c84], eax
mov esi, ebp
pop eax
jbe 0xf01037
insb byte es:[edi], dx
scasb al, byte es:[edi]
pop esp
invalid

Function at 0xfdf19f
Capabilities:
Encode data using base64

Disassembly:
dec edi
lea ebx, [ebx + ecx - 0x752f0004]
dec ecx
not ecx
inc ebx
mov dword [ecx + ebx + 0x752f0001], edi
inc ecx
mov edi, ecx
pop ebp
inc ecx
pop ebp
pop edi
pop ecx
inc ecx
pop edx
inc ecx
pop ecx
jae fcn.00fff3bb
Function at 0xfe09a9
Capabilities:
Authenticate hmac

Disassembly:
add edi, edx
mov dword [esp + eax - 0x3b21], ecx
sub byte [esp + eax*2 - 0x7642], 0x8a
pop eax
pop ecx
jp fcn.0182fdb4
aad 0x68
jno 0xfe09d2
xchg ebx, eax
xchg dword [eax - 0x67cab80f], ecx

Function at 0x1024899
Capabilities:
Encode data using base64

Disassembly:
mov dword [esp + 4], 0xa09c1373
lea esp, [esp + 4]
call fcn.00f963e9

Function at 0x103e3c0
Capabilities:
Execute syscall

Disassembly:
adc esi, 4
mov dword [esp], 0xb800ed90
call fcn.00df4c32
sysenter
push ecx
mov dword [esp], 0x5f9c91ea
call fcn.01a09160

Function at 0x10411c4
Capabilities:
Encode data using base64

Disassembly:
mov byte ss:[eax + ecx - 0x75116915], dl
setae cl
mov edx, dword [edi + ecx - 0x75116901]
mov dword [esp + ecx - 0x75116901], 0xcc9ea78b
lea edi, [edi + ecx - 0x751168fd]
xor edx, ebx
movzx eax, cl
rol edx, 2
and dword [esp + ecx - 0x75116901], eax
xor edx, 0x5831cc27
add edx, eax
call fcn.018d23dc

Function at 0x10516be
Capabilities:
Encode data using xor

Disassembly:
dec dword [esp + 4]
xor ecx, ecx
test edx, edx
push 0x34875719
call fcn.01a2d36f

Function at 0x17ce47c
Capabilities:
Encode data using base64

Disassembly:
adc edi, 5
push ecx
btc cx, cx
mov byte ss:[edx], al
adc ecx, ecx
lea ebp, [ebp + ecx*4 - 0x62891c1c]
mov eax, dword [ebp + ecx*2 - 0x31448e0c]
call fcn.00dbe38e

Function at 0x17db84e
Capabilities:
Encode data using xor

Disassembly:
dec ecx
ror ecx, 3
lea eax, [eax*8 - 0x54c03ce2]
cbw
xor ebx, ecx
jmp 0x196bff7
neg ecx
inc ecx
imul edx
mov dword [esp + eax - 0x7f9267e4], eax
sbb word [esp + eax - 0x7f9267e3], dx
not ecx
jl 0xe9952b
cmp eax, 0x1bea87f0
add ecx, dword cs:[esi - 6]
div dword [edx + 0x5a]
aaa
and al, 0x35
pop ebp
invalid
inc ax
shl eax, 0x24
adc edi, ecx
mov cx, word [esi + eax - 0x7d3003f0]
idiv al
and byte [esp + eax - 0x7d3000c0], dh
lea esi, [eax + esi - 0x7d3000bf]
sbb eax, edx
lea ebp, [eax + ebp - 0x7d3000f6]
sub eax, dword [esp + eax - 0x7d3000f5]
lea eax, [edx*8 + 0x7ebd2890]
sal edx, 0xd6
movzx eax, byte [ebp + eax - 0x7ebd26f0]
xor al, bl
shr dx, 0x6f
rol al, 1
dec edx
shl edx, 0xbb
neg al
xor edx, 0x1c23e533
push edx
neg dword [esp + 2]
xor al, 0x1b
neg al
imul dx, dx
sal edx, 0xb1
lea edx, [edx*2 + 0x272ba40c]
xor bl, al
lea eax, [esp + eax + 8]
or dx, dx
mov byte [edx + eax - 0x47cfa40c], cl
mov dword [esp + edx - 0x47cfa40c], edi
ret 4
Function at 0x17ee897
Capabilities:
Encode data using xor

Disassembly:
mov eax, dword [ecx + edi - 0x1bfedf4f]
push ecx
call fcn.018d3707
mov word [ebp], dx
mov dword [esp], 0x8ba89d01
mov edx, 0x4589058f
movzx eax, dx
mov ecx, dword [edx + edi - 0x4589058f]
neg ax
neg dword [esp + eax - 0xfa70]
shl ax, 0x81
lea edi, [edx + edi - 0x4589058b]
sar word [esp + eax - 0xf4dc], 0x8a
xor ecx, ebx
mul word [esp + edx - 0x4589058d]
jo 0x1a31c72
mov eax, 0x6809d581
rol al, 2
movzx edx, ax
movzx edx, byte [edi + edx - 0xd506]
movsx ecx, al
adc ecx, eax
dec cx
lea edi, [eax + edi - 0x6809d505]
inc cx
cmovae ax, cx
rol ecx, 0x75
xor dl, bl
dec al
and ecx, eax
xor dl, 0x3e
inc ecx
bts ax, cx
not dl
adc dl, 0x93
not ecx
ror cl, 0xe1
dec ax
not dl
inc cx
btr cx, ax
shr ecx, 0x43
xor bl, dl
sub ax, ax
lea ebp, [eax + ebp - 0x68090002]
setb al
mov word [eax + ebp - 0x68090000], dx
je 0xf80916
lds ebx, [edi]
jns 0x17ee950
call dword [ebp + 0x6f]
push ebp
outsd dx, dword [esi]
jo 0x17ee94d
lcall 0x91f8, 0xaeacde1e
and esi, edi
xor al, byte [edi]
fld xword [ecx]
lea ebx, [edi]
push es
mov ch, 0x3f
aas
xor eax, dword [ebx]
clc
popfd
xlatb
nop
cmp eax, edi
and eax, 0x3a07e422
jb 0x17ee966
cmp ecx, dword [ebx + 7]
push es
ror dword [eax + edi*8 + 0x577e9470], 0xe3
stc
jp 0x17ee960
pop esi
or ch, ch
test byte [ecx], dl
fnstsw word [ebp + edx - 0x20]
call dword [ecx - 0x58]
mov ecx, 0x7d576051
add al, byte [edi - 0x17]
clc
pop ecx
xchg esp, eax
inc ecx
mov edx, 0x25cfe8d3
mov ebx, 0x21c5a623
loope 0x17ee9e3
pop esp
mov cl, 0xc4
mov edx, 0xa5294abf
mov al, byte [0x94b3fc23]
mov eax, dword [0x69a3b95d]
cmp byte [ecx + 0x36eb872c], 0xb3
ret
stc
pop es
sbb al, byte [eax + 0x69]
aam 6
test al, 0x7a
xlatb
enter 0x28f8, 0xffffffffffffffc2
je 0x17ee9e5
clc
xor dh, al
das
pop es
cmp esp, dword [edi]
invalid
mul word [esp + edx - 0x45896f47]
neg ecx
idiv byte [esp + eax*2 - 0x1fc01]
or dx, dx
not ecx
neg ecx
and dword [esp + edx - 0x4589490f], edx
sal eax, 0x1f
bts ax, 0x10
rol ecx, 1
xor ebx, ecx
sar byte [esp + edx - 0x4589490e], 0x86
not edx
adc esi, ecx
cwde
mov dword [esp + eax - 1], esi
ret 4

Function at 0x182ca7a
Capabilities:
Encode data using xor

Disassembly:
mov dword [esp + 4], 0x8956510
lea esp, [esp + 4]
call fcn.0185502a

Function at 0x18320cf
Capabilities:
Encode data using base64

Disassembly:
not dword [esp]
mov word [ebp], ax
imul dx, dx
pop ecx
pop ecx
jno fcn.017f4682
bts cx, 0xa0
xor eax, 0x679a8307
push edx
sub edx, ecx
mov dword [esp + ecx - 0x11f5], edx
lea eax, [eax + ecx - 0x79afd207]
bswap ecx
ror eax, 2
xchg dword [esp + 3], ecx
sal ecx, cl
pop ecx
sbb eax, 0x5bb06186
inc cx
xor ebx, eax
add esi, eax
lea ecx, [ecx + ecx*8 + 0x6e301121]
bswap edx
add byte [esp + 3], 0x95
movzx eax, word [edi]
ror dword [esp], cl
sar dl, cl
sar word [esp + 2], 0x26
adc edi, 1
xor ax, bx
add edx, dword [esp]
lea ecx, [ecx + ecx - 0x5351b7e1]
xor ax, 0xb72f
ror dword [esp + edx - 0x1f6622], 0xb7
btc edx, ecx
sub dword [esp + edx - 0x1f662a], 0x2229550b
neg ax
shl byte [esp + edx*8 - 0xfb3150], cl
xor cx, cx
dec ax
xchg byte [esp + edx - 0x1f6627], cl
xor ax, 0x1cba
add ax, 0x7cb3
dec ecx
inc dx
xadd ecx, edx
xor bx, ax
shr cl, 5
sbb ebp, 2
push edx
jmp 0xe4b306
Function at 0x1836940
Capabilities:
Encode data using xor

Disassembly:
dec esp
lea ebp, [0xfff96f61]
dec eax
lea esp, [esp + 8]

Function at 0x18441b7
Capabilities:
Encode data using base64

Disassembly:
mov dword [esp], ecx
xor bl, dl
sub cl, cl
lea ecx, [ecx + ecx*8 + 0x1e8b63ba]
lea edx, [esp + edx + 0xc]
call fcn.01a24ffc

Function at 0x1848d21
Capabilities:
Encode data using base64

Disassembly:
movzx ax, byte [ecx + eax - 0x69b27802]
xadd byte [esp + edx - 0x69b277f5], dl
lea ecx, [edx - 0x11fa7e58]
lea edi, [ecx + edi - 0x57b7fa81]
bts cx, cx
mov dword [esp + edx - 0x69b278d7], 0x281fee06
imul cx, word [esp + ecx - 0x57b7fa71]
mov word [edi + ecx - 0x57b75026], ax
pop edx
pop edx
pop edx
pop edx
jo fcn.00dc29b0

Function at 0x1848d69
Capabilities:
Encode data using base64

Disassembly:
lea ebp, [ebp + ecx - 0xfe]
call fcn.00ed29cc
mov eax, dword [ebp + eax*2 - 0x400]
sar cl, 1
mov dx, word [eax + ecx*2 - 0x400]
shr cx, 0x81
ja 0xec6b07

Function at 0x1868e0d
Capabilities:
Encode data using base64

Disassembly:
inc edi
mov edx, dword [edi + ebx + 7]
dec edi
lea ebx, [ebx + ecx + 0x1820aae4]
dec eax
dec eax
dec ecx
not esp
inc ecx
xadd ah, dl
inc esi
mov dword [edi + ecx + 0x1820aad8], edx
call fcn.00f3683c
Function at 0x186a5c9
Capabilities:
Encode data using base64

Disassembly:
mov ax, word [edi + edx - 0xa]
lea edi, [edx + edi - 8]
xadd edx, ecx
ror ecx, 9
lea ebp, [ebp + ecx*2 - 0xa000001]
rol cx, 0xac
bts edx, 0x1f
movzx edx, byte [ebp + ecx*8 - 0x28000000]
not cl
shr ecx, cl
sal cl, 0x61
xor dl, bl
push ecx
rol dl, 1
or cx, word [esp + ecx]
sbb dl, 0xa5
not dl
or ecx, ecx
bswap ecx
setnp byte [esp + ecx*8]
sbb dl, 0x8c
add cx, word [esp + ecx]
push ecx
xor bl, dl
lea edx, [esp + edx + 8]
sal cx, 0xe4
sub ecx, ecx
setns byte [esp + ecx*4 + 4]
mov byte [edx + ecx*8], al
sal dword [esp + ecx + 4], 0xf4
or dword [esp + ecx + 4], ecx
lea ebp, [ecx + ebp - 4]
mov edx, dword [ebp + ecx]
jge 0x1a60ecd
xor edx, edx
inc dword [esp + 2]
dec eax
test ecx, ecx
call fcn.00e51fd4
mov dword [esp + ecx], esi
ret 4
xor ebx, edx
dec eax
cwde
add esi, edx
inc word [esp + ecx*2 + 2]
setle cl
jg 0xf7d593
call fcn.0183f164
imul ebx, dword [esi + ecx*2 + 0x7c], 0xd0adc8c2
pop eax
insd dword es:[edi], dx
js 0xf9c616
fld xword [edx + 0x7221ef40]
aam 0x85
sal dword [eax + 0x3e9a1dbf], 0x6f
mov ecx, dword [eax - 0x3b]
mov eax, dword [0x8b86b146]
jae 0xf9c684
invalid
ja 0xf9c695
cmp byte [ecx], ah
add al, 0x1f
jmp [ebx]
lodsd eax, dword [esi]
out 0xb3, al
dec edx
and edx, ebx
das
cwde
xor eax, ebx
jae 0xf9c66c
cmp byte [ebx - 0x15], bl
sbb al, 0xef
out dx, eax
push 0x6a
jnp 0xf9c6a9
int1
invalid
shr dword [edi - 0x33], cl
fdiv dword [esi - 7]
scasb al, byte es:[edi]
shr byte [ebx], cl
iretd
mov dword [esi + 8], ebx
add al, ah
mov dword [esi + 4], ecx
lea ebx, [eax*4 + 0x70a811a4]
ror byte [esp + ebx - 0x4952a123], 7
mov dword [ebx + esi - 0x4952a12c], edx
mov ebx, dword [esp + ebx - 0x4952a120]
pop edx
mov ecx, 0x798b0132
mov edx, eax
pop edx
pop edx
pop edx
ja fcn.0182fdb4
mov edx, 0x989e9d38
lea ecx, [edx + edx - 0x67dc0a56]
shl edx, 0xb0
mov eax, dword [edi]
adc edi, 4
xor eax, ebx
xchg dh, dl
xor eax, 0xb7266f10
rol eax, 1
shr ecx, 0x16
adc dx, dx
lea eax, [eax + ecx*2 + 0x50325a68]
shl cx, cl
neg cx
adc dx, cx
not eax
adc ecx, edx
xor ecx, ecx
xor ebx, eax
inc dl
shr ecx, 0x9c
bt cx, 0x8a
adc esi, eax
movzx eax, dx
xor ecx, ecx
ror ecx, 0x36
mov dx, word [ebp + ecx*2]
jb 0xf046a1
add cl, byte [ebp + ecx*2 + 2]
lea ebp, [ebp + eax - 0x9b61]
neg al
btr eax, 0x80
sar al, 0xa7
sal dx, cl
mov word [eax + ebp - 0x9bff], dx
movsx edx, al
jmp esi
xor edx, ebx
bswap ecx
xor word [esp + ecx + 1], 0x4b1e
ror edx, 1
dec word [esp + ecx*4 + 6]
xor word [esp + ecx + 5], 0x7816
not edx
mov eax, 0xe227a08c
neg edx
lea edx, [ecx + edx - 0x361f3b37]
or cl, byte [esp + ecx*4]
bt cx, ax
shl ecx, 0xd5
ror edx, 1
rol ecx, 0xd3
jae 0xf9c614
invalid
Function at 0x186d1a5
Capabilities:
Check for software breakpoints

Disassembly:
sbb esi, 3
cdq
mul dword [esp]
lea eax, [edx + eax*2 - 0x70c093f7]
mov dword [esi], ecx
or eax, dword [esp]
shr byte [esp + 3], 0xe6
shr eax, 0x22
pop eax
jns fcn.00fc7ff1
mov dword [esp], edx
or al, dh
xor ebx, ecx
pop edx
push eax
ror al, 0x63
add ebp, ecx
shr dl, 0xc1
mov ecx, esi
jo 0x17e5085
mov eax, 0x959496a0
mov ecx, eax
dec cx
mov ecx, dword [edi]
add edi, 4
xor ecx, ebx
or eax, eax
lea ecx, [ecx + eax - 0x380ce18b]
movsx edx, ax
xor ecx, 0x20bd19ac
inc dl
ror eax, 0x54
bswap ecx
inc ecx
or dx, ax
shr al, 0x82
shr dx, 0xe6
xor ebx, ecx
btr edx, 0xb3
and dl, ah
adc ebp, ecx
not ax
ror dl, 0xe2
movzx ecx, byte [edi + eax - 0x496af6e9]
lea edi, [edi + eax - 0x496af6e8]
call int.01ae8140
Function at 0x187435e
Capabilities:
Encode data using base64

Disassembly:
dec ebp
mov edi, ebx
dec ecx
sub ebp, 0x8599208a
inc ecx
push ecx
dec ebp
lea ebx, [ebx + edi - 0x2b382f08]
dec esp
bt edi, ebp
inc esp
movzx esp, word [esp + edi - 0x2b382ef2]
inc di
mov dword [ebx + edx + 0x9ce015c], edi
inc eax
or dh, byte [esp + edi - 0x2b382ef3]
inc ecx
pop edi
inc ecx
pop edi
pop edx
ja fcn.00fff3bb
movzx esi, dl
not ecx
dec edx
mov dword [esp + edi - 0x2b382f06], esi
inc eax
shr dh, 6
inc ebp
mov ecx, edx
bswap ecx
dec eax
bswap edx
not dword [esp + edi*2 - 0x56705e08]
neg ecx
inc ecx
push ecx
inc ecx
imul esi, edx
dec esp
mov dword [esp + edi - 0x2b382efe], esi
inc ecx
mov ebp, 0x3b76b8c
mov ebp, 0xada0f43c
xor dword [esp + edi*2 - 0x56705e04], ecx
inc edx
neg byte [esp + edi*2 - 0x56705e0a]
dec esp
mov esi, dword [esp + edi - 0x2b382efe]
dec eax
arpl cx, cx
dec esp
mov dword [esp + edi*2 - 0x56705e04], edi
inc ecx
adc ebp, 0x370cbc20
dec esp
lea edi, [ebp*2 + 0x760981bd]
dec eax
adc ebx, ecx
dec eax
add dword [esp + edi*2 - 0x56705e04], 0x102ea030
jne 0x103f42e

Function at 0x189c104
Capabilities:
Authenticate hmac

Disassembly:
je 0xdbe3d0
mov dword [esp], eax
not edx
mov dword [esp + 4], ecx
shr eax, 0xa5
push ecx
neg edx
not edx
rol cx, 0xed
and byte [esp + eax - 0x5c8ae6f], cl
jbe 0x103aa48
bswap edx
xor edx, 0xde82a707
sal ax, 0x48
call fcn.00ec3433
Function at 0x189d732
Capabilities:
Encode data using base64

Disassembly:
mov eax, 0xe42e0e3b
sub esi, 4
sub al, 0x1f
cwde
bt eax, eax
mov eax, dword [esi + eax*4 - 0x3870]
call fcn.00e6e550
inc ecx
pop edx
pop esi
ja fcn.00fff3bb
mov eax, 0xf0811a9c
lea edx, [eax*8 + 0x7f860abe]
lea ebp, [ebp + edx - 0x38edfa2]
xchg dx, ax
cbw
mov edx, dword [ebp + edx*4 - 0xe386a70]
xor ax, 0x7388
mov ecx, 0x12a87322
and eax, eax
xor edx, ebx
bswap ecx
lea ecx, [eax*2 + 0x790a1c2a]
bswap edx
ror eax, cl
not edx
rol edx, 1
call fcn.01a3b870
lea esi, [esi + edx*2 - 0x1ffe8]
mov edx, dword [esi + edx - 0xfff2]
xor edx, ebx
sar eax, 0xed
sub byte [esp + ecx*2 - 0x16], ch
lea edx, [edx + ecx*4 - 0x491a186b]
bswap edx
and byte [esp + ecx*8 - 0x62], 0x14
not dword [esp + ecx*2 - 0x16]
dec edx
push ecx
not al
call fcn.0197fae3
mov edx, ebp
inc ecx
xor esi, esi
dec eax
mov dword [esp], 0x31079516
inc esp
movzx ebp, bp
dec esi
xor esi, 0x1088a186
inc ecx
movzx eax, bp
dec esi
inc esi
movsx ecx, byte [esp + ebp*2 - 0x956d]
xor esi, 0xe9b8cbb2
dec esi
mov dword [esp + ebp*8 - 0x255b8], esi
bt dx, ax
inc edx
xor dword [esp + ebp - 0x4ab7], esi
dec bp
mov edi, 0x65005795
inc ebp
mov edi, ecx
inc ecx
pop esi
inc al
dec eax
arpl si, si
bts eax, eax
inc ecx
movzx ecx, cl
inc ebp
movsx esp, di
dec eax
adc ebx, esi
dec edi
lea eax, [ebp + eax - 0x4ab8]
push eax
inc esp
movzx edx, bp
inc edi
movzx edi, byte [eax + ebp*8 - 0x255b8]
dec ecx
bts ebp, 0x2a
sar dword [esp + eax - 0x1004ab6], 0x2d
inc ebp
xor bh, dh
mov esi, 0xf4b61806
rol eax, 0xcb
or word [esp + eax*2 - 0x4ab800d], 0x9e85
inc ecx
inc bh
inc ecx
bts esp, 0xb8
sub byte [esp + eax - 0x255c008], 0xba
dec eax
rol dword [esp + eax - 0x255c008], 0xf6
inc ecx
neg bh
dec eax
bswap esi
rol ecx, cl
inc ecx
dec bh
not al
inc ecx
rol bh, 1
inc eax
rol bh, 0xa4
xadd byte [esp + eax - 0x255c0f2], ch
inc ecx
push ecx
inc ecx
neg bh
inc sp
btr ecx, ebp
inc cx
mul edx
inc ebp
xor dh, bh
dec esi
lea edi, [esp + edi + 0x10]
inc cx
sub ecx, ebp
dec eax
sar edi, 0x32
sub word [esp + eax - 0x255958c], cx
inc cx
mov eax, dword [edi + eax*2 - 0x4ab2b34]
dec ebp
lea ebx, [ebx + edi - 2]
dec byte [esp + edi + 3]
inc ecx
add cl, 0x3d
inc cx
mov dword [ebx + edi], eax
movsx eax, si
jp 0x1899211
movzx edx, ax
mov dword [esp + edx*2 - 0x7c4a], 0xf98b8a95
neg cx
and edx, eax
ror cx, 1
imul eax
xor cx, 0x862f
cwd
call fcn.018b75f5
jmp 0x17fd66c

Function at 0x189f886
Capabilities:
Encode data using base64

Disassembly:
adc ax, ax
mov ecx, dword [edi + eax*2 - 0x5ad157c0]
lea edi, [edi + eax*2 - 0x5ad157bc]
movzx edx, ax
setge al
xor ecx, ebx
mov dword [esp + eax*2 - 0x5ad15602], 0xf83fe9ad
not edx
mov dword [esp + eax*2 - 0x5ad155fe], edx
not ecx
Function at 0x18a25c3
Capabilities:
Authenticate hmac

Disassembly:
push edx
xchg dword [esp + ecx*2 - 0x1687c], edx
mov dword [esp + ecx*4 - 0x2d0fc], ebp
ret 8
lea edx, [edx + eax*2 - 0x61ca67f6]
xadd eax, ecx
ror edx, cl
or ecx, ecx
add eax, 0x992f2591
cmovnp ecx, eax
lea edx, [eax + edx - 0x44549d94]
inc cx
inc ecx
xor edx, 0x9a890c11
call fcn.00e9b56d
adc ebp, eax
jmp 0x100d1fc
rol edx, 3
bts ecx, 0xac
not edx
ror edx, 3
sal dword [esp + ecx - 0x1016], cl
rol ecx, cl
xor ebx, edx
mov dword [esp + ecx - 0x68000040], ecx
add edi, edx
rdtsc
add ecx, 0x3f8b59a8
sbb esi, 8
or dword [esp + 4], ecx
sar ecx, cl
mov dword [esi + 4], eax
sal cl, 0x41
inc byte [esp + 6]
mov dword [esi], edx
pop eax
pop ecx
jne fcn.0182fdb4
jno 0x1874230
stosd dword es:[edi], eax
test dword [edx], 0x18dbcf99
loopne 0x18a25b7
int3

Function at 0x18d3fc4
Capabilities:
Encode data using base64

Disassembly:
movsx edx, bl
call fcn.019992e5
lea esp, [esp + 0xc]
call eax
mov ebx, 0x4b2ed6bf
movsx ecx, bl
movzx esi, cx
mov ebp, dword [esi + ebp - 0xffc3]
mov edi, 0x39056f09
btr si, 0x1b
add esi, esi
mov dword [ebp + esi*2 - 0x3defc], eax
and si, bx
rol ebx, cl
mov edi, ebp
js 0xdb07b0
sysenter
call fcn.00eea575
xchg byte [eax], cl
xchg edi, eax
outsd dx, dword [esi]
rcr dword [eax + 0x79], 1
cli
lodsd eax, dword [esi]
pushal
and esi, eax
pop ebx
das
sub dword [ecx + 0x6e], ecx
imul eax, ecx, 0x317e512e
and eax, 0xbf0d5a52
rcl cl, cl
js 0x18d4045
lodsb al, byte [esi]
retf
in al, 0xbb
ror byte [ecx + 0x217d6ee8], 1
sal dword [ecx - 0x32], 1
and eax, 0x2e39adc5
push edx
jmp 0x18d405f
add eax, dword [edx + ecx*4 - 0x29c6cd16]
jmp 0x18d4072
in eax, dx
add al, 0x39
aas
ja 0x18d40ec
cmp al, 0xd1
daa
shl dword [ecx], cl
cmp ch, byte [edi - 0x17]
adc edi, dword [ecx]
in al, 0x13
pushal
pop es
add eax, 0x5d0e5fb7
jg 0x18d40a6
popal
adc dh, byte [ebx + 0x42]
xor ebx, ebp
invalid
mov al, 0x4e
dec esi
sbb ah, byte [ecx - 0x6b]
mov edi, 0xaefe5946
sbb dword [ebx + eax*4 + 0xc0fa0c], 0xe83b8aa7
sub byte [edi - 0x1a], bh
clc
xor eax, dword [eax + 0x14]
popal
test eax, 0xb376afe8
scasd eax, dword es:[edi]
jbe 0x18d407a
jnp 0x18d4078
jmp 0x18d40c4
aad 0xda
int 0x62
xchg ebx, eax
idiv dword [ebx]
jae 0x18d40a5
xor dh, dl
das
xchg ebx, eax
test eax, 0xca2d9297
in al, 0x1b
cli
cmc
or edx, eax
iretd
Function at 0x18e1a2c
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
lea ecx, [ecx + eax*8 - 0x5c87b731]
cwde
adc word [esp + eax*2 - 0xb9fd], 0xc11d
neg ecx
btr eax, eax
shl dx, 0xe4
lea ecx, [ecx + eax*8 + 0x56b8fd3f]
xor ebx, ecx
pop eax
add edi, ecx
rol eax, 0x63
setb al
add eax, eax
movzx dx, byte [ebp + eax*4 - 0x2aad2808]
mov cl, byte [ebp + eax*4 - 0x2aad2806]
shr al, 0x43
lea ebp, [eax + ebp - 0xaab49fe]
sal eax, 0x93
and al, ah
sbb eax, 0x763c3a1e
sal dl, cl
lea ecx, [eax + eax*2 + 0x3daadc14]
add ecx, 0x99ae808
mov word [ebp], dx
jmp edi
dec eax
xor dl, 0xae
neg dword [esp + ecx - 0x5512149c]
push ecx
xor ebx, eax
sal dx, 0x2a
mov word [esp + ecx - 0x551214a0], cx
add esi, eax
ror ecx, 0x44
lea eax, [ecx*8 - 0x28f93d5b]
mov ax, word [eax + edi - 0x18fccf5]
and dl, 0x30
call fcn.018368f9
mov eax, 0xf781a7a8
mov eax, dword [edi]
mov cl, byte [edi + 4]
add edi, 2
shr eax, cl
mov edx, 0x3e1cc190
movsx ecx, dx
call fcn.01b0a53c
mov eax, 0x9904a881
movsx ecx, ax
sub esi, 4
lea edx, [ecx*8 + 0x6ea422a4]
div eax
mov edx, dword [esi]
call fcn.00e830ea
sal edx, 2
movzx eax, dx
ror ecx, 2
sar edx, 0x91
not al
jne 0xdd20b8