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

Disassembly:
pop ecx
bt cx, cx
adc eax, esp
xor edx, ecx
or cl, 3
mov ecx, dword [eax + ecx - 0x2b]
movzx eax, dx
jle 0x1196114
dec eax
lea edi, [eax + edi - 0x408e]
or edx, eax
mov dword [edi + eax - 0x408a], ecx
jne 0x10fa5f7
btc ecx, ecx
add ebp, eax
movzx ecx, byte [edi + ecx*4 - 0x4af843f4]
mov dword [esp], edx
lea eax, [edx + edx*4 + 0x5b04e29e]
not eax
add edi, 1
xor cl, bl
sar byte [esp + 3], 0x46
cwd
sub cl, dl
bts edx, eax
setb dl
jae 0xd7b8fe
neg cl
ror cl, 1
pop eax
push eax
sub cl, 0x2c
xor bl, cl
and al, 0xae
cbw
cwde
mov dword [esp], edi
push ebp
cdq
sbb ax, 0x8daf
push ebx
movsx ebx, dx
dec edx
cwde
mov ebp, esi
btr ax, ax
xchg dh, dl
and eax, edx
mov ebx, ecx
add eax, eax
mov edx, ebx
xor ax, ax
sbb eax, eax
shr al, 0x21
shl edx, 2
cwde
push eax
add eax, ebp
inc dword [esp]
jns 0x1a0163c
lea esi, [eax + esi - 0x408e]
mov ecx, 0xa19eb482
mov edx, dword [esi + eax*2 - 0x8114]
or al, ah
xor edx, ebx
xor edx, 0x258c58b7
call fcn.019f8f51
fcom qword [edx + 0x1b]
invalid
shl edx, 0xc
xor ebx, ecx
shr eax, 0xff
add esi, ecx
bswap edx
movsx ecx, al
cbw
mov eax, dword [ebp + eax - 1]
mov ecx, dword [eax + ecx - 1]
mov dword [ebp + edx - 0x5072cc], ecx
movzx eax, dl
btc ax, dx
jmp esi
add eax, edx
push 0xdf0a5bbd
neg byte [esp + 7]
sar word [esp + 4], 0xa2
mov dword [ebp - 4], eax
xor dword [esp + 4], 0xba957eb3
call fcn.0108cc02
sub dl, dh
sbb edx, 0x121274b4
mov dword es:[eax], ecx
lea eax, [edx + edx*2 - 0x3c7036f9]
movsx ecx, al
sets al
jmp edi

Function at 0xf2f4c4
Capabilities:
Encrypt data using speck

Disassembly:
rol edx, 1
push 0x9db40482
call fcn.019cd428

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

Disassembly:
or dx, word [ebp + edx*2]
pop eax
dec ecx
lea ebp, [ebp + ecx*8 - 0x5a07fe96]
movsx eax, cx
cmovnp eax, ecx
je 0xd8b338
movzx ecx, byte [ecx + esi - 0xb40ffd3]
sub eax, 0x3296bf37
xadd al, ah
adc eax, eax
adc esi, 0
shr al, 0xc6
sbb eax, 0x55afda23
adc eax, eax
xor cl, bl
sar eax, 0xe4
xor cl, 0xaa
push eax
and eax, eax
inc cl
ror byte [esp + 3], 0xe1
rol cl, 1
sar eax, 0x84
adc cl, 0x1c
neg eax
Function at 0xf3b233
Capabilities:
Encrypt data using speck

Disassembly:
xor esi, esi
stc
cmc
or eax, 0xffffffff
cmp sp, ax
cmp bl, 0x91
sub edi, edi
test dl, dh
test bl, 0x95
cmp ecx, dword [ebp - 0x40]
jmp 0xebc09f
rep stosw word es:[edi], ax
movzx eax, si
sal ch, cl
mov ecx, dword [ebp + 8]
xchg ah, al
lea eax, [ecx - 1]
test eax, edx
cmp edi, esi
mov dword [ebp - 0x40], eax
jmp 0xd170df
mov dword [ebp - 0x2c], edi
jmp 0x19fa863
rep stosd dword es:[edi], eax
jmp 0x10c2559
je 0xeaff72
movzx edx, byte [ecx]
shl esi, 8
inc edi
stc
test ecx, esp
cmc
or esi, edx
jmp 0xee1b2a
inc ecx
cmp edi, 5
jmp 0xfe0492
cmovns ecx, dword [esp + ecx - 0x45dcf804]
mov word [ecx + esi - 0x45dcf808], dx
pop ecx
pop ecx
jne fcn.011ad0eb
mov dword [ebp - 0x24], edi
jmp 0xdaac69
jl 0xd170f3
mov dword [ebp - 8], ecx
rol dl, cl
shl ecx, cl
lea esp, [esp]
bt edx, eax
adc ecx, ecx
jmp 0xd5c15f
je 0xd5c167
mov ecx, eax
cmovl eax, ebp
add edi, 0x5eb2c886
bt edi, esp
mov eax, 0x400
mov edi, edx
sal dh, 0x32
rcr dl, cl
shl edx, 0xb5
movzx edx, ax
ror ah, 0x9f
mov eax, edx
clc
test esp, 0x17374388
shl edx, 0x10
or eax, edx
shr ecx, 1
jmp 0xdceed2

