joyce8/EMBER2024-capa huggingface dataset:
Function at 0xef3ba0
Capabilities:
Check http status code
Encode data using base64

Disassembly:
mov dword [esp + edx - 0x87f0006], ebp
ret
mov dword [esp + edx*4 - 0x21fca51c], eax
rol dx, 0xec
bswap ecx
xor ebx, ecx
xor eax, dword [esp + edx*2 - 0x10fee524]
adc ebp, ecx
lea ecx, [edx*8 + 0x68ad848f]
sal byte [esp + eax - 0x4d63bcdf], 1
mov ax, word [edx + esi - 0x87f7294]
ror dl, 0xc4
mov cl, byte [esi + edx*8 - 0x43fb9246]
rol dword [esp + edx*8 - 0x43fb9244], 0x84
lea esi, [edx + esi - 0x87f7247]
sal ax, cl
pop ecx
sar dx, 0xc
dec dl
mov word [esi + edx*4 - 0x21fc0018], ax
lea ecx, [ecx + 0x5c21072a]
jge 0x1afd6ff
mov ecx, 0x1d2888a3
mov edx, dword [ebp + ecx - 0x1d2888a3]
movzx eax, cl
lea eax, [eax - 0x41fe44da]
lea ebp, [ecx + ebp - 0x1d28889f]
inc eax
shr eax, cl
xor edx, ebx
dec ecx
dec al
bt ecx, 0x17
lea edx, [edx + ecx*4 + 0x560936a8]
bswap ecx
xadd al, ch
call fcn.01331a03
adc cl, dl
movzx edx, al
btc ax, ax
mov word [ebp + eax - 0x69300181], cx
movzx ecx, dl
call fcn.011c179f
xor eax, 0xc32cc9b4
dec eax
jmp 0x136eb31
neg eax
xadd dx, cx
xor ebx, eax
add ebp, eax
jmp fcn.00fa3814
jge 0xe7a14b
mov eax, 0x94916627
cwde
movzx ecx, ax
movzx cx, byte [ebp + eax*2 - 0xcc4e]
movsx edx, ax
mov dl, byte [eax + ebp - 0x6625]
bt eax, eax
ror al, 0x81
ror eax, 0xc
lea ebp, [ebp + eax - 0x69300004]
or eax, eax
rol ax, 0x66
jne 0xf21300
dec esi
push ebp
mov cl, 0x80
mov al, 0x8f
jecxz 0x1afd79f
test dword [esi - 0x1e], ecx
mov edx, 0xe4cebf47
xor eax, ebx
popfd
mov cl, 0xb9
or al, 0xf
dec esi
les ecx, [eax - 0x4eb33a63]
xor byte [eax], 0xa8
out dx, eax
mov al, 0xc9
xor byte [0xdd0dddce], dh
cmp byte [edi], cl
adc byte [ebx - 0x549870ec], ah
bound esi, qword [ebp + 0x6f]
dec ecx
bnd jo 0x1afd77c
jmp 0x1afd786
jne 0x1afd7c0
xor edx, dword [ecx]
and dword ds:[eax + edi*2], eax
mov ah, 0x50
in eax, 0xc8
or edi, esi
invalid
xlatb
cmp ebx, edx
lcall 0xdf28, 0x201a3526
push 0x13
iretd
outsd dx, dword [esi]
pop es
je 0x1afd820
inc eax
aaa
and ebp, dword [ebx + 3]
shl byte [edx + 0x7708fc4a], 1
mov dword [0xf4a97c7d], eax
pop es
xchg ebp, eax
mov edx, 0x1d8ac22e
invalid
cld
int1
std
retf

Function at 0xef3c7e
Capabilities:
Encode data using xor

Disassembly:
mov cl, byte [ebp + 2]
sbb edx, edx
pop edx
mov edx, 0x7833d1a3
lea ebp, [ebp + edx - 0x7833d1a1]
shr al, cl
neg edx
jnp 0x1225ad3
call 0x8bff178e
cmp byte [esi], bl
xor eax, dword [eax]
cdq
xchg esp, eax
dec edi
jl 0xef3c92
scasb al, byte es:[edi]
rcl byte [ebp + 0x6c], 0xeb
push ebx
popfd
xchg ebx, eax
and dword [ebp + 0x62], eax
sub al, ah
and byte [eax], dh
invalid
invalid
mov word [ebp], ax
push edx
jno 0x1b0e7d8
adc al, 0xe2
add eax, 0x79f1c89d
mov ebp, 0x3430eb7
sub al, 0x19
popfd
enter 0x79f1, 0xffffffffffffffbd
mov bh, 0xe
inc ebx
add ebp, dword [ecx + ebx]
push edx
aad 0x23
inc ebx
mov dword [0xdacca3d6], eax
loope 0x1225ae3
jmp 0x1225b27
add eax, 0x26d55527
fnstsw word [ebp - 0x46298bf2]
inc ebx
loope 0x1225ac1
daa
cwde
invalid
shr byte [esp], 5
pop eax
jmp esi
Function at 0xf05f96
Capabilities:
Encode data using base64

