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

Disassembly:
shl dword [esp + edx*8], 0x41
xor ebx, ecx
bts edx, edx
jae 0xb9417c
xor ecx, ebx
movsx eax, word [esp + edx]
sub ecx, 0x971008be
sar ax, 0x66
xchg edx, eax
not edx
rol ecx, 1
not edx
xor eax, 0x2685b496
push eax
inc ecx
cwde
ror al, 0xe6
sbb ax, word [esp + 5]
ror ecx, 1
xor ebx, ecx
call fcn.0081626c
jmp 0x7eefff
mov dword [esp + eax - 0x54e6], edi
ret 8
mul dword [esp + edx*2 - 0x2f30363c]
pop eax
xor ecx, ebx
shr dword [esp + edx - 0xdcc7061], 0x94
ror ax, 0xe
adc eax, eax
ror ecx, 2
sal eax, 0xff
push edx
sbb ecx, 0x98b95421
sar edx, 2
shl edx, 0x7c
cdq
bswap ecx
dec word [esp + edx]
div dword [esp + edx + 4]
rol ecx, 1
lea ecx, [ecx + edx - 0x1d8a4d16]
jmp 0xbc9f8c
adc ebp, ecx
rol edx, 0x62
adc ax, word [esi + edx*4 - 0x12]
movzx ecx, byte [edi + edx*2 - 3]
shr word [esp + edx*2 - 3], 0x82
pop edx
call fcn.008b1bf1
adc esi, 3
push 0x84ab3430
shr word [esp + 5], 0xc5
dec byte [esp + 7]
xor ecx, ecx
not dword [esp + 3]
test eax, eax
jmp 0xc64f87
not dl
mov dword [esp], eax
sub dl, 0x30
xor dword [esp + 3], eax
rol dl, 1
shl dword [esp + 2], 0x78
not cl
add dword [esp + 2], 0x57bada38
xor dl, 0x2a
xor bl, dl
lea ecx, [eax + eax*2 - 0x7d78ca5c]
lea edx, [esp + edx + 8]
bswap ecx
rol word [esp + ecx - 0x612cf17f], 0x84
movzx ax, byte [edx + ecx - 0x612cf183]
lea edx, [ecx + ecx*4 + 0x31b76391]
mov word [ecx + esi - 0x612cf185], ax
lea eax, [edx + edx*4 - 0x24d418c5]
shl cx, 0xc4
btr ecx, ecx
mov ecx, dword [ecx + edi - 0x612c182f]
jae 0x8d9b4d
pop ecx
pop ecx
pop ecx
jne fcn.007ce4d4
jmp 0x719ea0

Function at 0xbb28a5
Capabilities:
Encrypt data using speck

Disassembly:
and dl, 0xa3
dec eax
xor ecx, 0x4425a1bb
call fcn.00b3feef
pop eax
pop edx
pop edx
jmp fcn.007e2cc2
lea esi, [esi + edx - 0x32be8d2e]
mov dword [esp + edx - 0x32be8d34], edx
mov byte es:[eax + edx*2 - 0x657d1a68], cl
mov dword [esp + edx*2 - 0x657d1a68], ebp
ret
dec dword [esp + ecx - 0x750f070e]
lea ebp, [ebp + ecx - 0x750f070e]
mov dword [esp + ecx - 0x750f0712], 0x25b40b1b
xor eax, ebx
rol cx, 0x45
jae 0x80aa7d
lea ecx, [ecx - 0x4bfd82de]
dec edx
or dword [esp + eax - 0x40b40bc3], 0x3d2852a0
div byte [esp + ecx - 0x671073ce]
xor edx, 0xbf84090e
rol eax, cl
xor dword [esp + eax*4 - 0x76488168], ecx
lea edx, [eax + edx - 0x699b91fe]
sar dword [esp + eax*4 - 0x76488168], cl
bswap edx
dec ax
lea ecx, [ecx + eax - 0x6b4335f8]
xchg ecx, eax
xor ebx, edx
sal eax, 0x41
sar byte [esp + ecx - 0x1d922058], 2
neg dword [esp + ecx - 0x1d922059]
add ebp, edx
movzx edx, word [esp + ecx - 0x1d922059]
mul dword [esp + ecx - 0x1d922059]
mov eax, dword [esi + edx*2 - 0x657d1a6a]
mov cl, byte [esi + ecx - 0x1d922055]
dec edx
jg 0xbaf3a6
mov ecx, dword [ebp]
add ebp, 4
sal dx, 0xc6
mov eax, edx
xor ecx, ebx
call fcn.00c27013
Function at 0xbb2d8c
Capabilities:
Encrypt data using speck