Function at 0xf3c131
Capabilities:
Encrypt data using speck

Disassembly:
neg edx
not cl
lea edx, [edx + ecx - 0x6679c808]
xor edx, 0x59379521
bt eax, ecx
btc ax, cx
xor ebx, edx
cwde
shl ecx, 0x9f
shr ax, 0x26
adc ebp, edx
jmp ebp
jb 0x1a3185a
mov dword [esp + edx - 0x60c431c0], edx
xor ecx, 0xdca40000
inc dl
and eax, edx
xchg dword [esp + edx - 0x60c431c1], edx
inc ecx
xor ecx, 0x1211593c
mul byte [esp + edx - 0x60c431bd]
push eax
add edx, eax
rol ecx, 1
xor ebx, ecx
pop edx
add ebp, ecx
or byte [esp + edx*4 - 0x617f], dl
call fcn.00cef4ce
fcom qword [edx + 0x1b]
mov ebp, ebx
adc eax, 0xec2ae7a3
pop edx
out 0x8c, al
mov bl, 0xd8
mov dword [esi + eax - 0x27ac186f], edx
mov edx, eax
dec eax
sar edx, 5
mov ebx, dword [esp + ebx - 0x2d843a13]
mov dword [esp + eax - 0x27ac1866], ecx
and ecx, eax
pop eax
pop edx
pop ecx
jg fcn.00de3977
lea esi, [esi + ecx*4 - 0xaead7b6]
ror ecx, 0x48
not ax
not dx
ror ecx, 0xb3
sets cl
or ax, dx
sar ecx, 0x21
adc ecx, ecx
mov word [ecx + esi - 0x5756bd01], ax
mov ecx, dword [edi + ecx - 0x5756bd01]
adc edi, 4
mov eax, 0xbc8ce694
sal eax, 0x4f
xor ecx, ebx
cdq
lea eax, [eax*2 + 0x19338a9c]
dec ecx
inc eax
dec al
jne 0x1a41b66
out 0x58, al
invalid
pop eax
sbb cx, 0x3e3e
mov edx, dword [edi]
jnp 0xf2c428
adc edi, 3
btc eax, eax
sar al, cl
push ecx
xor edx, ebx
lea ecx, [ecx*4 - 0x27c9fb59]
bswap edx
dec edx
xor cx, 0xd79e
xor byte [esp + 2], al
xor edx, 0xebbb89a0
pop eax
not cl
jmp 0xed22a0
push 0x9319e300
mul ecx
mov ecx, 0xbc1b048e
sal word [esp + 2], cl
setp cl
mov dword [esi], edx
mov dword [esi + 4], eax
jae 0x113dbac
bswap ecx
lea ecx, [ecx + edx*8 + 0x2a92adbb]
call fcn.00d0a0f6
mov eax, 0xa02107a9
movzx ecx, al
mov ecx, dword [esi + ecx*2 - 0x152]
rol eax, 0x39
mov eax, dword [esi + eax - 0x5340420b]
jb 0xf0abba

Function at 0xf708f2
Capabilities:
Encrypt data using speck

Disassembly:
lea esp, [esp + 4]
jne 0xd95b21
Function at 0xf713b2
Capabilities:
Encode data using base64

Disassembly:
sbb esi, 8
push 0x9a0fb389
mov dword [esi + 0xc], eax
and dword [esp], 0xfb81da96
mov eax, dword [esp]
or ax, 0xe4b6
mov dword [esi + 8], ebx
sar al, 0x42
mov dword [esi + 4], ecx
rol eax, 0x4a
add eax, 0xda080030
lea ecx, [eax*8 - 0x10c7245b]
mov dword [esi], edx
mov dword [esp + 4], ecx
mul cl
mov ebx, dword [esp + 8]
pop eax
pop ecx
pop ecx
jb fcn.00f82f13
jge 0xd17dd9

