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

Disassembly:
mov eax, dword [ebp]
push 0x5a90253d
not dword [esp]
push 0xbb1bee0f
lea esp, [esp + 8]
call eax
mov ebx, 0x88050b93
movzx ecx, bx
mov ebp, dword [ecx + ebp - 0xb97]
movzx edx, bl
movsx edi, bl
mov dword [ebp + ecx*8 - 0x5c98], eax
mov edi, ebp
movzx eax, bx
idiv ecx
pop ebx
pop esi
shl ax, 0x8b
cbw
pop ebp
sar edx, 0xeb
mov ecx, dword [ebp + ecx - 0xb93]
inc ax
lea ebp, [ebp + edx + 4]
cbw
xor eax, 0x18bda423
xor ecx, ebx
neg ax
rol edx, 0xea
xadd dl, ah
neg ecx
sar dl, 0x43
rol ecx, 3
and eax, eax
jno 0xd6eff5
xor eax, 0xe2af684
inc ecx
btr ax, 0x16
btc edx, edx
neg al
ror ecx, 2
call fcn.00de672a
test ebx, ebx
jmp 0x117c2d2
lea esp, [esp + 8]
je 0x117c2fb
mov eax, 0x958f493e
bt eax, eax
xor al, ah
mov eax, dword [ebp + ebx*4]
push eax
push 0x66b8f38a
dec ebx
lea esp, [esp + 4]
jne 0x117c2dc
jmp 0xd4a6c1

Function at 0x10d5cce
Capabilities:
Encrypt data using speck
Manually build aes constants

Disassembly:
push 0xbca187a0
sar dword [esp], 0x75
xor edi, ecx
ror dword [esp], 0x4a
shl dword [esp], 0x42
and edi, 0xff
ror byte [esp], 0x63
call fcn.019f536f
movsx eax, cl
adc ebp, 4
xor edx, ebx
mov dword [esp], ecx
sub edx, 0xd6bc168c
not edx
ror edx, 1
sub dword [esp], ecx
xor ecx, dword [esp]
xor edx, 0x7a91ee17
mov dword [esp], 0xf59f25af
sub edx, 0x9482e9bd
xor ebx, edx
add edi, edx
movsx edx, cx
shl word [esp], cl
pop eax
jmp edi
neg eax
mov edx, dword [edi]
sbb eax, eax
lea ecx, [eax + eax*8 + 0x26268297]
xor edx, ebx
bswap edx
shr al, 0xc1
neg edx
sub eax, eax
xor cl, cl
bswap edx
btr ecx, eax
ror edx, 3
bswap eax
bt eax, 0x9b
imul ecx, ecx
neg edx
xor ax, cx
dec ax
inc edx
lea eax, [ecx + ecx*8 - 0x6bf351cf]
not edx
sal ecx, 0x5e
neg edx
btr eax, eax
xor ebx, edx
shr cx, 0xc8
adc esi, edx
add ecx, esi
jmp ecx
mov edx, 0x25a14e26
push edx
not ecx
jmp 0xf2f428
sal edx, 0xc5
mov dword [esi], ecx
rol byte [esp], 0xc6
mov eax, edx
inc edx
mov eax, dword [ebp]
sbb edx, dword [esp]
jl 0x19aeaac
sar word [esp + 9], 0x45
test edx, edx
lea esp, [esp + 0xc]
je 0xeb3104
push edi
mov edi, 0x1735e81b
sub di, 0x2b09
btr di, 0xab
movzx edi, byte [eax + edi*4 - 0x5cd6d448]
jb 0xd079a4
mov edx, 0x7ac0eb5
rol dx, 0x81
mov ecx, dword [ebp + edx*2 - 0xf583ad4]
adc dl, 0xb0
shl edx, 0x16
mov eax, edx
mov edx, dword [eax + ebp - 0x467ffffc]
lea ebp, [ebp + eax - 0x467ffff8]
mov dword ss:[ecx + eax - 0x46800000], edx
lea edi, [edi + eax - 0x46800004]
jb 0xde3f0a
adc ebp, 4
movsx ecx, byte [esp]
xor eax, ebx
sub eax, 0x8802de2d
inc ecx
add edx, edx
bswap eax
neg dword [esp + edx*2 - 0x3a21d8dc]
pop edx
not eax
ror cl, 0x63
shl ecx, cl
rol ecx, 0x3b
neg eax
sar cx, 0x43
bt ecx, edx
lea eax, [eax + ecx - 0xc9b88ad]
xor ebx, eax
add edi, eax
movzx eax, cx
jmp edi

Function at 0x10f0cd0
Capabilities:
Encrypt data using speck