Disassembly:
dec edx
mov ebp, dword [esp + ebp - 0x5750d0a4]
jmp 0xe4a9fa
dec esp
lea eax, [ebx + ebx*8 - 0x76de91cc]
inc ebp
movzx ebx, al
dec esi
mov eax, dword [esp + ebx*4 - 0x38]
dec edx
mov dword [esp + ebp - 0x5750d0b4], ebx
dec esi
mov ebx, dword [esp + ebp - 0x5750d094]
dec ecx
not ebp
jmp 0x1ae0c5a
xor bl, al
xadd dword [esp], ecx
movsx edx, word [esp]
shl byte [esp + edx*2 - 0x184], 0xe6
lea eax, [esp + eax + 4]
mov dl, byte [eax + edx - 0xc3]
xor eax, ebx
pop edx
inc eax
neg eax
mov dword [esp], 0xad3bce91
sub eax, 0x6300593
mov edx, 0x58bdd682
lea ecx, [edx + edx*2 - 0x28648748]
xor eax, 0x970f3013
or edx, ecx
sub cx, 0x66bb
bswap edx
inc eax
bts edx, edx
inc dx
and ecx, 0x6e374095
xor ebx, eax
shl dl, cl
lea edi, [edi + ecx - 0x60140085]
btr cx, 0x82
sal cl, cl
xadd dword [esp + ecx - 0x6013ffff], edx
mov dword [edi + ecx - 0x60140002], eax
xor dword [esp + ecx - 0x60140002], ecx
shl byte [esp + ecx - 0x6013fffb], 0x83
lea ebp, [ebp + ecx - 0x60140006]
neg ecx
js 0xf5bd1a
add byte [eax], al
add byte [edi + 0x70], cl
outsb dx, byte gs:[esi]
push ebx
inc ebx
dec ebp
popal
outsb dx, byte [esi]
popal
jb 0xf06061
add byte [ebx - 0x41ffdab4], cl
mov ebp, 0xc581d525
loope 0xf06072
mov dword [edi + esi*2], esp
sahf
movzx eax, word [esp + 2]
mov eax, dword [ebp + eax*8 - 0x60978]
xor cl, ch
xor eax, ebx
pop ecx
bt edx, edx
shl byte [esp + 3], 0x24
lea eax, [eax + edx - 0x958ad99]
lea edx, [edx - 0x38579746]
shr cl, 0xe1
jp 0xf82598
rol eax, 1
btr edx, ecx
bswap eax
jae 0xfc3a4f
dec dword [esp + ecx - 0x80000000]
xor al, 0x8c
or byte [esp + ecx - 0x7fffffff], cl
shl dword [esp + ecx - 0x80000000], 0xc6
btc ecx, 0x20
not al
rol al, cl
btc cx, cx
inc byte [esp + 1]
jbe 0xee393c
mov ecx, 0x3c148a94
and cx, cx
mov ecx, dword [edi + ecx*2 - 0x78291528]
call fcn.00f53313
dec esi
mov ecx, dword [esp + esi - 0xf780]
inc ecx
movsx ebp, dx
dec esi
mov esi, dword [esp + esi - 0xf778]
pop ebx
dec esi
mov edx, dword [esp + ebp - 0x5750d0a4]
inc ecx
pop eax
dec edx
not dword [esp + ebp - 0x5750d0d4]
jmp 0xd830da
ror eax, 1
shr byte [esp + edx - 0x71a7f167], 0xa1
bswap eax
xor ecx, 0xca1337af
inc dword [esp + edx - 0x71a7f167]
sbb eax, 0x1239ca14
xchg byte [esp + edx - 0x71a7f167], cl
inc edx
bts dx, 0xa
xor ebx, eax
dec dx
rol word [esp + edx - 0x71a7f565], 0x21
bts cx, cx
adc esi, eax
pop ecx
sub ecx, 0xb986bb91
jb fcn.00e4dc2f
dec esi
mov ebp, dword [esp + ebp + 0x5750d11d]
dec eax
mov ebx, dword [esp + 0x50]
dec eax
lea esp, [esp + 0x58]
ret
Function at 0xf1091b
Capabilities:
Encode data using base64

