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

Disassembly:
call fcn.007f4af3
xor eax, 0x9008909b
inc cl
sub dx, cx
jae 0x79a098
rol eax, 1
not edx
push edx
xor ebx, eax
sar cl, 0x24
ror dword [esp + edx*2 - 0x2c44b5a], cl
adc esi, eax
imul dx, word [esp + edx*4 - 0x58896b2]
sub dl, ch
shr dword [esp + edx*2 - 0x2c542e0], 0x30
movzx eax, byte [edx + ebp - 0x162a170]
jae 0x8619d6
inc esp
movsx edi, bp
xor eax, 0x1ca04280
jmp 0x74b752
lea ebp, [ebp + edx - 0x162a16f]
dec byte [esp + edx - 0x162a16f]
adc edx, ecx
xor al, bl
xchg ecx, edx
inc al
push ecx
neg al
jmp 0x79fa94

Function at 0x81b1d6
Capabilities:
Encrypt data using speck

Disassembly:
push ecx
pushfd
mov ecx, 0xd29db31
mov ecx, dword [esp + ecx - 0xd29db2d]
mov dword [esp + 4], 0xe97c11a7
push dword [esp]
popfd
lea esp, [esp + 4]
call fcn.007aee31
xor ebx, edx
sal word [esp + 0xd], 0xca
add edi, edx
push 0xf89bf311
lea esp, [esp + 0x1c]
jmp 0x75a3e8
shr dword [esp + 0x10], 0x1b
jae 0xbb9c7e
sbb edx, 0x612a4eb4
jmp 0x78f8ca

Function at 0x81ba53
Capabilities:
Encode data using xor

Disassembly:
sar dx, 0x23
adc edi, 1
call fcn.008b0716
not dword [esp + ecx*8 - 0x74158]
lea esi, [esi + ecx - 0xe827]
xor edx, ebx
shl ecx, 0xf8
js 0x79bd65
ror edx, 2
movsx eax, cl
call fcn.00b3358b

Function at 0x81e6a9
Capabilities:
Authenticate hmac
Encode data using base64
Encrypt data using speck
Parse credit card information

Disassembly:
push edx
div dword [esp + eax - 0x5fe]
xor ebx, ecx
shr edx, 0xdb
adc edi, ecx
ror dword [esp + eax*4 - 0x247c], 0xb2
mov ecx, eax
rol cl, 0x44
pop edx
pop ecx
pop ecx
pop edx
pop edx
pop ecx
jb fcn.008001e8

Function at 0x81ee3b
Capabilities:
Encrypt data using speck

Disassembly:
mov edi, 0x6818efab
lea esi, [edi + edi*8 + 0x44af3c8d]
mov ebp, dword [ebp + edi - 0x6818efaf]
call fcn.00c6a8df
mov ecx, 0x6c16ea36
movzx edx, cx
mov edx, dword [ebp + edx*8 - 0x751b0]
shl cx, 7
mov ecx, dword [ebp + ecx - 0x6c161afc]
mov eax, 0x55a21193
lea ebp, [eax + ebp - 0x55a2118b]
cwde
mov dword [edx + eax - 0x1193], ecx
bt eax, 0x91
mov ecx, dword [eax + edi - 0x1193]
jae 0xb4fd9f
mov dword [esp], 0x392fa883
mov eax, 0x35a5e3ba
mov eax, dword [ebp + eax*2 - 0x6b4bc774]
push 0x20270432
lea esp, [esp + 8]
call eax
jmp 0x716174
mov edx, 0x3927e52e
sar dx, 0xd
lea edi, [eax + edi - 0x118f]
sbb edx, 0xddb93005
lea eax, [edx*4 - 0x2ef761ec]
xor ecx, ebx
and edx, 0x6c17e607
not eax
sbb ecx, 0x7a28a019
lea edx, [edx + eax*8 + 0x579eca0e]
bswap ecx
lea ecx, [eax + ecx - 0x1b1b6f77]
rol edx, 0xb8
cwde
inc eax
bswap ecx
call fcn.007ce4ef
call fcn.0080c8d6
mov ecx, 0x6b6679b
mov ecx, dword [edi + ecx*4 - 0x1ad99e6c]
mov edx, 0xada09597
add edi, 4
movsx eax, dx
sar dx, 0x25
xor ecx, ebx
sub ecx, 0x7a145d87
not ecx
sub edx, eax
imul al
ror ecx, 1
btc edx, 0x92
jb 0xc69cfb
adc ecx, 0x50dedb9
btr eax, edx
shl dx, 0x62
rol eax, 0xc6
xor ebx, ecx
add ebp, ecx
lea ecx, [edx + edx*2 + 0x22a90d29]
mov edx, dword [esi + ecx - 0x2b99e225]
lea esi, [esi + ecx - 0x2b99e221]
not eax
push edx
ror eax, 0x8f
popfd
not eax
mov edx, eax
jmp ebp
Function at 0x821ba7
Capabilities:
Encode data using xor