Function at 0xf746be
Capabilities:
Encrypt data using speck

Disassembly:
lea esp, [esp + 0x10]
jne 0xdb501a
pop edi
inc ecx
push 0x50098596
xor eax, 0x92162b1b
neg dword [esp + 0xc]
dec edx
jmp 0xd49309

Function at 0xf7634a
Capabilities:
Encrypt data using speck

Disassembly:
bts edx, edx
mov dword [esp + eax - 0x5d9a003f], edx
xor ebx, ecx
add esi, ecx
or dword [esp + edx - 0x5d9aec8f], eax
dec dl
pop ecx
pop edx
pop edx
ja fcn.00f18fc4

Function at 0xf821ef
Capabilities:
Encrypt data using speck

Disassembly:
pop eax
pop eax
pop edx
jne fcn.00f18fc4
lea ecx, [edx + edx*2 - 0x64dd535b]
ror ax, 1
sal edx, cl
sbb ax, 0x9a10
rol cx, cl
not cx
neg ax
not edx
xor ax, 0xb48f
and cx, cx
sal dl, 0x45
xor bx, ax
lea ebp, [ebp + edx*2 - 0x16ffdfc4]
call fcn.00ffa591
sub edi, 4
push 0x8031ea02
and byte [esp + 1], 0xb2
pop eax
mov edx, dword [eax + edi + 0x7fce5dfe]
xor eax, eax
xor edx, ebx
inc edx
mov ecx, eax
neg edx
sub ecx, ecx
lea edx, [edx + ecx*8 - 0x1f34100f]
call int.00e24e46

Function at 0xf8a39e
Capabilities:
Encode data using xor

Disassembly:
xor eax, ecx
ror eax, 0xac
neg edx
rol edx, cl
btr eax, ecx
sbb edx, 0x96b96822
neg cx
call fcn.00d82a04
mov ch, 0x8f
xchg ebx, eax
pushal
sub ch, byte [ebp + esi*2 - 0x75]
call 0x850f645e
sbb eax, 0xf9eb9a86
and eax, dword [ebp - 0x79ec2945]
jnp fcn.00f8a39e
out 0xd, eax
pushal
jl 0xf8a43b
pop esi
lahf
cmp edx, dword [ebx - 0x71]
sbb dword [esi], edx
xchg byte [eax - 0x64], ah
in eax, 0x60
mov cl, 0xeb
xor dword [ecx + 0x73d09fc4], ebp
xchg ch, dh
ljmp 0xaee2
sub eax, 0x5edebb2f
into
mov dh, 0xfa
xlatb
int1
add byte [eax], dh
push ss
int3

Function at 0xfa8298
Capabilities:
Encrypt data using speck