Disassembly:
inc ecx
mov edx, dword [ebx + ebp - 0x1288a42a]
dec esp
lea eax, [ebp + ebp + 0xa985b83]
push ebp
xor edx, esi
dec eax
not dword [esp + ebp*2 - 0x25114854]
inc esi
movzx ebp, byte [esp + eax*2 - 0x5f5347aa]
inc bp
xadd ebp, eax
bswap edx
neg edx
inc ebp
movsx esi, ch
not edx
inc edx
shr dword [esp + eax - 0x2fa900fd], 0xbe
dec edx
pop ebx
bswap edx
dec esi
mov dword [esp + eax - 0x2fa900ff], ebp
dec eax
mov dword [esp + ebp*4 - 0x4a2290a8], esi
jmp 0x1a9e5fb
inc ecx
movzx eax, dh
dec eax
dec ebp
xor dword [esp + ebp*2 - 0x25114852], edx
pop esi
inc ecx
bswap ebp
movzx ecx, al
dec eax
arpl dx, dx
dec eax
not eax
dec esp
lea edi, [ebp - 0x6141a6cc]
dec esp
add esp, edx
inc cx
inc edi
dec ecx
bts edi, ebx
dec esp
mov eax, edi
dec eax
cwde
inc eax
or ch, 0x16
inc ebp
movzx edx, bp
dec eax
lea edi, [ebp + edi - 0x1288a443]
inc esp
mov dword [ebp + edi - 0x1288a43f], eax
inc ebp
mov ecx, ebp
dec ecx
xchg ecx, ebp
jae fcn.01b06334
Function at 0xf1d667
Capabilities:
Encode data using base64

Disassembly:
shrd dx, ax, cl
mov eax, 0x4117371e
mov word [eax + edi - 0x4117371e], dx
mov edx, dword [eax + ebp - 0x4117371e]
call fcn.00eeed69

Function at 0xf1d684
Capabilities:
Encode data using base64

Disassembly:
not eax
neg edx
not eax
call fcn.0129edc7

Function at 0xf343f8
Capabilities:
Encode data using base64

Disassembly:
dec ecx
sbb ebx, 4
mov edx, 0xc028322c
mov ebx, edx
xchg dl, bl
inc ebp
mov edi, dword [ebx]
inc esp
xor edi, esi
push ebx
inc esp
mov ebp, dword [esp + 5]
bswap ebx
inc ecx
inc edi
dec eax
bswap ebx
inc esp
xchg byte [esp + 7], ch
inc ecx
bswap edi
inc esp
movsx edx, bl
inc ecx
neg edi
inc ecx
inc edi
inc dx
shl dword [esp + edx + 7], 0x8d
inc ecx
push edx
inc ecx
xor edi, 0xfdb9469c
mov ecx, 0xc5306739
inc ecx
not edi
dec edx
mov dword [esp + edx + 0x10], esi
inc edx
ror dword [esp + edx*2 + 0xb], cl
inc edx
rol byte [esp + edx*4 + 0xf], 5
movzx ebp, dx
inc esi
xor dword [esp + edx*2 + 0x10], edi
dec edx
mov esi, dword [esp + edx + 0x10]
dec esi
lea eax, [edx*2 - 0x7b5dbb65]
dec edx
mov dword [esp + edx + 0x10], edx
call fcn.01acb7f6
inc ecx
not edi
inc dx
neg dword [esp + ebp*4 - 0x6e]
dec edx
mov dword [esp + ebp*4 - 0x70], esi
inc esi
xor dword [esp + ebp - 0x1c], edi
pop esi
jmp 0x11d022d
mov eax, dword [esp + eax*4 - 0x1265c62c]
call fcn.00fb2d85
mov eax, 0x6417f1b1
movzx ebp, al
mov ecx, dword [esi + eax - 0x6417f1b1]
and ax, ax
cbw
mov edi, 0xf6b63583
lea esi, [esi + eax - 0x6417ffad]
shl eax, 0x35
btc ebp, edi
mov ebp, ecx
adc al, 0x96
movzx edx, ax
not dx
mov edi, esi
div eax
inc edx
mov ecx, eax
jne 0xfb1bc7
push 0x8c35609c
sar dword [esp], 0x7f
ja 0xe65e1a
sub ebp, 4
mov eax, 0x2b917b0d
mov eax, dword [ebp + eax*2 - 0x5722f61a]
mov ecx, 0xd5a136b2
xor eax, ebx
shr cx, 0x2c
btr ecx, ecx
ror eax, 1
inc cx
or ecx, ecx
jle 0x13a1e33
push edx
dec ebp
arpl di, di
call fcn.01368dc0
in eax, dx
xor al, ch
sub al, ch
invalid
neg eax
xor ecx, ecx
btc cx, cx
sbb eax, 0xdd0aa13e
shr cx, cl
neg cx
not eax
btc cx, cx
neg eax
neg ecx
xor ebx, eax
add esi, eax
mov eax, dword [edi]
mov ecx, dword [edi + 4]
call fcn.00d6cc40
Function at 0xf3cc21
Capabilities:
Encode data using base64

