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

Disassembly:
mov dword [esp + edx*2 - 0x4a], edx
not eax
bswap ecx
rol eax, 1
sar dword [esp + edx*2 - 0x4a], cl
bswap eax
btc ecx, ecx
xor ebx, eax
add edi, eax
sub dword [esp + edx - 0x25], edx
movzx eax, byte [esp + edx - 0x25]
mov al, byte [edx + esi - 0x25]
shl cx, 0xe5
btr cx, dx
lea edx, [edx + ecx*8 + 0x46039408]
lea esi, [esi + edx - 0x194f862c]
adc edx, dword [esp + edx - 0x194f862d]
xor al, bl
shr edx, 0x73
neg al
xor ecx, 0x23a1140e
add dword [esp + edx - 0x329], 0x380eb599
jo 0x13402438
rol al, 1
call fcn.120c3f6b
mov eax, 0xc7ba1d30
not eax
lea edx, [eax + eax*4 - 0x125e807e]
mov dl, byte [ebp + eax - 0x3845e2cb]
not eax
cwde
lea ebp, [ebp + eax - 0x1d2a]
rol eax, 0xdb
mov byte [ecx], dl
lea edx, [eax + eax + 0x2bae2590]
lea esi, [esi + edx - 0x2bae2766]
sar edx, 0x91
xor ebx, eax
lea ecx, [edx + 0x618398a0]
sub dx, dx
jb 0x133de1b6
adc edi, eax
call fcn.133558c8
inc ecx
sub ecx, 0xf0350c06
inc ecx
ror esi, 0xa2
inc ecx
bswap ecx
inc ebp
movsx esp, si
inc ecx
movzx eax, sp
inc ecx
dec ah
inc ecx
inc ecx
inc esp
movzx eax, bh
call fcn.1345763d
inc sp
mov esi, dword [ebp]
mov edi, 0x55832109
inc sp
mov edi, dword [ebp + edi - 0x55832107]
dec eax
lea ebp, [ebp + edi - 0x55832107]
dec eax
lea ebx, [edi*4 - 0x2f7a8e80]
dec eax
lea ecx, [ebx + edi*4 - 0x48ec184d]
inc esp
movsx ecx, bx
inc bp
add esi, edi
inc sp
mov dword [edi + ebp - 0x55832109], esi
inc cx
add edi, ecx
neg cx
inc ecx
mov edx, 0x4bdd6b4
inc edi
mov ecx, dword [edx + ebp - 0x4bdd6b4]
imul edi, ecx
inc cx
add edx, 0x81498c26
fisub dword [eax + 0x4f33a579]
lea ebp, [edx + ebp + 0x2ee816cb]
inc esp
mov esi, ebx
dec bx
inc ebp
xor ecx, ebx
inc ecx
rol ecx, 3
inc esp
movsx eax, cl
inc bp
xadd eax, esi
jnp 0x126c32b3

Function at 0x126124e0
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
not ecx
xor ebx, ecx
mov dword [esp], 0x20b64b15
add esi, ecx
lea esp, [esp + 0x20]
jmp 0x13512087
push 0x5712162d
pushfd
cmp byte [esp + 4], 0xb8
mov dword [esp + 4], 0x9d394b26
push dword [esp]
popfd
lea esp, [esp + 4]
call fcn.11f7dfad
mov ecx, 0x78abda7
lea ebp, [ecx + ebp - 0x78abdab]
movsx edx, cl
jmp 0x11f6b5ba
Function at 0x12617604
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
ror dword [esp + 9], 0x41
rol edx, 1
shr word [esp + 4], 0xcb
js int.13378321
rol dword [esp + 3], 0x5d
inc edx
not byte [esp + 3]
not edx
xor ebx, edx
not dword [esp + 7]
add edi, edx
lea esp, [esp + 0x10]
push 0x9e832b8d
call fcn.12087a6e
mov ecx, 0xf4b0ad05
or byte [edx + 0x5b9ffa8], 0xad
mov al, 0xf4
lea ecx, [ecx + 0xa4451e]
call fcn.1356721e
push ss
sbb dword [ebp - 0x60], esp
shl dword [edx + 0x7592a1f1], cl
push es
mov ch, 0x11
fisub dword [ebx + 0x5d]
sub dword [ecx + 0x405f5191], ebx
xchg esi, eax
insd dword es:[edi], dx
jg 0x125ff044
xchg edi, eax
or eax, 0x899f2a6e
push 0x24909ee6
into
shr byte [eax + edi + 0x70], cl
dec esi
insd dword es:[edi], dx
add ebp, dword [esp + ebx*2 - 0x43]
sub byte [esi - 0x4b], 0x95
stc
adc dword [si - 0x3578], esi
mov edx, 0x810393ff
hlt
dec ecx
dec edi
jae 0x125fefe8
outsb dx, byte [esi]
mov esi, 0x93893068
mov dword [edi], ecx
dec esi
nop
lds ecx, [ebx + 0x1b6c4d63]
adc ebp, dword [edx + 0x6fb8681]
dec esi
in al, 0xb9
scasd eax, dword es:[edi]
sub al, 0xc7
wait
aam 0xc3
loope 0x125ff072
push 0x22
pop eax
ret 0xd4f1
adc byte [esi - 0x560ea30e], 0x26
aam 0x81
insb byte es:[edi], dx
xor byte [edi], dl
in al, 0x86
das
clc
dec ebp
sub ebp, dword [ebx + 0x7568fb18]
cwde
mov ah, 0x5a
imul ebx, ecx, 0x7e7b834
aad 0x87
invalid
push 0x631a519f
neg edx
mov dword [esp + 4], 0xbe84c790
jmp 0x125fefb7

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

