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

Disassembly:
pop ecx
add cl, byte [esi + 4]
add esi, 4
jmp 0x2479c9a
call fcn.01e2fefe
rol cl, 1
push edx
xor bl, cl
shr edx, 2
lea ecx, [esp + ecx + 0x10]
mov word [ecx + edx*4 - 0x495be268], ax
jp 0x255c756
and ebx, 0xff
push 0x7da8da03
mov ebx, dword [ebx*4 + 0x16b58a0]
mov dword [esp + 4], 0xf5b5ddb6
shr edx, 8
xor edx, ebx
inc eax
xor edx, 0x1bbc0db4
dec ecx
lea esp, [esp + 8]
jne 0x24bdfd8
mov ebx, 0x5494499e
movzx eax, bl
pop ebx
call fcn.0255bdc7
jmp 0x24da985
xchg esp, eax
add al, 0x80
pop edi
cli
test cl, al
leave
add cl, byte [ecx - 9]
shr al, cl
pop edi
int3
mov ebx, 0xf53155a7
push ebp
xor ebp, esi
movzx ebx, byte [eax]
xor ebx, edx
call 0x2479cb9
inc ebp
xor edi, ebx
inc ebp
lea edi, [edi + edi*8 - 0x4a981693]
inc eax
inc ch
dec eax
not ebp
inc ecx
bswap edi
inc ecx
not edi
dec edx
lea ecx, [eax*2 - 0x2eef05fb]
inc ecx
dec edi
call fcn.0163d12a
sub ecx, edx
ror eax, 3
sub ecx, ecx
xor ebx, eax
sub dx, dx
adc edi, eax
sub cl, 0xab
call fcn.024ee177
jl 0x24da95f
insb byte es:[edi], dx
js 0x24da987
movsd dword es:[edi], dword [esi]
pop ebx
mov dl, 0xce
pop ebp
adc dword [ecx], esi
dec eax
invalid
xor ebx, edx
add al, 0x2f
adc edi, edx
mov dword [esp + eax*2 - 0x5e], 0x90b062a4
xchg byte [esp + eax*4 - 0xba], al
mov ax, word [eax + esi - 0xb0]
add dword [esp], ecx
xchg dword [esp], ecx
mov dx, word [esi + ecx*2 - 0x7e84c546]
jbe 0x165419b
mov eax, dword [edx + ebp - 0x1256f89a]
pop ecx
lea ebp, [ebp + edx*2 - 0x24adf130]
xadd dword [esp + edx - 0x1256f892], edx
jae 0x25717d2
mov edx, dword [edi]
mov ecx, 0x45bd45ad
inc cx
call fcn.0165cf74
mov dword [esp + eax - 0x6ec73454], 0x6a1823bd
neg dl
xor bl, dl
or ax, word [esp + eax - 0x6ec73452]
pop eax
setp al
adc edx, esp
movsx ecx, ax
call fcn.0252d91e

Function at 0x249c827
Capabilities:
Encode data using xor

Disassembly:
bswap ecx
push edx
inc eax
mov dword [esp + eax - 0x5c3d2ffb], 0x711ab5af
lea ecx, [ecx + edx*2 - 0x69f073ad]
xor dword [esp + edx*4 - 0x68bffffc], 0x64861295
sbb word [esp + eax - 0x5c3d2ffb], ax
bswap ecx
xchg byte [esi + 0x19], ah
test byte [eax + 0xfa3c2d0], al
leave
call fcn.025b080c
nop
inc edi
jnp 0x249c846
push esp
mov edi, 0xb5061ecb
or byte [edi - 6], al
mov ch, 8
inc edi
cli
fldenv [edx + 0x7bd3e2d]
cmp bh, ch
pushal
xor byte [edi + 0x6e81b47e], al
inc ebx
js 0x249c860
jl 0x249c85b
inc ebx
add cl, byte [esi + 0x39]
lds edx, [ebx - 0x4e712c17]
cwde
pop eax
jp 0x249c8b5
fld xword [edi + 0x75c2becf]
push edx
stc
push ds
invalid
or al, 4
insd dword es:[edi], dx
invalid
Function at 0x24a2b05
Capabilities:
Authenticate hmac
Encrypt data using speck