Disassembly:
jge 0x13b086b
movzx edx, ax
xadd ax, dx
mov edx, dword [edi + ecx - 0xf8f1819]
dec cx
mov word [esp + ecx*2 - 0x1f1e302e], 0x4f8f
xadd cl, ah
xor edx, ebx
sub edx, 0x959a3b02
and byte [esp + ecx*4 - 0x3e3c6328], ah
jns 0xffc94c
bts eax, 0xc
rol edx, 3
not cx
neg edx
add cl, al
adc cl, byte [esp + ecx*8 - 0x20003985]
lea edx, [edx + eax + 0x376d3c84]
shr ecx, cl
xor ebx, edx
shr word [esp + ecx - 0xe], 0xa5
bts cx, 2
adc edi, edx
movsx edx, byte [esp + ecx - 0x14]
pop eax
jmp fcn.012b031e
mov dword [esp], ebx
movzx ebx, byte [ecx]
xor ebx, edx
push 0x393c6a9b
and ebx, 0xff
dec byte [esp]
call fcn.0121dd04
inc ecx
setb cl
dec ecx
inc ebp
inc edx
imul ebx, dword [esp + edi - 0x2341]
dec ecx
neg ebp
inc ecx
sal edi, 0x1b
inc ecx
pop ecx
dec esi
mov dword [esp + edi*4 - 0x5ffffff8], eax
dec ecx
xor esi, ebp
dec eax
cwde
jmp 0x100ff33
add al, 0xbc
not edx
cwde
dec edx
cwde
sub cl, byte [esp + eax - 0x18a4]
sub cx, cx
xor edx, 0x3a95e384
sar ecx, 0xd7
jnp 0x101672b
mov eax, 0x24a685be
push eax
inc eax
mov eax, dword [edi + eax*2 - 0x494d0b7e]
add edi, 4
xor eax, ebx
mov edx, 0x935f4be
inc eax
jmp 0x1327a72
inc ecx
inc ecx
dec edx
lea edi, [edi + edi*2 - 0x30000008]
jno 0xed3478
xor ebx, edx
ror ecx, cl
or dword [esp + eax - 0x18a4], ecx
sub word [esp + ecx - 0x3c], cx
adc ebp, edx
not eax
neg eax
or edx, edx
movzx ecx, dx
inc eax
xchg ch, dl
xor dx, cx
neg eax
sar ecx, 0xb0
add dl, cl
xor ebx, eax
add dl, 0x85
shr edx, 0xf9
sub dl, ch
adc ebp, eax
btc edx, ecx
dec dword [esp + edx*8 - 0x28]
fild dword [esi + edx*4 - 0x14]
mov dword [esp + edx - 5], ebp
ret
dec esp
mov dword [edi + edx - 0x62], ebp
inc ecx
cmovg ecx, esi
cbw
inc ecx
pop ebp
inc ecx
pop eax
jne fcn.01b06334
cmc

Function at 0xf430e7
Capabilities:
Encode data using base64

Disassembly:
push 0x72a0f191
call fcn.013b1c67

Function at 0xf48b1e
Capabilities:
Encode data using base64

Disassembly:
inc ebp
mov ebp, dword [ebx + ecx*2 - 0x9160]
inc esp
movzx edx, cx
inc ebp
movzx ecx, al
inc esp
xor ebp, esi
inc ecx
not ebp
mov ebx, ecx
call fcn.012eaf78
add edx, esp
and cx, cx
sbb ecx, 0x7f83e7b1
mov word [edx], ax
mov eax, ecx
xor ecx, 0xd39811b1
sbb ax, cx
jmp esi
inc ecx
div ecx
mov dword [edi + ecx*2 - 0x9160], edx
inc esp
movzx eax, bp
pop ebp
push ecx
mov dword [edi + ecx*8 - 0x2457c], eax
shl word [esp + ecx - 0x48ad], 0xe9
dec ebp
lea ebx, [ebx + ecx - 0x48b4]
jbe 0xea7da5

Function at 0xf49bc8
Capabilities:
Encode data using base64

Disassembly:
mov ebp, dword [esp + eax - 0x650051a7]
lea eax, [ebx*8 - 0x2370e1d6]
mov eax, dword [esp + eax*2 - 0x7c4327d4]
pop ecx
push ebx
mov ecx, dword [esp + 0x14]
jmp 0x100e7ec
pop ebx
mov ebx, dword [esp + 0x14]
jmp 0xf05c35

Function at 0xf58aad
Capabilities:
Encode data using add xor sub operations
Encode data using xor