Disassembly:
sub eax, 0x8d974427
jmp 0xc2cff4
call fcn.00b6972c
push 0x408f470f
add esi, 4
ror dword [esp], 0x54
xor eax, ebx
xor eax, 0xc6358710
dec dword [esp]
js 0x788ac8
dec byte [esp + eax*2 - 0x1f1c81b9]
movsx edx, al
mov dword [esp + eax*2 - 0x1f1c81c0], edi
ret 0xc
sal dword [esp + eax - 0xa8cd], 0xcb
mov word [eax + esi - 0xa8d3], cx
btr ax, 0x9e
mov ecx, dword [edi + eax*8 - 0x54687]
xor ecx, ebx
ror ecx, 2
neg al
and al, byte [esp + eax - 0xa828]
sbb ecx, 0x98b95422
sar al, 0xe1
xchg edx, eax
push dword [ebx]
retf
clc
loope 0x821b6d
setl al
bswap ecx
cwde
push edx
dec al
rol ecx, 1
lea ecx, [edx + ecx - 0x1d8af516]
bts ax, dx
sal eax, 8
xor ebx, ecx
push edx
rol edx, 0x96
adc ebp, ecx
div word [esp + edx*2 - 0x54]
cwd
cdq
mov eax, dword [edi + edx + 5]
push edx
lea edi, [edi + edx*4 + 9]
xor eax, ebx
or edx, edx
movzx ecx, dx
sbb eax, 0xee89ecb4
dec dword [esp + edx*2 + 6]
bswap eax
lea ecx, [edx + edx*2 + 0x1436b23f]
dec eax
call fcn.00801054
mov dh, 0xee
mov al, byte [ecx]
push cs
stosb byte es:[edi], al
push ebx
jae 0x821c02
in al, 0x42
stosb byte es:[edi], al
push ebx
jae 0x821bc2
sub al, 0x46
stosb byte es:[edi], al
push ebx
jae 0x821bd8
mov bl, 0x56
push edi
cmc
sub edi, dword [0x144ee115]
sbb ebx, ecx
scasb al, byte es:[edi]
test al, 0x30
cmp cl, byte [ecx + 0x61]
invalid
ror eax, 1
neg eax
xor ebx, eax
not word [esp]
jmp 0xc76309
Function at 0x824fa6
Capabilities:
Encode data using base64
Encrypt data using speck
Parse credit card information

Disassembly:
ror byte [esp + 5], 0x63
adc cl, byte [esi + 2]
call fcn.00b9b7f5
mov eax, 0xd334082a
bswap eax
lea edx, [eax - 0x6c6b296e]
mov edx, dword [edi + eax*2 - 0x541069a6]
lea edi, [eax + edi - 0x2a0834cf]
xor edx, ebx
dec edx
call fcn.0075f01c
inc ecx
xor edi, 0xb406af36
inc edx
lea esi, [esi + edi - 0x1305a182]
dec eax
inc edx
xor esi, 0xe3257f36
inc cx
shr eax, cl
inc ecx
push esp
xor dword [esp + eax*4 + 0xf540], esi
inc ecx
rol dh, 0x27
inc ebp
mov esp, edx
not edx
inc ecx
pop esp
dec ebp
lea ebx, [ebx + ebp*4 - 0x2f4e06da]
inc ebp
add bl, bl
inc cx
dec edx
dec eax
arpl si, si
inc bp
inc sp
and ebp, ecx
dec eax
adc ebx, esi
dec ecx
add edx, 0xaca3ee18
cdq
inc ebp
or ch, ch
jmp ebx
mov dword [esp + edx - 0x1f], ecx
neg dx
inc eax
sar cx, cl
xor edx, edx
imul ecx, dword [esp + edx]
bswap eax
jno 0x85d268
mov edx, 0xa324753e
mov eax, dword [edi]
lea ecx, [edx - 0x3161ab4e]
bswap ecx
add edi, 4
call fcn.00880fc6
sub esi, 4
mov eax, 0x2411853e
call fcn.007c3b85
xor ebx, edx
sal byte [esp + 5], 0xe7
adc ebp, edx
and cl, ch
mov ax, word [esi]
xchg word [esp + 4], cx
jns 0x80141a
inc ecx
bt esi, eax
dec ebp
and edi, edx
inc ecx
xor esi, esp
inc cx
btc ebp, eax
lea esi, [esi + eax*4 + 0x52abf5f2]
inc ecx
btr esi, ebp
dec ecx
bswap edi
neg esi
shr edx, 0xbc
rol ebp, 0x88
dec esi
inc cx
or esi, 0xd6f7b8ad
jl 0x808677
mov edx, 0xe82cf3a0
movzx cx, byte [edi]
mov al, byte [edi + 2]
and dl, dh
sub dl, dh
adc dl, 0x34
not cl
not al
sbb dx, 0x5998
bts dx, 0x29
or cl, al
jmp 0x888b70
setae dl
sbb eax, edx
mov word [esp + ecx*2 - 0x18f9bb], cx
inc dword [esp + ecx*4 - 0x31f37f]
ror eax, 1
imul cx, cx
not cx
xor ebx, eax
sal ecx, 0xb1
bt edx, 0xa8
sbb edx, 0x9a38db3d
add ebp, eax
mov eax, 0x821e2e2b
xadd eax, ecx
add cx, 0x3c9b
pop ecx
pop ecx
pop eax
jns fcn.007e2cc2
mov word [edi + 2], cx
mov ecx, dword [ebp]
not dl
add ebp, 4
call fcn.00c704e3