Disassembly:
not dl
or ax, 0x343f
ror ax, 0x81
sub eax, 0xbb1c5203
adc dl, 4
rol dl, 1
inc dl
dec eax
lea eax, [eax - 0x2a465363]
rol eax, 0x9f
xor bl, dl
imul eax, dword [esp + eax*2 - 0x6e8359f8]
ror dword [esp + eax*2 - 0x5e2d0a98], 0xdf
setae al
lea edx, [esp + edx + 4]
ror al, 0x64
mov byte [edx + eax*2 - 0x5e2d0a00], cl
xchg dword [esp + eax*2 - 0x5e2d0a00], eax
call fcn.012207de
mov cx, word [ecx + esi - 0x20090bb]
ror byte [esp + 4], 0x81
adc esi, 2
mov dword [esp], 0x3e05b08b
pop eax
shl al, 0xe5
lea edi, [edi + eax*2 - 0x7c0b60c1]
shl dword [esp + eax - 0x3e05b060], 0x61
movzx edx, byte [eax + edi - 0x3e05b060]
xor dl, bl
inc dword [esp + eax*2 - 0x7c0b60c0]
dec dl
xor dl, 0x30
sub eax, 0xea1fd5b7
jne 0xefcdce
Function at 0xfaf3c4
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
movzx eax, cx
not eax
lea ebp, [ebp + ecx - 0x39b92d8f]
sal eax, cl
btr cx, cx
mov dword [esp + ecx - 0x39b92d93], ecx
xor edx, ebx
lea eax, [eax*2 - 0x2adde577]
jmp 0x10da5b4
sub edx, 0xbd92253f
ror edx, 3
inc edx
cwde
bts eax, ecx
xadd ax, cx
rol edx, 1
or cl, 0x3a
and ecx, eax
not edx
mov byte [esp + ecx*4 - 0x202060], 0x1a
xor ecx, 0xaf896200
call fcn.01a07f51
mov ecx, 0x2c96cb2f
movzx eax, cx
btr eax, eax
lea edi, [ecx + edi - 0x2c96cb33]
lea edx, [ecx + eax*2 + 0x398ded0b]
push eax
mov ecx, dword [edi + eax*4 - 0x12cbc]
xchg byte [esp + eax - 0x4b2c], dl
jae 0xecb2f8
inc esp
sar esi, cl
inc dword [esi - 0x4b2bfb6c]
invalid
shr eax, 0x4a
xor ecx, ebx
dec ecx
rol eax, 0xce
xchg word [esp + eax - 0x47fff], dx
not edx
not ecx
lea ecx, [ecx + eax + 0x2fa6a010]
jae 0x119603a
push edx
fisttp dword [esi]
xor al, 0xb1
mov bh, cl
or al, 0x59
mov cl, 0x76
adc dword [ecx], ebp
dec esp
cdq
xor eax, 0x406875e5
mov ecx, 0x624ec540
or byte [edx + 8], 0xb1
and eax, 0x4e1edb8b
nop
lodsb al, byte [esi]
pop ss
jbe 0x10da5ff
dec esi
int 0x29
mov eax, 0x7394ae17
adc al, 0xd5
in eax, dx
pop edx
mov al, 0x1a
jp 0x10da6b2
jmp 0x10da680
xchg edx, eax
cmp eax, dword [esi - 0x38]
in eax, 0xc3
inc ebx
movsb byte es:[edi], byte [esi]
ret
pop edi
ljmp 0xc93

Function at 0xfb7fc1
Capabilities:
Encrypt data using speck

Disassembly:
xor ebx, edx
btr ecx, 0x3d
setae cl
adc esi, edx
not cl
ror cx, 0xa1
pop edx
jno fcn.00cf358c
ror edx, 2
sal cl, 0x83
bswap edx
imul ecx, eax
mov dword [esp + eax - 0x5c85666a], 0xf3311a16
lea edx, [edx + ecx*2 - 0x45313541]
jb 0xed735a

Function at 0xfb8d86
Capabilities:
Encrypt data using speck

Disassembly:
call fcn.00fddfeb
lea edi, [edi + eax*8 - 0x3cde4]
jno 0x1041c88
btr eax, eax
xor edx, ebx
or ax, word [esp + eax*2 - 0xf37a]
inc edx
dec word [esp + eax*2 - 0xf37a]
movsx ecx, al
setno al
xor edx, 0xb0a06898
rol edx, 1
dec al
lea ecx, [eax + eax*4 + 0x152414be]
bswap edx
mov word [esp + eax - 0x7900], cx
bts cx, ax
lea edx, [eax + edx - 0x7e1e7e89]
or eax, eax
shl byte [esp + eax - 0x78fd], 2
dec word [esp + eax - 0x78ff]
rol edx, 3
btc eax, 0xb2
lea eax, [ecx*8 + 0x4a97cdb3]
shr eax, 0xf5
neg edx
ror dword [esp + eax*4 - 0x1e78], cl
xor ebx, edx
shl cl, 0x61
add ebp, edx
add byte [esp + eax*2 - 0xf3a], al
xor dword [esp + eax - 0x79e], 0x9186f49f
mov dword [esp + ecx*2 - 0x2a4ce2fc], ebp
ret
Function at 0xfc08ef
Capabilities:
Encrypt data using speck

Disassembly:
neg eax
lea edx, [ecx*2 + 0x5fbc7c2e]
rol edx, cl
xor ebx, eax
sub dl, byte [esp + edx*8 - 0x5fbb1c23]
call fcn.01a16d74

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

