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

Disassembly:
shr eax, 0x58
or al, al
dec ecx
sal edx, 0x49
push eax
neg ecx
lea ecx, [ecx + eax*2 - 0x2db5ac39]
call fcn.00d02f15
mov edx, 0xcc9c573e
jmp fcn.00c90661
lea esp, [esp + 0x18]
je 0xcfb1d2
jmp 0xceb5e2
call fcn.008b2985
movzx eax, dl
xor ecx, 0x92139da2
mul eax
xor ebx, ecx
cwd
add edi, ecx
rol dx, 0x4a
movzx ecx, dl
or eax, dword [edx + esi]
lea esi, [esi + edx*4 + 4]
inc edx
bts dx, cx
and edx, 0x3e0fa3a2
adc cl, byte [edx + ebp]
lea ebp, [ebp + edx*4 + 1]
inc edx
xor cl, bl
add cl, dl
xor cl, 0x9b
add cl, dl
and edx, edx
imul edx, edx
not cl
neg cl
bts dx, dx
jb 0xc00a94
xor bl, cl
push edx
lea ecx, [esp + ecx + 4]
shr byte [esp + edx*8 - 0x17], 0xa1
sub dl, byte [esp + edx*8 - 0x15]
shl dx, 0x2f
mov dword [edx + ecx - 0x8000], eax
movzx eax, dx
ror word [esp + eax - 0x8000], 0x28
mov dword [esp + edx*4 - 0x20000], edi
ret
mov eax, dword [ebp + ebx*4]
push eax
dec ebx
call fcn.00842667
mov eax, dword [ebp]
call eax
mov ebx, 0x5c9a8400
sub bx, 0x1485
mov ebp, dword [ebx + ebp - 0x5c9a6f7f]
jnp 0x723ca8
mov dword [ebp + ebx - 0x5c9a6f7b], eax
mov esi, ebp
mov ecx, ebx
rol bx, 0x44
sar bx, 0x48
pop ebx
movzx edx, cx
movzx eax, dl
pop ebp
xadd ecx, eax
pop edi
mov edx, dword [edx + edi - 0x6f7b]
push ecx
lea edi, [eax + edi - 0x5c9a6f77]
jns 0xbe81af

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

Disassembly:
xor ebx, eax
add ebp, eax
mov dword [esp + ecx - 0x47cc2a00], edx
movsx eax, cx
not edx
mov eax, dword [edi + edx - 0x144e5fff]
add cl, byte [edi + edx*2 - 0x289cbffa]
sub dl, dl
lea edi, [edi + edx - 0x144e5efe]
pop edx
call fcn.00d0b368
or al, ch
push es
pop edi
dec ebx
inc edx
add byte [edx], cl
lds eax, [esi]
mov ah, 0xf7
call 0xf80a1d7b
or al, 0xae
pop ecx
imul edi, dword [ebx - 0x6c], 0x555facc8
pop ecx
sub eax, 0x2674d2ad
and al, 4
xor al, 0x80
sal byte [ecx - 0x72ff76f5], 0x8f
jno 0x8e6805
ror byte [edx], 1
mov esp, 0x9f673e00
mov dh, 0xc7
out 0xd7, al
adc dword [edx - 0x65], edi
mov dl, 0xd6
xchg byte [esi + 0x67], al
mov al, byte [0x1ea92532]
cmpsd dword [esi], dword es:[edi]
dec cx
and dword [edx - 0x64], edi
xchg edx, eax
push edx
and byte [ebp - 0x3e2ea8d3], bh
sal dword [ecx], 0x2f
invalid

Function at 0x8eae0f
Capabilities:
Encrypt data using speck

Disassembly:
xor edi, ecx
jmp 0xc3e71f
jmp 0x88af53

Function at 0x8efd81
Capabilities:
Authenticate hmac

Disassembly:
mov dword [esp + 8], 0x597dc8e0
lea esp, [esp + 8]
call fcn.0074b44f
mov ecx, dword [esi]
mov edx, 0x21acbd26
push edx
and dword [esp + edx - 0x21acbd26], edx
lea esi, [esi + edx*2 - 0x43597a48]
xor ecx, ebx
mov dword [esp + edx*2 - 0x43597a4c], 0x2ca70fa3
neg byte [esp + edx - 0x21acbd25]
inc ecx
and byte [esp + edx - 0x21acbd24], dl
movsx eax, byte [esp + edx - 0x21acbd26]
idiv dl
not ecx
xor edx, edx
ror ecx, 3
bswap ecx
xor ebx, ecx
btc eax, 7
add ebp, ecx
shl ax, 0xce
movzx eax, byte [esi + edx]
movsx ecx, dl
and word [esp + edx + 1], dx
lea esi, [edx + esi + 1]
sar dl, 0x81
inc ecx
imul ecx, ecx
xor al, bl
call fcn.00d06e12
Function at 0x8f0ab0
Capabilities:
Encrypt data using speck

