joyce8/EMBER2024-capa huggingface dataset:
Function at 0xc05644
Capabilities:
Authenticate hmac
Encode data using base64
Encrypt data using speck
Parse credit card information

Disassembly:
or eax, eax
xor edx, ebx
sub ecx, ecx
neg edx
dec ax
sub edx, 0x90b6e425
inc cx
sub al, 0xb9
neg edx
mov dword [esp + ecx*8 - 8], eax
rol edx, cl
sal eax, 0xf3
neg ecx
xchg ecx, eax
xor edx, 0xb1b65a30
call fcn.00b3e21b

Function at 0xc05afb
Capabilities:
Encrypt data using speck

Disassembly:
mov dword [esp], 0x585708a
jmp 0x71428e

Function at 0xc0760c
Capabilities:
Encode data using base64

Disassembly:
mov dword [esp + edx - 0x4d8a6e63], 0x39042105
not ecx
imul edx, edx
push edx
ror ecx, 1
push edx
ror word [esp + eax*2 - 0x1fe04], 0x83
push edx
xor ecx, 0x743d7c16
xor ebx, ecx
xadd byte [esp + eax*8 - 0x7f816], ah
and byte [esp + eax - 0x54fd], 0x8a
adc ebp, ecx
mul dword [esp + eax*2 - 0xa9fa]
bt eax, 0x86
xor dword [esp + edx - 0x12ed], 0xe786bf17
movzx edx, byte [esi + edx - 0x12ef]
bswap eax
adc word [esp + eax*2 - 0x1e180610], ax
jno 0x850ad1
lea esi, [esi + eax*2 - 0x1e180613]
lea ecx, [eax*4 + 0x347f99]
div cl
xor dl, bl
inc dl
sal word [esp + eax*2 - 0x1e180bfc], 6
ror dl, cl
xor ecx, eax
ror word [esp + eax - 0xf0c0600], cl
adc dl, 0xd
sar word [esp + eax*4 - 0x3c301805], cl
dec ecx
xor dl, 0xf
or eax, ecx
shl cx, cl
adc dl, 0xaf
rol dl, 1
lea eax, [ecx + 0x2ab6cd3b]
neg dl
push eax
not dl
not eax
call fcn.00b6bd1c
adc ecx, ecx
mov edx, dword [edx + ebp - 0x76]
sal ecx, 0x3f
sal cx, 0x4b
jb 0x80bbee
lea ebp, [ebp + ecx*2 + 4]
xor edx, ebx
movsx eax, cl
call fcn.00b6d0a9
xor ebx, edx
movzx eax, cl
add edi, edx
sub ecx, ecx
mov dword [esp + ecx*4], ecx
movzx edx, word [ebp + ecx*4 + 4]
ror dword [esp + ecx + 4], 0x75
lea ebp, [ebp + ecx*2 + 6]
call fcn.00828869
mov edx, dword [esi]
mov cl, byte [esi + 4]
mov eax, 0x25ac24ba
add al, ah
lea esi, [esi + eax*2 - 0x4b5849ba]
btc ax, ax
add eax, 0x28215e8e
shr edx, cl
mov dword [esi + eax - 0x4dcdc36c], edx
mov edx, eax
xchg edx, eax
mov ecx, dword [ebp + edx - 0x4dcdc36c]
ror edx, 0x18
lea ebp, [ebp + eax - 0x4dcdc368]
shr edx, 0x15
lea edx, [eax*8 - 0x3652167d]
xor ecx, ebx
lea eax, [edx + edx + 0x51905513]
not ecx
or dl, dl
xchg edx, eax
neg dx
rol ecx, 2
rol edx, 0x26
sub al, 0x87
neg ecx
add dx, dx
sbb ecx, 0xc9129f99
btr dx, dx
neg edx
xor ebx, ecx
bswap edx
add edi, ecx
jmp 0x871457

Function at 0xc07823
Capabilities:
Encode data using xor

Disassembly:
mov eax, dword [esi + ecx*2 - 0x58885474]
shr ecx, 0xc1
dec cx
lea esi, [esi + ecx*4 - 0x58885470]
adc edx, eax
xor cx, cx
not cx
mov dword [esi + ecx*2 - 0x2c45fffe], edx
call fcn.008662c9
btc ecx, ecx
mov dword [esp + ecx - 0x7f23fd2d], ecx
xor edx, 0xc82a1ab8
rol dword [esp + ecx - 0x7f23fd2d], cl
dec ecx
dec edx
lea eax, [ecx + ecx*4 - 0x15d19b6d]
sar dword [esp + ecx - 0x7f23fd2c], cl
neg edx
sal cl, 0xe5
lea edx, [edx + eax - 0x4f4a2d34]
push ecx
cwde
xor ebx, edx
lea ecx, [ecx + ecx*4 - 0x4f6fc944]
neg word [esp + ecx*2 - 0x58885472]
dec word [esp + ecx*2 - 0x58885472]
add edi, edx
mov edx, ecx
mov edx, dword [esi + ecx*2 - 0x58885478]
add ax, ax
ja 0x78cab6
Function at 0xc1b183
Capabilities:
Encrypt data using speck