Disassembly:
add edi, 2
call fcn.011c766d
test eax, esi
pushfd
invalid
Function at 0xf5b5f1
Capabilities:
Encode data using base64

Disassembly:
jmp 0xe6756e
mov eax, 0x8c124598
lea eax, [eax*8 + 0x54914fa5]
mov eax, dword [ebp + ebx*4]
push eax
call fcn.011e21be
mov eax, dword [ebp]
mov edx, 0x4d3db918
rol edx, 0x93
push edx
mov ecx, dword [ebp + 4]
not dword [esp]
adc ebp, 3
or edx, 0xa2927813
adc eax, ecx
mov dword [ebp], eax
jmp 0x127608f
not ecx
lea edx, [edx + ecx*2 + 0x630d2525]
call 0xd79e28
xor eax, ebx
call fcn.012b0449
push 0x6c984331
lea esp, [esp + 0x10]
jne 0xda65ab
jmp 0x11dc3dd
mov eax, 0x5020a61a
call fcn.00df20ff
movsx ecx, dl
sub esi, 4
inc word [esp + 1]
movzx eax, dl
pop edx
mov edx, dword [edx + esi - 0x373d9712]
sal ax, 0x66
push eax
xor edx, ebx
dec word [esp + eax*2 - 0x7f7f]
ror edx, 2
lea eax, [ecx - 0x3e55ba4f]
bts ax, 0x3a
xor edx, 0x1939b89b
sar dword [esp], 0x77
jp 0xf532b4
call fcn.01409e1b
dec ebp
btc ecx, edx
inc esp
xor byte [esp + eax + 6], bh
inc ecx
not al
Function at 0xf5f61e
Capabilities:
Encode data using base64

Disassembly:
mov ecx, dword [ebp + ecx - 0x7189ab0a]
not byte [esp + 1]
movsx eax, dl
xor ecx, ebx
xor dx, dx
ror ecx, 1
dec dl
sar ax, 0x66
pop edx
lea ecx, [eax + ecx + 0xba7fc3b]
dec edx
rol ecx, 2
add edx, edx
shl dl, 0x21
push edx
bswap ecx
add dx, 0xda26
rol edx, 0x55
sub eax, 0xf53b068d
inc ecx
rol ecx, 1
ror dl, 0x41
push eax
imul edx, dword [esp + eax - 0xac4f974]
lea ecx, [ecx + eax*2 + 0x3dfd0838]
lea edx, [edx + edx*4 - 0x465116cd]
bts eax, 0xa4
not ecx
rol edx, 0x79
xor edx, eax
lea edx, [edx + edx*2 + 0x938af09]
xor ebx, ecx
sub byte [esp + edx - 0x113acf7d], dl
shl ax, 0xeb
xor eax, eax
adc esi, ecx
rol al, 7
mov dword [esp + edx - 0x113acf82], esi
ret 4
sub edx, 0x8d359013
mov dword [esp + ecx*2 - 0x11a3c], eax
not edx
rol edx, 2
rol ecx, 0x59
setb byte [esp + ecx - 0x3c000118]
bswap edx
dec edx
call fcn.00f8696d
mov ecx, 0x5b2b410a
mov edx, dword [ebp + ecx - 0x5b2b410a]
imul ecx, ecx
mov ecx, dword [ebp + ecx*2 - 0xbc428c4]
mov eax, 0x6bbed03f
sal eax, 0x52
lea ebp, [ebp + eax - 0x40fbfff8]
sar eax, 0x54
dec eax
add eax, eax
mov dword [eax + edx - 0x81c], ecx
mov edx, dword [eax + edi - 0x81c]
lea ecx, [eax + eax*4 - 0x4c62c568]
lea edi, [edi + eax - 0x818]
bswap eax
setne al
xor edx, ebx
ror eax, 0x38
rol edx, 3
xor cx, cx
lea edx, [edx + eax*8 - 0x1cf04b31]
sbb eax, 0x8605ac92
not ecx
ja 0x1240635
ror edx, 2
lea eax, [ecx + ecx + 0x5c952934]
xadd al, ch
dec edx
and ecx, 0xb2ba2523
shr cx, cl
btr ax, cx
xor ebx, edx
lea ecx, [ecx + ecx*4 - 0x586e2c45]
not ax
add esi, edx
jmp esi
lea ebp, [ebp + ecx - 0x76a6e272]
mov dword [esp + ecx - 0x76a6e274], ecx
not al
neg word [esp + ecx - 0x76a6e273]
lea ecx, [ecx + ecx*4 + 0x13bfd015]
xadd cl, ch
not dl
add dword [esp + ecx - 0x65025995], 0x31813caa
btc ecx, 0xb
neg dword [esp + ecx - 0x65025195]
and al, dl
or cx, word [esp + ecx - 0x65025194]
adc dword [esp + ecx - 0x650275b5], ecx
and cx, word [esp + ecx - 0x650275b5]
mov word [ebp + ecx - 0x65021095], ax
mov edx, dword [edi + ecx - 0x65021095]
add dword [esp + ecx - 0x65021095], ecx
lea edi, [edi + ecx - 0x65021091]
jnp 0x1adf7af
lea ebp, [ecx + ebp - 0x7189ab0e]
js 0xe1d008
popfd
ret
inc edx
lea edi, [edi + edx - 0x7189ab04]
push edx
mov byte es:[eax + edx - 0x7189ab0a], cl
lea ecx, [edx + edx*4 + 0x46025023]
xadd edx, ecx
jae 0x132965e
xor edx, ebx
sub cx, 0x2198
not ecx
jge 0x1aa388e
lea edx, [edx + ecx + 0x5e28e51f]
add cl, byte [esp + 3]
movsx eax, cx
bswap edx
shl cx, 0xae
dec edx
ror edx, 1
xor al, 0xa6
cmovnp eax, ecx
xor edx, 0x70958f0d
cbw
mov byte [esp + eax - 0xff7f], ah
inc edx
and cx, 0xc727
dec dword [esp + eax - 0xff82]
xor ebx, edx
add esi, edx
inc ax
mov edx, dword [esp + eax - 0xff83]
mov dword [esp + eax*2 - 0x1ff06], esi
ret