Disassembly:
movzx edi, byte [edx]
push 0x3dbc6315
neg word [esp]
xor edi, ecx
and edi, 0xff
dec dword [esp]
dec dword [esp]
mov edi, dword [edi*4 + 0x16f5ac8]
shr ecx, 8
xor ecx, edi
dec dword [esp]
inc edx
ror word [esp + 1], 0x61
xor ecx, 0xc809cd1b
ror dword [esp], 0xcd
jb 0x241cbd5
dec eax
lea esp, [esp + 4]
jne 0x24a2b2d
mov edx, 0xb5b7330d
pop edi
push 0xcc2ca6b3
mov eax, dword [esp]
not ecx
sal eax, 0xc5
adc dword [esp], eax
mov dword [edi], ecx
dec word [esp + 1]
or eax, dword [esp]
mov ecx, 0x8eb52884
mov eax, dword [esi]
adc esi, 4
xor eax, ebx
inc eax
pop ecx
sar ecx, 0xee
xor eax, 0x31983537
not eax
mov edx, ecx
sub ecx, ecx
xor eax, 0xe00a5629
dec dl
dec eax
bswap ecx
shl dl, 0x24
jne 0x254b82a
xor ebx, edx
rol ecx, 0xb5
adc esi, edx
push eax
add dword [esp + ecx - 0x1ff8f0], esi
ret
bswap edx
jne 0x241b81d
mov ecx, 0xf81d8c24
inc esp
movzx eax, cx
inc ecx
mov ecx, 0x7c9f1abc
inc edi
mov eax, dword [ebp + ecx - 0x7c9f1abc]
mov ebx, ecx
push ebx
dec ebp
lea edx, [ecx + ecx*2 - 0x715ad06b]
dec edi
lea ebp, [ecx + ebp - 0x7c9f1ab8]
inc edx
movzx ebp, byte [esp + ecx - 0x7c9f1ab9]
inc dx
or dword [esp + ecx - 0x7c9f1ab8], ebx
inc ebp
xor eax, ebx
dec ecx
xchg ecx, ebp
inc ecx
neg eax
inc edi
lea eax, [eax + ecx*8 - 0x5e11f16e]
inc ecx
bswap eax
inc ecx
mov esi, 0xcb9f4530
dec esi
xchg dword [esp + ecx - 0xf8], esi
inc ecx
inc eax
dec esi
mov dword [esp + ecx*4 - 0x3e0], ebx
inc sp
xadd ecx, ecx
inc esi
xor dword [esp + ecx*2 - 0x11848], eax
inc ecx
pop ebx
dec ebp
arpl ax, ax
inc ecx
movzx edi, si
dec ecx
add esi, eax
jmp fcn.0258c4a6
mov edx, dword [edi]
mov eax, dword [edi + 4]
add edi, 4
xor ecx, ecx
test eax, eax
mov dword [esp], 0xfd938c1d
lea esp, [esp + 4]
je 0x1671652
push 0x188515bb
mov dword [esp], edi
mov edi, 0xe40f023f
sal edi, 0xde
jb 0x1671601
enter 0x3296, 0x21
rol dword [edx + ecx*4], 0x5c
popal
dec ebx
cmp dword [edi + 0x6030b15], edi
pop ds
enter 0xfffffffffffffa5a, 0xffffffffffffffc3
and ch, ch
and edi, dword [ebp + 0x7d3d08e4]
xor byte [ebp + 0x4373419e], al
push edx
sub ah, byte [ecx - 0x1d]
mov ecx, 0xd8f974c0
xchg ebx, eax
rcl dword [ebx], cl
xchg ebx, eax
mov cl, 0xf3
jp 0x24a2bbb
out dx, eax
invalid
std
pop ss
aam 0xa3
nop
add byte [ecx + eax*2 + 0x2b82f229], 0x46
xchg dword [ebp + 0x3f], edi
push ds
xchg dword [edi + 0x3f0f0fd], eax
stosb byte es:[edi], al
or eax, 0x44868c02
out dx, eax
add ch, byte [ebx + 0x2c027375]
and al, 0x16
aas
idiv byte [ebp - 0x37]
adc al, 0x23
push cs
std
dec eax
enter 0x208, 0xffffffffffffff80
jmp ebp
xor eax, 0x558e4abf
rol eax, 3
shl edx, 0xc5
xor ebx, eax
and cl, dl
setg cl
adc ebp, eax
jmp 0x2543e46
Function at 0x24a4410
Capabilities:
Execute syscall