Function at 0x828097
Capabilities:
Execute syscall

Disassembly:
mov dword [esp + edx - 0x3c1d], 0x308667a0
or edx, ecx
inc eax
not eax
sub ecx, 0xe0840bd
push edx
xor ebx, eax
neg cl
push ecx
sbb cl, 5
adc ebp, eax
pop eax
movzx eax, byte [esi + edx*4 - 0xf074]
lea esi, [edx + esi - 0x3c1c]
xor al, bl
xor al, 0x91
Function at 0x82905f
Capabilities:
Encrypt data using speck

Disassembly:
js 0x75cf5d
jl 0xb7144a
mov ecx, 0x89831101
mov eax, dword [esi]
mov ecx, dword [esi + 4]
push ebx
mov edx, 0xfe1d38a3
cpuid
sub esi, 8
mov dword [esi + 0xc], eax
mov eax, 0xa5058ead
mov dword [esi + 8], ebx
mov dword [esi + 4], ecx
mov dword [esi], edx
movzx ecx, al
pop ebx
xchg ecx, eax
mov eax, dword [ebp + eax*2 - 0x15a]
add ebp, 4
jmp 0xb5c0a8
btc eax, eax
rol dl, 1
jmp 0xc6c681
jle 0x8a2adf
lea ebp, [ebp + ecx*8 - 0x12c]
shl ecx, 0xae
lea edx, [ecx + ecx - 0x4853aa55]
xor eax, ebx
call fcn.008d8f3d
mov dword [esp], 0xb7062480
mov dword [esp], eax
jle 0x71b826
invalid
xor eax, ebx
movzx edx, cx
xadd cx, dx
lea ecx, [edx + edx*4 - 0x6a439949]
rol eax, 3
xadd edx, ecx
setae cl
dec eax
neg eax
or ecx, edx
shl edx, 0xb1
bswap ecx
sbb eax, 0xf715812b
not edx
xor ebx, eax
or ecx, edx
adc edi, eax
mov eax, edx
ror dx, 0x4e
jb fcn.0075bcd3
mov ecx, 0x43a7f83f
movzx eax, cl
mov ecx, dword [ecx + esi - 0x43a7f83f]
imul eax
xor edx, dword [esi + eax - 0xf7d]
lea esi, [eax + esi - 0xf79]
shl al, 0x22
adc al, al
adc ecx, edx
lea edx, [eax + eax*4 - 0x5b737e6e]
movzx edx, byte [edi + eax*4 - 0x3c20]
xor dl, bl
jmp 0x78ca86
dec ebx
call fcn.00769d9f
call fcn.0075f0b6

Function at 0x835997
Capabilities:
Encrypt data using speck