Function at 0xf602fb
Capabilities:
Encode data using base64

Disassembly:
btr ecx, edx
pop edx
movzx dx, byte [edi]
mov eax, ecx
mov al, byte [edi + 2]
dec ecx
neg ecx
sar cl, 5
lea edi, [edi + ecx - 0x65f374fa]
add ecx, 0x37304b25
js 0x12cb2e9
movzx cx, bh
and dl, al
movzx eax, cx
cwde
not dl
or al, 1
sal ax, 0x66
and eax, 0x6e980825
mov word [edi + eax - 0x6e980800], dx
jmp esi
Function at 0xf60359
Capabilities:
Execute syscall

Disassembly:
and al, 0
xor ecx, ebx
xadd byte [esp + eax*2 - 0x55875562], ah
movsx edx, al
rol ecx, 1
jmp 0x13ba199
ljmp 0x53:0xd02fe8ec
setp dl
not ecx
bt dx, dx
not edx
mov dword [esp + eax - 0x2dbbc83a], edx
xor ecx, 0xfc93da98
xor ebx, ecx
pop eax
lea esi, [esi + eax*2 - 0x1dd22e00]
dec ax
bts edx, 0x98
mov dword [esi + eax - 0xee916fd], ecx
add ebp, ecx
push ss
int1
jae 0xf596bc
jb 0xeb51f0
sal cl, 1
dec edx
jns 0xeb527f
or ebp, ecx
or eax, 0x1e1defd0
sbb esp, dword [ecx]
imul ecx, dword [ebp + 0x13], 0x7660dae6
lodsb al, byte [esi]
jmp 0x1edb2286
out 0xda, al
pushal
jbe 0xeb5230
push es
out 0xfb, eax
mov bl, 0xdd
cli
inc ebx
xor byte [ebx + 0x257a5094], ch
stosd dword es:[edi], eax
xchg esp, eax
push eax
jp 0xeb52b6
pushfd
jecxz 0xeb528c
mov eax, 0xdc934ea
xchg edx, eax
mov dh, bl
dec eax
insb byte es:[edi], dx
mov dword [0xc744963b], eax
push es
stosd dword es:[edi], eax
inc ecx
ja 0xeb5263
mov edx, 0xd09962ca
retf 0x2999
out dx, eax
push esi
xchg esi, eax
imul edi, dword [edi - 0x55], 0xa59d70a4
pop eax
int1
ficomp dword [edi - 0x848560b]
jge 0xeb5273
hlt
and dl, ah
jge fcn.00fcea13
syscall
push edx
push esi
dec eax
mov edx, 0x5b3875a4
cmp byte [edi + edi], al
xor cl, byte [eax - 0x75]
push esp
and al, 8
dec eax
mov dword [esp + 8], 0xe9438521
dec eax
lea esp, [esp + 8]
call fcn.01b195b0
dec ax
xchg dh, dl
ror ecx, 2
inc ax
jp 0xeb5237
mov ecx, 0x47b696a4
jmp 0x12b8fd3
mov eax, ecx
mov edx, dword [ebp + eax - 0x47b696a4]
and al, al
lea ebp, [ebp + ecx - 0x47b696a0]
shl ecx, cl
rol eax, 0x78
xor edx, ebx
inc ecx
dec edx
dec al
not cx
neg edx
lea edx, [edx + ecx - 0x58af4835]
dec al
bswap edx
xor ebx, edx
bt ecx, eax
adc esi, edx
xor cl, cl
mov ecx, dword [edi + ecx - 0x7b699500]
not al
mov eax, dword [edi + 4]
push 0x8313342a
ror word [esp + 2], 0x81
push 0xf3351f1b
adc edi, 3
sar dword [esp + 4], 0x56
xor edx, edx
dec byte [esp + 6]
call fcn.0120f908
neg ecx
inc ecx
sar al, 0x44
call fcn.00ed6700