Disassembly:
imul edx, dword [esp + edx*4 - 0x1698]
add dl, 0x19
lea ebp, [ebp + edx*2 - 0x2a1bfe04]
cmovb edx, eax
mov word [edx + ebp], cx

Function at 0xc2e976
Capabilities:
Encode data using xor

Disassembly:
inc esi
movzx esi, byte [edi + edx - 0x48b5b029]
inc ebp
xor dh, ah
inc ecx
rol dh, 1
inc ecx
inc dh
inc ecx
xor dh, 0xa6
dec esi
mov dword [esp + edx - 0x48b5b028], edx
dec edx
dec dword [esp + edx - 0x48b5b028]
inc ecx
movsx eax, dl
inc ecx
rol dh, 1
inc esp
movzx ebx, al
dec edx
lea ecx, [edx*2 - 0x78cb21c4]
jmp 0xc36bae
inc ecx
inc dh
inc bp
imul edx, ebx
inc ecx
not dh
inc ebp
xor ah, dh
bswap ecx
dec esi
lea esi, [esp + esi + 8]
inc esp
movzx edi, cl
dec ebx
lea ebp, [edx + ebx*2 + 0x252e1b9b]
inc ebp
mov eax, ebx
inc edi
mov eax, dword [esi + edx - 0x48b58640]
inc ecx
mov esi, 0xe7169fb3
dec ecx
dec edi
or ecx, eax
inc ebp
mov ebp, eax
dec eax
lea esi, [eax - 0x7d756480]
inc eax
shl dh, 0xa1
inc edx
mov cl, byte [eax + ecx - 0x28]
inc si
sbb dword [esp + edx - 0x48b58640], ebx
inc edx
ror byte [esp + edx - 0x48b5863b], 0xe3
inc ecx
pop edx
inc ecx
shl ebp, cl
inc ecx
dec esi
inc edi
mov dword [edx + ecx - 0x48b5b000], ebp
shl ax, 0x2e
dec esi
lea ecx, [eax + ecx - 2]
rol ebp, 0x37
inc ecx
shr dh, 0x46
inc ecx
mov ebp, dword [edx + edi - 0x48b5b003]
mov ecx, esi
dec ecx
lea edi, [edx + edi - 0x48b5b003]
mov edx, 0xa2ca9a2
dec esp
lea ebp, [edx*2 + 0x652c9a1e]
sar cl, 0x61
inc ecx
xor ebp, esp
xor eax, esi
inc ecx
dec esi
lea ebp, [esi + ebp - 0x4e4a25f4]
push edx
dec ecx
dec ebx
neg ebp
inc edx
add dword [esp + ebx*2 - 0x4a], 0xe699aa91
inc edx
mov byte [esp + edx - 0x48b5affa], dl
inc dx
rol dword [esp + ebx - 0x27], cl
sbb al, 0xd9
not ebp
dec ebp
bt edi, ebx
cwd
rol ebp, 2
dec eax
bt eax, edx
lea ebp, [ebp + eax*2 - 0x16f9d27f]
dec eax
neg esi
bswap ebp
dec edx
neg dword [esp + edx - 0x48b5affe]
inc ecx
xor bl, 0x23
inc edx
lea ebp, [ebp + ebx - 0x170deaae]
inc ecx
mov eax, 0xa6987900
dec ebp
add esi, edi
inc ecx
inc bh
dec esi
mov dword [esp + ebx - 4], esp
call fcn.007602bc
stc
mov ecx, 0x2185bb35
add eax, 0x82473c5d
and dword [ebp - 0x7db8abf7], eax
and ebp, ebp
loope 0xc36c76
inc edi
and byte [ecx], 0xfd
std
mov word [edi - 0x7e], es
and dword [0x82477c2d], esi
and dword [ebp + 0x2d], eax
insb byte es:[edi], dx
inc edi
and byte [ecx], 0xf5
int1
fadd qword [edi - 0x7e]
and dword [ebp - 0x477c5984], eax
ror dword [esi + 0x26], 0x49
inc ebx
popal
xchg dword [ebx + 0x11], esp
outsb dx, byte [esi]
mov bl, 4
add byte [eax], al
add byte [esi - 0x7e], ch
pop esi
add eax, 0x5726b869
test edx, edi
invalid
Function at 0xc302a2
Capabilities:
Encrypt data using speck