Disassembly:
popfd
push 0x2118899b
push 0xd200b6b1
mov edi, dword [esp + 8]
call fcn.007b35b5
lea edx, [ecx*4 + 0x7a327783]
imul cx, word [esp + ecx - 0x1012c4f6]
xor eax, 0xa8bc1892
mov dword [esp + ecx - 0x1012f645], edx
shl byte [esp + ecx - 0x1012f63b], 0xe4
shl word [esp + ecx*2 - 0x2025ec81], cl
lea eax, [eax + ecx*8 + 0x4c7c5784]
sal edx, cl
jne 0x839e62
add edi, 4
movsx eax, cx
xor al, ah
xor edx, ebx
ror eax, 0x67
xor edx, 0xdd950e02
shl cl, 0x21
btr eax, 9
sub al, ch
sbb edx, 0xa5a9af02
neg edx
sub al, ah
sal ecx, cl
ror edx, 3
ror al, 0x47
xor ebx, edx
btr eax, eax
push ecx
shr dword [esp + eax*2 - 0x6bffea96], 0x2f
adc ebp, edx
imul eax
mul byte [esp + edx - 0xb63fb7b]
mov dx, word [esi + edx*4 - 0x2d8fedec]
or ecx, 0xda217abb
mov ax, word [esi + 2]
mov cl, byte [esi + 4]
call fcn.00821044
mov dword [esp], 0x28196220
add ebp, 4
xor ecx, ebx
and dword [esp], 0xea332810
jl 0x76a02d
not ecx
ror ecx, 3
shr word [esp], 0xed
jnp 0xbbde3c
mov esp, esi
jmp 0x7069c3
call fcn.008734f3
mov ecx, 0xf89b17b0
call fcn.0078737c
bswap ecx
ja 0x8d2546
mov edx, 0xb91bea20
mov eax, dword [esi]
movzx ecx, dx
lea esi, [esi + ecx - 0xea1c]
bswap ecx
push ecx
xor eax, ebx
sub eax, 0xffa04539
call fcn.0081f7ae
Function at 0x83aa15
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
shrd edx, eax, cl
mov ecx, 0x6f21423e
mov dword [esi + ecx - 0x6f21423e], edx
mov edx, 0xaa845d9c
dec byte [esp + ecx - 0x6f21423a]
mov eax, dword [ebp + ecx - 0x6f21423e]
lea ebp, [ebp + ecx - 0x6f21423a]
dec ecx
xor eax, ebx
add dword [esp + ecx - 0x6f214239], 0xf8063915
mov dword [esp + ecx - 0x6f21423d], 0x3cacd723
and word [esp + ecx - 0x6f21423d], 0xf617
rol eax, 3
imul edx, edx
sar dword [esp + ecx - 0x6f214239], cl
not eax
sbb edx, dword [esp + ecx - 0x6f214239]
not dl
or dl, ch
dec eax
push ecx
rol ecx, cl
rol eax, 1
xadd byte [esp], dl
and dword [esp + 8], ecx
sbb eax, 0xb823d101
sar cx, cl
ror dx, 0xab
ja 0xb8031d
xor ebx, eax
ror dl, 0x26
xor cx, 0xb029
adc edi, eax
sar edx, cl
pop edx
pop edx
pop ecx
jmp edi
jb 0x769b92
mov eax, 0x6c38fc9a
mov ecx, eax
mov edx, eax
mov eax, dword [edi + edx - 0x6c38fc9a]
xadd cx, dx
shr dl, 0xa1

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

Disassembly:
rol ecx, 2
push eax
neg ecx
sal al, 0x42
sub al, al
inc ecx
sal al, 0x24
sbb edx, edx
xor ebx, ecx
or word [esp + edx*8 + 9], ax
add edx, 0x5011e50b
adc ebp, ecx
imul eax
shl dword [esp + edx - 0x85627a9], 0xd1
pop edx
pop eax
pop edx
pop ecx
jp fcn.007e2cc2
inc ecx
mov edi, 0xeb9763be
inc ebp
movzx ebx, bh
inc di
mov edi, dword [ecx + ebx*2 - 0x17c]
inc bx
mov eax, dword [ecx + ebx - 0xbc]
inc ecx
movsx ecx, bl
inc ebp
movzx esi, bl
inc ebx
mov cl, byte [ebx + ecx - 0xba]
inc ecx
movzx ebp, si
dec edi
lea ecx, [ebx + ecx - 0xba]
dec ecx
btc ebx, 9
inc ecx
push ebx
push ebp
inc cx
shld edi, eax, cl
inc esi
movzx ebp, word [esp + esi*8 - 0x5e4]
inc edx
movsx esi, word [esp + ebx - 0x2b3]
ror si, 2
inc di
mov dword [ecx + ebx*2 - 0x57c], edi
inc esp
movzx eax, ch
dec ecx
lea edi, [ebx + edi - 0x2c2]
dec esi
sbb ebp, dword [esp + ebx - 0x2ba]
inc cx
neg eax
inc edx
shl dword [esp + ebx - 0x2b4], 0x5c
inc edx
or esi, dword [edi + ebx - 0x2be]
inc ecx
neg ebp
inc ecx
xor esi, esp
inc ecx
push ebx
inc ecx
push ebp
inc edx
sar dword [esp + ebx - 0x2a5], 0x2a
xor esi, 0x86257287
inc edx
lea esi, [esi + ebx*8 + 0x30913f91]
dec ecx
lea ecx, [esi + ebp + 0x52297a25]
inc esp
bt ebp, esi
rol cx, cl
xor esi, 0x8c086703
inc ecx
push ebp
dec esi
xchg dword [esp + ebx - 0x2b8], ebx
lea esi, [esi + ecx*2 + 0x1d4be91e]
inc sp
add ebx, ebp
neg esi
dec esi
mov dword [esp + ebx - 0x9e], esp
inc esi
mov edi, dword [esp + ebx - 0xad]
inc edx
xadd dword [esp + ebx - 0xa4], ebp
inc ecx
dec esi
inc edx
xor dword [esp + ebx - 0x9e], esi
dec esi
mov esp, dword [esp + ebx - 0x9e]
movzx eax, cl
dec esi
xchg dword [esp + ebx*2 - 0x173], eax
inc edx
not byte [esp + ebx - 0x9f]
dec eax
arpl si, si
dec eax
add ebx, esi
inc eax
shl ch, cl
dec ebp
lea edx, [eax + ebp*8 - 0x62d14369]
dec edx
mov dword [esp + ebx*4 - 0x2f8], ebx
ret 0x20
Function at 0x83ec84
Capabilities:
Encrypt data using speck