Disassembly:
not ecx
mov dword [esi + ecx*2 - 0x65a854a8], edx
call 0x81db40

Function at 0x8f0ac6
Capabilities:
Encrypt data using speck

Disassembly:
mov dword [esp], 0xc29bdc
call fcn.008ba99b

Function at 0x8f5677
Capabilities:
Encode data using xor

Disassembly:
xor ebx, eax
jmp 0x85f380
sal dword [ebx], 0xd3
sal eax, 0xf
setns al
xor edx, 0xc9907fa8
push ecx
not edx
dec ecx
btr cx, 0
bswap edx
neg ecx
inc ecx
jo 0x86cf45
inc edx
add eax, dword [esp + ecx*8 - 0x25818]
and dword [esp + ecx - 0x4b03], ecx
ror edx, 1
or ecx, ecx
xor ebx, edx
cbw
inc dword [esp + ecx - 0x4b03]
add ebp, edx
cdq
mov eax, dword [edi + ecx - 0x4b03]
and ecx, ecx
bswap ecx
lea ecx, [ecx + ecx + 0x23e298c]
mov edx, dword [edi + ecx*8 - 0x46a14c5c]
push ecx
shr byte [esp + ecx - 0x8d4298c], 0xe4
mov cl, byte [ecx + edi - 0x8d42984]
adc word [esp + 5], 0x8e19
shl dword [esp + 4], 0x35
sal byte [esp], 0xe2
adc edi, 6
ror dword [esp + 2], 0x5f
and al, 4
xor eax, 0x2474c0
loop 0x78d2df
xlatb
push es
add byte [eax], al
add cl, al
dec esp
and al, 2
pop edi
jae 0xc1a36c
push ebx
mov dword [esp], 0x8bb36a09
call fcn.007a92df
xor eax, 0x949aeaea
jl 0x78d3ce
inc eax
jns 0x78d3c0
sub al, 0x93
jle 0x78d355
retf
dec dword [edi + 0x6c5fa9c8]
aaa
adc esp, dword [ecx + 0x1ba9920b]
movsd dword es:[edi], dword [esi]
adc cl, bl
ret
call 0xe9bb1138
xor al, 0x6c
mov ebp, 0xfb0bca53
jo 0x78d3ef
in eax, 0x7b
fyl2xp1
popal
sahf
inc edi
dec eax
ror byte [0x95156771], 0x21
adc dword [edx - 0x424d75e], edi
add byte [eax], al
add byte [eax], al
sar byte [edx], 0x9d
mov byte [0x3436c388], al
sal byte ds:[esi + 0x40], cl
push ecx
jb 0x78d389
dec ecx
add edi, dword [ecx + 0x40]
mov edi, 0x4a44674c
test al, 0x3d
invalid
mov dword [esp], 0x429fd5b3
add esi, eax
jmp 0x9075e5
inc eax
mov dword [esp + 8], 0x4a9843b7
dec dword [esp + 7]
rol eax, 1
inc eax
ror dword [esp + 5], 0x9e
shr byte [esp + 6], 0xe4
jnp 0x751d16
not dword [esp + 7]
lea esp, [esp + 0xc]
jmp 0x78d36e
shld eax, edx, cl
mov edx, 0xa4115d1b
mov dword [edi], eax
pop edx
pop eax
jmp ebp
Function at 0x8f92ca
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
movzx ecx, dl
bswap eax
xor eax, 0xe3b9eb0f
or edx, ecx
xor cl, dh
dec eax
push edx
pop edx
btc ecx, ecx
xor ebx, eax
xchg cl, dl
bts cx, cx
adc ebp, eax
xor ecx, 0x43337cb8
setbe cl
mov dl, byte [esi + edx - 1]
mov al, byte [ecx + esi - 0x43337bfe]
call fcn.00782d58
mov edx, 0x8a1e023
movsx ecx, dl
shr edx, cl
lea edi, [edi + edx*2 - 0x228780c]
mov ecx, dword [edi + edx - 0x1143c04]
xor dl, dl
sub edx, 0xd7ae6dbc
xor ecx, ebx
dec ecx
not ecx
movzx eax, dx
neg edx
sar eax, 0x33
inc ecx
sub eax, 0xac80ca2f
bswap ecx
xadd eax, edx
xadd ax, dx
neg ecx
add edx, eax
not ecx
sbb edx, edx
xor ebx, ecx
imul edx
setno dl
not al
adc ebp, ecx
imul ax, dx
mov esi, dword [esi + edx*2 - 2]
jae fcn.00d0b40c
lea esp, [esp + 8]
call eax
push 0x6202d795
mov ebp, dword [ebp - 4]
add word [esp + 2], 0x47a8
mov ecx, 0x660a3d88
movzx esi, word [esp + ecx - 0x660a3d88]
mov dword [ebp + ecx - 0x660a3d88], eax
add byte [esp + ecx - 0x660a3d88], ch
mov edi, 0x613067b2
shl ecx, cl
mov edi, ebp
jp 0xd45a8c
mov ebx, dword [esp + ecx*4 - 0x28f61ffc]
call fcn.0088266b
mov edx, 0x471a3c91
lea ecx, [edx*2 - 0xada8a5d]
mov ecx, dword [edi + edx - 0x471a3c91]
mov dl, byte [edx + edi - 0x471a3c8d]
mov eax, 0xa08ac41d
add edi, 6
add ax, 0x2f39
mov byte es:[ecx], dl
mov ecx, eax
mov eax, dword [esi]
adc esi, 4
mov edx, 0xe625d628
push edx
xor eax, ebx
not eax
or byte [esp], ch
bts edx, ecx
xor eax, 0xbbbeaf93
call fcn.00730e6b
mov eax, dword [edi]
mov edx, 0x892d179c
sub edx, edx
lea edi, [edx + edi + 4]
xor eax, ebx
inc eax
sal edx, 0xa2
xor eax, 0x9e38f292
sub eax, 0x838a34ae
jmp 0x8f54ce
Function at 0x8f930a
Capabilities:
Encrypt data using speck