Disassembly:
lea ecx, [ecx*4 - 0x7df076cf]
dec cl
not eax
lea ecx, [ecx*4 + 0x192e50a4]
lea ecx, [ecx + ecx + 0x73037483]
bswap ecx
neg eax
xor cl, byte [esp + ecx - 0x4b73dd71]
and cl, 0x88
rol eax, 3
lea ecx, [ecx + ecx + 0x180c219e]
and word [esp], cx
sbb ecx, 0x4d2a8501
neg eax
and dword [esp + ecx - 0x61c956ad], ecx
call fcn.00825496
mov ecx, 0xde8ca29b
rol cl, 0xe2
mov ecx, dword [edi]
mov dl, byte [edi + 4]
mov eax, 0x32a0ae30
dec eax
lea edi, [edi + eax - 0x32a0ae29]
dec al
mov byte [ecx + eax*2 - 0x65415c5c], dl
movsx edx, al
shl edx, 0x67
mov edx, dword [ebp + eax*2 - 0x65415c5c]
lea ebp, [eax + ebp - 0x32a0ae2a]
movsx ecx, al
lea eax, [ecx + eax*2 - 0x2e65b7f5]
xor edx, ebx
bt ecx, ecx
call fcn.0073869e
mov edx, 0xca221528
movzx eax, dx
mov eax, dword [edi + eax - 0x1528]
mov ecx, edx
bts edx, edx
imul cx, cx
adc edi, 3
xor eax, ebx
neg eax
ror eax, 2
xchg dl, cl
bts edx, edx
dec eax
neg edx
rol eax, 1
add cx, cx
xor ebx, eax
add ebp, eax
mov si, word [esi + edx - 0x35ddeabf]
jmp fcn.007e2cc2
xchg byte [esp + 5], cl
add dword [esp + 6], ecx
adc esi, 4
movzx edx, cl
shl byte [esp + edx*2 - 0x1a], 0xa2
xor eax, ebx
rol eax, 2
sub eax, 0xbb2b1733
sal cl, 0x84
neg eax
call fcn.007fc9c9
push 0xc48231b3
inc bp
mov eax, dword [ecx]
dec word [esp + 5]
inc ecx
mov ebx, 0x7c0c68bb
dec edi
lea ecx, [ecx + ebx - 0x7c0c68b9]
call fcn.00745e5d
mov eax, 0x428fdd02
btc ax, 0x1d
lea ecx, [eax + eax*4 + 0x3918178b]
mov eax, dword [esi + eax - 0x428ffd02]
push ecx
adc esi, 4
sal cl, 0xc5
xor eax, ebx
jmp 0x855d57

Function at 0xbb8712
Capabilities:
Encode data using xor

Disassembly:
not eax
movzx ax, byte ss:[ecx + eax - 0x3c435f7c]
mov edx, 0x4b835696
lea ecx, [edx + edx*8 - 0x52c0745f]
dec ecx
lea esi, [esi + ecx - 0x54dd96e4]
call fcn.00b92884
nop
xor al, 0x26
lahf
jne 0x8ec348
pop es
xchg edi, eax
invalid
sbb edi, 8
mov dword [edi + 0xc], eax
pop eax
mov dword [edi + 8], ebx
mov dword [edi + 4], ecx
mov ecx, 0x66b4e98f
movzx eax, cx
mov dword [ecx + edi - 0x66b4e98f], edx
shl ax, cl
movzx edx, cx
sub ecx, ecx
pop ebx
jge fcn.0070334b
je 0xb7e7ad
mov eax, 0xc3bca083
mov ecx, dword [esi]
jmp 0x8ec33c
Function at 0xbb9567
Capabilities:
Authenticate hmac
Encode data using base64
Encrypt data using speck
Parse credit card information