Disassembly:
mov ebx, eax
ror edx, 0xa5
mov edx, ebx
call fcn.01e29dd2
sal ecx, cl
lea edi, [edi + ecx - 0x7ffffffe]
ror cx, 0xc2
mov word [ecx + edi - 0x80000000], dx
movzx edx, cl
mov eax, 0x9f20683b
and ecx, eax
mov ecx, dword [esi + edx*2]
sar ax, 0x2a
lea esi, [esi + edx*4 + 4]
xor edx, eax
xadd al, dh
xor ecx, ebx
ror edx, 0xd5
not ecx
neg al
bswap ecx
js 0x25aff52
dec esp
adc ecx, esp
inc ecx
movsx ecx, bh
inc cx
mov dword [ecx + ebp - 0x4f000008], eax
and cx, 0x3e30
dec esp
or esi, esi
inc ecx
jmp esi
inc esp
xadd ch, dh
jge 0x24ad492
xor al, bl
xor al, 0xf
jmp 0x158bace
xor edx, 0x195d6a4
pop eax
neg ecx
sub edx, 0xf501b332
or cx, cx
sub cx, 0x88ae
xor ecx, ecx
xor ebx, edx
push ecx
movsx eax, word [esp + ecx]
add esi, edx
sub cl, 0x10
inc byte [esp + ecx - 0xf0]
add al, byte [ecx + ebp - 0xf0]
mov edx, 0xfb035999
dec byte [esp + ecx*8 - 0x77d]
lea ebp, [ecx + ebp - 0xef]
add edx, 0xb10b4c8d
ror edx, cl
jbe 0x16bbe1e
mov eax, 0x16b7d28b
inc esp
movsx edx, al
inc ebp
mov eax, edx
inc ecx
mov edi, dword [ebp + eax - 0x16b7d28b]
push eax
inc ecx
movzx ebp, dx
not dword [esp + eax - 0x16b7d288]
dec ebp
lea ebp, [ebp + eax*4 - 0x5adf4a28]
call fcn.024a72af
inc ecx
sub cl, 0x1e
sal ebp, 0x8c
sal ebx, 0xe6
inc ecx
ror cl, 1
jmp 0x167619d
push es
add byte [ebp + 0x32], al
fld st(1)
in eax, 0x23
inc ebp
xor bl, cl
shl ebp, 0x23
jnp 0x1657850
lea edx, [edx + edx*4 + 0x3a02d23f]
xor bl, al
lea edx, [edx + edx*2 - 0x5cea894b]
push edi
and dl, dh
shl dx, 0x87
push esi
push ebx
jae 0x14cc5b0
loope 0x24ad490
enter 0x496, 0xffffffffffffffef
add al, 0x8a
mov byte [0x394b9ec1], al
call 0x84ec92b
push ecx
aaa
pop edx
cli
pop ebp
jbe 0x24ad4e9
and edi, dword [ebp + 0x7dc2a623]
xor byte [edx], cl
jnp 0x24ad511
mov esi, 0xd5fc4373
popal
jecxz 0x24ad540
push cs
jp 0x24ad4f2
fcom dword [ebx - 0x4e6c1323]
lodsd eax, dword [esi]
insd dword es:[edi], dx
mov ss, word [eax]
invalid
sbb bh, byte [ebp - 0x5a]
iretd
pop esp
nop
or dl, 0x1f
salc
xor byte [ebp - 0x47], 0x87
jge 0x24ad56e
add byte [eax - 0x79], bh
std
push cs
invalid
std
std
mov ecx, 0x7139b93e
neg ecx
sbb cx, cx
mov eax, dword [edi]
movzx dx, byte ss:[eax]
jbe 0x165329e
call fcn.01e20fb8

Function at 0x24a616f
Capabilities:
Authenticate hmac
Encrypt data using speck

Disassembly:
add dword [esp + ecx - 0x5fb8f20b], ecx
add esi, edx
sub eax, dword [esp + ecx - 0x5fb8f213]
lea edx, [ecx + eax*8 - 0x20db8e7f]
mov dword [esp + ecx - 0x5fb8f216], esi
ret 0xc
sar edx, 0x43
je 0x1e2d322
neg ecx
rol ecx, 1
push eax
push eax
lea ecx, [ecx + eax + 0x1eb17f83]
pop edx
push eax
sub dword [esp + 3], eax
xor ebx, ecx
dec word [esp]
call fcn.015db64f
cmc
dec edx
mov dword [esp + ecx - 0x5fb8f28b], 0x1594d6ab
neg edx
neg word [esp + ecx - 0x5fb8f28a]
js 0x247a97a
sal cl, 0x81
xor edx, 0x9aaac28
push eax
xor ebx, edx
not ax
jmp 0x14f6c62
Function at 0x24a7717
Capabilities:
Encode data using xor