Disassembly:
jns 0xc20e14
dec ebp
lea esi, [esp + 0x59b5f60a]
inc ecx
rol edi, 1
dec eax
lea eax, [ebx + ebx + 0x79a25b05]
call fcn.007c4ad3
mov dword [esp + 8], ebx
call fcn.007e9b0c
mov ecx, 0xd6b2762e
movsx eax, cl
lea ecx, [eax*4 + 0x342cde17]
mov ecx, dword [ecx + esi - 0x342cdecf]
lea esi, [esi + eax - 0x2a]
xor ecx, ebx
bswap ecx
inc ecx
or al, 0xf
not ecx
lea ecx, [ecx + eax*4 - 0x778a7040]
movzx edx, ax
sbb eax, 0x5fbc239a
cdq
xor ebx, ecx
add ebp, ecx
lea ecx, [edx + eax + 0x14a4ae30]
mov eax, dword [edi]
not dl
xor dl, ch
mov cl, byte [edi + 4]
adc edi, 2
shr eax, cl
mov ecx, edx
call fcn.00bea06e
mov eax, 0x698ac1ab
inc ebp
mov edi, dword [ebp + eax - 0x698ac1ab]
inc esp
movsx ecx, al
dec ebp
lea ebp, [ebp + eax - 0x698ac1a7]
inc ebp
movzx esp, cl
bts ax, 0x2a
inc esp
xor edi, ebp
inc ebp
btc ecx, esp
movzx ebx, ax
inc ecx
ror ah, 1
inc ecx
not edi
inc ecx
movsx edx, cl
inc ecx
mov esi, esp
dec ecx
lea ecx, [ecx + 0x659a4b3d]
inc ecx
rol edi, 1
inc ecx
dec edi
inc ebp
movzx eax, sp
inc esp
xadd esi, esp
xor bx, si
inc ecx
not edi
ja 0x830baa
mov edx, 0x3526fdaf
mov edi, 0xca12f21f
inc ebp
mov eax, dword [ebp + edx - 0x3526fdaf]
dec ebp
lea ebp, [ebp + edx - 0x3526fdab]
dec esp
lea ecx, [edx*4 - 0x644c44d1]
dec ecx
btr ecx, 0x27
inc esp
xor eax, ebp
inc eax
movsx eax, bh
inc ecx
ror eax, 3
inc esp
movsx esi, dl
inc bp
bt esi, esi
inc ecx
xor eax, 0x8a83407
inc ecx
not eax
inc ecx
ror eax, 2
dec edx
lea ecx, [esi*8 + 0x3381b821]
imul di, ax
inc ecx
shl cl, 0xa1
push ebp
inc esp
xor dword [esp + edx*2 - 0x6a4dfb5e], eax
pop ebp
inc ecx
mov ebx, esi
inc ecx
sub ecx, 0x54383589
inc ecx
xchg cl, bl
dec ebp
arpl ax, ax
dec eax
sar edx, 0x6d
inc esp
mov esp, edi
dec ecx
and edi, esp
dec ebp
adc ebx, eax
inc edi
jl 0xca9717
mov dh, 0x64
out dx, eax
retf
dec ecx
xor edx, dword [ebp + edx*2]
dec edi
lea ebp, [ebp + ecx - 0x1c177ca7]
dec eax
xor edx, ebp
inc ebp
mov edi, ecx
inc ecx
sub ebx, ecx
dec cl
dec eax
inc edx
inc ecx
ror ah, 0x67
dec eax
neg edx
sal ebx, 0x33
dec eax
ror edx, 1
inc ecx
sal esi, cl
dec esp
cmovp ecx, edi
dec ecx
lea edx, [esi + edx - 0x30a12c14]
dec eax
lea esi, [ebx*8 - 0x24eedee]
rol edi, cl
inc ebp
and esp, esp
dec eax
xor ebp, edx
bt bx, 0x28
inc ebp
or ah, bh
add ecx, edi
dec ebp
lea edx, [edx + eax*4 - 0x84]
dec ecx
bts ecx, 0x3d
dec ecx
mov dword [edx + eax - 0x1f], edx
jae fcn.00c25987
lcall 0x312a, 0x921453d1
rol esi, 1
invalid
Function at 0x8fae1b
Capabilities:
Encode data using xor