Disassembly:
dec eax
mov edx, dword [esp + edx*2 - 0x507e9df6]
dec esi
mov dword [esp + ecx*2 - 0x507e9e16], eax
pop ecx
inc esi
xchg byte [esp + ecx - 0x283f4f0a], cl
dec esi
mov ebx, dword [esp + ecx*2 - 0x507e9fc0]
jmp 0xc63b70
not ecx
dec edx
mov ecx, dword [esp + ecx - 0x283f4fc8]
inc ecx
pop esi
inc esp
movzx esp, ax
dec edx
mov esi, dword [esp + ecx*2 - 0x507e9fb8]
call fcn.007e535e

Function at 0x840b48
Capabilities:
Authenticate hmac
Encode data using base64
Encrypt data using speck
Parse credit card information

Disassembly:
mov dword [esp + 8], 0x26b4fe1d
lea esp, [esp + 8]
call fcn.00c47f0d

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

Disassembly:
lea esp, [esp + 0xc]
je 0x8e74da
call fcn.008b6423
mov eax, 0x29b525b6
rol eax, 0xd7
jae 0x73e3fe

Function at 0x84b873
Capabilities:
Encrypt data using speck

Disassembly:
mov word [esi + ecx*8 - 0x6e08], ax
sal dword [esp + ecx - 0xdbd], 0x6c
pop edx
pop ecx
jbe fcn.007ce4d4
mov ecx, dword [edi]
add edi, 4
mov eax, 0x2013832f
cwde
bt eax, eax
xor ecx, ebx
cwde
add ecx, 0x77bcd9a6
ror ecx, 1
xor ecx, 0xc535f2a4
btr eax, eax
and al, 0xa4
bswap ecx
movsx edx, al
sal ax, 0xa3
xor ebx, ecx
btc edx, 2
push eax
jb 0x73c1d5
xor bx, ax
mov dword [esp + ecx - 0x3707], ecx
lea esi, [ecx + esi - 0x3709]
sar edx, cl
shr ecx, 0xc2
jnp 0x7abe39
jle 0x84b858
mov eax, dword [0x337c10db]
mov dl, 0x67
or bh, byte [eax]
push esp
xor esi, dword [edx + 0x107c3e67]
xor esi, dword [edx + 0x23400667]
clc
mov al, byte [0x9bbfb5cb]
mov dh, 0xdb
rcr ebx, cl
aas
and eax, dword [edi + 0x651654e9]
push ds
rcl dword [edi]
sbb byte [ecx], 0x1a
outsb dx, byte [esi]
pop edx
scasb al, byte es:[edi]
aad 0x9c
mul dword [eax - 0x72]
ret

Function at 0x84d6bf
Capabilities:
Encrypt data using speck

Disassembly:
or cl, 0x95
dec eax
push ecx
ror eax, 3
and ecx, 0xb5bc4393
call fcn.00ba2d4c
Function at 0x84eadf
Capabilities:
Encrypt data using speck