Disassembly:
push 0x9b90a7b2
dec ecx
adc esi, 0xb
push 0x88162fa8
dec eax
inc dword [esp + 5]
jno 0x102d890
mov edx, 0xfa2da202
sub esi, 1
mov ecx, edx
add cl, dh
movzx ecx, byte [esi]
lea eax, [edx*2 + 0x693a0823]
dec dl
adc edx, 0x561846b2
xor cl, bl
add eax, eax
and dx, dx
ror cl, 1
or al, dl
sbb cl, 0xbe
and edx, 0xe333fe26
xor cl, al
jmp 0x1a302e0
Function at 0x110ccfd
Capabilities:
Encode data using xor

Disassembly:
cwde
mov dword [esp], 0x9a3e8ab
push eax
mov dword [ebp], edx
movsx edx, al
pop eax
lea edi, [edi + edx - 0x4e]
bts dx, 0xa7
xchg dword [esp + edx*4 - 0x328], eax
jae 0xf3bf67
mov edx, dword [edi + eax - 0x9a3e8ab]
adc word [esp + eax - 0x9a3e8a9], 0x2121
movsx ecx, byte [esp + eax*4 - 0x268fa2ac]
xor edx, ebx
cwde
push ecx
lea edx, [edx + eax - 0x29ca4620]
or eax, eax
xor edx, 0x1fa3eb18
shl cx, cl
imul ecx, eax
shl dword [esp + 4], 0x7e
dec edx
sar ecx, 0xd1
rol ecx, 0x50
not edx
shl word [esp + 2], 0xb
call fcn.00e00269
sub edi, 4
mov edx, 0xc79d9218
mov edx, dword [edi]
mov eax, 0xe338302c
rol eax, 0xe2
xor edx, ebx
add eax, eax
ror edx, 2
xor edx, 0xd19e4e02
cwde
movsx ecx, ax
dec edx
xor edx, 0x52281c8a
sub ecx, 0x362b6683
xor ebx, edx
bswap ecx
call fcn.0117cabc
jo 0xeefa92
adc edi, 4
mov dword [esp], 0x190b803
call fcn.00e5ddce
and word [esp + 2], cx
xchg dword [esp], edx
sbb eax, 0xc2b84e0b
not eax
or edx, 0x230467b8
xor eax, 0x309d2582
inc byte [esp + 1]
sub dx, 0xcc02
xor ebx, eax
neg dl
adc ecx, 0x4c04e42c
add edi, eax
bswap edx
mov eax, edx
mov edx, dword [ecx + esi - 0x4c04b1b1]
mov cl, byte [eax + esi - 0x451b84e3]
sub dword [esp + eax - 0x451b84e7], eax
lea esi, [esi + eax - 0x451b84e1]
push eax
mov byte [edx + eax - 0x451b84e7], cl
mov dword [esp + eax - 0x451b84e7], edi
ret 4
Function at 0x1110423
Capabilities:
Hash data using murmur3