Disassembly:
xchg dx, ax
ror ecx, 1
and eax, edx
not ecx
sar byte [esp + eax - 0x2283fc], 0xc1
mov dword [esp + eax - 0x228401], 0x67a24aad
xor ebx, ecx
shr dword [esp + eax*4 - 0x8a1003], 0xc1
adc edi, ecx
mov eax, dword [esi + eax - 0x228401]
mov edx, dword [esi + 4]
ror dword [esp + 3], 0x99
push esi
add al, 0xc1
dec esp
and al, 3
cdq
add esi, 4
call fcn.024361b6
shl eax, 0xd5
adc ebp, 4
xor edx, ebx
dec al
bswap edx
ror edx, 1
call fcn.0242922f
xor dword [edx + 0xfe4d5ab], ebx
dec edi
dec esi
and eax, 0x1af3c76d
sal dword [ecx], cl
mov edx, 0xb68a0362
je 0x24a7746
dec esp
cmp dword [ebp + 0x604a886], ebp
mov word [ebx + 0x5d], gs
cli
push ecx
xor ecx, dword [esi + 0x24]
mov ebp, 0x7a9ef306
xor dh, bl
out dx, al
movsd dword es:[edi], dword [esi]
loop 0x24a7812
inc ebx
imul ecx, dword [ecx - 0x55d1c9a], 0x93df5af7
push eax
mov al, 0x94
mov cl, 0xa0
adc ebx, ebp
dec esp
shr dword [ebp*2 + 0x75d8ddbe], 0x32
xor byte [ebp - 0x69], bh
invalid
stosb byte es:[edi], al
add bl, dh
jae 0x24a7888
ret 0xb47e
cli
mov bl, byte [eax + 0x7d9f8048]
inc eax
push 0xfffffffffffffff1
inc edi
dec dword [ebp - 0x2452e71c]
int3
sub dword [edx + 0x4f02d940], edi
rol byte [edx], 1
out dx, eax
or byte [esp + 6], 0xa3
nop
stosb byte es:[edi], al
xchg esi, eax
push esp
add byte [ebx + 0x5496aa90], ah
out dx, eax
sar byte [ecx + 0x3096f1d], 1
push ds
sbb dword [ebp + 0x57], ebp
jp 0x24a782d
lodsb al, byte [esi]
sbb al, 0x50
pop ecx
inc ecx
adc eax, 0xa5c4c26c
push ecx
dec ebx
sbb eax, 0x798261f7
fiadd word [ebp + 0x36f5fdf4]
adc bh, byte [edx + 3]
push ds
sub eax, 0x1e4f96c3
xchg esi, eax
dec edi
push ds
in eax, dx
outsb dx, byte [esi]
out 0xfd, eax
jb 0x24a78da
add byte [0x99b135fd], 0xfd
shl byte [edx - 0x7de30480], cl
cmp bl, 0x1c
adc byte [edi + 0x2e4e77a], 0x5e
sti
sbb al, 0x82
xchg edi, eax
jp 0x24a78b9
in al, 2
pop esi
loope 0x24a78be
jge 0x24a792e
lds esi, [edx + 0x3dfd3509]
jg 0x24a78ee
mov dl, 9
xor eax, 0xd7f3dfd
mov bh, 0x47
mov edi, 0x62c55e94
fsubrp st(2)
call dword gs:[ebx + 0x3371818c]
aas
xchg edx, eax
int1
js 0x24a7878
xor dword [ecx + 0x33], 0x78f1923f
xor byte [eax + 0x228c8b68], 0xc6
dec esi
mov esi, 0x95effb8a
mov al, 0x68
mov ecx, dword [edx - 0x7541b13a]
sti
out dx, eax
xchg ebp, eax
cld
mov dl, byte [ebp + 0x55]
retf
fucomp st(1)
mov ecx, dword [ebx - 0x774d6c51]
mov al, byte [0xf08ae39b]
dec edx
sar ecx, cl
jge 0x24a78cf
dec eax
xor bl, byte [ebx - 0x6704c0de]
jge 0x24a78cb
adc al, 0xdf
js 0x24a78cc
adc al, 0xad
loopne 0x24a793c
mov ch, byte [edi + 0x17]
pop ss
add edi, ebx
enter 0xffffffffffffd7e5, 0xffffffffffffffba
js 0x24a796c
movsb byte es:[edi], byte [esi]
jp 0x24a78d4
mov eax, esp
push esi
cld
lcall 0x6172, 0x63a3a6b4
and dword [ebp + 0x6a], esi
imul dword [ebx + 0x49]
invalid
push 0xca749f37
nop
mov edx, 0xfe6f9852
xlatb
dec ebx
js 0x24a7909
add dh, byte [esi + 0x4ea2212d]
cli
out dx, al
fisttp dword [eax + 0x74]
imul edx, dword [ecx], 0xffffffe9
js 0x24a7988
invalid

Function at 0x24abd1f
Capabilities:
Encrypt data using speck

Disassembly:
mov dword [ebp + ecx*8 - 0x24a05f80], edx
jno 0x2509822
inc esp
xor esi, edi
inc ecx
movzx eax, si
dec ebp
arpl ax, ax
call fcn.0164df78
Function at 0x24b2092
Capabilities:
Encode data using base64

Disassembly:
xor bl, al
inc byte [esp + 8]
mov dword [esp + 8], ebp
push edx
movsx ebp, dl
mov dword [esp + ebp*2 - 0x74], 0xcd919aa4
mov dword [esp + ebp - 0x34], edi
mov dword [esp + ebp - 0x38], ebx
mov ebp, esi
mov ebx, eax
setle byte [esp]
movzx eax, dx
mov edx, ebx
jno 0x162be3a

Function at 0x24b8cd6
Capabilities:
Encode data using xor

Disassembly:
mov dword ss:[eax + ecx*2 - 0x6dcc8998], edx
mov eax, dword [ebp + ecx*2 - 0x6dcc8998]
lea ebp, [ebp + ecx*2 - 0x6dcc8994]
xchg byte [esp + ecx*2 - 0x6dcc898f], cl
xor eax, ebx
mov dword [esp + ecx*2 - 0x6dcc8972], ecx
or cl, 0xa3
ror eax, 1
mov dword [esp + ecx - 0x36e644bb], ecx
pop ecx
inc ecx
lea eax, [eax + ecx - 0x6811a0ce]
push ecx
rol eax, 1
shr word [esp + ecx*2 - 0x6dcc8978], 0x4f
xor eax, 0x4695b3af
lea eax, [eax + ecx - 0x6a68175e]
call fcn.0162f97b
Function at 0x24c5636
Capabilities:
Encode data using base64