Disassembly:
shrd eax, edx, cl
mov edx, 0xbf0c2aab
mov dword [esp], edx
movsx ecx, dl
mov dword [esi], eax
call fcn.00e3dfc9
dec cx
shr ecx, 0x30
not eax
inc eax
rol cl, 0x41
imul edx, edx
btc edx, edx
bswap eax
xor ebx, eax
xor cl, cl
adc esi, eax
not ecx
mov ax, word [ebp + edx - 0x44d91b03]
mov cx, word [ebp + edx - 0x44d91b01]
sal edx, 0x53
sbb edx, edx
sal dx, 0x4d
lea ebp, [ebp + edx*2 + 2]
xor dl, dh
not ax
inc edx
sal edx, 0xd5
not cx
ror dl, 1
bt edx, edx
and ax, cx
lea ecx, [edx*8 - 0x7c40b157]
call fcn.00e8e150
jno 0xcfb9d0
add esi, dword [edx - 0x24801b81]
inc eax
add eax, 0x5ddb9fd6
fsub dword [edi - 0x40]
and al, 0x11
retf
jmp 0xcfb972
jmp 0xcfce47
adc esi, 5
jmp 0xd7cbe1
not word [esp + 2]
call fcn.010cf465
jne 0xded5b8
mov dword [esp], 0xd0372e02
sub dword [esp], 0xbab034b9
sbb eax, ecx
jmp 0xf1a617

Function at 0xfd0936
Capabilities:
Encrypt data using speck

Disassembly:
dec eax
mov dword [esp + ecx*2 - 0x4f82], edx
pop ecx
pop ecx
ror eax, 1
call fcn.00f910d4
Function at 0xffd950
Capabilities:
Encode data using base64

Disassembly:
mov ecx, dword [esi + eax - 0x7fff00ff]
xor byte [esp + eax - 0x7fff00f5], ah
lea esi, [esi + eax - 0x7fff00fb]
xor ecx, ebx
lea edx, [eax + eax + 0x322deaa7]
imul ax, word [esp + eax - 0x7fff00f7]
or dword [esp + edx*2 - 0x6457d946], edx
lea ecx, [ecx + edx*4 - 0x6589f9ed]
ror dx, 0xea
shr word [esp + edx*2 - 0x645652ee], 0xea
neg ecx
lea ecx, [ecx + edx*4 - 0x24f7eed5]
call fcn.00d7a542

Function at 0x1006e8f
Capabilities:
Encode data using xor

Disassembly:
pushal
mov ebx, 0x81520006
push edx
invalid
loop 0x1006ec1
push edx
and edx, 0xf42ce92e
sbb edi, 4
lea eax, [edx*8 + 0x79ae418c]
not eax
mov ecx, dword [edi]
xchg dword [esp], edx
jmp 0xe08262c4
ror byte [ebx + 0x5487270c], 1
and al, 0
xor ecx, ebx
inc dl
ror eax, 0xeb
call fcn.0112e5be
movsd dword es:[edi], dword [esi]
sbb eax, 0xa497fb4a
push ecx
loope 0x1006ea4
xchg edi, eax
adc dword [ebp - 0x6297d414], 0xd5683554
xchg ebp, eax
int 0x60
add dl, byte [esi + 0x6920c61d]
mov byte [eax + 0x7a], dl
je 0x1006f42
push ds
xchg esi, eax
adc eax, 0x359f978c
push esi
popfd
xchg edi, eax
daa
sar byte [edi + edx*4 + 0x7fe203c3], cl
push 0x96c16dcd
loopne 0x1006e8b
mov al, 5
push ds
aad 0x97
lds ebp, [ecx]
adc ebx, dword [0x3ab2168]
push 0x9f717159
xor al, 0x96
mov eax, dword [0x34691639]
mov word [ebp + 0x4bc26842], es
ret
iretd

Function at 0x10342fa
Capabilities:
Encrypt data using speck

Disassembly:
cpuid
shr byte [esp + 6], 0xe7
call fcn.01009149

Function at 0x103fca3
Capabilities:
Encrypt data using speck

Disassembly:
movsx ecx, word [esp + 4]
mov word [esi], ax
lea eax, [edx + ecx*8 - 0xedad8df]
mov edx, dword [ebp]
mov dword [esp], ecx
call fcn.00e68eaf
mov edx, 0x4ab60d22
lea edi, [edi + edx - 0x4ab60d26]
call fcn.00f13ff3
Function at 0x104a2b3
Capabilities:
Encode data using xor