Disassembly:
movsx eax, cx
mov ecx, dword [edx + edi - 0x3ca4]
rol al, 0xc1
lea edi, [edi + edx*4 - 0xf28c]
mov dword [esp + edx*2 - 0x7948], edx
lea ebp, [ebp + edx - 0x3ca5]
mov eax, 0x8dffff86
lodsb al, byte [esi]
adc eax, 0xffffc35b
movzx eax, byte [edx + ebp - 0x3ca4]
dec dl
setbe dl
xor al, bl
sar dword [esp + edx - 0x3c00], 0xd0
xchg dword [esp + edx*2 - 0x7800], edx
pop edx
rol al, 1
or dl, dh
not al
call fcn.11ec0315
sub edx, ebx
mov al, 0x91
std
test dword [esi - 0x74df4434], esp
push 0xffffffffffffffa1
fiadd word [esi + 0x55579397]
shl byte [edx + edi*8 - 0xf6b156b], 0x21
xchg ecx, eax
cmp esi, esi
pushfd
ror esp, cl
add byte [edi + 0x6a7c8ffd], bh
js 0x12618b05
mov dword [edi + ecx], ecx
inc ebp
adc ebx, dword [ecx + 0x523c0303]
ror dword [edx + ebp*2 + 0x64], 0xf0
insb byte es:[edi], dx
invalid
Function at 0x126227bb
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
xor eax, ebx
add dx, dx
not ecx
xor eax, 0x6a1cbbb6
dec edx
add cx, dx
inc eax
rol eax, 3
sar cx, 0xa4
neg dx
dec eax
bswap eax
not edx
ror eax, 1
and cx, 0xa4be
xor ebx, eax
sub ecx, 0x1f0c7d82
call fcn.1334b4a8
cwde
pop esp
ljmp 0x93b5
xor eax, esi
push 0x2e8bb5be
dec dword [esp + 8]
inc ecx
call fcn.1333231d
shr ax, cl
adc dl, 0xac
dec cx
rol cx, cl
neg dl
sal ax, 9
setb cl
or al, 0x8c
dec dl
rol dl, 1
shr eax, 0xe1
dec dl
xor bl, dl
push ecx
jmp 0x13224f22
not ecx
lea ebp, [ebp + edx - 0x4aa41537]
neg cx
rol edx, 0xfe
jae 0x1204453e
xchg ecx, eax
lea edi, [ecx + edi - 0x7e563c4a]
neg al
xor dword [esp + eax - 0x348f2000], 0xf8a7a791
btc ax, 0x1a
mov dword [ecx + edi - 0x7e563c46], edx
or eax, 0x8a942800
cwde
pop eax
jne fcn.12693695
mov ecx, 0x83362e1c
mov ecx, dword [edi]
mov eax, dword [edi + 4]
mov edx, 0x91876d85
lea edx, [edx*2 - 0x70473558]
add edi, 8
shl edx, 0xe1
bts dx, dx
jae 0x1354dd2a
mov eax, 0x1f36ae98
and eax, eax
push eax
mov ecx, dword [eax + edi - 0x1f36ae98]
pop eax
mov eax, dword [edi + eax - 0x1f36ae94]
call fcn.11f77604
mov dword ss:[ecx + edx - 0x658f4b74], eax
lea edx, [edx - 0x1aeae8cd]
ror dx, 0x6d
lea ecx, [edx*8 + 0x5a91d87]
mov eax, dword [ebp + ecx - 0x5ac9c75f]
jae 0x12694093

Function at 0x12637179
Capabilities:
Encode data using xor