Disassembly:
pop eax
xor edx, 0x9501f902
mov eax, ecx
sar dword [esp], 0xf
xor ebx, edx
sar cx, 0x6d
adc esi, edx
sub ebp, 4
sub eax, ecx
shr dword [esp], cl
mov edx, 0x4809bf23
mov ecx, dword [ebp + edx - 0x4809bf23]
inc word [esp + edx - 0x4809bf23]
inc dx
xor ecx, ebx
xor byte [esp + edx - 0x4809bf23], 0x3f
call fcn.025501bc
call fcn.014bc189

Function at 0x24ccd8b
Capabilities:
Encode data using xor

Disassembly:
dec dx
dec ecx
mov dword [esp + edx - 0x5b2ec22e], 0x62919422
push eax
bswap edx
xor ecx, 0xf838279f
call fcn.016aab0c
shr ecx, 0x5a
neg eax
shr cl, cl
shr dl, 0xa4
rol eax, 1
shl ecx, 0xa9
bswap eax
xadd edx, ecx
inc eax
shl edx, 0xb5
jns 0x24fba4b
shl edx, 0x51
xor ebx, eax
ror dx, 0xc2
adc esi, eax
mov eax, 0x6d9adb22
jmp 0x25295be

Function at 0x24d3255
Capabilities:
Authenticate hmac

Disassembly:
mov ebp, dword [ebp + ecx - 0x6d20]
mov dword [esp + ecx - 0x6d20], 0x7ea2402c
rol cx, 0xa1
pop eax
jo fcn.02513ddd

Function at 0x24d5270
Capabilities:
Encrypt data using speck

Disassembly:
sub cl, 0xbf
xor edx, ebx
rol edx, 2
lea edx, [edx + ecx - 0x7070a7d8]
neg edx
lea eax, [ecx*2 + 0x461962bf]
bswap edx
sub ax, cx
inc edx
rol edx, 3
mov dword [esp + ecx - 0x67342fd3], eax
or eax, ecx
xor edx, 0x7e8f8caf
ror dword [esp + eax - 0x77b5bfd3], 0x91
sar al, 0xc4
sets byte [esp + ecx - 0x67342fd3]
ror edx, 1
xor edx, 0xd30ad800
dec edx
xor edx, 0x401575a7
xor ebx, edx
lea eax, [ecx + ecx - 0x5de2f6ce]
push eax
add edi, edx
shr ax, 0xaf
call fcn.02468fbd
test cl, ah

Function at 0x24e1b6a
Capabilities:
Encrypt data using speck

Disassembly:
push dword [esp + 4]
popfd
mov dword [esp + 4], eax
sub ebp, 4
pop ecx
call fcn.02575cb2
not eax
lea ebp, [ebp + ecx*2 - 0x10680004]
xadd ax, dx
mov eax, dword [ecx + ebp - 0x8340000]
push ecx
dec ecx
sar ecx, cl
xor eax, ebx
sal byte [esp + edx*8 - 0x79263], 0x83
rol ecx, 0x73
rol dword [esp + ecx + 4], 0xe6
ror eax, 1
xor edx, 0xe7b65c35
and dword [esp + ecx*8], ecx
xor eax, 0x56b5db1d
not dx
dec edx
jne 0x251fd65
not eax
inc dx
neg eax
xchg dword [esp + ecx + 4], ecx
add eax, 0x3908cdb7
mov dword [esp + 4], ecx
or cl, dl
sal dword [esp], 0xad
rol eax, 3
call fcn.0168c6e6
Function at 0x24e1bc3
Capabilities:
Encrypt data using speck