Disassembly:
mov dword [esp + edx - 0x1101e00], ebx
push edx
mov ebp, esi
dec edx
sal edx, 0x62
or dx, dx
mov ebx, eax
lea eax, [edx + edx*8 - 0x4d109e3]
btc eax, edx
mov dword [esp + edx*2 - 0x880eff8], eax
mov edx, ebx
shr eax, 0x95
cbw
sal al, 0x63
sal edx, 2
or eax, dword [esp + eax*8 - 0x7fac0]
sar al, 0x62
cbw
mov eax, ebp
adc eax, edx
dec dword [esp]
jno 0x1178220
sar dword [esp], 0x7e
mov dword [ebp - 4], eax
test ebx, ebx
push 0xaf82b213
lea esp, [esp + 8]
je 0xcfcc7f

Function at 0x105d350
Capabilities:
Encode data using xor

Disassembly:
xor bx, 0xeb12
dec eax
arpl si, si
cwd
inc ecx
mov ecx, 0xd2b82082
dec eax
not dword [esp + ebx - 0xeb00]
dec esp
adc edi, esi
xchg dword [esp + ebx*2 - 0x1d5fd], ebx
dec ecx
mov edi, dword [esi + edx*8]
jmp 0x1110205
mov dword [esp + eax - 0x5ea02005], 0x7b351eb0
inc ax
not cl
xadd dword [esp + eax - 0x5ea02006], edx
cdq
mul edx
dec cl
bts edx, edx
neg eax
rol cl, 1
sal dword [esp + eax], 0x35
xor edx, edx
not dword [esp + eax]
adc cl, 0x21
add byte [esp + eax*2], dl
xor bl, cl
neg byte [esp + edx + 1]
lea esi, [eax + esi - 2]
and byte [esp + eax + 1], 0x87
mov word [esi + eax*2], cx
adc edx, dword [ebp + eax*2]
rol al, 0xe4
ror al, 1
xchg dword [esp + eax*4], eax
adc ebp, 4
bts eax, eax
lea ecx, [eax*4 + 0x328d59b2]
jb 0x117a85b
mov ecx, 0x93045b83
push ecx
sal dword [esp], 0x1c
sbb edi, 4
bts ecx, 0xa
sar dword [esp], cl
mov edx, dword [edi]
pop eax
xor ax, cx
xor edx, ebx
call fcn.00f339f2
inc ecx
xor esi, ebp
rol esi, 3
or ax, ax
lea esi, [ecx + esi - 0x3f744929]
sar ebx, 0x7a
ror esi, 1
inc ecx
movsx ebp, bl
ror al, 0x27
xor esi, 0xb406779f
inc ecx
push ebp
dec eax
sub ebp, 0x52b7a185
inc ecx
push ebx
xor dword [esp + ebx*2 - 0x1c], esi
dec eax
cdq
dec esp
mov ebp, dword [esp + ebx - 0xa]
jmp 0xd90343
inc si
mov dword [edx + esi], eax
dec esp
mov dword [esp + ecx - 0x710324dc], edi
ret 8
mov dword [esp + eax - 0x304c3507], edi
mov dword [esp + eax*2 - 0x60986a16], edx
dec edx
mov dword [esp + eax - 0x304c350b], ebp
mov ebp, 0x1b9a0422
sal ebp, 0xed
push ebx
btc eax, 0x3c
mov ebp, esi
shl al, 0xc4
mov ebx, ecx
shl dx, 0xc6
shl eax, 0x77
mov edx, ebx
neg eax
cwde
sub ax, ax
sal edx, 2
dec al
mov eax, ebp
push 0x188076b7
jge 0xde2fa9
add eax, edx
call fcn.010469f7
mov ecx, 0x71032494
dec ebp
lea edx, [edx + ecx - 0x71032498]
sub cl, 0xb8
dec eax
lea eax, [ecx*4 - 0x28c54200]
dec eax
lea ebx, [ecx + ecx*2 - 0x76aa7e0]
inc ecx
mov esi, dword [edx + ecx - 0x710324dc]
dec esp
lea ebx, [ebx + eax*4 + 0x4820380f]
js 0xef1b28
inc esp
movsx eax, dl
inc esp
xor al, byte [edi + ecx - 0x710324dc]
dec esi
lea esi, [ecx + esi - 0x710324d6]
jmp 0xf25c7e
xor edx, ebx
pop ecx
dec edx
xadd al, ch
bt ecx, eax
not edx
btc ecx, 0x1c
bswap ecx
rol edx, 3
bswap edx
shl al, 0xc7
and eax, 0x41252437
neg edx
shr eax, 0x11
bt eax, 0x32
xor ebx, edx
rol eax, 0xd8
adc edi, edx
jmp fcn.010bb9ce