Disassembly:
mov dword [esp + eax - 0x31279600], 0xfcb3702e
mov bl, 0xfc
xor ecx, ebx
add al, dh
inc al
sar ax, 0x47
xor ecx, 0xa198d98a
call fcn.1338a03a
jae 0x12637203
lea esp, [edx - 0x601e0e39]
xchg edx, eax
push es
xchg ecx, eax
xchg edx, eax
xchg ecx, eax
pop eax
push cs
jp 0x12637182
inc edi
xchg edx, eax
inc edi
sbb byte [esi + 0x78999193], ah
sub dl, byte cs:[ebx]
outsd dx, dword [esi]
outsd dx, dword [esi]
pushfd
clc
and dword [edx - 0x6e58b6fa], edx
pavgw mm4, qword [eax + 0x6c91fca9]
sub eax, 0x106e1d8c
dec eax
mov cl, 0
add al, 0x6f
std
sub byte [eax - 0x6d], cl
push eax
adc dword [edi - 0x75], edi
cdq
xchg ebx, eax
dec ebx
invalid
cmp eax, 0xe7cf691e
sbb bh, bl
xchg esp, eax
lahf
fidivr dword [edi]
mov ecx, dword [edi - 0x44]
xchg ecx, eax
aaa
outsb dx, byte [esi]
sal dword [ebp - 0x4ce73d91], cl
xchg dword [ecx + 0x21], ecx
imul esi, ecx, 0xfffffff1
mov ch, 0x32
insd dword es:[edi], dx
out dx, al
and al, 0x29
or esp, eax
ret 0x749e

Function at 0x1263af1e
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
dec eax
xchg dh, dl
bswap eax
or ecx, edx
shr cl, 0xa5
Function at 0x1264b015
Capabilities:
Encode data using base64

Disassembly:
lea esp, [esp + 0xc]
jne 0x12643112

Function at 0x12655f33
Capabilities:
Encode data using xor

Disassembly:
neg edx
add eax, 0x10af7928
xchg ecx, eax
xor ebx, edx
pop ecx
add edi, edx
call fcn.132470f9
inc ecx
push edx
js 0x12655f84
cmpsb byte [esi], byte es:[edi]
mov al, 0xf6
mov ah, 0x28
popal
outsb dx, byte [esi]
nop
out dx, al
mov ecx, 0x27deea6e
aas
push ebx
mov ecx, 0xdccfd593
movsd dword es:[edi], dword [esi]
dec edi
adc bl, byte [ecx]
invalid
xchg ebx, eax
pop es
push es
add eax, 0xb140edcb
mul dword [eax - 0x6b93f841]
invalid
Function at 0x12658625
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
mov eax, dword [edi]
mov ecx, 0x7aa65cbe
movsx edx, cl
lea edi, [edi + ecx - 0x7aa65cba]
xor eax, ebx
ror dl, 0x22
not eax
ror ecx, cl
btr ecx, ecx
xor eax, 0x7a0f5f97
lea eax, [ecx + eax - 0x22e9facc]
lea ecx, [edx + edx + 0x24d589]
ror eax, 1
neg eax
shr ecx, cl
imul edx, edx
rol eax, 1
not edx
shl cl, 0x86
xor ebx, eax
xchg cx, dx
bt ecx, edx
adc ebp, eax
movzx edx, byte [ecx + edi - 0xe65e]
lea ecx, [ecx*8 + 0x2e08141c]
mov eax, ecx
jmp 0x133fb102
sar dword [esp + edx + 1], 0x42
adc al, 0x1c
mov dword [esp + edx + 4], ecx
add ecx, edx
push edx
xor bl, al
xor word [esp + edx + 2], cx
xor dx, 0xbb94
adc byte [esp + edx - 0xbb90], dl
lea ebp, [ecx + ebp - 0x4129c002]
cmovbe dx, word [esp + ecx - 0x4129bffb]
setp dl
mov word [ecx + ebp - 0x4129c000], ax
jae 0x1269a8f3
jmp 0x126365f5
call fcn.13383d4f
fbstp tbyte [ebx + 0x76]
dec edx
and byte [edx + ebp*4], dh
sub byte [eax + esi*8], cl
dec edi
fild word [eax - 0x77]
sub cl, byte fs:[eax + 0x3d256210]
jp 0x126585d9
dec edx
jns 0x1265866f
mov bh, 0xf8
jne 0x12658684
lodsd eax, dword [esi]
aad 0xc0
sahf
pop es
inc edi
nop
push ss
mov ebx, dword [esi - 0x12]
sub al, 0xdb
pop ebx
mov bl, 0x84
int3
hlt
xor dword [esi + 0x6e8d16bd], edi
test al, 0xc5
mov bl, 0x64
dec ecx
mov dl, 0xcc
shr dword [edx], 1
mul ch
sub al, 0xa1
mov dword [0xec3c6ec7], eax
mov ebx, 0x20a278af
xchg esi, eax
outsd dx, dword [esi]
ret
adc dword [esp + edx - 0xbafe], ecx
mov ecx, dword [edi + edx - 0xbb00]
setnp dl
lea edi, [edi + edx*2 - 0x175fc]
setl byte [esp + edx*2 - 0x175f8]
xor ecx, ebx
call fcn.11ed8760
lea eax, [eax*4 - 0x3ed9c4d9]
sal dx, cl
mov word [eax + edi - 0x51788b63], dx
lea ebp, [eax + ebp - 0x51788b67]
mov edx, dword [ebp + eax - 0x51788b63]
mov ecx, eax
xor edx, ebx
xchg al, cl
lea edx, [edx + eax - 0x32c28ba4]
jmp fcn.133b75c1
lea edi, [edi + eax*2 - 0x5c1e8e17]
dec eax
sal cl, 0x24
xor dl, bl
sub dl, 0x16
xor dl, 0x13
rol dl, 1
inc eax
inc cx
inc dl
sub ecx, eax
jg 0x120a62e2
adc esi, 2
xor edx, 0x4cb08823
lea edx, [eax + eax*8 - 0x5c46cb65]
cdq
sbb ebp, 1
inc edx
shr eax, 0x70
movzx eax, byte [ebp + eax*4 - 0x24204]
neg dx
dec edx
xor al, bl
ror al, 1
rol edx, 0x42
xor edx, 0xdb1f1893
not al
xor dl, dl
neg dx
adc edx, 0x551bc50c
xor al, 0xb4
add edx, edx
bswap edx
shr edx, 0x4d
not al
neg dx
dec dl
rol dl, 0x61
xor al, 4
xor bl, al
add eax, esp
mov byte [edx + eax - 0x2a30], cl
lea eax, [edx*4 + 0x23a4600f]
movzx ecx, al
and cl, cl
lea ebp, [ebp + eax*2 - 0x474a11a2]
shr ecx, cl
xor ecx, dword [ebp + edx*8 - 0x15180]
xor ecx, ebx
shl al, 0x83
shr ax, 0x21
ror ecx, 3
and eax, edx
or al, 0x95
cwd
dec ecx
sal edx, 0x90
bswap ecx
cdq
adc ecx, 0x981827b1
xchg dh, al
xchg edx, eax
xor al, ah
bswap ecx
lea ecx, [ecx + edx*2 - 0xd006bae]
jb 0x133c0abd
imul edx
shl eax, 0xfd
xor ebx, ecx
cwd
push eax
inc word [esp + edx*2 + 1]
add edi, ecx
xor edx, 0xfb0025aa
mov ecx, 0x77245c9b
pop edx
add eax, edi
jmp eax
Function at 0x1266f36c
Capabilities:
Encode data using xor