Disassembly:
shld edx, eax, cl
push 0xa0891a38
mov eax, 0xd9be08bc
shl word [esp + 2], 0xc6
mov dword [edi], edx
sbb dword [esp + 7], eax
mov edx, dword [esi]
dec word [esp + 2]
adc esi, 4
call fcn.00873f0c
mov ecx, 0x849e3a9b
dec ecx
mov dx, word [esi]
dec ecx
mov eax, 0xb81b44aa
or al, al
mov ax, word [esi + 2]
inc ecx
dec ecx
adc esi, 2
inc ecx
ror cl, 0x62
not dx
sub cx, cx
not ax
bswap ecx
or dx, ax
mov word [esi + ecx*2 - 0x13d08], dx
sub cx, 0xd32e
mov edx, dword [edi + ecx*2 - 0x196ac]
movsx eax, cx
lea edi, [ecx + edi - 0xcb52]
lea ecx, [eax + eax*2 - 0x469144e]
xor edx, ebx
shr eax, 0xdb
not eax
setns cl
inc edx
or ecx, 0x9b659bb
not edx
inc eax
jo 0x83fb91
sar cl, 0x27
rol edx, 2
call fcn.00797e8f
inc dx
movsx ecx, dl
rol ax, 1
jmp 0xbbbec4
shr edx, 0x10
lea esi, [esi + edx*2 - 0x350]
neg edx
setp cl
shr ecx, 0xa7
mov word [ecx + esi - 0x8e], ax
sal byte [esp + ecx*2 - 0x116], 6
mov eax, dword [esp + ecx*4 - 0x238]
neg eax
pop ecx
pop ecx
jle fcn.007e2cc2
mov dword [esp], 0xf45cbad
call fcn.00c134d4
pop eax
pop edx
pop eax
pop ecx
jb fcn.007a41b7
je 0x84eb03
mov word [ecx], es
int3
mov dl, 0x8f
sal dh, 0x1b
sbb edi, ecx
dec eax
fdiv qword cs:[edx]
dec ecx
lds ebx, [eax + 0x7e]
fdiv qword [edx]
dec ecx
wait
pop eax
inc esi
fdiv qword [edx]
dec ecx
mov bl, 0
cmpsb byte [esi], byte es:[edi]
mov ebp, 0x8bce4a38
dec esp
and eax, 0x8402ba00
xchg dword [esi], edi
lea ebp, [ebp + edx*2 - 0x7d0f0800]
sal dl, 0xe3
mov eax, edx
xor ecx, ebx
call fcn.0087c6b6
mov ecx, 0xcdb169a2
movsx edx, cl
add edx, 0xa8b5dd08
mov eax, dword [ebp]
mov cx, word [ebp + 4]
ror dl, 0x82
push edx
adc ebp, 5
xor word [esp + 2], dx
pop edx
neg edx
mov word [eax], cx
movzx ecx, dx
sal edx, 0xf1
lea esi, [esi + ecx - 0x235a]
xor edx, 0x69391e9a
mov edx, dword [esi + edx - 0x2f951e9a]
xor edx, ebx
lea edx, [edx + ecx + 0x6b312732]
and ecx, ecx
jae 0x8d0791
mov eax, 0x279b942f
mov edx, dword [edi + eax - 0x279b942f]
lea ecx, [eax + eax + 0x588af92c]
mov eax, dword [edi + eax*2 - 0x4f37285a]
mov cl, byte [edi + 8]
push 0x1d095c1c
push 0xde10b6a9
not word [esp + 6]
add edi, 6
jmp 0xc5eaf9
lea eax, [ecx + ecx*4 - 0x3dd3e5ed]
rol edx, 3
shl cx, 0xc3
xadd eax, ecx
xor edx, 0x6924d504
add eax, 0xc63eaeb7
setle cl
rol edx, cl
dec cx
bts cx, 7
xor ebx, edx
bts ecx, ecx
adc edi, edx
cdq
neg dx
jmp edi
or cx, word [esp + edx - 0x1a7c814]
xor bx, ax
bt cx, 0x94
jb 0x816fc5
add esi, eax
mov eax, 0x370320a0
and dl, dl
mov dword [esp + edx - 0x10001], esi
ret
jmp 0x7b3a8d
Function at 0x84fe09
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
shl eax, 0xa5
mov eax, dword [edi + eax - 0x4b47135c]
jb 0xb664db
call fcn.008e52e1
sub esi, 4
mov ecx, dword [esi]
xor ecx, ebx
inc ecx
mov eax, 0xf6be4594
mov edx, eax
imul al
bswap ecx
or dl, 0x2b
not dl
shl edx, 0xd2
not ecx
jns 0xbaa037
sub edx, 0x971008be
rol edx, 1
cbw
xchg cx, ax
bt ecx, 0x83
inc edx
lea ecx, [eax + eax*4 - 0x7a56726a]
ror edx, 1
xor ebx, edx
xor cx, cx
lea ecx, [ecx + eax + 0x71a82900]
mov dword [esp + eax*2 - 0x216ac436], 0x8fba0280
adc ebp, edx
movzx edx, byte [eax + edi - 0x10b5621d]
or eax, ecx
sete cl
and byte [esp + ecx - 0x5b918af9], ah
lea edi, [edi + ecx - 0x5b918aff]
sub eax, dword [esp + eax - 0x5bb5eb19]
jp 0x755320
rol al, 0x66
xor dl, bl
pop eax
add eax, 0x3fa16a
jmp eax
ror cl, 1
inc cl
shr eax, 0x9c
cdq
xor bl, cl
and edx, 0x56b0feb1
lea ecx, [esp + ecx + 4]
push edx
mul dx
cwd
xor dx, word [ecx + eax*2]
lea ebp, [ebp + eax*2 - 2]
cbw
movsx ecx, al
mov word [eax + ebp], dx
neg eax
pop edx
pop edx
jp fcn.008c0304
mov ecx, 0x7f275c27
mov eax, dword [ebp + ecx - 0x7f275c27]
lea ebp, [ebp + ecx - 0x7f275c23]
imul ecx, ecx
call fcn.0088d116
inc ecx
mov eax, 0x300953aa
inc ecx
movsx eax, al
dec ecx
lea edi, [eax + edi - 0x300953b2]
dec eax
cdq
dec ecx
mov eax, dword [eax + edi - 0x300953aa]
inc esp
mov esi, edx
mov ebp, edx
dec ecx
xor eax, esp
call fcn.00c600b9
bswap eax
rol ecx, 1
or dx, dx
inc ecx
not edx
imul edx
ror edx, 0x4a
xor ebx, ecx
xor eax, edx
bt edx, 0xb1
sbb eax, 0x519c33ae
adc edi, ecx
lea ecx, [edx + eax*4 + 0x6315890]
bts cx, 0xaf
cbw
lea esi, [esi + eax - 0x42b30057]
shl eax, cl
movzx ecx, byte [esi + eax - 0x2b000000]
xor cl, bl
push edx
and edx, 0xe2008e14
shr dword [esp + eax*2 - 0x56000000], 0x49
not cl
sbb edx, edx
add edx, 0x821ef231
ror cl, 1
sal word [esp + eax*2 - 0x56000000], 0xca
sets byte [esp + eax - 0x2afffffe]
xor cl, 0xaa
sub cl, 0x81
jmp 0x85a209
Function at 0x85054f
Capabilities:
Authenticate hmac
Encode data using base64
Encrypt data using speck
Parse credit card information