Function at 0xfd4cf1
Capabilities:
Encode data using base64

Disassembly:
mov dword [edi + ecx - 0x43b8514c], edx
mov dword [esp + ecx - 0x43b8514c], ecx
lea ebp, [ebp + ecx - 0x43b85150]
mov ecx, dword [ebp + ecx - 0x43b8514c]
lea edx, [eax + eax*4 + 0x5307372f]
xor ecx, ebx
cbw
not dl
not ax
ror ecx, 1
cwde
jmp 0xee1bd7

Function at 0xfffaa1
Capabilities:
Encode data using base64

Disassembly:
dec edx
mov dword [esp + ebp - 0x16], 0xa83c5f33
dec edx
mov edx, dword [esp + ebp - 0xe]
inc ebp
xchg ebp, eax
inc edx
mov edi, dword [esp + ebp - 0x1f32b65d]
dec esi
lea esi, [edi - 0x38653bf9]
dec edx
mov edi, dword [esp + ebp - 0x1f32b64d]
dec esi
mov dword [esp + ebp - 0x1f32b64d], esi
inc ecx
push esi
pop ebx
dec edx
mov esi, dword [esp + ebp - 0x1f32b645]
call fcn.012a4750

Function at 0x10004f0
Capabilities:
Encode data using base64

Disassembly:
dec eax
test ebp, ebp
call fcn.00deebb6
jmp 0x134e4f0
inc ebp
xor ecx, ecx
jmp 0xf79372

Function at 0x1008208
Capabilities:
Encode data using base64

Disassembly:
inc word [esp + 5]
dec eax
call fcn.00daddd5
xor ecx, 0x3a13062a
mov dword [esp], 0x102b11af
jmp 0xfa357b
Function at 0x101702e
Capabilities:
Encode data using xor

Disassembly:
pop ebp
pop ebp
jmp fcn.01b06334
neg ecx
ror eax, 0x12
add edx, 0x551e7b14
xor ebx, ecx
xor eax, 0x7619b08c
shl al, 7
inc eax
adc edi, ecx
mov ecx, edx
call fcn.010183f1
inc ecx
mov edx, 0x7360736
dec ebx
lea ebx, [edx + edx*4 - 0x43c61771]
dec esi
lea ebx, [ebx + ebx + 0x1fb7f35f]
inc ecx
mov ebp, 0xea162433
inc ecx
movsx eax, dl
inc ecx
mov edx, ebp
inc ebx
mov ebp, dword [ebx + edx - 0x7360736]
inc ecx
mov eax, 0x6d32ceb3
xor ebp, esi
rol ebp, 1
inc edx
lea ebp, [ebp + edx*4 + 0x77bc68b5]
inc ecx
sub ch, 0xc
xor ebp, 0x5c0fe4a9
inc esp
movsx edi, dl
inc ecx
btc edx, eax
inc ecx
movzx ecx, dx
dec ebp
neg edx
ror ebp, 1
inc cl
not ebp
jp 0xe00cfe
mov ebx, 0xb70f41c2
retf 0xcdff
aad 0xf
mov dl, cl
loop 0xf42a17
dec dword [edx - 0x73]
sbb al, 0x45
mov edi, 0x418419ae
dec edx
lea ebx, [eax*2 - 0x7be65141]
inc ecx
sar ebp, cl
dec ebp
call fcn.00fd4270
lea edi, [eax + edi - 0x1d319236]
sbb word [esp + eax*2 - 0x3a632474], ax
call fcn.013de59e
inc ecx
xor al, cl
or eax, 0x74b5a3c2
loop 0xf42a26
mov cl, 0xf1
ret
shl dword [esp + eax*8 + 4], 0xea
xor ecx, ebx
call fcn.01293630
movsx edx, ax
xor ecx, ebx
cdq
shl eax, 0x28
adc ecx, edx
sal eax, 0x4d
rol ecx, 3
add ecx, 0x41399e1f
neg ax
jae 0xf429ab
invalid
Function at 0x1024111
Capabilities:
Encode data using base64