Disassembly:
mov dword [esp], 0xe0a7172c
mov dx, word [esi]
mov ecx, 0xd1d3e87
mov cl, byte [esi + ecx - 0xd1d3e85]
mov eax, 0xad9ff6ae
add esi, 2
sub word [esp + 1], ax
not dword [esp]
xor ax, 0x9bbb
shr dx, cl
mov word [esi], dx
sub ebp, 4
cwde
call fcn.133f2cc5

Function at 0x126a61c9
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
pushfd
mov dword [esp], 0xd594f56e
call int.12646420
lea edi, [edi + ecx*4 - 8]
ror cx, 0x87
setns al
push edx
mov eax, dword [edi + ecx - 0x200]
xor eax, ebx
sub eax, 0xf6baaa3a
shl cl, 0xc5
imul edx, edx
xchg cl, dl
rol eax, cl
shl edx, 0xa5
mov dword [esp], 0x569cf919
lea esp, [esp + 8]
jmp 0x11fbe2c8

Function at 0x126b0642
Capabilities:
Authenticate hmac

Disassembly:
inc eax
neg bh
dec esi
lea esp, [edx + ecx + 0x6b1d0e06]
cwde
inc eax
add bh, 0x8c
inc ecx
ror ah, 0xc3
inc eax
rol bh, 1
inc esp
xor bl, bh
dec eax
lea edi, [esp + edi + 0x10]
inc ecx
rol esp, 0xd7
inc edx
mov dword [edi - 0x70b13100], ecx
inc esp
xchg edx, ecx
cbw
call fcn.13560756
dec eax
lea esp, [esp + 0x28]
je 0x134b853e
inc ecx
mov ecx, 0xc191389b
dec esi
lea esi, [ecx*2 - 0x234482df]
dec ecx
inc ecx
dec esp
lea esi, [0xdf3786]

Function at 0x126c2935
Capabilities:
Encode data using xor