Disassembly:
ror edx, 2
rol eax, 0xf
dec edx
xchg cx, ax
neg edx
neg eax
xor ebx, edx
neg ecx
sbb ax, 0x8c03
inc eax
add esi, edx
cdq
mov ecx, dword [ebp + eax*2 - 0x748be7fa]
neg ax
mov eax, dword fs:[ecx + eax - 0x3a450c03]
mov dword [edx + ebp], eax
movsx eax, dx
sbb eax, eax
mov ecx, eax
add edx, esi
jmp edx
dec ecx
adc esi, 0xc
xor esi, esi
dec eax
test ebx, ebx
dec eax
lea esp, [esp + 0x10]
je 0x10972d2
inc ecx
push ebp
dec esp
lea ebx, [0x1d7ba8]
inc ecx
mov ebp, 0xf0a7f097
inc ecx
neg ch
dec ecx
sbb ebp, 0xee13a48b
inc esp
movzx ebp, byte [edi]
jns 0x10dd6bc
mov edx, 0xdb816387
lea eax, [edx + edx*4 + 0x12234391]
lea ecx, [eax*2 + 0x4224dd35]
lea edi, [eax + edi - 0x5baa3538]
cwd
rol eax, 0xd
sbb edx, 0x9914416
mov edx, dword [edi + eax - 0x46a68b75]
xor edx, ebx
btc eax, eax
sar ecx, 0xa
sal cx, 0xcf
neg edx
dec edx
cwde
jmp 0xd1119e
not esi
mov eax, 0x5734bb03
dec eax
lea edx, [eax + eax*8 + 0x56a80c08]
inc ecx
mov dword [esi + eax - 0x5734bb03], esi
cdq
dec ecx
add edx, edi
jmp edx
inc esp
xor ebp, esi
inc ecx
and ebp, 0xff
inc edi
mov ebp, dword [ebx + ebp*4]
jmp 0xd27f08
dec esp
mov ebp, dword [esp + ebx - 0x237c]
dec eax
arpl cx, cx
dec eax
cmovg edi, ebx
or di, 0x850e
push ebx
dec esp
adc edi, ecx
or bx, word [esp + edi - 0xa78d]
dec word [esp + edi*2 - 0x14f17]
shl edi, 0x15
dec edx
mov edi, dword [ebx + esi - 0x23a7]
dec eax
mov dword [esp + ebx - 0x2397], ebx
dec bx
pop ebx
dec ecx
mov ebx, dword [esi + 8]
dec eax
mov dword [esp], 0xb0104b21
dec eax
sal dword [esp + 2], 0x3b
js 0xf0ec38
mov ecx, 0xb1a28594
call fcn.00ec5cd7
mov ecx, 0x1ca2c736
not ecx
mov ecx, dword [ebp]
mov edx, 0x1c15532b
lea ebp, [ebp + edx*4 - 0x70554ca8]
xor ecx, ebx
or dx, dx
ror ecx, 1
mov eax, edx
sar edx, 0x5c
btr edx, 0x25
sbb ecx, edx
not edx
or al, 5
setge al
ror ecx, 1
inc ax
bswap eax
xor ecx, 0x371544bd
xor edx, edx
xchg dx, ax
ror ax, 0x87
xor ebx, ecx
xor dx, dx
adc esi, ecx
rcl byte [ebx], cl
int1
inc edx
xchg edx, eax
mov eax, dword [edx + ebp - 0x2530000]
movzx ecx, dl
lea ebp, [ebp + edx - 0x252fffc]
imul ecx, edx
btc edx, edx
ror dl, 6
xor eax, ebx
bswap eax
btr ecx, edx
inc eax
or dx, dx
shl edx, 0x91
xor eax, 0x82bff08
shl cx, 0x25
adc ecx, 0xc70b9799
neg eax
call fcn.00f7dceb
nop
stosb byte es:[edi], al
xor esi, dword [ebx + 0x5c353d75]
jl 0x11104cf
sub al, 0x9e
pop ds
insd dword es:[edi], dx
mov bl, 0x8c
wait
dec esp
mov bl, 0x58
and byte [ebx + 0x66fe4c8f], ch
and bl, bh
adc byte [ebx + 0x2557f6b3], dh
mov bl, 0x36
mov edx, 0xb24ced5a
loop 0x1110530
mov bl, 0xf6
push edi
and eax, 0x5aba36b3
in eax, dx
dec esp
mov dl, 0xe2
dec esp
dec esp
invalid

Function at 0x1113b4b
Capabilities:
Encode data using xor

Disassembly:
xor edx, 0xd6b3b4b5
not dword [esp + ebx - 0xecb7a10]
bswap edx
dec esp
mov dword [esp + eax - 0x7d245582], esp
sub edx, 0xa79b2e94
dec esp
mov dword [esp + eax - 0x7d24557a], ebp
shr ax, 0x2c
dec eax
btr ebx, 0x86
xor dword [esp + eax - 0x7d23fffd], edx
inc esp
xchg al, cl
rol dword [esp + eax - 0x7d23ffff], 0xfc
dec esi
Function at 0x1117321
Capabilities:
Encrypt data using speck

Disassembly:
inc edx
lea ecx, [ecx + ebx*2 + 0x7a69216]
inc ebp
mov eax, esp
call fcn.010a23b0

Function at 0x11287fc
Capabilities:
Encrypt data using speck

Disassembly:
lea eax, [esp + eax + 8]
sets cl
ror dx, 0xe3
ror ecx, cl
mov ecx, dword [eax]
sub word [esp + 4], dx
sbb esi, 3
call fcn.019f91ae

Function at 0x11801d3
Capabilities:
Execute syscall

Disassembly:
lea esp, [esp + 0xc]
je 0x104d548

Function at 0x11865fa
Capabilities:
Encrypt data using speck

Disassembly:
pop eax
adc eax, 0xff389e2b
jmp eax
mov ecx, dword [edx + ecx*2 - 0x40000000]
jae 0xe0015b

Function at 0x1196034
Capabilities:
Encrypt data using speck

Disassembly:
mov dword [esp], 0xfb91043d
call fcn.010a0565
fcom qword [edx + 0x1b]
mov es, ecx
push ds
xchg esp, eax
lds esp, [ebx]
neg dword [edx + 5]
test dword [edx + 0xfa2b081], 0xe7ef5281
jno 0x1014f8c
jae 0xe87997

Function at 0x11ada75
Capabilities:
Encrypt data using speck