Function at 0x1069eb4
Capabilities:
Encrypt data using speck

Disassembly:
push esi
dec eax
mov dword [esp + 8], 0x40828e92
dec eax
lea esp, [esp + 8]
call fcn.01189bc7
Function at 0x10730ab
Capabilities:
Encrypt data using speck

Disassembly:
lea esp, [esp + 0xc]
je 0x10c198d
jmp 0x1a1d08d
fld dword [edi + eax]
push es
xchg esi, eax
add esi, edx
mov edx, 0xb43a12a3
rdtsc
sub ebp, 8
mov dword [ebp + 4], eax
mov word [esp], cx
inc cx
neg cl
mov dword [ebp], edx
pop ecx
dec ecx
and eax, 0xf495900
mov esp, dword [0xf000dc6]
add esi, 0x89009843
push ebp
in al, 0xe9
xchg edx, eax
invalid
add byte [ecx + 0x49], bl
jnp 0x1110244
jno fcn.019b7feb
push edi
movzx edi, byte [edx]
call fcn.00e9566e
not dword [edx - 0x44]
mov dl, 0x98
sub al, 0x96
salc
mov dl, 0xfe
pop esi
sbb cl, cl
mov dl, 0x7f
adc byte [esi], bh
add al, 0x4d
mov byte [esi + eax - 0x4d4d19d3], cl
push ecx
adc eax, 0x549e2cb2
dec ebp
adc dword [0x4d08b2e2], ebp
sahf
sub edi, ebx
xchg ebp, eax
outsd dx, dword [esi]
dec esi
mov esi, 0x45fe59b8
jns 0x1033bf1
jbe 0x1033cbd
stosd dword es:[edi], eax
lahf
int1
jg 0x1033c97
jae 0x1033c15
xchg byte [ecx + 0x43], ch
mov ebp, 0x6498226d
mul dword [edi]
int 0xb1
cmp byte [ebp + ebx*2 + 0x6d9a41c], cl
jg 0x1033c16
test al, 3
jecxz 0x1033cde
shr dword [ebx], 0x27
mov bl, 0x21
cmp al, 0x5f
jp 0x1033c8d
cmc
add ch, byte [ebp - 0x363405df]
ret
sbb edi, edi
loop 0x1033d21
cmp ah, byte [edx - 0x4566e7e3]
jle 0x1033cc1
retf
adc ah, 0x16
scasd eax, dword es:[edi]
adc al, 0xe4
push ecx
invalid
pop es
lea edi, [esi]
sub bh, ah
cli
jae 0x1033cd4
pop ecx
invalid
adc ecx, dword [esi - 3]
pop ecx
pop ss
popfd
sub dword [edx], ecx
insd dword es:[edi], dx
and bh, byte [eax - 0x2e]
or eax, 0x687aa975
clc
int 0x35
mov cl, 9
add bl, byte [ebx + 0x6d]
jmp 0x1033cff
dec eax
loop 0x1033da4
or cl, byte [edi - 0x1e]
push eax
lahf
mov byte [ecx], 0x2c
or dword [ecx + 0x63], esp
jb 0x1033ceb
hlt
jmp 0x2bca4eb4
js 0x1033de8
cmp ebp, dword [edi]
jbe 0x1033d75
arpl word [esi + 0xe], bx
sub dword cs:[ecx], esi
test dl, ch
cmp byte [ebp - 0x26], 0xc9
invalid
in eax, 0x9b
or esp, dword [ebx]
sub dword [eax - 0x2c], edi
daa
invalid
jmp 0xe14cf4
jmp 0xe60932
jmp 0x1033c2d

Function at 0x107df9d
Capabilities:
Encrypt data using speck

Disassembly:
call fcn.010da52e
pop ecx
mov dword [ebp + ecx + 0x74d531e2], eax
add dword [esp + ecx + 0x74d531de], ecx
lea edx, [ecx + ecx*2 - 0x42f19054]
call fcn.019f9114

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

Disassembly:
ja 0xd494bc
xor ebx, eax
dec cl
add ebp, eax
sal dx, 0xe1
imul dx, dx
mov dx, word [esi]
jb 0xdb5001
movsx eax, cx
mov cl, byte [esi + eax*4 - 0x63fa]
shr word [esp + eax - 0x18f7], 0xe
lea esi, [esi + eax - 0x18fd]
shr dx, cl
inc byte [esp + eax*2 - 0x31f6]
inc dword [esp + eax - 0x18f7]
mov word [eax + esi - 0x18ff], dx
mov dword [esp + eax*2 - 0x31fe], eax
mov dword [esp + eax - 0x18ff], ebp
ret 8
Function at 0x10972b4
Capabilities:
Hash data using murmur3