Disassembly:
xor ebx, ecx
and ebx, 0xff
push 0xe520d995
mov ebx, dword [ebx*4 + 0x830cc4]
shr byte [esp + 3], 0xe3
mov dword [esp + 4], 0xa48fd32a
shr ecx, 8
xor ecx, ebx
push 0x4e8bb4bc
inc word [esp + 0xa]
sal byte [esp + 0xb], 0xa3
inc eax
neg dword [esp + 5]
push 0x3aa0ec84
jne 0xc3d757
mov edx, 0xd1acd811
movzx cx, byte [esi]
sub dx, 0xb189
mov al, byte [esi + 2]
sal dl, 0x46
call fcn.00c1ea34
dec ecx
mov esp, ecx
inc ecx
movsx ebp, di
inc ebp
movzx edx, di
pop ebx
inc esp
movzx ebp, bp
inc ecx
pop edi
inc ecx
push ebp
inc esp
and dword [esp + ebp*2 - 0x4c35], ebp
dec esp
mov edx, dword [esp + ebp*4 - 0x9864]
dec esp
mov ebp, dword [esp + ebp - 0x260b]
movzx eax, byte [esp + ebp*4 - 0x986c]
dec esp
lea ebx, [ebp + eax*4 + 0x3b06a914]
push dword [esp + 0x18]
popfd
dec eax
lea eax, [eax + eax*4 + 0x6b6a296]
jmp 0xb91601
xor ecx, 0x301df225
push 0x9e91b313
xor word [esp + 7], 0xc4b2
dec edx
not byte [esp + 0x12]
lea esp, [esp + 0x14]
jne 0x855fd3
call fcn.00b41748

Function at 0xc30350
Capabilities:
Encrypt data using speck

Disassembly:
ror ecx, cl
xor eax, ebx
mov dword [esp + ecx - 0x80000000], ecx
mov edx, ecx
mov word [esp + edx - 0x7ffffff8], dx
not eax
call fcn.00b3cdeb

Function at 0xc3d127
Capabilities:
Encrypt data using speck

Disassembly:
add ebp, eax
or dl, dh
mov eax, 0x618df89
cdq
movzx ecx, byte [edi + edx + 5]
not edx
add dword [esp + eax - 0x618df83], eax
lea edi, [edi + eax - 0x618df83]
jle 0x7be258
xor cl, bl
shl al, 0xc4
adc cl, dl
idiv dword [esp + eax - 0x618df84]
rol cl, 1
dec eax
dec dword [esp + 8]
dec edx
add cl, 0xa4
shl dword [esp + 5], 0xeb
neg cl
ror word [esp + 8], 0xcd
xor dword [esp + 5], eax
dec cl
xor dword [esp + 5], edx
xor bl, cl
ror eax, 0x57
lea ecx, [esp + ecx + 0x10]
pop eax
mov eax, dword [ecx]
rol dword [esp + 6], 0x19
add byte [esp + 6], dh
mov dword [esi - 8], eax
adc esi, 0xfffffff7
movzx eax, dl
pop eax
pop ecx
pop eax
jmp fcn.007e2cc2

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

Disassembly:
not edx
not eax
mov dword [esp + ecx - 0x82008d], eax
xor ebx, edx
neg dword [esp + ecx*2 - 0x104011a]
call fcn.0073435e
Function at 0xc47c37
Capabilities:
Encrypt data using speck

Disassembly:
pop eax
pop eax
jne fcn.007e2cc2
xor eax, 0xd5230191
imul cx, cx
not edx
xor ebx, eax
btr dx, dx
adc edi, eax
movzx eax, cx
xchg ah, dl
push ecx
movzx ecx, word [esi + eax*2 - 0x1fe06]
lea esi, [esi + edx - 0x36372b06]
bt edx, 0x96
xor cx, bx
bt edx, edx
xor cx, 0x2617
bswap eax
shl al, 0x65
ror cx, 1
shr ax, 0xa6
not cx
setbe dl
imul dword [esp + eax - 0xff0000]
sbb cx, 0x5694
btr ax, 0xab
xadd dword [esp + eax], edx
call fcn.0071926f
ror eax, 1
mov dword [esp + ecx*2 - 0x2d6f41fe], ecx
sal word [esp + ecx - 0x16b7a0fd], 0x8a
sbb eax, 0xce001416
ror eax, 1
sal edx, 0xe9
xor eax, 0x768f68a0
sub cx, dx
sal cx, 0xc6
xor ebx, eax
sal dword [esp + ecx - 0x16b73fc0], 0xb2
adc ebp, eax
push edx
movzx eax, byte [edi + ecx - 0x16b73fc0]
neg dword [esp + ecx*4 - 0x5adcfefe]
lea edi, [edi + ecx - 0x16b73fbf]
bswap edx
xor al, bl
inc al
xor ecx, dword [esp + ecx*4 - 0x5adcfefd]
add ecx, dword [esp + edx*4 - 0xa2f9b7]
rol al, 1
xor ecx, 0x4db41695
shl dl, 5
push ecx
inc al
not ecx
rol al, 1
xor al, 0x1f
pop edx
dec cx
xor bl, al
shr word [esp + ecx - 0x5b91eb11], 0x6d
lea esi, [esi + ecx - 0x5b91eb14]
sbb ecx, ecx
not ecx
xadd byte [esp], cl
mov word [esi], ax
xor byte [esp + 4], 0x30
jne 0x723951
mov edx, 0xd7256e9a
mov ecx, edx
mov ecx, dword [ebp]
mov eax, 0xf2b3eb90
add ebp, 4
div eax
bswap edx
xor ecx, ebx
shl al, 7
call fcn.0087631d