Disassembly:
and byte [ebx + 0x22], bl
lodsb al, byte [esi]
neg edx
btr cx, ax
xor ebx, edx
cwde
xchg ecx, eax
add edi, edx
mul cl
movzx eax, byte [ebp + ecx*2 - 0x475e]
shl cl, 0xc5
lea edx, [ecx + ecx*4 - 0x3f55cc7]
jnp 0x816e29
mov esi, 0x598d1810
mov esp, edi
mov ecx, 0x9d23dd99
popfd
pop esi
pop edx
movsx ebp, cx
lea ebx, [ebp + ecx + 0xe24ea8d]
pop ebx
movzx eax, cx
lea edi, [eax*4 + 0x62bb7798]
jmp fcn.00c6ecba
add ebp, 4
mov dword [esp], 0xc73dd521
xor eax, eax
test edx, edx
push 0x101d8e9f
call fcn.0072b80d
lodsd eax, dword [esi]
jne 0xbb950f
test dword [ebx + 0x21], 0xba88979
dec esp
and dword [ecx + 0x4c0bd8a9], edx
and dword [ecx + 0x79], eax
cmp byte [ebx], cl
dec esp
and dword [ecx], eax
sub dword [eax + 0xb], ecx
dec esp
and dword [ecx], edx
mov ch, 0xd8
or ecx, dword [ecx - 0x1f]
adc eax, 0x214c0b40
fstp dword [ecx + 8]
or ecx, dword [ecx - 0x4f]
cwde
or bh, 0x76
shr dword [edx], 0x22
add eax, 0x8150618d
mov edx, 0x48e
add byte [ecx + edi*2], ch
add eax, 0x2fddd25b
test eax, edi
std
pop esi
xor dword [eax], eax
test dword [ebp + esi*4 - 0x7affcee2], ebp
dec eax
sub eax, 0x850031f6
aam 0xbd
jle 0xbb9617
add byte [ebp + 0x314ecde8], al
add byte [ebp + 0x31ce2d70], al
add byte [ebp + 0x311e5c68], al
add byte [ebp - 0x7aef2b04], al
ret
and dword [esp + ebp*8 - 0xb], ecx
or ecx, dword [ecx - 0x54]
or byte [ebp + 0xb], ah
dec esp
and dword [eax + edi + 0x6d], edi
or ecx, dword [ecx - 0xc]
pushal
cmp eax, 0x84214c0b
insd dword es:[edi], dx
xchg edi, eax
iretd

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

Disassembly:
ror ax, 0xc2
mov eax, dword [ebp + ebx*4]
push 0xa935fe12
mov dword [esp], eax
push 0x4896802b
shr dword [esp], 0x29
dec ebx
jmp 0xb453c1
lea esp, [esp + 4]
jne 0xbb9a02
mov eax, 0xa9aa0c1b
mov eax, dword [ebp]
push 0xfebbfd06
call fcn.00c4e99f
dec edx
movzx eax, cl
ror edx, 1
push ecx
xchg dword [esp + eax*4 - 0x58], ecx
btc cx, 0x9b
bswap edx
inc edx
not edx
call fcn.007ca976
ror byte [esp + 7], 0x86
shr edx, 8
xor edx, ebx
inc eax
mov dword [esp], 0x83b5aab9
call fcn.008e51fe
push 0x5bb37238
test ebx, ebx
push 0x7ea74cbf
push 0x4d2b6514
lea esp, [esp + 0x10]
je 0xb453cb
mov eax, 0xa0a6fdbb
jmp 0x8220fa
Function at 0xbba0f2
Capabilities:
Encrypt data using speck

Disassembly:
lea esp, [esp + 8]
jmp 0x8aed95
not cx
dec cx
xchg ah, al
cdq
not cx
rol cx, 1
xor bx, cx
btc edx, edx
shr dl, 0xc6
lea esi, [edx + esi - 2]
xadd edx, eax
mul dx
mov word [edx + esi - 0x24eb0000], cx
cbw
lea eax, [eax + edx*2 - 0x2a4dc7f6]
mov ecx, dword [edx + edi - 0x24eb0000]
lea eax, [edx*2 + 0x6b8e4316]
inc edx
lea eax, [edx + edx*8 - 0xd23243]
lea edi, [edi + eax - 0x4b70cdc2]
setl al
xor ecx, ebx
dec ax
dec ecx
ror ecx, 2
btc ax, dx
inc ecx
or edx, 0x821cbf16
ror edx, 0xe2
dec dx
bswap ecx
rol ecx, 1
xor ebx, ecx
add ebp, ecx
push edx
pop edx
jmp fcn.007e2cc2
push ebp
mov ebp, 0xc41df780
pushfd
shr bp, 0xdd
mov ebp, dword [esp + ebp + 0x3be30004]
mov dword [esp + 4], 0xcf6eab59
push dword [esp]
popfd
lea esp, [esp + 4]
call fcn.0080adb6
xor ebx, edx
bt ax, 0x34
mov dword [esp], 0x1fb5099f
adc ebp, edx
sal cl, 0x61
mov di, word [edi]
pop eax
pop edx
jb fcn.007a41b7
mov edx, 0x618413a8
movzx ecx, word [edi + edx - 0x618413a8]
lea edi, [edi + edx - 0x618413a6]
xor dl, dl
ror edx, 0x77
lea eax, [edx*8 - 0x1c4502fb]
xor cx, bx
add edx, eax
jge 0x7fb40c
jmp 0x75b6bc

Function at 0xbc2eba
Capabilities:
Encode data using base64