Disassembly:
jmp 0x13c8635
btc eax, 0x8b
adc ebp, 3
xor ecx, ebx
bts eax, eax
shr al, 0xe3
neg ecx
not al
sal eax, 7
sbb ecx, 0x8fa8d68c
sub eax, eax
sub eax, eax
neg ecx
call fcn.013e0587
bts dx, dx
mov byte [eax], cl
jb 0xf27913
jmp edi
not eax
sal edx, 0x8f
bts ecx, edx
xor edx, edx
rol eax, 2
xor ebx, eax
add edi, eax
inc edx
mov cx, word [edx + esi - 1]
lea esi, [esi + edx + 1]
movzx eax, byte [ebp + edx*4 - 4]
lea edx, [edx*4 - 0x42dd90c2]
imul edx, edx
lea ebp, [ebp + edx*2 - 0x63c49a07]
dec edx
shl dl, 0x85
btr dx, dx
xor al, bl
inc al
sal dl, 0x67
neg al
ror edx, 0x78
ror al, 1
shr dl, 0x61
adc al, 0xb1
inc dx
ror dx, 0xa4
xor bl, al
inc edx
jno 0x128d42a
lea ecx, [eax + ecx - 0x727c326f]
bt eax, ecx
xor ebx, edx
inc eax
not eax
add ebp, edx
push eax
pop edx
jmp ebp
inc ebp
xchg ecx, ebx
dec esi
mov dword [esp + ebx - 0x5f4a2615], ecx
dec edx
mov ecx, dword [esp + ecx - 0x5f4a260d]
inc ebp
xchg ebx, ecx
dec ebp
xchg ecx, ebx
dec esi
mov ecx, dword [esp + ebx - 0x5f4a2605]
inc ecx
movzx ebp, bx
call fcn.0124030f
mov edx, 0x5f8f399a
movsx ecx, dl
mov ecx, dword [ebp + edx - 0x5f8f399a]
lea ebp, [ebp + edx - 0x5f8f3996]
movsx eax, dx
dec dl
sar edx, 0x13
xor ecx, ebx
div al
jmp 0x12ba898
lea ecx, [ecx + edx*2 + 0x62258617]
xor ebx, ecx
push edx
add ebp, ecx
mul dword [esp + edx - 0x771de42]
cwde
neg edx
pop edx
jmp ebp
add eax, esp
not dl
jmp 0xf303ca
add esi, 6
jmp 0xd91003
push eax
rol ecx, 3
sar edx, 0xb
not ecx
cwde
neg ecx
xor ecx, 0xe7841e0f
xchg dword [esp + edx*4 - 4], edx
btr eax, edx
ror ecx, 1
jmp 0x1402d8c
ror ecx, 2
jmp 0x124c8d4
shrd edx, eax, cl
mov dword [esi], edx
jmp 0x1ac6698
xor ebx, ecx
push eax
add esi, ecx
call fcn.00d5fd33
mov edx, 0x963cdf3c
or edx, edx
movzx eax, dx
mov eax, dword [ebp + eax*2 - 0x1be78]
inc dl
setbe dl
adc ebp, 4
xor eax, ebx
mov ecx, 0x26b42723
btc edx, 0xb5
sbb eax, 0xf1241781
neg eax
and ecx, ecx
bts ecx, edx
not eax
dec eax
btr edx, ecx
jae 0xfa6c98
mov edx, 0x24a3389b
movzx ecx, dl
mov edx, dword [esi + edx - 0x24a3389b]
lea eax, [ecx + ecx*2 + 0x5433629e]
mov eax, dword [ecx + esi - 0x97]
sar ecx, cl
xor ecx, ecx
sub cl, cl
or cl, byte [esi + ecx*4 + 8]
jmp 0x12b2a93
sub edi, 4
mov ecx, 0x882e2ba8
movsx edx, cx
mov eax, edx
mov ecx, dword [eax + edi - 0x2ba8]
xor ecx, ebx
sal eax, 0x10
imul edx, edx
xadd dl, al
ror ecx, 3
dec ecx
inc edx
rol ecx, 3
neg al
sbb ecx, 0xf017773a
inc edx
jno 0x1363854

Function at 0x1027beb
Capabilities:
Encode data using base64

Disassembly:
mov dword [esp], edi
mov edi, 0xb93a2408
jmp 0x1225932
not edi
push esi
lea edi, [edi*2 - 0x4ff2d56]
pushfd
neg di

Function at 0x102973d
Capabilities:
Execute syscall

Disassembly:
push edi
mov dword [esp + 4], 0xc337843f
lea esp, [esp + 4]
call fcn.00fc6c32
sysenter
call fcn.0123e57e

Function at 0x11d96b4
Capabilities:
Encode data using base64

Disassembly:
not eax
mov edx, 0xa3bc7912
call 0x12e15c7