Disassembly:
dec eax
lea esp, [esp + 0x18]
jne 0xf0ec58
inc ecx
mov ebx, 0x1b3163a9
inc ebp
mov eax, ebx
dec ebx
lea edx, [eax + eax*2 - 0x1be392dd]
inc ecx
pop ebp

Function at 0x109740b
Capabilities:
Encode data using xor

Disassembly:
xor ebx, ecx
mov dword [esp + eax - 0x7eb70021], eax
btc ax, 3
adc edi, ecx
cwde
lea ecx, [eax + eax*8 + 0x6d35d732]
bts ecx, 9
mov eax, dword [esi + eax - 0x29]
xor ecx, dword [esp + ecx - 0x6d35da9c]
shr edx, 0x87
mov edx, dword [esi + edx - 0xfd6f59]
je fcn.00d2e5c7
mov cl, byte [esi + 8]
adc esi, 5
shld eax, edx, cl
sub byte [esp + 0xb], 4
mov ecx, dword [esp + 8]
xor byte [esp + ecx - 0x7ab7aeb5], 0x29
mov dword [esi + ecx - 0x7ab7aebb], eax
movzx eax, word [esp + ecx - 0x7ab7aeb3]
mov dword [esp + eax*2 - 0x15d76], edi
ret 8

Function at 0x109e498
Capabilities:
Encrypt data using speck

Disassembly:
lea ebp, [ebp + edx*2 - 0x71efdec7]
mov dword [esp + edx - 0x38f7ef64], edx
lea eax, [edx + edx*8 + 0x12169a23]
imul eax
xor cl, bl
dec ax
push edx
neg cl
shr al, 0x21
xor byte [esp + edx - 0x1619e6f], ah
ror cl, 1
dec cl
lea eax, [eax - 0x70e2ca80]
pop eax
xor cl, 0xc
cwde
call fcn.010ec5f0

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

Disassembly:
bswap edx
setl cl
xadd cl, ch
jne 0xdeaf08
mov edx, 0xea82dc16
not edx
lea eax, [edx + edx*2 - 0x4d564ad5]
mov edx, dword [ebp + edx*2 - 0x2afa47d2]
movzx ecx, ax
or eax, 0x59a02204
lea ecx, [ecx*4 + 0x228594ab]
lea ebp, [ebp + ecx*2 - 0x450c3082]
rol ax, 0x27
jbe 0x11a478e
mov eax, 0xbbafc4be
movzx edx, al
inc edx
lea edi, [edi + edx - 0xc0]
movsx ecx, dx
not dx
xchg ecx, eax
movzx ecx, byte [edi + eax*2 - 0x17e]
mul edx
xor cl, bl
call int.0101b183
bt eax, 0x88
imul edx
add ebp, ecx
push eax
mov dword [esp + 4], edx
call fcn.00f7a820
sub edi, 4
mov edx, 0x5e35993a
call fcn.0110e058
mov eax, 0x7d9b8987
lea edi, [edi + eax - 0x7d9b898b]
cdq
add edx, dword [eax + edi - 0x7d9b8987]
movsx ecx, ax
xor edx, ebx
bt ax, ax
sbb byte [ecx + 0x79389403], 0x76
or byte fs:[edi], 0xbf
enter 0xffffffffffffd333, 0x66
bt eax, eax
ror edx, 3
dec cl
js 0xd4b3c9
cmp ah, 0x22
sbb byte [edi], bl
jo 0x109ebac
int 0x1f
pop ds
sbb al, bl
mov eax, 0x68e1fae8
dec esi
fcomp dword [esi]
std
jne 0x109ebd1
mov word [edi], ds
cmp edi, dword [ebx - 0x1f8b6275]
invalid
btc eax, eax
xor edx, ebx
rol cx, 0xab
bts eax, ecx
push ecx
inc edx
xor ecx, 0x3f871c3d
neg eax
bswap edx
xchg byte [esp + eax - 0x45c8ce8], cl
call fcn.01a056aa

Function at 0x10ac663
Capabilities:
Encode data using xor

Disassembly:
add ebp, 4
pop edx
xor ecx, ebx
sal word [esp], 0x66
ror ecx, 1
jmp 0xeaa239