Disassembly:
lea esp, [esp + 0x18]
jne 0x134a9430
mov edx, 0x3981c5af
pop ebx
Function at 0x126c8607
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
call fcn.1356e55f
mov eax, 0x72941135
movsx ecx, ax
movzx cx, byte [edi + ecx - 0x1135]
mov edx, 0x9f9eb59a
and eax, 0xca9a660e
mov dl, byte [edi + eax - 0x42900002]
neg eax
sal eax, 0x3b
lea eax, [eax + eax*8 + 0x3dacd69e]
lea edi, [eax + edi - 0x1dacd69c]
and cl, dl
not cl
add eax, eax
bts eax, 0x8c
ror ax, 0xf
mov word [edi + eax*2 - 0x76b2f4f2], cx
or ecx, dword [ebp - 0x77]
lea ebp, [eax + ebp - 0x3b597a7d]
lea ecx, [eax - 0x1ece3742]
cwde
btc eax, 0x17
mov eax, dword [ebp + eax*2 - 0x100f4f2]
xor eax, ebx
sal ecx, 0xa8
call fcn.1338c753
lea edx, [edx + edx*8 - 0x104ba479]
bts edx, 0xa4
bswap eax
inc edx
or ecx, dword [esp + ecx - 0x60b095a6]
not eax
lea edx, [ecx*2 + 0x75987433]
or ecx, edx
ror ecx, cl
bswap eax
add word [esp + edx - 0x5cfc5f7f], dx
xor ecx, dword [esp + edx - 0x5cfc5f7f]
add dword [esp + edx - 0x5cfc5f7f], 0x191f6f01
xor ebx, eax
add dword [esp + edx - 0x5cfc5f7f], 0x7697e78b
shl cx, 0xf
adc edi, eax
lea esi, [esi + edx - 0x5cfc5f80]
pop edx
jmp 0x13518f57
dec eax
lea esp, [esp + 0xc]
jne 0x13282fb0
mov edi, 0x450b8fa9
pop edi
mov eax, 0x61db613
movsx ecx, al
not edx
sal al, 0xe7
mov dword [ebp + eax - 0x61db680], edx
lea edx, [ecx - 0xd5591f9]
inc ecx
jmp esi
mov edi, 0x1aa3b598
lea edi, [edi*2 - 0x4c59c7fe]
movzx edi, byte [ecx]
push 0xc78fa830
sal dword [esp], 0xcf
xor edi, edx
sal dword [esp], 0x64
and edi, 0xff
jmp 0x1265b7d2
movzx ecx, byte [edx + esi + 0x7ca6e8d1]
lea eax, [edx*2 - 0x2647cb6c]
not dl
xor cl, bl
cwde
push edx
xor cl, 2
sar dx, 0xe9
shl edx, 0xb1
sar dl, 0xc1
ror cl, 1
and dl, al
not cl
idiv ax
bt edx, eax
neg cl
cwde
xchg word [esp + eax*8 - 6], dx
not cl
ror cl, 1
neg cl
div al
neg edx
cbw
xor bl, cl
shr dx, 0xaf
cdq
add byte [esp + eax*2 - 1], al
lea ebp, [eax + ebp - 3]
neg dx
sar dword [esp + eax*2 - 2], 0x18
mov byte [esp + eax - 1], ah
mov word [eax + ebp - 1], cx
btc ax, ax
pop eax
jae fcn.11ec5778
push esi