Disassembly:
add esi, eax
ror dword [esp + edx*2 - 0x9eb64cc], 0x46
sub dword [esp + edx*4 - 0x13d6c998], 0xac3a62a0
mov ecx, dword [ebp + edx - 0x4f5b266]
movzx eax, word [esp + edx*2 - 0x9eb64cc]
mov al, byte [ebp + edx*2 - 0x9eb64c8]
lea ebp, [edx + ebp - 0x4f5b260]
mov byte es:[edx + ecx - 0x4f5b266], al
pop ecx
inc cx
jmp esi
mov eax, dword [edi + edx - 0x4b26a813]
lea ecx, [edx + edx*4 - 0x286621ef]
lea edi, [edi + edx - 0x4b26a80f]
push ecx
xor eax, ebx
ror eax, 1
dec dword [esp + edx - 0x4b26a813]
neg ecx
sbb eax, 0x569bec34
add cl, 0x33
or edx, dword [esp + edx - 0x4b26a813]
sets cl
xor eax, 0xefb1459a
xadd dword [esp + edx - 0x4f7fae7f], ecx
inc eax
add dx, cx
bswap eax
inc eax
pop edx
shr ecx, 0xa4
rol eax, 3
sal dl, 0x86
bt edx, edx
not eax
xchg edx, ecx
bts ecx, 0x8f
neg ecx
bswap eax
xor ebx, eax
push edx
jmp 0x852d9d
rol dl, 5
dec al
dec ebp
sar cx, 0x6c
pop ebp
rol al, 1
dec al
ror al, 1
bswap ecx
neg al
or ecx, ecx
xor bl, al
xchg dword [esp + edx], edx
add edx, edx
mov ebp, ecx
lea eax, [esp + eax + 4]
mov edx, dword [eax + ecx*2 - 0xc010386]
xchg edx, esi
shr dword [esp + ecx - 0x60081c3], 0xbd
je 0xc55c02
mov edx, 0x4b26a813
jmp 0x8e6ec0
mov ebp, edx
movzx edx, word [esp + ecx*2 - 0xc010386]
mov eax, ecx
shr cx, cl
pop edx
ja 0xc1ed84
Function at 0xbc6336
Capabilities:
Authenticate hmac
Encode data using base64
Encrypt data using speck

Disassembly:
sbb dword [esp], 0x72258489
test ebx, ebx
call fcn.00776a15
inc ecx
mov esi, 0x392e44b7
inc ecx
xor ebp, esp
inc cx
btc eax, 0x3d
not ebp
mul dx
dec eax
and eax, ecx
dec eax
btr esi, eax
sbb ebp, 0xe2112501
inc cx
neg edi
inc esp
movsx ebp, ax
sal ecx, cl
rol ebp, 1
xor ebp, 0xc9b1a783
sal dl, 0x65
xor dl, cl
inc ecx
push esp
inc edx
xor dword [esp + eax - 0x31b35e00], ebp
inc ecx
pop esp
bswap eax
dec eax
arpl bp, bp
inc eax
sar dh, 0x23
inc ecx
mul ch
dec eax
adc ebx, ebp
inc ecx
mov ebp, ebp
jmp fcn.008a1785
mov dword [esp], 0xde29f11f
adc eax, edx
rol dword [esp], 0x48
rol word [esp + 2], 0xcd
mov dword [ebp - 4], eax
jae 0x769c42
dec esp
lea edx, [eax + 0x7798e99e]
inc cx
neg ebp
inc ecx
sal eax, cl
cwde
inc ecx
inc edx
inc cx
ror ebp, 1
ror cl, 0xa1
inc cx
dec ebp
inc esp
movzx edi, cl
inc bp
xor esp, ebp
inc ecx
shr al, 0xe6
dec edi
lea ecx, [ecx + eax - 0x31b37e02]
sar al, cl
inc ecx
movsx edx, bl
inc di
mov dword [ecx + eax - 0x31b37e00], ebp
inc ecx
mov esi, eax
sbb dl, 0x3a
dec edx
lea edi, [edi + eax*2 - 0x6366fc04]
inc ecx
mov ebp, dword [ebx + edi - 0x4698f609]
dec ebp
xadd ebx, edi
jno 0xbbd7cc
Function at 0xbc63ec
Capabilities:
Encode data using base64
Encrypt data using speck
Parse credit card information