Disassembly:
lea edx, [eax + ecx*2 + 0x3b10603d]
lea edi, [edi + edx*2 - 0x387362b8]
dec ecx
mov edx, dword [edx + edi - 0x1c39b15a]
not byte [esp + 1]
div al
xor edx, ebx
sub dword [esp], 0xdda52c83
not edx
shl eax, 0xa5
lea edx, [edx + eax*8 - 0x6d2679c2]
bts eax, ecx
inc eax
add ecx, dword [esp + eax*2 - 0x4aae8aca]
bswap edx
shl ecx, cl
rol word [esp + eax*2 - 0x4aae8aca], 0xe1
or al, ah
neg edx
cwde
rol cl, 0xc4
btr ecx, ecx
bswap edx
neg edx
xor ebx, edx
push eax
add ebp, edx
xadd byte [esp + ecx - 0x5d7ffffa], ah
not ecx
pop edx
pop edx
jp fcn.00d0b40c
xchg ecx, edi
mov dl, 0x9b
nop
sbb byte [edi + edi*8 - 0x4918005c], cl
invalid
mov word [esi], dx
mov dword [esp], eax
jmp 0x756a09

Function at 0x8fb959
Capabilities:
Encrypt data using speck

Disassembly:
call fcn.00776660
rol eax, 3
sub cx, cx
sbb eax, 0x6a154e99
movzx edx, cx
not edx
neg dl
neg eax
inc dl
or cl, 0x31
xor ebx, eax
shl dword [esp + 0xa], cl
call fcn.00830082
dec byte [esp + edx - 0x6316312e]
movsx eax, dx
rol ecx, 1
lea eax, [edx + eax*8 + 0x5683cbbc]
xchg word [esp + edx - 0x63163130], dx
bswap ecx
and ax, 0xb58a
xor ecx, 0xc9b2d12c
shr byte [esp + edx - 0x6316272f], 0x43
lea ecx, [edx + ecx + 0x7ea0f95b]
sbb dword [esp + edx - 0x63162731], edx
setp al
xor ebx, ecx
dec al
mov dword [esp + edx - 0x63162731], 0xb3305f0b
xchg dh, dl
add edi, ecx
dec dx
xchg word [esp + edx - 0x63163124], dx
mov eax, dword [edx + esi - 0x6316b330]
jnp 0xd62784
sub word [esp + 0xc], 0xe3bc
xor eax, 0xe72759b1
mov dword [esp + 4], 0x6f2f903c
dec ecx
jmp 0x8988a7
lea esi, [esi + edx - 0x6316b32c]
mov ecx, edx
mov dword [esp + ecx - 0x6316b330], eax
popfd
lea eax, [edx + 0x7307bb12]
imul ax
cbw
jmp edi

Function at 0xbdb0d4
Capabilities:
Encode data using base64

Disassembly:
lea eax, [eax + ecx*8 - 0x6d1bdb80]
bswap eax
shl word [esp + ecx - 0x94ffffe], 0xad
not eax
xor eax, 0x2d028da3
dec dword [esp + ecx*8 - 0x4a800000]
ror eax, 3
pop ecx
bt edx, ecx
lea ecx, [edx + ecx*8 - 0x397828dd]
xor ebx, eax
sub edx, edx
btc ecx, 0x8e
shr ecx, 8
adc ebp, eax
xor edx, ebp
jmp edx
and cl, cl
mov word [edi + edx*2 - 0x30000000], ax
mov eax, dword [edx + esi - 0x18000000]
mov dword [esp + edx*2 - 0x30000000], 0x55173a31
dec edx
neg edx
lea esi, [esi + ecx - 0x4480e090]
sbb byte [esp + ecx - 0x4480e092], cl
inc cx
btr cx, dx
xor eax, ebx
shl ecx, 0x74
lea edx, [ecx - 0x73615c5a]
jne 0x72a01c
Function at 0xbdcaeb
Capabilities:
Encode data using base64