Function at 0x1321bf7f
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
xor dword [esp + esi*2 - 2], edx
add bx, 0x204
mov dword [esp + ebx - 0x1e1], ebp
setne byte [esp + esi*4 - 3]
call fcn.1339b51f
mov eax, dword [ebp]
mov edx, 0x2482209b
sal edx, 1
mov edx, dword [ebp + edx - 0x49044132]
call fcn.1342ad0d
mov edx, 0x833fe60a
mov word [ebp], ax
movzx eax, dl
mul al
jmp edi
push esi
mov esi, 0x8809e89b
jmp 0x133c65e4
jmp 0x134521ec
push ebx
push ecx
mov ebx, esi
jmp 0x13544207
push ebx
jmp 0x1268eece
jmp 0x1354675a
push edi
mov ecx, ebx
xchg esi, ecx
push edx
pushfd
mov edi, 0xab232ea1
mov ecx, 0
shl ebx, 0x44
mov dword [esp + 0x18], ecx
lea edx, [ebx + esi*2 + 0x1e8f59a8]
push esi
mov edi, dword [esp + 0x24]
or edx, dword [esp]
dec byte [esp]
lea edi, [edi + esi + 0x43af1d67]
cmovle ebx, dword [esp]
sbb ebx, dword [esp]
bts si, si
not edi
xor esi, dword [esp + ebx]
shr bl, 0xa6
sbb edi, esi
inc ebx
not edi
add dword [esp + esi - 1], 0x96848a90
sbb edi, 0xf1290d0b
add edi, ecx
shl edx, 0x3e
movzx ecx, si
mov dword [esp + esi + 0x1f], eax
jbe 0x120d9566
Function at 0x1321dac6
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
inc ecx
mov ecx, eax
inc edx
movzx eax, byte [esp + eax*2 - 2]
inc ecx
xor ebx, ebx
inc ecx
push eax
sub ebx, 0xe1335910
cbw
inc ecx
mov edi, 0xaa091b3f
bswap ebx
dec ebx
ror ebx, 3
inc ebp
movsx edx, si
imul al
neg ebx
cdq
dec ebp
lea eax, [edi + edx*8 + 0x20317d09]
inc ebx
dec eax
mov dword [esp + ecx*8 - 0x28], 0x782c1628
xor ecx, dword [esp + ecx + 5]
dec word [esp + ecx*2 - 0xf7]
dec esp
mov dword [esp + ecx*2 - 0xec], ebx
cwde
inc ebp
xchg esi, edx
xor dword [esp + eax + 0x10], ebx
dec ecx
sar edx, cl
pop edi
dec esp
mov ebx, dword [esp + ecx*2 - 0xf4]
dec eax
cdq
inc cx
rol edx, 0x43
dec eax
mov dword [esp + ecx - 0x76], 0x359e17b7
dec eax
arpl bx, bx
bswap ecx
dec eax
adc esi, ebx
call fcn.1343f35f
push 0xb532aca1
pushfd
shl dword [esp + 4], 0xb0
or word [esp + 4], 0xf618
mov dword [esp + 8], 0x124a0b8b
push dword [esp]
popfd
lea esp, [esp + 8]
call fcn.11eb8f1a
stc

Function at 0x1321db4a
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
inc ecx
mov ecx, eax
inc edx
movzx eax, byte [esp + eax*2 - 2]
inc ecx
xor ebx, ebx
inc ecx
push eax
sub ebx, 0xe1335910
cbw
inc ecx
mov edi, 0xaa091b3f
bswap ebx
dec ebx
ror ebx, 3
inc ebp
movsx edx, si
imul al
neg ebx
cdq
dec ebp
lea eax, [edi + edx*8 + 0x20317d09]
inc ebx
dec eax
mov dword [esp + ecx*8 - 0x28], 0x782c1628
xor ecx, dword [esp + ecx + 5]
dec word [esp + ecx*2 - 0xf7]
dec esp
mov dword [esp + ecx*2 - 0xec], ebx
cwde
inc ebp
xchg esi, edx
xor dword [esp + eax + 0x10], ebx
dec ecx
sar edx, cl
pop edi
dec esp
mov ebx, dword [esp + ecx*2 - 0xf4]
dec eax
cdq
inc cx
rol edx, 0x43
dec eax
mov dword [esp + ecx - 0x76], 0x359e17b7
dec eax
arpl bx, bx
bswap ecx
dec eax
adc esi, ebx
call fcn.1343f35f
push 0xb532aca1
pushfd
shl dword [esp + 4], 0xb0
or word [esp + 4], 0xf618
mov dword [esp + 8], 0x124a0b8b
push dword [esp]
popfd
lea esp, [esp + 8]
call fcn.11eb8f1a
stc
Function at 0x13275fff
Capabilities:
Authenticate hmac
Encode data using base64
Encrypt data using speck

Disassembly:
add dword [esp], 0xaa99c4a5
test ebx, ebx
push 0x4737d889
push 0x4f00f42a
lea esp, [esp + 0xc]
je 0x134db556
mov eax, 0x688956a5
mov eax, dword [ebp + ebx*4]
call fcn.1348db9c
mov edx, 0xad01018e
sub ebp, 1
lea ecx, [edx + edx*8 + 0x25bcd106]
movsx eax, cl
movzx edx, byte [ebp + ecx - 0x3ac5df04]
xor ecx, ecx
xchg ch, cl
xchg ecx, eax
xor dl, bl
btr ecx, eax
not dl
inc eax
sbb dl, 0x8b
not al
sub cl, al
lea ecx, [ecx*2 - 0x1057cb50]
not dl
sbb eax, eax
sub dl, al
xadd cx, ax
xchg ch, cl
xor bl, dl
shl cl, 5
lea ecx, [eax + eax*8 - 0x47d0c273]
adc edx, esp
rol ecx, 0x8b
rol al, cl
mov eax, dword [ecx + edx - 0x40c14dc1]
lea esi, [esi + ecx - 0x40c14dc5]
or cl, 0x2a
mov dword [ecx + esi - 0x40c14deb], eax
ror ecx, 0x62
lea edx, [ecx - 0x2ecb7bd5]
sbb ebp, 3
jmp 0x134fecbc
mov dword [ebp - 4], eax
jmp 0x12011c19
jl 0x1356b67f
jmp 0x11ecae02
mov dword [esp], 0xa18a02a0
jmp 0x11f017dc
mov eax, dword [ebp]
jmp 0x134fb3c7
call eax
mov edi, 0x5fb0aca3
lea esi, [edi*2 - 0xcc00270]
mov ebp, dword [ebp + edi - 0x5fb0aca7]
imul esi, edi
mov dword [esi + ebp - 0x40321242], eax
movsx ecx, di
xor cl, 0x85
sub esi, edi
pop ebx
movzx eax, di
pop edi
jno 0x11f34456
pop esi
btr eax, eax
cdq
inc dx
lea esi, [esi + eax*4 - 0x2b290]
push eax
pop eax
call fcn.134bb8a7
call fcn.133c2b93
Function at 0x13285bbb
Capabilities:
Encode data using base64
Encrypt data using chaskey
Encrypt data using speck