Disassembly:
shl dl, 0x44
not al
sbb cl, ch
sal ebp, cl
rol al, 1
sub al, 0x2d
and bp, cx
je 0xb39fce
xor bl, al
add eax, esp
btc ecx, ebp
add esi, edx
mov edx, dword [eax + esi - 0x4e8aa405]
mov eax, edx
movsx edx, cx
not ebp
or ecx, ebp
mov ebp, eax
movsx eax, cx
sal eax, 0xd7
setbe cl
mov esi, edi
ror al, 0x81
ja 0xba1b34
mov eax, 0x9bbb8e83
movsx ecx, ax
xor al, ah
mov ecx, dword [edi]
adc edi, 4
cwde
xor ecx, ebx
lea edx, [eax + eax*4 + 0x269c9289]
lea ecx, [eax + ecx - 0x30e05a84]
and dl, al
call fcn.007d7470
mov eax, 0x9ea29818
dec eax
sub edi, 1
dec eax
cwde
mov esi, eax
movsx ebp, ax
movzx esi, byte [edi + eax + 0x615d67e8]
inc ecx
xor dh, ah
dec esp
lea ebx, [eax*2 - 0x38c67b00]
inc eax
ror dh, 1
dec esi
lea edx, [ebx*8 + 0x8a43da0]
movzx edx, al
dec eax
cdq
inc eax
sub dh, 0x94
inc eax
xor dh, dl
dec esi
lea esi, [ebx*4 - 0x7b407647]
inc eax
rol dh, 1
inc esp
xor ah, dh
call fcn.00bc333a
inc ecx
pop eax
sub ecx, 0xfdb15001
xor ecx, 0x13193b19
dec edx
mul dword [esp + ebp - 0x2211ca4]
inc edx
setae byte [esp + ebp*4 - 0x8847298]
inc cx
mul eax
bswap ecx
inc sp
xor eax, edx
dec esp
lea ebx, [ebp*4 + 0x46a8ef1a]
lea ecx, [ecx + edx + 0x1307b707]
inc edx
shr dword [esp + ebp - 0x2211c9f], 0x77
inc ebp
movsx edx, si
dec edx
mov dword [esp + ebp - 0x2211ca6], 0xd195011b
xor ecx, 0x5c9628b6
cbw
inc ecx
pop ebx
dec esi
mov dword [esp + ebp - 0x2211ca8], esp
inc edx
xor dword [esp + ebp - 0x2211ca8], ecx
inc esp
mov edi, ebp
inc ecx
inc bl
inc ecx
pop esp
dec eax
arpl cx, cx
dec eax
cdq
inc al
dec eax
add ebx, ecx
dec ecx
bswap edx
inc esi
movzx ebp, byte [edi + ebp - 0x2211cad]
dec edx
lea esi, [edx + esi*8 - 0x2bd066c1]
dec eax
lea edi, [edi + edx*4 - 5]
inc cx
sar esi, 0x27
inc ebp
bt eax, esi
jae 0xb431b1
inc ebp
xor ch, ah
dec eax
cdq
inc ecx
add dh, bl
jne 0xc3df8a
mov dword [esp], 0x7d1dc40e
jmp 0xbc80df
add edi, 4
call fcn.00c2a544
mov esi, 0x90813a95
mov edx, 0xbe0969a7
lea ecx, [esi*8 - 0x64e8ef66]
movzx eax, byte [ebp + ecx*4 - 0x7c839508]
lea ecx, [edx*8 + 0x50206e90]
xor al, bl
xor al, 0xb7
btr cx, 0x38
mov ebp, ecx
and ecx, edx
inc al
shr ebp, 0xf6
jbe 0x7188a3
dec word [esp + 2]
shrd eax, edx, cl
mov dword [edi], eax
pop eax
jmp esi
inc esp
sub ch, al
inc ecx
ror ch, 1
dec eax
cwde
inc ecx
not ch
inc ecx
rol ch, 1
inc esp
sub ch, al
inc ecx
shr dl, 0xe3
dec esp
cmovp esi, edx
inc bp
btr eax, esi
inc ebp
xor ah, ch
inc ecx
or eax, 0xc92b9f9b
dec esp
adc ebp, esp
dec ecx
or edx, dword [ebp + eax*2 - 2]
dec esp
lea esi, [ebp*2 + 0x4a1c1b92]
dec ecx
mov dword [ecx + eax - 1], edx
dec eax
sal ebp, 0xe3
inc ecx
ror ebx, 0xde
jmp ebx

Function at 0xbc6b86
Capabilities:
Encrypt data using speck

Disassembly:
call fcn.00c54d12
inc ecx
not word [esp + 0x11]
xor edx, 0xce1ad9b7
mov dword [esp + 8], 0x2c3b7308
mov dword [esp], 0x5393370b
neg dword [esp + 9]
dec eax
jmp 0x73f3ee

Function at 0xbcc9be
Capabilities:
Encrypt data using speck

Disassembly:
inc eax
xor ecx, 0x792da011
jmp 0x89a7cf
jmp 0xbc39db
Function at 0xbcd0d4
Capabilities:
Encrypt data using speck