Disassembly:
pop ecx
xor edx, ebx
inc edx
mov eax, 0x339be810
bswap edx
sub edx, 0x4e1da728
bt eax, eax
xor edx, 0xafb267b5
movzx ecx, ax
dec edx
sar cx, 0x48
bt ax, 0xaa
jae 0x806ea1
neg edx
sal cl, 0xa1
and ecx, ecx
cwde
not edx
xchg cx, ax
dec edx
call fcn.007a5ae2
push 0xd83ceb0f
sub edi, 4
mov ecx, 0x959ad5b6
pop edx
neg ecx
mov edx, dword [edi + edx*2 + 0x4f8629e2]
jno 0x71c282
mov eax, 0x15b6a790
movzx edx, ax
mov edx, dword [edi + eax - 0x15b6a790]
sar al, 0x26
lea edi, [edi + eax*4 - 0x56da9ff4]
inc al
lea ecx, [eax + eax*4 - 0x7b5d5cd1]
sal cx, 0x66
xor edx, ebx
ror ecx, 0xee
jae 0xce2e1d
cmpsb byte [esi], byte es:[edi]
lea esp, [esp + edi]
iretd
btr eax, 0xc
rol edx, 2
sub cx, cx
sar al, 0x83
inc edx
rol edx, 2
inc ecx
rol ax, cl
rol eax, cl
dec edx
xor eax, 0xa3b412ba
xor ebx, edx
shr cx, cl
sub cx, 0xc0ac
add ebp, edx
shr eax, cl
lea edx, [ecx*2 + 0x4bba9582]
lea edx, [edx + ecx*2 - 0x38d2edea]
mov esi, dword [esi + eax*4 - 0x2234]
add dl, al
jns fcn.00c1fb28

Function at 0xbed6d7
Capabilities:
Encrypt data using speck

Disassembly:
mov ecx, 0x7fa1c604
movsx edx, cx
mov eax, dword [ecx + edi - 0x7fa1c604]
xchg ecx, edx
call fcn.00d69c5a
mov ecx, dword [ecx + esi - 0x39b80cf6]
lea eax, [edx + edx*4 - 0x2ffebde]
rol dword [esp + edx - 0x2ffffffb], 0xf5
mul eax
mov edx, dword ss:[ecx]
pop eax
mov dword [esi + eax - 0xba0000], edx
cdq
jo 0x87b548
xor al, 0xa7
xor edx, 0xd99fee96
div al
mov dword [esp + ecx - 0x5880fc2a], ecx
call fcn.00cde6f7
jmp 0x8e98ba

Function at 0xbedd53
Capabilities:
Encode data using base64
Encrypt data using speck
Execute anti-debugging instructions

Disassembly:
lea esp, [esp + 0x10]
je 0xcd4ce9

Function at 0xbf681d
Capabilities:
Encrypt data using speck

Disassembly:
cmp ecx, dword [ebp - 0x40]
je 0xd208e5
movzx edx, byte [ecx]
test di, di
shl esi, 8
inc edi
clc
or esi, edx
inc ecx
stc
cmp bp, 0xda9b
test bp, cx
cmp edi, 5
jmp 0xbf682a
mov dword [esp], 0x59b2a23e
call fcn.00879a43
jl 0x8c1217
mov dword [ebp - 8], ecx
bt ecx, 0x25
lea esp, [esp]
sar edi, 0x10
movzx edi, bp

Function at 0xbf85e6
Capabilities:
Encode data using base64

Disassembly:
mov word [esi + ecx - 0x2e1e8f29], ax
inc byte [esp + ecx - 0x2e1e8f23]
mov dword [esp + ecx - 0x2e1e8f29], ecx
bts cx, 0x9c
lea edi, [ecx + edi - 0x2e1e9f2d]
call fcn.0076cba1
mov esi, 0x6a969520
inc esp
movsx edi, si
inc esp
movsx esp, dh
dec ecx
mov esp, edx
pop ebp
inc ecx
movsx ebx, bh
rol ebx, 0x9c
pop eax
dec eax
lea edi, [ebx + 0x148ef122]
call fcn.0072da23
Function at 0xc039eb
Capabilities:
Encrypt data using speck