Disassembly:
mov ecx, 0xd92eeb28
movzx edx, cx
btr cx, dx
mov eax, dword [esi + edx*2 - 0x1d650]
dec ecx
bswap ecx
movzx dx, byte [eax + ecx*2 - 0x4fd45db2]
mov eax, ecx
sal ax, 0x24
xor ax, 0x62a7
lea esi, [esi + eax - 0x27ea8f35]
cbw
or ecx, ecx
mov word [esi + eax*2 - 0x4fd4006e], dx
mov edx, eax
shr ecx, 0x21
lea edi, [ecx + edi - 0x13f51770]
or eax, ecx
imul edx
adc cl, 0x10
mov ecx, dword [edi + ecx*2 - 0x27ea2efa]
xor ecx, ebx
btc eax, edx
add eax, 0xfe37ea28
setle al
rol ecx, 1
xadd eax, edx
inc ecx
jmp 0x1219754
lea ebp, [ebp + ecx - 8]
bts ecx, ecx
mov dword [ebp + ecx*4], eax
mov dword [esp + ecx*4 - 4], 0x2328eaac
lea eax, [ecx*4 + 0x2521b5bb]
xchg word [esp + ecx - 1], ax
mov dword [ebp + ecx*2 - 2], edx
not dword [esp + ecx*4 - 4]
pop eax
jae fcn.010128d4
push eax
add ebp, ecx
add dword [esp + eax*2], ebp
ret 8
mov edx, dword [esi + edx*4 - 0x6ee0de1c]
cbw
mov dword [esp], 0xdba36eb5
movzx ecx, byte [esp]
lea esi, [esi + ecx*8 - 0x5a4]
imul eax, dword [esp + ecx*8 - 0x5a8]
dec ax
rol cl, 0x61
xor edx, ebx
sal ecx, cl
neg edx
xor edx, 0x3db2ee0d
lea ecx, [ecx + eax - 0x275b9065]
cwde
neg edx
dec ax
jns 0xd5ed97
bswap edx
inc edx
ror edx, 2
xchg dword [esp], eax
add byte [esp + 3], cl
xor edx, 0xc6b8b48e
sal word [esp + 2], 0xcc
or byte [esp], 5
lea edx, [edx + eax - 0x1d12cb34]
xor ebx, edx
lea ecx, [ecx + ecx*4 - 0x24a65fd]
mov dword [esp + ecx - 0x50d96940], 0x6dacb8aa
add edi, edx
or word [esp + ecx - 0x50d9693f], cx
rdtsc
rol ecx, 0x54
xor ecx, ecx
jp 0xe53d83
mul ax
and eax, edx
neg ecx
push edx
xor eax, eax
cwde
not ecx
sbb dword [esp + eax*2], eax
sal ax, 0x4a
add dword [esp + eax], eax
rol ecx, 1
shl al, 0xc2
push eax
dec ecx
sal dword [esp + eax + 4], 0x9f
mul edx
xor ebx, ecx
jmp 0xe6ab03

Function at 0x120b2af
Capabilities:
Encode data using xor

Disassembly:
sub ecx, ecx
movsx eax, byte [esp + edx - 0x223d82d8]
lea edi, [edi + edx - 0x223d82df]
xor dword [esp + edx*2 - 0x447b05b5], eax
bts edx, ecx
mov al, byte [edi + edx*2 - 0x447b05be]
call fcn.010db3d5
jl 0xf8b1c7
Function at 0x121d5b7
Capabilities:
Encode data using xor

Disassembly:
movzx edx, byte [ebp + ecx*2 - 0xe20eb80]
lea ebp, [ecx + ebp - 0x71075bf]
mov dword [esp + ecx - 0x71075c0], 0x9968a35
xor dl, bl
dec ecx
or ecx, 0x8b1baf2e
inc dl
sub cl, cl
rol dl, 1
inc dl
not dl
neg ecx
xor bl, dl
call fcn.00e610ec

Function at 0x1228c94
Capabilities:
Encrypt data using speck

Disassembly:
add eax, edx
mov byte [esp + 4], 0x16
sal word [esp + 6], 0x45
push 0xbbaa5800
mov dword [ebp - 4], eax
mov dword [esp + 4], 0xc89a5830
ror word [esp + 6], 0xca
sal dword [esp + 2], 0x68
test ebx, ebx
jmp 0xecd104
push eax
push 0x5c215417
neg byte [esp]
push 0x5bc3701
dec ebx
lea esp, [esp + 8]
jne 0xecd10e
call fcn.00f48884
lea esp, [esp + 0xc]
je 0xea3db8
mov eax, 0x9fb166a6
div al
shl al, 0x63
mov eax, dword [ebp + ebx*4]
ja 0x107d5f4
jp 0xea3d9e
adc al, 1
clc
stc
inc ebp
xchg ebp, eax
insb byte es:[edi], dx
mov ah, 0xf9
retf
jmp 0xe1536a
Function at 0x122fece
Capabilities:
Check for software breakpoints
Encrypt data using speck