Disassembly:
lea esi, [esi + eax - 0x5034e625]
xor ecx, ebx
bt edx, eax
sbb edx, 0x480ae18c
adc eax, edx
bswap ecx
or edx, 0x169fc939
cwd
dec ecx
xchg dx, ax
xor edx, edx
add eax, edx
xor ecx, 0xec9cf23e
not dl
neg ecx
dec ecx
not eax
jmp 0xb92914
call int.007cc4ce
mov edx, 0x8389b0a0
btc dx, dx
jae 0x8164dc
mov edx, dword [edi]
mov cl, byte [edi + 4]
mov eax, 0x5034e629
shl edx, cl
movzx ecx, al
add ecx, ecx
mov dword [eax + edi - 0x5034e627], edx
jae 0x8eba08
inc esp
mov ebp, dword [edi + esi - 0x1b]
dec ecx
neg edx
dec eax
mov dword [esp + esi*2 - 0x36], eax
inc ebp
xor ebp, esp
inc ebp
and dh, bl
inc ecx
dec ebp
inc ecx
bswap ebp
inc ecx
not ebp
inc ecx
movsx ecx, dh
inc ecx
rol ebp, 1
dec esi
lea eax, [ecx + esi*4 + 0x6fb488b7]
dec esp
mov dword [esp + esi*4 - 0x64], esp
inc esp
xor dword [esp + esi - 0x13], ebp
dec esp
mov esp, dword [esp + esi*2 - 0x2e]
xor word [esp + esi - 0x15], si
je 0x75df99
dec ebp
arpl bp, bp
dec eax
lea ecx, [edx + 0x2896e78e]
cdq
inc ecx
push esi
dec ecx
adc ebx, ebp
dec esp
mov dword [esp + esi*8 - 0xc8], esi
sal dword [esp + esi - 7], 0x5f
inc ecx
idiv edi
pop ecx
inc ecx
pop edi
pop ecx
jmp fcn.008a1785
movsx edx, cl
dec ecx
mov ecx, dword [esi + ecx*4 - 0x144]
jae 0x73efb6
mov eax, 0xb19c4a01
mov ecx, dword [ebp]
shl eax, 0xb
and ax, ax
adc ebp, 4
push eax
xor ecx, ebx
ror al, 0xc1
inc ecx
add dword [esp], eax
and al, byte [esp + 2]
ror ecx, 1
call fcn.00b541ad
or dx, 0xe31f
xor ebx, ecx
mul al
add ebp, ecx
sar dx, 0x84
setp dl
rol dl, 0xa4
mov eax, dword [edi + edx*8 - 0x7f07e]
mov ecx, dword [edi + edx*2 - 0x1fc1a]
adc eax, ecx
movsx ecx, dx
lea ecx, [edx + ecx*4 - 0x2a542755]
mov dword [edi + edx*4 - 0x3f83a], eax
xor dx, cx
and edx, edx
lea edi, [edx + edi - 0x30e5]
movsx eax, dl
xchg ecx, eax
add ecx, ecx
jmp ebp
Function at 0x855830
Capabilities:
Encrypt data using speck