Disassembly:
adc esi, edx
lea edx, [eax*2 - 0x7ac52be4]
idiv dl
inc edx
add eax, esi
jmp eax
mov dword [ebp - 4], eax
push 0x7001d3f
dec word [esp + 0xa]
test ebx, ebx
push 0x509b1c2a
call fcn.13498b7e
dec esi
mov ebx, dword [esp + ebx - 0x7928]
call fcn.1339b4da
mov ecx, 0xa6b4c73f
not ecx
mov edx, ecx
fsub qword [ecx + edi - 0x594b38c0]
lea ebp, [edx + ebp - 0x594b38c4]
movsx eax, dx
sub al, 0xb1
mov edx, dword [ebp + eax*2 - 0x701e]
cwde
adc cl, al
xor edx, ebx
sar eax, cl
dec edx
bt eax, 0x3a
xor al, ah
xor edx, 0x5b2fc932
neg edx
sar al, 0x86
bswap edx
sar ax, 0xc8
xor ebx, edx
shl al, 6
jbe 0x13269691
dec ecx
add ebp, 8
inc cx
ror esi, 0x22
dec edx
lea edi, [esi*4 + 0x702a173f]
inc eax
movsx ebx, bh
dec ebp
xor ecx, ebx
dec ecx
not ecx
dec esi
lea ecx, [ebx + ecx + 0x130020ae]
dec ebp
lea eax, [esi + edi*8 + 0x50d8689]
inc ecx
mov edi, 0xdb345ebc
dec ecx
rol ecx, 5
dec ecx
inc ecx
inc ecx
and bh, 0x20
dec ebp
xor ebx, ecx
dec eax
lea ebp, [ebp + ebx*2 - 0xb6]
inc cx
xadd esi, ebx
shr di, 0x23
dec esp
mov dword [ebp + ebx*2 - 0x818c], ecx
mov ecx, edi
inc ebp
movzx edx, di
inc bp
imul esi, esi
inc ecx
mov ebx, dword [ebp + ebx*8 - 0x20630]
inc cx
or edi, edx
inc ecx
mov ecx, 0xfea3b280
dec edi
lea ebp, [ebp + edx*4 - 0x1787c]
dec eax
neg ecx
xchg ch, cl
inc ecx
xor ebx, ebx
not cx
inc edx
lea ebx, [ebx + esi - 0x6285c2bb]
inc ebp
mov esp, edi
dec edi
lea edx, [edx + 0x3e25a4bf]
inc cx
sub eax, 0xc3c1679f
add al, byte [ebp + 3]
inc byte [ecx + 0xf]
mov bh, 0xc6
inc ecx
movzx edx, di
lea ebx, [ebx + ecx - 0x9dac9a5]
inc cx
add edx, 0xc1e81789
and bl, byte [0xe8d1f700]
mov ebx, 0xb001435
or ecx, ecx
mov dword [esp + ecx - 0x80000000], edx
movzx edx, cx
dec ax
popfd
cbw
imul dx
mov eax, dword [ecx + edi - 0x80000000]
rol ecx, 0xd
bts cx, dx
push edx
lea edi, [edi + ecx*4 - 0x4000]
shl word [esp + ecx - 0xfff], cl
xor eax, ebx
not eax
sub cl, dh
setbe cl
dec eax
inc word [esp + edx + 1]
xor dl, dl
ror eax, 1
dec dword [esp + ecx*4 - 0x4000]
xadd word [esp + ecx - 0x1000], cx
xor cl, byte [esp + ecx - 0xfe]
not eax
cmovg edx, ecx
not cl
or edx, ecx
lea eax, [eax + ecx + 0x2331b30c]
ja 0x1205c3c7
mov edx, 0x3082fb8f
lea edi, [edi + edx - 0x3082fb93]
mov ecx, dword [edi + edx*2 - 0x6105f71e]
movzx eax, dx
mul edx
xor ecx, ebx
call fcn.133ff5e6
Function at 0x13285cfa
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
adc esi, edx
lea edx, [eax*2 - 0x7ac52be4]
idiv dl
inc edx
add eax, esi
jmp eax
mov dword [ebp - 4], eax
push 0x7001d3f
dec word [esp + 0xa]
test ebx, ebx
push 0x509b1c2a
call fcn.13498b7e
dec esi
mov ebx, dword [esp + ebx - 0x7928]
call fcn.1339b4da
mov ecx, 0xa6b4c73f
not ecx
mov edx, ecx
fsub qword [ecx + edi - 0x594b38c0]
lea ebp, [edx + ebp - 0x594b38c4]
movsx eax, dx
sub al, 0xb1
mov edx, dword [ebp + eax*2 - 0x701e]
cwde
adc cl, al
xor edx, ebx
sar eax, cl
dec edx
bt eax, 0x3a
xor al, ah
xor edx, 0x5b2fc932
neg edx
sar al, 0x86
bswap edx
sar ax, 0xc8
xor ebx, edx
shl al, 6
jbe 0x13269691
dec ecx
add ebp, 8
inc cx
ror esi, 0x22
dec edx
lea edi, [esi*4 + 0x702a173f]
inc eax
movsx ebx, bh
dec ebp
xor ecx, ebx
dec ecx
not ecx
dec esi
lea ecx, [ebx + ecx + 0x130020ae]
dec ebp
lea eax, [esi + edi*8 + 0x50d8689]
inc ecx
mov edi, 0xdb345ebc
dec ecx
rol ecx, 5
dec ecx
inc ecx
inc ecx
and bh, 0x20
dec ebp
xor ebx, ecx
dec eax
lea ebp, [ebp + ebx*2 - 0xb6]
inc cx
xadd esi, ebx
shr di, 0x23
dec esp
mov dword [ebp + ebx*2 - 0x818c], ecx
mov ecx, edi
inc ebp
movzx edx, di
inc bp
imul esi, esi
inc ecx
mov ebx, dword [ebp + ebx*8 - 0x20630]
inc cx
or edi, edx
inc ecx
mov ecx, 0xfea3b280
dec edi
lea ebp, [ebp + edx*4 - 0x1787c]
dec eax
neg ecx
xchg ch, cl
inc ecx
xor ebx, ebx
not cx
inc edx
lea ebx, [ebx + esi - 0x6285c2bb]
inc ebp
mov esp, edi
dec edi
lea edx, [edx + 0x3e25a4bf]
inc cx
sub eax, 0xc3c1679f
add al, byte [ebp + 3]
inc byte [ecx + 0xf]
mov bh, 0xc6
inc ecx
movzx edx, di
lea ebx, [ebx + ecx - 0x9dac9a5]
inc cx
add edx, 0xc1e81789
and bl, byte [0xe8d1f700]
mov ebx, 0xb001435
or ecx, ecx
mov dword [esp + ecx - 0x80000000], edx
movzx edx, cx
dec ax
popfd
cbw
imul dx
mov eax, dword [ecx + edi - 0x80000000]
rol ecx, 0xd
bts cx, dx
push edx
lea edi, [edi + ecx*4 - 0x4000]
shl word [esp + ecx - 0xfff], cl
xor eax, ebx
not eax
sub cl, dh
setbe cl
dec eax
inc word [esp + edx + 1]
xor dl, dl
ror eax, 1
dec dword [esp + ecx*4 - 0x4000]
xadd word [esp + ecx - 0x1000], cx
xor cl, byte [esp + ecx - 0xfe]
not eax
cmovg edx, ecx
not cl
or edx, ecx
lea eax, [eax + ecx + 0x2331b30c]
ja 0x1205c3c7
mov edx, 0x3082fb8f
lea edi, [edi + edx - 0x3082fb93]
mov ecx, dword [edi + edx*2 - 0x6105f71e]
movzx eax, dx
mul edx
xor ecx, ebx
call fcn.133ff5e6

Function at 0x132a5c2c
Capabilities:
Encode data using xor

Disassembly:
movzx esi, byte [ecx + esi - 0x41fd4ac]
jmp 0x126230ab

Function at 0x132a5c39
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
rol dword [esp + 0xe], 0x6c
xor ebx, eax
add esi, eax
call fcn.11fec5b2

Function at 0x132aaf9b
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
mov dword [esp + edx - 0x70150200], ebx
cpuid
sbb edi, 8
mov dword [edi + 0xc], eax
mov eax, 0x8739a434
or ax, 0x7c83
dec eax
mov dword [edi + 8], ebx
mov ebx, eax
call fcn.1202b055