Disassembly:
jne 0xfd0af9
mov edx, 0xa3aac693
lea eax, [edx - 0x5d34000]
dec eax
mov ecx, dword [ebp]
add ebp, 4
xor ecx, ebx
and ax, 0xa5ba
or dx, dx
imul eax
ror ecx, 3
xor dx, ax
bt ax, 0x9a
mul al
lea ecx, [ecx + edx*4 + 0x5c28a52d]
rol ecx, 1
inc ecx
and al, al
add edx, 0x46af8b9d
ror edx, 0x9e
xor ebx, ecx
neg eax
js 0x19f2580
mov dword [esp + ecx - 0x32e80afa], edi
ret
dec edx
neg cx
shr ax, 0xa
bswap edx
dec edx
sal cx, 0x4c
xor ecx, ecx
and cx, ax
bswap edx
and ecx, 0xc19b3490
neg ecx
not edx
xor ebx, edx
xor ax, cx
jae 0xcf2ad1
push 0x993fb19d
pop eax
mov eax, dword [eax + edi + 0x66c04e63]
mov edx, 0x33a7278a
lea ecx, [edx + edx - 0x3efb8e6b]
neg dx
lea edi, [edi + ecx - 0x2852c0a5]
imul ecx, ecx
sar dl, 0xc1
btr cx, cx
xor eax, ebx
neg ecx
btc edx, ecx
imul edx, edx
not eax
lea eax, [eax + edx*2 - 0x7bbbe083]
bswap eax
btr ecx, 0x81
xor dx, cx
sar edx, 0xfa
inc eax
dec cl
setne cl
btr ecx, edx
xor eax, 0x960965bb
btr edx, edx
bts ecx, ecx
lea eax, [eax + ecx*4 - 0x4cc27ce]
neg cl
bts edx, ecx
xor ebx, eax
call fcn.00f2f444
mov word [esi + ecx - 0x32e80afa], dx
cdq
jne 0xd22a0e
mov ecx, 0xac1d2e2e
add esi, 1
xor dl, bl
xor dl, 0xaa
inc dl
not cl
call fcn.011fe3b1
adc ebp, edx
lea edx, [ecx*2 - 0x28606d4d]
btc ax, cx
add ecx, ebp
jmp ecx
adc esi, 4
jmp 0x19c7aab
lea ecx, [ecx + ecx*4 + 0x39ab75a9]
ror eax, cl
add edi, edx
mul eax
seto al
movzx dx, byte [esi + eax - 0x5f465d01]
mov cl, byte [esi + eax - 0x5f465cff]
ror eax, 0xf5
lea esi, [esi + eax*2 - 0x65d015f2]
mov dword [esp + eax - 0x32e80afa], eax
or dl, cl
pop ecx
not dl
mov dword [esp + ecx - 0x32e80afa], eax
neg eax
js 0xdceed9
jne 0xfdf3a2
mov eax, 0x9e8782a7
lea ecx, [eax + eax*2 + 0x3a885502]
mov eax, dword [edi + ecx - 0x161edcf7]
mov edx, ecx
shl ecx, cl
lea edi, [ecx + edi - 0x7b7ffffc]
adc edx, ecx
sar dl, 0xc5
xor eax, ebx
bt edx, ecx
dec eax
xchg ecx, edx
bswap eax
inc cl
not dl
lea edx, [ecx*2 - 0x38d4bcdc]
lea eax, [eax + ecx + 0x3cf3cc04]
lea ecx, [edx + edx*4 - 0x4e48c3cc]
sal ecx, cl
neg eax
add cx, cx
call fcn.00f9b9f8
div ecx
mov ecx, 0xc93e1fa7
mov dword [esi], edx
movsx edx, cx
mov dword [esi + edx*8 - 0xfd34], eax
movzx eax, cx
mov edx, dword [edi + edx*4 - 0x7e9c]
and ecx, ecx
xor al, 0x8d
lea edi, [edi + eax*4 - 0x7ca4]
xor edx, ebx
jmp 0x19ca037
lea eax, [eax + 0x5bd771c]
jmp 0xdb3c2d

Function at 0x19a8b82
Capabilities:
Encode data using xor

Disassembly:
mov dword [esp], 0xd8b17896
dec ebx
not dword [esp]
lea esp, [esp + 4]
jne 0x102ee37
Function at 0x19ae30f
Capabilities:
Encrypt data using speck