Function at 0xc49187
Capabilities:
Encode data using base64
Encrypt data using speck
Parse credit card information

Disassembly:
mov dword [esp + eax + 4], eax
sub cl, 0x82
xor cl, 0x16
mov dword [esp + eax], eax
rol cl, 1
dec dl
jno 0x85decc
lea eax, [eax + edx + 0x7a1566a0]
rol eax, 2
call fcn.00b72fb2
ror ax, 0xc
dec ecx
cwde
or ax, ax
add eax, eax
neg ecx
cbw
shl dx, 0xc9
sal al, 0x26
xor ebx, ecx
ror edx, 0x6d
rol edx, 4
lea edx, [edx + edx*8 + 0x3a2a5185]
adc esi, ecx
sub dl, ah
movzx dx, byte [edi + edx - 0x3a2a537d]
cbw
movsx ecx, al
lea ecx, [eax + eax*8 + 0x772d5d0b]
xor al, byte [edi + ecx - 0x77245d09]
sar cl, 0xa2
xor ecx, ecx
neg cl
lea edi, [edi + ecx*4 + 2]
ror cl, 0x26
sub cl, ch
sbb ecx, ecx
adc dl, al
lea eax, [ecx + ecx*2 - 0x2ed6d9fe]
mov word [ecx + edi], dx
movsx edx, ax
or ecx, edx
jmp esi
Function at 0xc49b43
Capabilities:
Encrypt data using speck

Disassembly:
add ebp, 1
mov eax, 0x7f8bf131
btr ax, ax
xor dl, bl
btr eax, eax
add eax, 0xaa006c0a
rol al, 0xc1
sbb dl, 0x23
imul eax, eax
push eax
xor al, ah
not dl
ror dl, 1
dec dl
btc eax, 0x88
xor bl, dl
sal eax, 0xfd
lea edx, [esp + edx + 4]
mov word [edx], cx
xor word [esp], ax
call fcn.0077551f
jl 0x798bdd
push 0xf42427bb
push 0x1e09bd93
neg edx
jmp 0xb374d8
push eax
inc esp
xor dword [esp + esi - 0xd], ebp
and word [esp + esi*4 - 0x53], ax
dec esp
mov esp, dword [esp + esi - 0xd]
dec edx
lea edx, [esi + eax + 0x3d00e323]
inc ebp
movsx edx, al
dec eax
mov dword [esp + esi - 0xd], eax
dec ebp
arpl bp, bp
inc esp
adc dword [esp + eax*2 - 0x8429], edx
inc esp
xchg dword [esp + esi - 0xf], edx
dec ecx
adc ebx, ebp
inc bp
mov ebp, dword [ecx + esi*4 - 0x54]
call fcn.00c759ec
mov edx, 0x1b176c98
xor edx, edx
adc edx, dword [edx + ebp]
add ebp, 4
push 0xdb37b6ab
xor edx, ebx
not word [esp + 2]
shr dword [esp], 0x52
ror edx, 1
jmp 0x74ecba
mov ecx, 0x7fb097a3
lea edx, [ecx*2 + 0x29310705]
mov edx, dword [ebp + edx - 0x2892364b]
movzx eax, cx
or eax, ecx
lea ebp, [ebp + ecx - 0x7fb0979f]
xchg ah, cl
sar ax, 0x61
bts eax, ecx
xor edx, ebx
dec eax
dec edx
add ecx, ecx
lea ecx, [eax*4 + 0x6a88399f]
not edx
rol edx, 3
bswap ecx
shr cx, 0x41
sal ax, 7
not edx
js 0xb4afc5
pop esi
inc esp
clc
mov esp, dword [ecx]
call 0x8c8a5d27
and dword [eax + 0x2c], esi
inc ecx
push cs
mov word [ecx], fs
sbb byte [ecx + 0xe], dl
mov word [ecx], fs
fsub st(0)
mov cl, 0xe
mov word [ecx], fs
mov byte [eax], bh
push ecx
push cs
mov word [ecx], fs
push 0x8c0ef9b0
and dword [eax - 0x73f16634], esp
and dword [eax], esp
loope 0x7b937a
retf 0xc1b6
jmp 0xc19309
neg edx
shl eax, 0xa2
inc edx
bswap edx
rol edx, 1
call fcn.00c69ccb
jmp 0x7b9318
pop eax
jmp 0x73a607

Function at 0xc4cd41
Capabilities:
Encrypt data using speck