Disassembly:
mov edi, 0x9325e834
xor di, 0x5b02
movzx edi, byte [ecx]
jl 0x25bfdf1
call fcn.025b959b
mov edx, 0xb90eb810
lea ecx, [edx*4 - 0x39fc81f0]
mov cx, word [ebp]
sar dl, 0x41
mov ax, word [ebp + 2]
call fcn.0251bb3d
mov edx, 0x4429d2ae
lea eax, [edx + edx*8 + 0x6f98af8d]
movzx ecx, byte [edi + edx - 0x4429d2ae]
lea edi, [edi + edx - 0x4429d2ad]
or dl, 0x21
dec eax
xor cl, bl
add cl, 0x12
push edx
rol cl, 1
sal dl, 0x87
sub cl, 0x27
xor cl, 0xa3
sub dl, dh
setb al
xor bl, cl
lea ecx, [esp + ecx + 4]
mov edx, dword [ecx + edx - 0x4429d2ae]
movsx ecx, al
call fcn.02523ccb
mov dx, word [edi]
mov eax, 0x4f0a7a29
lea eax, [eax*4 - 0x6d53da41]
jmp 0x250773e
lea esp, [esp + 0xc]
jne 0x14d65f9
mov edi, 0xc28be987
sal di, 0x4f
pop edi
push 0xb795449c
mov ecx, 0xe22a3e31
inc ecx
not eax
jle 0x255c738
jmp 0x24816d3
inc ecx
xor eax, 0x10089d99
jmp 0x15d7ffb
mov ax, word [edi + 2]
mov ecx, 0xd99a989c
call fcn.02531452
mov edx, 0xef031585
lea eax, [edx + edx*8 - 0x1d47e6f1]
lea ebp, [ebp + eax - 0x49d3dac0]
call fcn.024e169c
mov dword [ebp], eax
rol word [esp], 0x66
ror byte [esp + 2], 0xc6
mov eax, dword [edi]
adc edi, 4
pop ecx
xor eax, ebx
jmp 0x25b2166
dec eax
call fcn.016f364b
xor edi, eax
push 0x529b0138
and edi, 0xff
sar dword [esp], 0xd5
mov edi, dword [edi*4 + 0x1660838]
shr eax, 8
xor eax, edi
jmp 0x24f735f

Function at 0x24e1c3c
Capabilities:
Encrypt data using speck

Disassembly:
pop eax
ror edx, 3
movsx eax, cx
sal eax, 0xde
not edx
ror edx, 1
xor ebx, edx
rol eax, 0x3e
not eax
sbb ecx, ecx
adc edi, edx
lea ebp, [ebp + ecx - 2]
dec cx
mov cx, word [ebp + ecx*8 - 0x7fff8]
xor cx, bx
neg cx
add cx, 0x2105
movzx edx, al
neg cx
inc dx
add cx, 0xb52d
ror eax, 0xc
shl ax, 0x4a
Function at 0x24e862d
Capabilities:
Authenticate hmac
Encrypt data using speck

Disassembly:
bswap edx
rol al, 1
push edx
sub al, 0x2b
shl cx, 0x6f
lea edx, [ecx - 0x237f4ede]
not al
xor bl, al
ror dl, 0x87
sal dl, 0x87
bswap ecx
lea ebp, [ebp + ecx*2 - 0x1000002]
or dl, cl
xor byte [esp + ecx - 0x800000], 0x96
mov word [ebp + ecx*2 - 0x1000000], ax
xor byte [esp + ecx*2 - 0xffffff], dl
neg cl
rol cl, 0x41
pop ecx
je fcn.02513ddd
sar edx, 0x73
rol eax, 1
pop edx
neg eax
add eax, 0x13040ea5
xor eax, 0xc500ae08
ror eax, 1
not eax
xor ebx, eax
mov ecx, 0xb009fc94
mov dword [esp + 4], ecx
add edi, eax
mov ecx, dword [esi]
pop eax
mov eax, dword [ecx]
mov edx, 0x3a983926
and dword [esp + edx*2 - 0x7530724c], 0x9c941497
mov dword [esi + edx - 0x3a983926], eax
rol dword [esp + edx*2 - 0x7530724c], 0x75
pop eax
lea ecx, [eax + edx*8 + 0x3e0710bf]
jmp edi
lea ecx, [ecx + ecx*8 - 0x25fefd9]
not cl
mov ecx, dword [edi + 8]
js 0x240235d
add edi, 4
call fcn.0240ece0
dec cl
not edx
rol edx, 1
dec byte [esp + eax - 0x494da00]
sub cl, cl
inc ax
lea edx, [edx + eax*4 - 0x8c867fa]
bswap edx
ror edx, 1
neg edx
xor ebx, edx
add edi, edx
mov edx, dword [esp + eax*2 - 0x929b402]
xadd dword [esp + eax - 0x494da01], edx
pop eax
jle fcn.01577f93
setae dl
rol al, 1
sal cl, 0xa1
not cl
xor al, 0x97
jmp 0x1692159
mov eax, ecx
mov edx, dword [ecx + edi - 0x3a8e0519]
shr cl, 0xa3
bswap eax
lea edi, [edi + eax - 0x19058e36]
sal cl, cl
shl cx, 0x2f
xor edx, ebx
bswap edx
lea edx, [edx + ecx*2 + 0xa15f219]
sar ecx, 0x1d
jb 0x252d11b
movzx edx, cl
mov dword [esp + ecx - 0x439b829a], ecx
neg eax
pop edx
shl dx, 0xc3
dec word [esp + ecx - 0x439b8297]
xor ebx, eax
push ecx
xchg dword [esp + ecx - 0x439b8294], ecx
neg cl
adc esi, eax
dec ecx
setle byte [esp + edx - 0x439b14ce]
mov edx, dword [edi + edx - 0x439b14d0]
pop eax
neg eax
shl dword [esp + 2], cl
mov eax, dword [edi + 4]
jns 0x16a5395
outsb dx, byte [esi]
sbb byte [ebx + 0x77cca397], bl
jp 0x24e86c5
and ebp, edx
pop ebp
xor edi, ebx
push esi
ret 0x8c8d
shl eax, 0x2c
xor edx, 0x149ed0af
lea edx, [edx + ecx + 0x38a64b81]
neg edx
sal cx, 0xc
xor ebx, edx
add esi, edx
movzx eax, byte [ecx + edi - 0x1000]
mov edx, ecx
jmp 0x2533617
shr edx, 0x45
lea edi, [edi + ecx*4 - 0x3fff]
shl edx, 0x4d
xor al, bl
rol dl, 0x65
jae 0x23fe925