Disassembly:
add ebp, edx
cwde
dec al
cwde
mov dword [esp + eax*2 - 0x903a], ebp
ret
mov edi, dword [esp + ebx*2 - 0x1a2c6642]
mov dword [esp + ebx - 0xd163319], edx
pop ebx
lea ebx, [ebx + 0x41548e]
jmp ebx
lea ecx, [ecx + eax*2 + 0x442fdada]
not ecx
ja 0x81e4c2
pop eax
mov eax, 0x70ba0cb0
and cl, dl
push eax
movzx edx, al
mov word [eax + edi - 0x70ba0cb0], cx
movsx ecx, al
mov edx, dword [esi + edx*2 - 0x160]
bt eax, ecx
shl ecx, 0x58
lea esi, [esi + eax - 0x70ba0cac]
jb 0xc31489
mov dword [esp + eax*2 - 0x1922a70], eax
push eax
xor bl, dl
sal word [esp + eax - 0xc91537], 0x6d
lea esi, [eax + esi - 0xc9153a]
mov word [esi + eax*4 - 0x32454e0], dx
lea edi, [eax + edi - 0xc9153c]
btc ax, ax
mov edx, dword [esp + eax*2 - 0x192286c]
mov ecx, dword [esp + eax*2 - 0x192286d]
mov ecx, dword [edi + eax - 0xc91438]
sal word [esp + eax - 0xc91432], 0x48
xchg dword [esp + eax*4 - 0x32450dc], eax
dec edx
xor ecx, ebx
div dword [esp + edx*2 - 0x1922a6d]
push eax
ror ecx, 3
sal word [esp + eax*2 - 0x72e644b], 0xc4
bswap ecx
cwde
jae 0x863032
jae 0x78c302
xor edx, ebx
add eax, 0xa2b9ab31
cwde
rol edx, 1
xor edx, 0x2c90a8b3
rol dword [esp], 0xcf
bswap edx
cwde
rol edx, 1
inc ax
neg ax
xor ebx, edx
jmp 0x75fb5b

Function at 0xc0d7d1
Capabilities:
Authenticate hmac

Disassembly:
lea esp, [esp + 0x10]
jne 0x8dcc7f

Function at 0xc0dacf
Capabilities:
Encode data using xor

Disassembly:
neg eax
push 0xff9bfda0
xor ebx, eax
push 0x6cab0702
mov dword [esp + 0x20], 0xbb3b8517
call fcn.0070b0d4
inc eax
xchg ebp, eax
adc dword [edi + 0x41], 0xfffffff4
fisub dword [ebx - 0x1c2e2c2a]
loop fcn.00c0dacf
cmp eax, dword [esi - 0x42]
xlatb
wait
sbb byte [eax], 0x5f
push edi
xlatb
inc eax
and byte es:[edi], ah
or eax, 0xd6bb6c62
pop ebx
pop ebp
fcomp st(4)
mov bh, 0xd7
or dword [edi + 0x597cd7c9], 0xffffffed
xchg ebx, eax
pushal
fmul dword [0x28d62f3f]
jo 0xc0db96
in eax, 0xd5
inc ecx
invalid
retf 0xeac0
Function at 0xc0fa23
Capabilities:
Encrypt data using speck

Disassembly:
ror ecx, 1
dec ecx
bswap ecx
add dword [esp + 0xc], 0x6abe8117
jno 0xc640fa
add byte [eax], al
add byte [edi + 0x65], al
je 0xc0fa63
outsd dx, dword [esi]
jne 0xc0fa86
dec eax
popal
outsb dx, byte [esi]
insb byte es:[edi], dx
inc ecx
add byte [ecx + 0xffe6], al
and esi, 0xff
mov esi, dword [esi*4 + 0x8ad520]
jmp 0xd235e1
xor byte [ebx + 0x247cc166], ah
add dword [edx + 0x48], ebp
neg ecx
neg word [esp + 0xe]
sbb ecx, 0xc1ffdbb
mov dword [esp], 0x31bddd23
call fcn.00ce9fde
test al, 0x3a
sahf
dec esp
adc dword [ecx + 0x573758f6], eax
and ebp, dword [esi + 0xbc0a625]
jl 0xc6417f
fisttp dword [ebx + 0x3b]
loopne 0xc64117
pop eax
sub ch, bh
xchg edi, eax
cmpsb byte [esi], byte es:[edi]
sal dl, 0
add dword [edi + 0x6d129ed2], esp
rcr byte [ecx - 0x2d], cl
test byte [esi + 0x59], 0x1d
cmp eax, 0x58760ea3
aas
fistp dword [esi + 0x22]
sub ah, ah
idiv byte [edi]
test al, 0xc0
push eax
mov edi, 0x51ac5864
push edx
jp 0xc64169
cmp byte [eax + 0xd], bh
pop es
loope 0xc641a7
pop ebp
and esp, dword [ecx]
aam 0x30
fstp dword [esi + edi*8 - 0x4ef3214f]
or al, 0xb1
pop esi
into
sbb eax, dword [esp + 6]
ror cl, 0x43
not edx
rol edx, 1
xor ebx, edx
xchg byte [esp + eax - 0x524c02ff], cl
neg byte [esp + eax - 0x524c02ff]
add ebp, edx
call fcn.00cd5f99
shr ecx, 8
push 0x2002078a
call fcn.00c83cb0
loopne 0xd23575
mov eax, 0xa2e1c51d
mov dh, 0xd8
adc cl, byte [ecx - 0xeafd872]
pop esp
mov esi, dword [edi - 0x14f188c7]
mov ch, 0xb7
mov dh, 0x71
in eax, 0xb8
mov bh, 0xa3
or eax, 0xcdd8c584
jbe 0xd2366c
inc ecx
dec eax
lodsb al, byte [esi]
xor al, 0x76
clc
daa
sub byte [ecx], 0xb1
push dword [edi - 0x762fb43]
mov bh, 0xbc
scasb al, byte es:[edi]
xchg ebp, eax
xchg ebp, eax
xor dh, cl
repz ret 0x5e43
or al, 0x55
sub ebp, dword [ebp - 0x6508a93e]
movsd dword es:[edi], dword [esi]
xchg edx, eax
xor al, 0x42
dec ebx
invalid
Function at 0xc2311b
Capabilities:
Encrypt data using speck