Disassembly:
mov esi, dword [esi*4 + 0xc220b0]
call fcn.00876d3d
ror ecx, 3
mov edx, eax
bswap ecx
sar edx, 0x88
dec ecx
call fcn.00799ba8
mov ecx, 0x7f23dd2d
movzx edx, cx
shl dl, 0xa1
mov edx, dword [ebp + ecx - 0x7f23dd2d]
lea ebp, [ebp + ecx - 0x7f23dd29]
xor edx, ebx
call fcn.00c07823
mov eax, 0x2ebee9b1
mov edx, dword [ebp + eax - 0x2ebee9b1]
shr ax, 0x2a
movzx ecx, al
lea ebp, [eax + ebp - 0x2ebe0036]
inc cx
bts eax, eax
xor edx, ebx
neg edx
ror edx, 1
btc ecx, eax
jb 0xc45e26
neg edx
shl ecx, cl
sar cx, 0xa3
rol edx, 3
imul eax, ecx
neg edx
xor ebx, edx
dec ecx
bswap ecx
add edi, edx
cdq
or edx, edx
mov esi, dword [esi]
ja fcn.00b6be0d
mov edx, 0xdd2c829a
mov edx, dword [ebp]
mov eax, 0xa50fdd25
shr ax, 0xa9
adc ebp, 3
movsx ecx, ax
xor edx, ebx
lea eax, [eax + 0x711d9901]
inc ecx
add eax, 0xf8255f3b
xor edx, 0xef8ded84
inc ax
rol edx, 1
sub edx, 0xaca6418e
shr al, 0xa6
and eax, 0xcf0b089a
shl ecx, 0x72
rol edx, 1
sar eax, 0xb2
ja 0xc200ca
push eax
xor ebx, edx
sub dword [esp + eax - 0x380], ecx
shr ecx, 0xc2
adc edi, edx
idiv byte [esp + eax*2 - 0x700]
mov edx, dword [esi + eax - 0xf9]
ror ecx, 0x6e
mov eax, dword [eax + esi - 0xf5]
or cx, 0xb83e
seta cl
lea esi, [esi + ecx*2 - 0x171fe]
rol cx, 0x67
sbb cl, 0xbc
not edx
xor byte [esp + ecx*8 - 0x400fd], cl
neg ecx
sar ecx, 0x31
xor eax, ecx
sub ecx, ecx
setae byte [esp + ecx]
shl cl, 0x22
or edx, eax
mov dword [esi + ecx], edx
rol byte [esp + ecx*2 + 3], 0x62
movsx eax, cx
xadd byte [esp + eax], al
mov dword [esp + ecx*2], edi
ret
inc edx
shr cx, 0x2e
not edx
jae 0x86b661
adc dword [0x213260cd], 0x9c74297d
xor eax, 0x5c21cd21
pushfd
xor eax, 0x44056521
pushfd
xor eax, 0x5c3dfd21
pushfd
xor eax, 0xd4ade521
pushfd
xor eax, 0x74114d21
pushfd
xor eax, 0x6c49cd21
pushfd
xor eax, 0x8e8cf521
pop eax
xadd dword [esi], esp
scasb al, byte es:[edi]
xchg edx, eax
hlt

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

Disassembly:
inc esp
mov edi, dword [esp + edx*2 + 0x4df5ab2a]
dec esp
mov dword [esp + edx + 0x26fad599], esp
dec esp
mov dword [esp + edx + 0x26fad591], eax
xor dword [esp + edx + 0x26fad599], eax
inc dword [esp + edx*2 + 0x4df5ab22]
dec eax
sar ecx, 0x67
jp 0x896b2f