Disassembly:
xor ebx, eax
neg edx
sal ecx, 0xd8
adc esi, eax
lea eax, [edx + edx*2 - 0x73c94c6c]
mov eax, dword [ebp + ecx*4 - 0x4000000]
not edx
mov ecx, dword [ecx + ebp - 0xfffffc]
push ebx
movsx ebx, dl
xadd dl, bl
cpuid
push 0xacb9df10
rol dword [esp], 0x99
rol word [esp + 2], 0x81
sbb ebp, 8
inc byte [esp + 3]
sar word [esp], 0x41
call fcn.01a0c0cc
mov eax, ecx
bswap edx
lea edx, [edx + ecx - 0x2d83819c]
and cx, cx
sbb cx, cx
xor al, ch
xor ebx, edx
not ax
neg cl
call fcn.01a334ac
rol dl, 1
neg dl
dec ax
not dl
rol eax, 0xbd
xor bl, dl
ror ecx, 0x42
adc edx, esp
and ecx, 0xc8c0b06
shr eax, 0x62
sal cx, 0x27
mov ax, word [eax + edx - 0x25c13ad6]
lea edi, [edi + ecx - 2]
call fcn.019cc6e7
bt dx, cx
inc al
mov dword [esp + edx*2 - 0x13e4818], edx
ror al, 1
ror dx, 0xce
jae 0xe9dbd1
xor bl, al
btr ecx, edx
push ecx
lea esi, [esi + edx*2 - 0x13f2062]
sal byte [esp + edx*2 - 0x13f2060], 0x61
bts ecx, ecx
bswap ecx
mov word [esi + edx - 0x9f9030], ax
mov word [esp + edx - 0x9f902e], dx
pop eax
pop eax
jae fcn.011ad0eb
sub edi, 4
mov ecx, 0x53b5e8ba
xor ecx, ecx
mov eax, dword [edi + ecx*2]
xor eax, ebx
mov edx, 0xe98270b5
btr edx, edx
bswap eax
sar ecx, 0x10
ror eax, 1
sal cx, 0xa7
imul dx, dx
bswap eax
seto cl
lea eax, [eax + edx - 0x495387f0]
or edx, 0x6c3c0081
not dl
ror eax, 2
xor edx, 0x77239231
jne 0x10e6080

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

Disassembly:
xor ebx, eax
rol byte [esp + edx - 0x2e8d35d6], 0xe2
shl ecx, 0x13
js fcn.0109eb7f
adc esi, eax
mov dword [esp + edx - 0x2e8d35e0], esi
ret 0xc

Function at 0x19bf31b
Capabilities:
Encrypt data using speck

Disassembly:
neg eax
not eax
not cx
xor ebx, eax
jmp 0x1097316
add ebp, eax
lea eax, [edx*8 - 0x4fdc8ca]
lea edi, [edi + eax*2 - 0x5db1843d]
shl al, 0x26
movzx eax, byte [edi + eax*2 - 0x5db18500]
or dl, 0x28
xor al, bl
jmp 0x10c631f
sub al, 0xab
jmp 0x1117331
sar cl, 0x21
sal cx, 0xec
not al
not cx
call fcn.00d8ec73
jmp 0x19e4624
xor cl, 0x21
neg eax
sub edx, dword [esp + ecx - 0x66914025]
call fcn.0121ea63
bswap eax
adc ecx, edx
lea eax, [eax + ecx - 0x5c136b94]
add ecx, edx
xchg ecx, edx
jl 0xf8dfe9
mov ecx, 0x91831b28
mov eax, 0xa612f790
mov edx, dword [edi]
xchg cx, ax
call fcn.019b544f
mov eax, 0xd10cd925
add esi, edx
cdq
ror edx, cl
movzx dx, byte [ebp + ecx*4 - 0x5d32b234]
cmovae ax, cx
shl ecx, 0xd4
sub ax, 0x3191
add cl, byte [ebp + 2]
sub eax, eax
lea ebp, [ebp + eax*4 + 2]
not dl
or eax, 0x1a0c1fa6
sub eax, eax
not cl
sal eax, 0x30
btc eax, 0xb6
or dl, cl
movsx ecx, al
cwde
cwde
mov word [ebp + eax*2], dx
lea eax, [ecx + ecx + 0x438343ab]
add ecx, esi
jmp ecx
sub edi, 4
mov edx, dword [edi]
xor edx, ebx
call fcn.01160530
Function at 0x19e733c
Capabilities:
Encrypt data using speck