Disassembly:
lea esp, [esp + 4]
call eax
mov esi, 0xeabd2998
mov ebp, dword [ebp - 4]
and esi, esi
lea ebx, [esi - 0x45e0a856]
mov dword [ebp], eax
movzx edi, bx
movzx ecx, bx
jp 0xbb5cf8
mov edi, ebp
mov ebp, esi
pop ebx
pop esi
and ebp, ecx
imul cx, bp
pop ebp
lea eax, [ecx + ecx + 0x708a131a]
jmp esi
Function at 0xc54d12
Capabilities:
Encode data using xor

Disassembly:
movzx ebx, byte [ecx]
call fcn.00721dc3
sbb eax, 0x17dbadbe
jnp 0x88c23d
mov esi, 0xf631367
dec edx
mov esi, 0x7b171d67
dec edx
pop ss
jnp 0x88c249
mov esi, 0x680b1767
xchg byte [edi], ch
out 0xe3, eax
nop
aaa
rol byte [edx], 0xea
nop
sbb byte [ebx], cl
push eax
jne 0x88c19d
les ebp, [edi]
ja 0x88c223
xor edi, dword [edi + 0x5f12f219]
loope 0x88c275
sahf
fstpnce st(2), st(0)
dec ebx
invalid
add eax, 0x3566e704
jae 0x88c1fc
out 0x66, eax
xor eax, 0x6d08b873
sahf
or byte [ebp - 0x62], ch
fild dword [edx - 0x1c9af706]
cli
or byte [ebp - 0x1d], ah
add al, 0x64
inc esi
jl 0x88c23f
cmp dword [eax], esp
push ds
invalid
mov esp, 0x626a9047
int1
aaa
enter 0x7d71, 0x76
pop ss
sub byte [ebp - 0x74f54d39], dl
push esp
cmp byte [edx - 0x5967f007], bl
salc
and eax, 0x9b1dcae3
imul dword [ebp - 0x62]
and al, 0x10
in al, 0xc7
add ecx, dword [edi - 0x26f7c911]
clc
fst st(1)
mov ds, word [edx - 0x1ff7b030]
call 0x254622ed
call dword [ebx + 0x7c]
xchg ebx, eax
dec esp
cwde
adc dword [ebx - 0x54bba393], ebp
mov es, edx
mov dl, 0x67
out dx, al
push esp
mov byte [0x236ad2ca], al
int 0x73
mov ebx, es
hlt
lea esp, [esp + 0x18]
jne 0x88c1e4
pop ebx
not edx
mov ecx, 0x40a1fa8d
not ecx
mov eax, ecx
mov dword [esi], edx
jmp ebp

Function at 0xc55095
Capabilities:
Encrypt data using speck

Disassembly:
mov dword [esp], 0xe97c11a7
call fcn.007aee31

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

Disassembly:
rol edx, 0x21
xor ecx, ebx
sal edx, 2
or dx, dx
lea ecx, [ecx + edx*4 - 0x63f52d7c]
add byte [esp + edx - 0x540c1ff6], 0x21
rol ecx, 2
mov eax, edx
xadd ax, dx
not ecx
bswap ecx
mov byte [esp + edx - 0x540c2000], dh
cbw
and eax, 0x1d116db0
xor ebx, ecx
mov dword [esp + eax - 0x13fffffc], eax
add ebp, ecx
sub edx, edx
mov dword [esp + edx], ebp
ret 8
add dl, 0xaf
ja 0xb8f600
mov ecx, dword [edx + edi - 0xa81846a]
setno dl
lea edi, [edi + edx*4 - 0x2a060ffc]
push edx
jb 0x877096
inc ecx
mov ebp, 0x5732a0b9
inc ecx
movzx esi, bp
inc ecx
xchg ebp, esi
dec edx
lea edi, [edi + ebp*8 - 0x505cc]
inc ecx
movsx ecx, ch
inc esp
mov edx, esi
inc esi
mov esi, dword [edi + ebp*8 - 0x505c8]
inc bp
or edx, edx
movsx ebp, si
mov edx, ebp
inc ebp
xor esi, esp
call fcn.00b69099
Function at 0xc58482
Capabilities:
Encode data using xor

Disassembly:
call fcn.007cc16d
mov byte [ecx], dl
pop edx
rol dx, 0x85
pop eax
jmp edi
push edx
neg byte [esp + 8]
dec ax
mov dword [esp + 4], edx
rol ax, 1
shr edx, 0xc
pop ecx
adc dword [esp + edx*2 - 0x15807e], edx
dec ax
shr dword [esp + edx*2 - 0x15807c], 0x43
shl byte [esp + edx - 0xac03e], 0xa1
shr cx, 0x67
neg ax
xor bx, ax
imul dx, dx
xadd dword [esp + edx - 0xa0ffc], ecx
or dl, 0x95
mov word [esi + ecx*8 - 0xe], ax
lea esi, [esi + edx*8 - 0x5084ae]
shr ecx, cl
sal word [esp + edx - 0xa1092], 0x26
pop ecx
pop ecx
jp fcn.0075bcd3
mov ecx, 0x8f3fea26
dec eax
sub edi, 4
inc esp
movsx esi, cx
mov ebp, dword [edi]
mov edi, 0x272c8bf1
call fcn.008c16d5
xor byte [eax + 0x52], al
je 0xc5855e
pop ecx
cli
inc edi
xor esi, eax
dec edx
dec ecx
cli
inc edi
xor esi, esp
cmp bh, byte [ecx]
cli
inc edi
xor edi, esp
jbe 0xc584f5
fdivr qword [ebx + esi + 0x27]
and eax, 0xccda7c46
iretd
mov dh, 0x8f
out dx, al
push 0x84882e25
lea esp, [esp + 8]
jmp 0x85fcf2

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