Disassembly:
adc ecx, eax
neg ecx
cwde
bts edx, edx
jb 0xbe07d9
not ecx
or edx, eax
btr dx, ax
and edx, eax
rol ecx, 2
idiv al
neg ax
neg ecx
neg dl
adc ecx, 0xd4070a90
shr edx, 0xd1
adc eax, eax
dec dl
not ecx
xor ecx, 0x1f31a90a
and eax, eax
xor ebx, ecx
sar dx, 7
add ebp, ecx
mov ecx, 0xb97df27
lea ecx, [ecx*2 + 0x1389212a]
push ecx
mov ax, word [esi + eax*2 - 0x3fffc]
mov dx, word [edx + esi + 1]
xor cx, cx
xchg ch, cl
inc ecx
mov cl, byte [esi + ecx*2 - 0x556ffffe]
not byte [esp + 3]
adc esi, 4
sar dword [esp], 0x5f
shld ax, dx, cl
push 0xba089311
neg dword [esp + 4]
mov ecx, dword [esp + 3]
mov word [esi + ecx - 0x1ba], ax
mov edx, dword [esp + ecx*4 - 0x6e6]
mov word [esp + ecx*2 - 0x374], dx
sal cl, 0xa4
mov dword [esp + ecx - 0x1a0], ebp
ret 4
sal word [esp + 1], 0xc1
and ebx, 0xff
push 0x293c5985
inc word [esp + 5]
mov ebx, dword [ebx*4 + 0x8708c8]
shr ecx, 8
shl dword [esp + 8], 0xb
call fcn.00c49bcc
mov dword [esp + ecx - 0x1032], edx
mov dword [esp + edx - 0x42950a90], 0x45867822
neg eax
call fcn.00cf2ea9
mov ecx, 0x9ea2928c
mov ecx, dword [edi]
add edi, 4
mov eax, 0x211f9a87
xor ecx, ebx
movzx edx, ax
sub eax, eax
neg ecx
inc ax
shr edx, 0xcb
ja 0x7f5d10

Function at 0xc25a8d
Capabilities:
Encode data using base64

Disassembly:
mov eax, 0x9f2b093a
mov dword [ebp + 8], ebx
call fcn.00748397
dec ebx
mov ecx, dword [esp + edi - 0x682c7aad]
dec esi
mov dword [esp - 0x682c7aad], ecx
dec edi
lea edx, [edx - 0x682c7ab5]
dec ebx
mov dword [esp + edx - 0x682c7aad], ecx
inc ebx
mov ebx, dword [esp + ebp - 0x682c7aad]
shl dword [esp + edx - 7], 0x29
dec edi
lea ebp, [esp + ebp - 0x682c7aa9]
dec eax
not eax
dec edx
sar dword [esp + eax - 0x65ab26bd], 0x3f
mov ecx, 0x7bb8e903
xor ebx, ebp
dec ebp
lea ecx, [esp - 0x14d3e7d7]
jmp 0xd421e7
dec esp
and eax, dword [esp + edx - 0xa]
xor ebx, 0xd19a3005
dec ebp
xadd eax, esp
inc ecx
push esp
dec ebx
ror ebx, 2
inc edx
lea ebx, [ebx - 0x753ca21c]
dec esi
lea edi, [esi + ecx - 0x22434bd1]
not ebx
inc ecx
xor ecx, eax
dec edx
or dword [esp + 8], ebp
mov ebp, 0xb9085e33
rol ecx, cl
inc edx
xor dword [esp + 8], ebx
xor si, di
inc ebp
xadd bh, ah
dec edx
mov ebp, dword [esp - 7]
dec eax
arpl bx, bx
call fcn.0073f20c
mov ecx, 0x6d38370c
movzx eax, cl
movsx edx, ax
mov eax, dword [ebp + ecx - 0x6d38370c]
sal ecx, cl
xor ecx, ecx
adc ecx, dword [ebp + ecx + 4]
push ebx
btc edx, edx
cpuid
sbb ebp, 8
mov dword [ebp + 0xc], eax
jmp 0x77f0cd
Function at 0xc2bab1
Capabilities:
Encrypt data using speck