Disassembly:
seto al
not edx
mov dword [esp + ecx - 0x54388783], 0x75305127
shl byte [esp + ecx - 0x54388780], 0xc5
shr word [esp + ecx - 0x54388783], cl
xor edx, 0xe88a0c19
lea edx, [edx + eax + 0x1bb28faf]
ror edx, 1
neg edx
xor dword [esp + ecx - 0x54388783], ecx
adc ecx, 0x7a9a4c08
inc edx
rol edx, 2
sal ecx, cl
ja 0x10ffb84
mov eax, 0x143c0b3e
mov eax, dword [eax + ebp - 0x143c0b3e]
push 0x6dbecd23
neg byte [esp + 3]
setp byte [esp + 1]
adc ebp, 3
not word [esp + 1]
xor eax, ebx
push 0x993fe42e
inc eax
push 0x1b184e81
xor eax, 0x8733980b
not eax
jmp 0x10d96c3

Function at 0x19eee2a
Capabilities:
Encrypt data using speck

Disassembly:
lea esp, [esp + 0x18]
jne 0xdb35fe
mov esi, 0x17171810
lea ecx, [esi + esi*8 + 0x72cb282]
call fcn.00f3b262

Function at 0x19eeed2
Capabilities:
Encrypt data using speck

Disassembly:
inc esp
movzx esp, bp
dec esp
mov dword [esp + ebp - 0x7307], eax
div ecx
inc edx
add byte [esp + ecx - 0x66287304], 0x2b
inc edx
xor byte [esp + ecx - 0x66287301], ch
inc esp
sub dword [esp + ebp - 0x7304], eax
inc ebx
mov dword [ecx + esi - 0x66287307], edx
inc edx
movsx ebx, byte [esp + ecx - 0x66287307]
inc edx
movzx edx, word [esp + ecx - 0x66287305]
inc ecx
mov dword [esi + ebp - 0x7303], eax
ja 0x1a15941
mov ebx, 0x8d2aadba
pop ebx
dec ebp
lea edx, [edx + ebp - 0x730b]
inc ebp
movsx ebx, cx
inc ebx
mov eax, dword [ecx + edx - 0x66287307]
inc ecx
xor eax, ebp
sub eax, 0xa4bf8e16
inc ecx
push ebx
xor bx, si
neg eax
inc cx
shr ebx, 0x4b
lea eax, [esi + eax - 0x66f150b3]
setb bl
rol eax, 2
jmp 0xd8b491
Function at 0x19febd2
Capabilities:
Encrypt data using speck

Disassembly:
or dword [esp + eax + 0xc], 0xca0228bc
xadd word [esp + edx*2 - 0x76b786e5], dx
xor ecx, ebx
inc word [esp + eax + 0xb]
imul dword [esp + eax + 0xc]
mul dx
inc ecx
bswap ecx
pop eax
not edx
imul dx
ror ecx, 2
mul ax
xor ecx, 0x9d282524
pop eax
not ecx
add dword [esp + 4], 0x52247e0e
ror dword [esp + 4], 0x9e
xor ecx, 0x996cb9a
cwde
rol ecx, 1
jmp 0xe673d9
call fcn.00fa46f5
push 0x9b9a5e8f
lea esp, [esp + 4]
jmp fcn.00f21a18
lea edi, [edi + edx*8 - 0x577972dc]
add edx, 0xcf381cb9
pop ebp
movzx eax, dl
shr dl, 0x46
pop edi
not ax
cdq
mov eax, dword [edx + edi]
mov ecx, edx
lea edi, [edx + edi + 4]
xor eax, ebx
and ecx, 0x8d889931
sbb eax, 0xc5819501
ror eax, 2
sal dx, 0xe8
xchg edx, ecx
xor eax, 0x5b856e39
rol edx, 0xbd
or ecx, edx
call int.010f5e4b
lea esp, [esp + 4]
call eax
mov edx, 0xf5aa8131
mov ebp, dword [ebp - 4]
movsx edi, dx
mov ebx, 0xeb22558b
and ch, bl
mov dword [ebp], eax
xadd ebx, edi
mov esi, ebp
pop ebx
jl 0x1006468
mov eax, dword [esi]
mov ecx, 0x4586c2ab
inc cx
shr ecx, cl
mov ecx, dword [esi + ecx - 0x45868]
mov edx, 0x8c27ff88
bswap edx
push ebx
movsx ebx, dl
lea edx, [edx*8 + 0x73a72cac]
sbb dl, dl
cpuid
jge 0x1a2a550
dec esp
loopne 0x19febe7
adc dword [ecx - 0x60ceaf80], 0xfc5adbcb
pushal
rcr byte [esi - 0x64601535], cl
xor dword [esi + 0x66], esp
push edx
lahf
sub al, 0xd3
inc esi
lahf
or dword [ebx], edi
invalid
push 0xe514ad0d
push 0x21286d13
sbb esi, 8
inc word [esp + 5]
shl word [esp + 6], 4
push 0x34a7c735
mov dword [esi + 0xc], eax
rol dword [esp + 2], 0xa8
dec byte [esp + 8]
mov eax, 0x8d10f886
mov dword [esi + 8], ebx
movzx ebx, word [esp + 8]
setnp bl
and byte [esp + ebx*2 - 0x15bf7], 0xa9
mov dword [esi + ebx*2 - 0x15bfc], ecx
inc word [esp + ebx - 0xadf7]
xor word [esp + ebx*4 - 0x2b800], 0x8223
mov dword [esi + ebx*2 - 0x15c00], edx
movsx edx, bl
xchg dword [esp + ebx - 0xadf9], ebx
mov ecx, edx
mov ebx, dword [esp + edx + 0xc]
sub edx, 0xc4a43cbe
adc eax, edx
xor dl, 0x31
adc ecx, dword [edx + ebp - 0x3b5bc373]
or ax, dx
xor eax, eax
mov dword [esp + eax*8 + 0xc], eax
lea ebp, [ebp + eax*2 + 4]
jbe 0xe34d75