Disassembly:
lea edx, [edx + eax + 0x53cf0739]
sbb ax, word [esp + eax - 0x6a69aff0]
shl word [esp + ecx - 0x5009], cl
rol edx, 2
pop eax
lea edx, [edx + ecx*2 + 0x6c16a09f]
sal eax, cl
not edx
sub ecx, 0x14275499
bswap edx
add cx, 0xe7a8
rol eax, 0xac
rol cl, 6
xor ebx, edx
not byte [esp + 1]
add byte [esp + 1], al
add ax, ax
adc ebp, edx
movzx ecx, byte [edi]
movzx edx, al
lea edi, [edi + edx*4 - 0x177]
xor cl, bl
not cl
push edx
sar word [esp + edx*2 - 0xb9], 1
dec cl
mul eax
cbw
ror cl, 1
add cl, 0xbe
dec word [esp]
not ax
xor bl, cl
push edx
imul dx
movzx dx, byte [ecx + edx - 0x39a4fd87]
neg byte [esp + eax - 0x6002a5f9]
mov ecx, 0x5d0db23e
mov word [ebp + eax - 0x6002a604], dx
push eax
pop edx
push edx
lea ebp, [ebp + edx - 0x6002a604]
shr dword [esp + eax - 0x6002a5f7], 0x81
neg eax
pop eax
pop ecx
pop eax
pop ecx
pop ecx
pop ecx
jb fcn.008c0304
or cx, dx
neg eax
dec cl
ror ecx, 0x37
xor eax, 0xcb071810
xadd ecx, edx
jg 0x7c11cd
call fcn.0079fce3
Function at 0xc5b83f
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
dec dx
ror ecx, 0xa7
lea esi, [esi + ecx*4 - 0x526a6ba4]
xor eax, ebx
or byte [esp + edx - 0x476fdcb3], cl
sal dx, cl
ror ecx, 0x9b
rol eax, 3
rol cx, 0x2f
inc edx
dec eax
or cx, cx
btc dx, cx
xor eax, 0xb0c85a2
call fcn.00c4bfd7
mov ax, word [ebp]
mov edx, 0xd698f681
movsx ecx, dl
mov cl, byte [ebp + 2]
add ebp, 2
sal edx, 0x23
shr ax, cl
lea ecx, [edx + edx*2 + 0x140d3b96]
bts cx, dx
mov word [ebp + ecx*2 - 0x64c8af5c], ax
mov ecx, dword [edi + ecx - 0x326457ae]
adc edx, edx
ror dx, 0x61
lea edi, [edi + edx - 0x698fb404]
mov eax, edx
push eax
xor ecx, ebx
inc ecx
ror ecx, 3
mul word [esp + edx - 0x698fb408]
lea ecx, [edx + ecx - 0x10d2a98b]
sbb al, 0x9f
neg ecx
inc ax
xor ebx, ecx
xchg dx, ax
add esi, ecx
lea ecx, [eax + edx*8 + 0xdb9ce0e]
mul cl
inc eax
mov dword [esp + eax - 0x698f6b2c], esi
ret
add edx, 0xf4ab799a
xor cl, bl
and edx, edx
sbb dl, dl
call fcn.00b72144
rol word [esp + edx*2 - 0x5f22c913], 0xe7
sbb ecx, 0x8aac611c
sar dx, 0x8b
lea eax, [eax + eax*2 + 0x588d7599]
bswap ecx
not eax
xchg word [esp + edx - 0x2f910005], dx
ror ecx, 3
xor ebx, ecx
pop eax
movzx eax, dx
pop eax
add ebp, ecx
mov eax, dword [eax + esi - 0xc01fffc]
mov ecx, edx
xchg dword [esp + ecx - 0x2f912f11], edx
lea esi, [esi + ecx*2 - 0x5f225e1a]
ror cx, 0x43
movzx ecx, byte [ecx + edi - 0x2f9125dd]
adc edi, 6
or edx, edx
jne 0xc43556
dec ebx
lea edx, [esi + esi*4 - 0x4c61c560]
inc ebp
movsx ebp, dh
pop ebx
call fcn.00860e85
push 0x80c7ba0
mov cx, word [edi + 2]
dec word [esp + 2]
add edi, 2
and ax, cx
mov ecx, 0x75ba3b88
lea ecx, [ecx + ecx*2 - 0x13e11a43]
not ax
lea edx, [ecx + ecx*8 - 0x704a7e48]
mov word [edi + edx - 0x476fdcb5], ax
add cx, dx
bt cx, cx
mov eax, dword [esi + edx - 0x476fdcb5]
jb 0x889ee8