Function at 0x24e888e
Capabilities:
Encrypt data using speck

Disassembly:
dec eax
arpl bx, bx
and ax, 0xd20c
xadd ax, cx
dec eax
adc esi, ebx
dec eax
mov dword [esp + edi - 0x51dafff8], 0x7f0a631c
bswap ebp
call fcn.024e2c3b

Function at 0x24f559d
Capabilities:
Encrypt data using speck

Disassembly:
dec esi
mov ebx, dword [esp + edx - 0x1191e5c5]
dec esi
mov dword [esp + edx*2 - 0x2323cbba], eax
dec edx
lea edx, [esi*2 + 0x7a325c3f]
dec eax
arpl ax, ax
inc cx
not edx
dec eax
adc esi, eax
inc ecx
rol eax, 0x42
dec edx
mov dword [esp + edx - 0x11911a0a], ecx
inc ecx
pop esi
inc di
mov esp, dword [esp + edx*2 - 0x23223444]
pop ecx
pop ecx
inc ecx
pop edi
jae fcn.0159a611
Function at 0x24f7ced
Capabilities:
Encrypt data using speck

Disassembly:
movzx edx, cx
xor eax, ebx
xor cl, cl
not eax
xor cl, cl
setno cl
sbb eax, 0xb09ff539
neg cl
rol ecx, cl
ja 0x2541b9d
not eax
jne 0x16bb9ea
inc ecx
ror dh, 1
inc edx
not dword [esp + edx - 0x4212f8ab]
call fcn.0256aa9c
dec eax
call fcn.02515cd5
sub dword [ebp + 0x41c2ff41], edx
rol edi, 1
inc ebp
mov ecx, edx
call int.0249339c
mov eax, 0x6e1e2daf
lea ecx, [eax*8 + 0x4eb3afa9]
lea esi, [eax + esi - 0x6e1e2db3]
mov eax, dword [esi + eax - 0x6e1e2daf]
jmp 0x166368e
mov ecx, 0xc141ff16
invalid
inc ecx
rol edi, 0xd6
inc esi
mov esi, dword [edi + ebp - 0x3faba807]
call fcn.015e35ec
jo 0x24f7d62
sti
clc
jb 0x24f7cbe
adc ah, byte [ecx]
aas
push ss
and ebp, dword [eax + 0x64501f30]
fimul dword [0x8a14425e]
test al, 0x30
pop ds
push eax
fimul dword fs:[0x8a14425e]
inc edi
mov dword [0x9852d2c2], eax
xor byte [0x3e509e91], 0x2d
jecxz 0x24f7cea
stc
stosb byte es:[edi], al
pop eax
mov ch, 0xe4
adc eax, 0x936c4647
push esi
inc ecx
jno 0x24f7d1b
mov eax, dword [0x46bfda3c]
xchg dword [edx + edx*2 - 0x68], edi
out dx, eax
and ebp, dword [edx]
cmpsb byte [esi], byte es:[edi]
add al, ah
xchg byte [ebx + 0x79f17abf], ah
invalid
mov word [edi - 0x419073b1], ss
mov esp, 0x9e0196b9
in eax, dx
push es
pop ebx
jp 0x24f7d09
xchg ebx, eax
sub dword [edi*2 + 0x76ce26a6], ecx
jle 0x24f7dd6
sal dword [ebx], 0x77
mov dword cs:[0x62c6a802], eax
sbb bl, byte [esi - 0xabc57ec]
dec ebp
push esi
invalid
push 0xffffffffffffffc5
dec esp
dec ecx
imul edi, dword [ecx + edi + 0x1a], 0xffffff8d
push esp
push 0xffffffffffffff8f
push 0x314474e4
adc ebx, dword [edi + eax*2 - 0x2f]
mov eax, 0xadc10a84
into
add eax, 0xf3df8648
sub byte [eax - 0x4a], ch
int 0xa4
ljmp 0xdea4

Function at 0x24f82cf
Capabilities:
Authenticate hmac

Disassembly:
ror eax, 1
mov dword [esp + 4], ecx
mov dword [esp], ecx
inc ecx
bswap eax
dec eax
shl dword [esp + 4], 0x5c
call fcn.025369b2
sub ebp, 4
mov eax, 0xef88a2b9
jmp 0x256b6da
mov eax, dword [ebp]
call fcn.02553fe6