Disassembly:
test dword [ecx + 0x77777cc], eax
test dword [ecx - 0x3b3c2e5c], esi
pop esi
xor cl, 0x87
mov dword [esp + ecx - 0x87], eax
adc ebp, edx
cwde
movzx edx, cl
mov eax, dword [esi + edx*2 - 0x10e]
btc cx, dx
or dl, 0x90
jl 0x77c0ae
jbe 0xbcd14e
in al, dx
mov al, 0x4c
and dword [eax], ebx
jge 0xbcd14e
dec ebx
and dword [esp - 0x7b], eax
dec esp
dec ebx
and dword [esp + eax*8], ebx
fisttp qword [ebx + ecx*2 + 0x21]
test ah, al
mov ch, 0x4c
dec ebx
and dword [eax + ebx*8], ecx
lodsd eax, dword [esi]
dec esp
dec ebx
and dword [esp + ecx*2 + 0x214b4c75], esi
int3
in eax, dx
jg 0xbcd0b4
jno 0xbcd0ef
mov bh, 7
inc edx
mov ah, byte [ecx - 0x4b]
in al, 0x20
mov ebp, 0x48e
add byte [ecx + 0x3e], cl
and dword [0x289a3f0e], eax
test ecx, ebx
cdq
retf
jbe 0xbcd157
test ecx, edi
shr byte [ebx], 0x76
pop es
test ebp, ebx
fdivr dword [ebx]
jbe 0xbcd163
fstp st(0)
cmp esi, dword [esi + 7]
test ecx, edi
mov cl, 0x83
jbe 0xbcd169
test dword [ecx + 0x7762be8], esi
mov cl, 0xe8
sub esi, dword [esi + 7]
test dword [ecx + 0x10], esi
jno 0xbcd17b
stosd dword es:[edi], eax
jbe 0xbcd175
test dword [ebp + 0x28], esp
ret 0x5ec4
jns 0xbcd1d6
jecxz 0xbcd129
dec esp
and ebx, edx
mov edx, dword [edx + 0xb214b4c]
aaa
ror dword [ebx + 0x214b4c92], cl
or esi, dword [edi]
jb 0xbcd1d1
dec ebx
and ebx, ecx
xchg ebx, eax
loop 0xbcd1d7
dec ebx
and ebx, edi
ret
jbe 0xbcd1da
test dword [edx], eax
push edi
movsb byte es:[edi], byte [esi]
jbe 0xbcd1e0
test dword [esi], esi
paddsb mm6, qword [esi + 7]
paddsb mm6, qword ss:[esi + 7]
test edx, ebx
lahf
adc al, 0x76
pop es
test dword [esi], esp
jle 0xbcd235
ficomp dword [edi - 0x7af889ec]
jle 0xbcd235
jbe 0xbcd1f2
test dword [esi - 0x3b3d1d59], edi
pop esi
sub edi, dword [bp + di + 0x5c50]
fimul word [ebx + 0x67]
xor ch, byte [ebx + ebx*2 - 0x25687422]
lodsb al, byte [esi]
pop ebx
fisub word [ebx - 0x51]
shr byte [ebx + ebx*2 - 0x3d1c9422], cl
lodsb al, byte [esi]
pop ebx
fidivr word [ebx + 0x57]
push 0xffffffffffffffac
pop ebx
fidiv word [ebx]
repz ret 0x5bac
invalid

Function at 0xbcf2f4
Capabilities:
Encrypt data using speck

Disassembly:
inc ecx
dec ebp
dec esi
lea edx, [ebx*4 + 0x4892d82f]
dec eax
mov dword [esp + ebp - 0x44], 0xdbbf8a1f
inc ecx
movzx ecx, bx
inc ecx
not ebp
dec eax
lea eax, [esi + esi*4 + 0x5c84dc8e]
call fcn.007829ea
mov ecx, 0x330b8c37
movzx edx, cl
mov eax, dword [edi + ecx*2 - 0x6617186e]
and ecx, 0x52a5a281
xchg ecx, edx
lea edi, [edi + ecx - 0x33]
btr ecx, ecx
dec ecx
xor eax, ebx
btc dx, cx
rol edx, cl
inc eax
call fcn.00c45a7f
Function at 0xbd79bc
Capabilities:
Authenticate hmac

Disassembly:
not ebp
inc eax
div dh
dec ecx
sal esi, cl
inc edx
lea ebp, [ebp + ebx*2 - 0x6b23ae5]
inc ecx
mul eax
inc ecx
push edi
inc esi
or byte [esp + eax + 3], bh
dec esi
mov dword [esp + eax*2 + 0x18], esp
dec edx
mov dword [esp + edi - 0x7fa663f3], eax
xor dword [esp + esi + 0x14], ebp
inc ecx
neg al
sbb eax, 0x223fd42e
dec esi
mov esp, dword [esp + edi - 0x7fa663eb]
dec ecx
adc edx, eax
dec eax
arpl bp, bp
dec esi
mov dword [esp + eax + 0x18], ebx
dec eax
adc ebx, ebp
inc edx
mov ebp, dword [esp + edi - 0x7fa663e8]
dec ebp
add eax, dword [eax + edi - 0xd]
sal dword [esp + esi*8 - 6], 0x77
dec edx
lea edi, [edi + edi - 0x7fa66410]
dec esp
adc edi, dword [esp + esi + 0x14]
pop ecx
dec ebp
xor eax, esp
dec ecx
xor eax, 0x6a9883ab
dec esp
add eax, edx
dec eax
idiv ecx
call fcn.007cba67
Function at 0xbdc370
Capabilities:
Encode data using base64
Encrypt data using speck
Parse credit card information