Function at 0x1a0570f
Capabilities:
Authenticate hmac

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

Function at 0x1a14cb7
Capabilities:
Authenticate hmac

Disassembly:
shl dword [esp + edx*2 - 0x24a908ca], 0x5c
sub cl, 0xbf
pop eax
pop edx
pop ecx
pop eax
js fcn.019b7feb
Function at 0x1a1a02f
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
and ecx, 0xf82e60b8
jne 0x116c095
mov edx, eax
neg edx
mov eax, dword [eax + esi - 0x661afff2]
xor edx, edx
xor edx, dword [esi + edx + 4]
dec cx
jo 0xd9bdcc
lea esi, [esi + ecx - 0x669b03c6]
shr cl, 0x22
bt ecx, ecx
adc cx, cx
adc eax, edx
lea edx, [ecx + ecx + 0x2985c6b3]
btc edx, edx
mov dword [esi + ecx - 0x669b0664], eax
jae 0xdd7aac
mov ecx, 0x13a3a0a5
call fcn.00df4fe7
not byte [esp + edx*2 - 0x169fffc]
mov dword [esp + eax], eax
mov dword [esp + edx*4 - 0x2d3fffc], edi
and word [esp + edx - 0xb50000], ax
jp 0x11a47d6
mov edx, 0x1f00221c
movzx eax, dl
mov edx, dword [edi + eax*4 - 0x70]
mov ecx, 0xb73cd9ad
lea edi, [eax + edi - 0x18]
cbw
xor edx, ebx
rol eax, cl
neg edx
bswap eax
or ax, ax
dec edx
xor al, ch
xor edx, 0xf292a034
lea ecx, [eax + ecx - 0x1dd7dd7a]
not ecx
xadd ecx, eax
rol edx, 2
xor ebx, edx
dec cx
dec al
add ebp, edx
jmp 0xfe0577

Function at 0x1a1faa3
Capabilities:
Encode data using xor
Encrypt data using speck

Disassembly:
dec eax
bswap edx
mov word [esp + 4], 0xa528
pop edx
bswap eax
rol dword [esp], 0xd3
btc cx, cx
dec eax
rol eax, cl
bswap eax
mov edx, dword [esp]
dec dword [esp + edx - 0x2945dc2d]
lea ecx, [edx + edx + 0x4a2bb916]
xor eax, 0xdf3bb3a3
call fcn.00db2973

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

Disassembly:
mov eax, 0xab0df732
mov dword [esp], eax
mov esp, esi
pop edx
mov ebx, 0x3d83bc95
call fcn.01a17ca1

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

Disassembly:
mov edx, dword [ebp]
mov eax, 0xd5235e23
add ebp, 4
jmp 0xd17007
dec ecx
lea ebp, [ecx + esi*2 - 0x43ef32dc]
inc ebx
mov ecx, dword [edx - 0x787f592a]
inc ecx
xor ecx, ebp
inc eax
movsx ebx, dh
ror ecx, 2
mov edx, 0xb42a8d25
dec edx
mov dword [esp - 0x787f592a], 0x9a29148c
inc edx
lea ecx, [ecx - 0x3e532706]
inc ecx
shl ecx, 0xc4
inc dx
inc dword [esp - 0x3c3fac93]
sal di, 0xf
bswap ecx
inc esp
movzx eax, si
inc esp
btr esi, ecx
sal edx, 0xb1
sbb ecx, 0xfa0eaa96
dec esi
mov dword [esp - 0x787f592a], ebp
dec eax
neg esi
dec esp
cmovb ecx, ebp
bswap ebp
inc edx
xor dword [esp + eax - 0xff95], ecx
call fcn.01133d84
jmp 0xde3918