Function at 0xc5e310
Capabilities:
Encode data using base64

Disassembly:
adc dl, 0x23
mov dword [esp + ecx - 0x1986ad7], ecx
rol al, 0x23
shr eax, cl
ror dl, 1
imul eax, dword [esp + eax*4 + 4]
jae 0x820525

Function at 0xc62f2b
Capabilities:
Encrypt data using speck

Disassembly:
movsx ecx, word [esp + 4]
inc cl
xor eax, ebx
xor dx, word [esp + 6]
not eax
not ecx
pop edx
mov edx, 0xba8a62b5
rol eax, 2
rol cx, 1
add dword [esp + ecx*8 - 0x481d0], edx
inc eax
ror eax, 3
ror dword [esp + ecx*2 - 0x12074], cl
xor eax, 0x16bbda9e
bswap eax
xchg ecx, edx
call fcn.0087f382

Function at 0xc6301f
Capabilities:
Authenticate hmac
Encode data using base64
Encrypt data using speck

Disassembly:
jnp 0xb3e8a3
test ebx, ebx
push 0x75bc4a09
lea esp, [esp + 0xc]
je 0xc122db
mov eax, dword [ebp + ebx*4]
call fcn.0084392e
call fcn.0072a8b6
jg 0x7c6762
Function at 0xc63025
Capabilities:
Authenticate hmac
Encode data using base64
Encrypt data using speck

Disassembly:
xor eax, ebx
pop ecx
movsx ecx, dx
mov dword [esp + edx - 0x8dfb], ecx
lea eax, [eax + edx*2 - 0x4728f60a]
rol eax, 3
push edx
pop edx
not eax
xor dword [esp + edx - 0x8dff], ecx
sbb ecx, edx
sbb dword [esp + edx - 0x8dff], ecx
inc eax
mov dword [esp + edx*2 - 0x11bf6], edx
add cl, ch
neg eax
xor ebx, eax
add edx, edx
adc ebp, eax
call fcn.008dd061
mov ecx, 0xefa4f3b3
dec eax
sub edi, 4
sar cx, 0xc8
inc esp
mov esi, ecx
inc esp
movzx edi, cx
inc edx
mov esi, dword [edi + edi - 0xfff3]
inc esp
mov edx, ecx
inc ecx
movsx eax, bh
inc ecx
sar dl, 0xa7
inc ecx
xor esi, esp
mov edx, 0xe39ce49f
call fcn.00b477bb

Function at 0xc65ca4
Capabilities:
Encode data using xor

Disassembly:
rol ecx, 1
dec al
lea ecx, [edx + ecx + 0x580dc518]
sar edx, 0xfe
xor ebx, ecx
pop edx
ror eax, 0xc5
sbb esi, 3
neg dword [esp]
mov edx, 0xa49fb93e
mov dword [esi], ecx
lea ecx, [eax + edx*8 + 0x32e0083]
pop ecx
mov edx, dword [ebp + ecx - 0x4af5289a]
lea ebp, [ecx + ebp - 0x4af52896]
adc eax, 0xe29ca606
sub al, ah
xor edx, ebx
or ecx, ecx
shr eax, 0x30
call fcn.00b98fb3
cmp al, 0x98
push ecx
je 0xc65d72
jns 0xc65d1c
inc esp
xor eax, dword [eax + 0x44224142]
inc esp
xor edx, eax
jp 0xc65d7e
and al, byte [ebx + esi - 0xc]
push esi
cmp al, byte [edx - 0x212ccc76]
mov dh, byte [ebx]
rcr esi, cl
loopne 0xc65d00
aaa
imul ecx, ecx, 0x6980afa8
and eax, 0xf5e7cec1
out 0xf5, eax
jmp dword [bp + si - 0x10]
les eax, [edi]
fimul dword [esi]
jl 0xc65d0c
sub eax, 0x5c9f27a4
and eax, 0x1f6bcb4a
and ebp, edx
mov ch, 0xcc
into
or al, 0x2b
mov esi, 0xfb2c8f6a
sbb eax, ecx
int3
dec edx
retf

Function at 0xc69bc9
Capabilities:
Encrypt data using speck