Disassembly:
add cx, dx
xor ebx, eax
rol cl, 0x87
adc ebp, eax
mov eax, dword [esi]
mov edx, dword [esi + 4]
inc cx
or ecx, ecx
push ecx
mov cl, byte [esi + 8]
add dword [esp], 0x6c2bd503
adc esi, 5
jmp 0x7dbaff
mov bp, word [ebp + ecx - 0x46f90000]
jmp fcn.008c0304
lea ebp, [ebp + ecx*2 + 4]
shr byte [esp + ecx + 2], 0x67
xor eax, ebx
or word [esp + ecx*2], dx
jno 0x8ba0dc
xor cl, bl
add cl, 0x39
rol cl, 1
not eax
sub al, 0xb4
rol edx, 0x84
xor cl, 0x90
pop edx
lea edx, [edx*4 - 0x44e1ed63]
not cl
inc edx
xor bl, cl
dec edx
add ecx, esp
imul edx
sar eax, 0xcb
imul al
movzx ax, byte [ecx + edx*4 - 0x30]
movzx ecx, dl
mov word [esi + edx*2 - 0x1c], ax
ror dx, cl
movzx eax, cx
lea esi, [edx + esi - 0xc4]
jae fcn.007ce4d4
mov eax, 0x3c31c0b7
mov eax, dword [edi + eax*2 - 0x7863816e]
add edi, 4
xor eax, ebx
bswap eax
mov ecx, 0xdf2aec07
movsx edx, cx
rol eax, 3
add dl, dl
sbb dx, cx
adc ecx, edx
dec eax
ror eax, 2
jmp 0x72e458
mov edx, ecx
xor eax, ebx
btr dx, 4
inc dl
ror dx, cl
inc eax
xor cx, dx
ror eax, 1
add cl, dh
xor edx, edx
not eax
bts edx, edx
sbb eax, 0x972c5c24
bswap eax
or dx, 0x80bd
jle 0xc67175
neg ecx
mov eax, edx
sal ax, 0xce
lea edx, [eax*8 - 0x5fcd3f68]
ror ecx, 1
xor ecx, 0x3a932b0
xor ebx, ecx
bts edx, eax
adc edi, ecx
mov ecx, eax
jmp 0x7767cb
ror eax, 3
lea ecx, [edx*4 + 0x379d4b14]
add ecx, dword [esp + ecx - 0x379d4b14]
not ecx
lea eax, [ecx + eax - 0x60b94ce8]
not ecx
jno 0x7697c1
mov eax, 0x71ba258d
add eax, 0xb2055922
mov eax, dword [eax + edi - 0x23bf7eaf]
mov ecx, 0xac22410c
jno 0x88ec8a
lea eax, [ecx + ecx*2 - 0x37e0b94d]
mov edx, ecx
mov eax, dword [ebp + edx*2]
mov dword [esp + edx], ecx
jmp 0x7e70ec
shld edx, eax, cl
mov eax, 0xf23bea3f
dec dword [esp + 3]
mov dword [edi], edx
cdq
pop edx
pop edx
jmp ebp
rol edx, 0x3f
xor ebx, eax
bts cx, 0x98
bswap edx
not cx
mov ecx, eax
call fcn.00784374
mov edx, 0x1aaeb507
movzx eax, dx
mov eax, dword [edx + esi - 0x1aaeb507]
push edx
lea ecx, [edx*4 - 0x1b591580]
lea esi, [esi + edx*2 - 0x355d6a0a]
neg word [esp + edx - 0x1aaeb505]
xor eax, ebx
add ecx, 0x80ac6007
rol eax, 2
inc eax
neg eax
neg cx
xchg dword [esp + edx - 0x1aaeb507], ecx
xchg edx, ecx
lea eax, [ecx + eax - 0x4b441407]
adc dword [esp + ecx*2 - 0x355d6a0e], edx
sete byte [esp + ecx - 0x1aaeb507]
rol eax, 1
ror dx, 0xab
neg eax
xadd cx, dx
ror dword [esp + ecx - 0x1aae55fd], cl
dec eax
bswap edx
shr dword [esp + edx - 0x7b552e5], 0xf
neg eax
xor ebx, eax
sal ecx, 0x56
ror ecx, 0x35
xadd word [esp + edx - 0x7b552e4], dx
adc ebp, eax
movsx eax, dl
rol byte [esp + edx*2 - 0xf6a02ab], 0xc3
ror edx, cl
mov edx, dword [edi + ecx*2 - 0x7f4]
mov eax, dword [edi + ecx*2 - 0x7f0]
not word [esp + ecx*8 - 0x1fd0]
mov cl, byte [edi + ecx*4 - 0xfe0]
push 0x990e34b4
adc edi, 5
sub dword [esp + 2], 0x43a7bd03
jb 0xbe047f
call fcn.007e9280
Function at 0xbdf850
Capabilities:
Encode data using xor