Disassembly:
sub edx, 0xc733c987
sub ecx, ecx
ror edx, 1
lea edx, [edx + ecx*4 - 0x46010c8a]
xor ebx, edx
movsx eax, word [esp + ecx*2 + 4]
mov dword [esp + ecx*8], 0xf839ffac
add ebp, edx
movsx edx, cl
add cl, byte [ecx + esi]
lea esi, [esi + edx + 1]
xor cl, bl
ror cl, 1
cbw
shl word [esp + edx + 6], 9
and eax, dword [esp + edx + 2]
not cl
sbb cl, 0x8c
dec eax
neg cl
bswap edx
ror cl, 1
xor bl, cl
dec dword [esp + edx*2]
xchg word [esp + edx*2 + 6], dx
lea ecx, [esp + ecx + 8]
mov dx, word [edx + ecx - 0x1c00]
lea ecx, [eax - 0x3e782dd7]
lea edi, [edi + ecx - 0x683dca5b]
mov word [edi + ecx - 0x683dca59], dx
bt cx, cx
sar dword [esp + ecx - 0x683dca55], cl
pop eax
pop eax
je fcn.008b5794
sti
xor ebx, eax
inc esp
xor al, byte [esp + edi*4]
mov esp, dword [edx - 0x23767a11]
sbb edi, dword [eax + 0x5e7777fb]
sub bh, al
push ecx
sub byte [edx + 0x44c75153], al
and al, 4
xor ebx, dword [esi + 0x648d6dbc]
and al, 4

Function at 0xc41051
Capabilities:
Encrypt data using speck

Disassembly:
cwd
dec eax
mov eax, dword [esi + 4]
inc edx
not edx
lea esi, [esi + edx*2 - 0x68adfffa]
jno 0xd1f1b4
mov ecx, 0xc8b5e014
mov esp, esi
pop ebx
mov eax, 0xd2276131
pop eax
movzx ebp, cl
inc ecx
pop edi
movzx esi, cl
je 0x7c9ef9
pop ebp
ror esi, cl
pop esi
or cx, 0xe91d
add cl, ch
push ecx
push dword [esp + 4]
popfd
mov edx, dword [esp + 8]
mov ecx, dword [esp + 0xc]
lea esp, [esp + 0x10]
ret
xor eax, 0x2ea6e913
push ecx
sub eax, 0xf3af35b9
imul ecx, edx
setb dl
bt cx, 0x35
rol eax, 1
not eax
xchg dh, cl
mov dword [esp + 4], ecx
sal edx, cl
xor ebx, eax
add ebp, eax
and edx, edx
jl 0x813117
add word [esp + edx - 0x3ffffffb], 0x9d98
mov dword [esp + edx - 0x40000000], ebp
ret 4

Function at 0xc44bd8
Capabilities:
Encrypt data using speck

Disassembly:
pop ecx
xor edx, 0xa8938426
neg eax
jnp 0xcd4cbd
mov edx, 0x4636ef31
mov eax, edx
mov ecx, dword [edx + esi - 0x4636ef31]
lea esi, [edx + esi - 0x4636ef2d]
or ax, ax
sbb eax, eax
not ax
xor ecx, ebx
bt ax, ax
add eax, eax
neg ecx
add edx, 0x2436f93d
bswap ecx
sar edx, 0x9a
rol ecx, 1
sub dx, ax
push edx
pop edx
lea ecx, [edx + ecx + 0x7d9b79f5]
ror edx, 0xd7
call fcn.008979aa
dec edx
and dword [esp], 0x50904b3e
sal word [esp + 1], 0xa
xor ebx, edx
movzx ecx, word [esp]
inc cl
lea eax, [eax*2 - 0x1ad38e74]
add ebp, edx
mov dword [esp + ecx - 0x37], ebp
ret