Disassembly:
mov dword [esp + eax*2 - 0x61260000], 0x3302288d
xor edx, ebx
not dword [esp + ecx*2 - 0x49ef71c2]
pop ecx
bswap edx
bt eax, eax
dec edx
shl eax, cl
ror ecx, 0xbd
call fcn.008732e7
mov dword [esp + eax + 4], eax
xor ecx, ebx
mul al
adc byte [esp + eax*8 + 6], 0x3a
mov dword [esp + eax*4], 0x6287038c
rol ecx, 3
mul eax
bswap eax
add edx, dword [esp + edx*4 + 3]
bswap ecx
bts eax, 0x2a
sal edx, 0x6a
ror ecx, 1
sub ecx, 0xce001416
call fcn.00b453f8
mov edx, 0xa21f4d22
movsx ecx, dx
movzx cx, byte [edi + ecx*8 - 0x26910]
mov eax, edx
call fcn.00c5e62f

Function at 0xc69c3b
Capabilities:
Encrypt data using speck

Disassembly:
jmp 0x77063a
push 0x21190304
lea esp, [esp + 0x14]
je 0xb431ca
jmp 0x7e01a9

Function at 0xc6a0ea
Capabilities:
Encrypt data using speck

Disassembly:
neg eax
or ax, ax
xor edx, ebx
shr eax, cl
inc edx
xchg cl, al
cbw
mov dword [esp + eax - 0x2ffac], eax
rol edx, 1
inc edx
xchg word [esp + eax*2 - 0x5ff58], ax
call fcn.00c32aca
movzx edx, byte [ebp]
mov eax, 0xf8bb3e20
or eax, eax
or al, ah
adc ebp, 1
xor eax, 0x77a6c6b2
bts eax, eax

Function at 0xc70aec
Capabilities:
Encrypt data using speck

Disassembly:
mov eax, dword [esi + ecx - 0x252a36fe]
pop ecx
adc esi, 8
call fcn.00707dd4
Function at 0xc73345
Capabilities:
Encode data using base64
Encrypt data using speck
Parse credit card information

Disassembly:
adc word [esp + eax*8 - 0x13fa7], cx
btc ecx, ecx
xor edx, ebx
jmp fcn.008a2946
bswap edx
xor eax, 0xfc89e92b
mov dword [esp + ecx - 0x148a20fa], edx
lea eax, [eax + ecx*2 - 0x62372c86]
xor ebx, eax
add ebp, eax
shl cl, 0xc3
movzx eax, cl
pop ecx
mov eax, dword [edx + edi - 0x57fe0004]
or dword [esp + ecx - 0x57fe0000], ecx
mov edx, dword [ecx + edi - 0x57fe0000]
call fcn.008b04d3
shr al, 1
cmovbe ax, word [esp + 1]
rol dl, 1
movzx ecx, word [esp]
xor dl, 0
div al
xor bl, dl
not ecx
xchg word [esp], ax
lea edx, [esp + edx + 4]
not ecx
add eax, ecx
setg byte [esp + ecx*2 - 0x15802]
mov ecx, dword [ecx + edx - 0xac01]
movzx edx, al
sal eax, 0x95
mov dword [edi + eax - 0x400004], ecx
and byte [esp + eax - 0x3fffff], ah
mov ecx, dword [esp + eax*2 - 0x800000]
movzx ecx, byte [eax + esi - 0x3fffff]
or byte [esp + eax - 0x3ffffe], dh
call fcn.0074dd5c
mov cl, byte [esi + 2]
mov edx, 0x429c086
lea esi, [edx + esi - 0x429c084]
shr ax, cl
or edx, edx
adc edx, dword [esp + edx - 0x429c086]
mov word [esi], ax
and dword [esp], edx
lea ecx, [edx + edx + 0x612f7a4]
setns dl
mov eax, dword [edi + ecx*4 - 0x17205f58]
lea edi, [ecx + edi - 0x5c817d2]
jb 0xb4ab60
jnp 0x888856
ror word [esp + ecx*2 - 0xb902faa], 0xea
xor eax, ebx
btr edx, edx
xor word [esp + ecx*8 - 0x2e40beaf], cx
ror eax, 1
call fcn.00b4f08e
add edx, 0xa208d3a9
sub ax, word [esp + eax*2 - 0x4e5f]
mov word [ebp + eax - 0x2732], cx
pop edx
ror dword [esp + edx*2], 0xe1
xor edx, dword [edi + edx*2 + 6]
lea ecx, [eax + eax - 0x3547594d]
ror al, 0x24
xchg ch, al
lea edi, [edi + eax*2 - 0x4fe0]
jae 0xbc41ca
movzx cx, byte [esi]
mov edx, 0xe015073d
movzx eax, dx
mov dl, byte [esi + eax*4 - 0x1cf2]
imul eax, eax
adc cl, dl
btc ax, ax
jae 0x766bd5
mov dword [esp + eax*4], edi
ret 8

Function at 0xc76354
Capabilities:
Encrypt data using speck

Disassembly:
mov esi, dword [esp + ecx - 0x1b5]
mov ebx, dword [esp + ecx - 0x1b1]
mov dword [esp + ecx - 0x1b1], ecx
mov ecx, dword [esp + ecx - 0x1ad]
mov dword [esp + 0xc], edi
call fcn.008a6a18