Disassembly:
mov esi, 0xa2889d1e
movzx esi, byte [eax]
call fcn.00bc0d35
shl bp, 0xcc
dec eax
add ebx, edx
inc ecx
dec ch
call fcn.00b6e3d6
mov byte [0xb4742a3c], al
mov bh, 0x86
aas
xor edi, dword [esi]
lodsb al, byte [esi]
scasd eax, dword es:[edi]
xchg byte [edi], bh
xor eax, dword [esi]
mov esp, 0x333f86bf
adc bl, byte [eax + esi*8 + 0x1933f126]
inc esp
add cl, byte [edx + 0x4c]
imul edi, dword [eax - 0x7d9f2488], 0x130b9221
push eax
sbb al, 0xff
push ss
add eax, 0x9502f36d
ja 0xbdf85e
mov al, byte [0x5d5bf414]
cmpsd dword [esi], dword es:[edi]
das
cwde
invalid

Function at 0xbe0fb1
Capabilities:
Encrypt data using speck

Disassembly:
shr dl, 0xa6
btr eax, edx
rol ecx, 1
xor ebx, ecx
xor al, dl
adc ebp, ecx
xor dl, 0xbd
idiv eax
jmp fcn.007e2cc2
sub eax, 0x68c660e
not eax
mov edx, 0xa53e538f
call fcn.00c26e66
mov eax, 0x2324af1c
jmp 0xc423c4
movsx ecx, ax
mov eax, dword [edi + eax*2 - 0x46495e38]
and ecx, ecx
sbb edi, 0xfffffffc
xor eax, ebx
xor ecx, ecx
call fcn.00806ff8
cbw
shr edx, 0xfe
inc ecx
bswap ecx
jmp 0x748389

Function at 0xbe285c
Capabilities:
Encrypt data using speck

Disassembly:
dec esi
mov dword [esp + ebp - 0x18be482c], ebp
inc ecx
bswap edi
dec edx
mov dword [esp + ebp - 0x18be482c], ecx
inc ecx
not edi
inc ecx
xor edi, 0x79b5c815
inc ecx
bswap edi
dec esi
mov dword [esp + ebp*2 - 0x317c9058], esp
inc ebp
bt ebp, edx
inc esi
xor dword [esp + ebp - 0x18be482c], edi
inc ecx
pop esp
inc bp
and edx, ebp
dec ebp
arpl di, di
inc ebp
movzx esi, ch
inc bp
sub esi, ebp
inc ecx
push esi
dec ecx
add ebx, edi
dec ecx
btr esi, 0x84
call fcn.00760e56
dec eax
sub edi, 1
inc esp
movzx ebx, byte [edi]
inc ebp
xor bl, ah
inc ecx
sub bl, 0x26

Function at 0xc00ea1
Capabilities:
Encrypt data using speck

Disassembly:
mov ax, dx
mov cx, word [esi + ecx - 0x365765d8]
mov edx, 0xc9a9b0b2
not ax
neg dx
not cx
bt dx, dx
inc dl
or ax, cx
mov word [esi], ax
mov ecx, dword [ebp + 2]
call fcn.00766040
lea ecx, [esp + ecx + 8]
adc ax, word [ecx + eax]
pop edx
add edx, 0xa72a9
jmp edx
xor dx, bx
mov eax, ecx
not dx
sal ecx, 0x32
sub al, cl
rol dx, 1
dec dx
xor cl, al
dec cx
shr eax, cl
xor dx, 0x5f83
sub cx, 0xbc19
lea ecx, [eax + ecx*8 - 0x7eee6269]
xor bx, dx
jmp 0x75c8e4
dec dx
xor bl, cl
sar edx, 0x53
add dword [esp + eax + 4], 0xdf2f4715
jnp 0x8d7d6d
movzx edx, word [ebp]
mov ecx, 0xea07522f
and cl, ch
ja 0xb9d064
jmp 0x812777

Function at 0xc029b6
Capabilities:
Encrypt data using speck

Disassembly:
lea esp, [esp + 8]
jne 0xb7f94b