Function at 0x250707c
Capabilities:
Encrypt data using speck

Disassembly:
rol ecx, 1
call fcn.0162d798
dec cl
not edx
mov dword [esp + ecx - 0x70084036], ecx
inc ecx
call fcn.025184c1
xor ecx, ebx
xchg edx, eax
jmp 0x163e4ab
Function at 0x250ec92
Capabilities:
Encrypt data using speck

Disassembly:
lea edx, [ecx + ecx*8 + 0x543f17b4]
lea eax, [eax + ecx*2 + 0x74301cc0]
push edx
lea edx, [ecx*4 - 0x73febeee]
bswap eax
inc eax
mov byte [esp + ecx - 0x312f36a1], dh
or cl, byte [esp + edx - 0x50be1b9a]
xor eax, 0x60a049a3
ror dx, 0x6b
adc dx, 0x8fb7
jbe 0x23e28e0
add edi, 4
mov dword [esp], 0x96ac7ca0
not eax
not edx
and eax, edx
mov dword [edi], eax
sub ebp, 4
mov edx, 0x49ad1f1f
mov dword [esp + edx - 0x49ad1f1b], 0x2eb14830
neg word [esp + edx - 0x49ad1f1a]
mov eax, dword [ebp + edx - 0x49ad1f1f]
and edx, 0xa32be58c
xor eax, ebx
lea ecx, [edx + edx*8 + 0x750274bc]
neg eax
call fcn.0253442e
lea eax, [eax + ecx + 0x378c132a]
sar ecx, 0xe
sal word [esp + ecx - 0xc4ba], 0xe6
ror ecx, 0xe4
xor eax, 0xfe265184
rol cl, 0x63
shl dword [esp + edx - 0x50be02fa], cl
call fcn.0252fd6e
add edi, 2
call fcn.0251a123
mov ecx, 0x312f36a2
lea esi, [esi + ecx*2 - 0x625e6d48]
mov eax, dword [esi + ecx - 0x312f36a2]
xor eax, ebx
jmp 0x16e0e3a

Function at 0x250f494
Capabilities:
Encode data using xor

Disassembly:
lea eax, [ecx + ecx - 0x48e162e6]
mov ecx, dword [edi + eax*8 - 0x23df6410]
xchg word [esp + eax - 0x47bec7d], ax
lea edi, [edi + eax - 0x47baea3]
call fcn.015ec1b3

Function at 0x2510922
Capabilities:
Encode data using xor

Disassembly:
test eax, eax
not dword [esp + 4]
lea esp, [esp + 8]
je 0x14ccc36
push edi
movzx edi, byte [edx]
push 0xb80eb3b2
xor edi, ecx
not word [esp]
and edi, 0xff
mov edi, dword [edi*4 + 0x24e7ba8]
shr ecx, 8
xor ecx, edi
inc edx
xor ecx, 0x1e2ac885
dec eax
lea esp, [esp + 4]
jne 0x14ccc03
pop edi
not ecx
mov edx, 0x44a0419b
mov dword [edx + ebp - 0x44a0419b], ecx
lea eax, [edx + edx*4 - 0x6976f6e1]
xor edx, edx
add edx, esi
jmp edx
jmp 0x14ccbf2

Function at 0x2512704
Capabilities:
Execute anti-debugging instructions

Disassembly:
xchg dword [esp + eax*4 - 0x2b2c408], eax
lea edi, [edi + eax*2 + 4]
lea edx, [edx + edx*4 + 0x3e3a3a3c]
xor ecx, ebx
shl ax, 0x85
bswap ecx
call fcn.0250ae6c

Function at 0x2512af9
Capabilities:
Encrypt data using speck

Disassembly:
mov ecx, dword [edi]
or edx, 0x98885d90
movzx ax, byte ss:[ecx]
lea ecx, [edx + edx*4 - 0xafcc25a]
dec edx
adc edi, 2
lea edx, [ecx*2 - 0x556c3c58]
ror cl, 6
sub cl, byte [esp + 6]
mov word [edi], ax
jbe 0x251fd87
pop eax
pop eax
jmp esi
neg eax
shr byte [esp + edx*4 - 0x62b0bdda], 0x21
sal word [esp + edx - 0x18ac2f72], cl
sar dword [esp + edx*2 - 0x31585eec], 0xb1
bswap eax
sub edx, dword [esp + edx - 0x18ac2f74]
adc cl, cl
or cl, 0x20
xor ebx, eax
neg edx
mov dword [esp], ecx
add esi, eax
jmp 0x163f11d
jg 0x2402b9a
xor ebx, ecx
add al, dl
adc esi, ecx
sub edx, edx
adc edx, esi
jmp edx

Function at 0x2515e61
Capabilities:
Encrypt data using speck

Disassembly:
xor ecx, 0x5da96087
push eax
sub edx, 0x2faa7013
xor ebx, ecx
call fcn.016a994c