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

Disassembly:
xor ebx, eax
mov dword [esp + ecx - 0x4ae8f5e0], edx
btc edx, edx
rol cx, 0xc3
add ebp, eax
btr edx, 0x3f
mov eax, 0xfb999b21
movzx edx, word [edx + edi - 0x5ed5f5e3]
not eax
cbw
dec eax
lea edi, [ecx + edi - 0x4ae8af05]
sub byte [esp + ecx - 0x4ae8af04], ch
xor dx, bx
not dx
xchg ecx, eax
imul cx, cx
setae al
dec dx
not dx
bts ax, 0x23
lea eax, [eax*4 - 0x75cdd4d6]
rol dx, 1
xor bx, dx
cwde
lea esi, [esi + ecx*2 - 0x8cc0994]
mov word [esi + ecx*4 - 0x11981324], dx
or dword [esp + ecx - 0x46604c9], eax
pop ecx
pop eax
jle fcn.007e2cc2
mov cl, byte [esi + 4]
push 0x7686aab1
rol word [esp + 0xa], 0xe
shr dword [esp + 8], 0x14
adc esi, 3
call fcn.00b6fc43
and cx, ax
div al
not edx
inc edx
sar ecx, 0xfe
dec al
xadd al, cl
rol edx, 2
shr ecx, cl
bt ecx, ecx
xor ebx, edx
xor ecx, ecx
cbw
adc edi, edx
cbw
lea edx, [ecx + ecx*4 + 0x75a84f86]
push ecx
movzx dx, byte [esi + ecx*8 + 2]
xchg word [esp + ecx + 2], ax
xor cl, byte [esi + ecx*2 + 4]
dec al
shl word [esp + 2], 0x46
and dl, cl
xor dl, al
sal word [esp + 2], 0xe3
lea ecx, [eax*4 + 0x468cbb26]
not dword [esp + ecx - 0x4ddcbf22]
mov word [esi + ecx - 0x4ddcbf1e], dx
cwde
lea esi, [eax + esi - 0xfb]
imul eax, eax
and ax, ax
mov dword [esp + eax - 0xfe01], edi
ret

Function at 0xb4e321
Capabilities:
Encrypt data using speck

Disassembly:
inc ecx
pop esp
inc ecx
sar edi, 0x1b
dec ebp
arpl bx, bx
dec eax
ror ecx, cl
dec ecx
adc ebx, ebx
inc cx
and ebp, ebp
inc eax
setbe ch
dec eax
or edx, ebx
jmp edx
xor edx, ebx
pop eax
not edx
mov eax, 0x2629ff9c
xor edx, 0xe4937b3e
sar cl, 0x45
sal ecx, 0x7e
sbb edx, 0x8aac611d
bswap edx
ror edx, 3
btr eax, eax
shr eax, 0x8a
xor ebx, edx
call fcn.00bcd0d4
inc ecx
mov eax, 0xbbb004a3
dec edi
lea edx, [eax + eax*8 + 0x73ad06bc]
dec ebp
mov edx, dword [ecx]
inc ebp
mov edi, eax
inc ecx
movsx ecx, bh
inc ebp
mov ebp, eax
dec ecx
mov esi, dword [ecx + 8]
dec ecx
add ecx, 8
dec eax
lea ebp, [ecx + ecx*4 + 0x64880381]
push ecx
movzx eax, cl
dec esp
and edx, esi
dec esp
lea esi, [eax*8 - 0x33fa4eee]
inc cx
ror eax, cl
dec ecx
not edx
dec ecx
rol eax, cl
dec ebp
mov dword [ecx + eax*4 - 0x28c], edx
inc byte [esp + eax*2 - 0x140]
dec eax
lea edi, [edi + eax - 0xa7]
inc esp
mov ebx, dword [edi + eax*2 - 0x146]
inc esp
movzx edx, ch
inc esp
or dh, byte [esp + eax - 0x9c]
inc ebp
xor ebx, esp
or word [esp + eax - 0xa2], bp
inc ecx
bswap ebx
inc ecx
not ebx
inc ecx
movzx esi, dx
mov edx, 0x54819ca3
xadd dword [esp + eax - 0xa1], esi
inc ecx
dec ebx
inc ebp
xor edx, edi
and al, 5
inc ecx
and ecx, esi
inc ecx
not ebx
dec ecx
rol edx, 0xfe
sal word [esp + eax*8 - 4], cl
inc cx
cmove eax, edi
inc ecx
neg ebx
neg dword [esp + eax*2]
not word [esp + eax]
dec esp
mov dword [esp + eax*2 - 2], esp
inc ecx
sal ebp, 0x84
inc esp
xor dword [esp + eax*2 - 2], ebx
cdq
dec ecx
mul edx
jno 0x8e0c0a
Function at 0xb4e44e
Capabilities:
Encrypt data using speck

Disassembly:
xor ebx, ecx
sal byte [esp + edx*2 + 0xa], 5
mov dword [esp + eax*4 - 4], 0x26199416
adc ebp, ecx
cdq
neg eax
mov ax, word [edi + edx*8]
add dx, word [edi + edx*4 + 2]
mov ecx, dword [esp]
sal cx, 0xa8
or ecx, ecx
or cl, byte [edi + ecx - 0x261915fc]
call fcn.00c456ed

Function at 0xb5218b
Capabilities:
Encrypt data using speck

Disassembly:
mov eax, dword [esp + 4]
mov dword [esi + eax - 0x79005a5c], ebx
lea ebx, [eax*4 - 0x52790ef5]
mov dword [esi + eax - 0x79005a60], ecx
mov dword [esp + eax - 0x79005a64], ebx
mov dword [esp + eax - 0x79005a64], 0x958432ba
lea ecx, [ebx + eax*8 + 0x537cf9a]
mov dword [esi + ecx - 0x5ec2fd55], edx
mov ebx, dword [esp + ecx - 0x5ec2fd4d]
pop ecx
pop ecx
pop eax
jae fcn.007e2cc2

Function at 0xb5a504
Capabilities:
Encrypt data using speck

Disassembly:
adc ebp, 2
mov edx, 0x1bb3a6bd
pop edx
imul edx, ecx
mov word [edx + ebp - 0x2b89de00], ax
jmp esi
mov edx, dword [ebp + edx*2 - 0x70d76700]
mov dword [esp], ecx
pop eax
movzx ax, byte ss:[edx]
jno 0x70a43e
mov ecx, 0x178651ab
mov ecx, dword [ecx + edi - 0x178651ab]
xor ecx, ebx
mov eax, 0x61afd906
ror ecx, 2
sub ecx, 0x98b95422
push eax
bswap ecx
rol ecx, 1
sal dword [esp + eax - 0x61afd906], 0xab
inc byte [esp + eax - 0x61afd904]
mov edx, eax
lea ecx, [ecx + edx - 0x7f3a261c]
add ax, ax
sal word [esp + eax - 0x61afb20b], 0xee
jp 0xbc51d1
inc esp
movzx esi, word [edi - 2]
inc bp
xor esi, esp
inc cx
rol esi, 1
inc ecx
mov ebp, 0x518a0626
inc cx
add esi, 0xc1419733
int 0xa7
inc cx
rol esi, 1
inc cx
dec esi
dec esi
lea eax, [ebp*8 - 0x5044bdfa]
inc ecx
mov ecx, ebp
dec edx
lea esi, [ebp*2 + 0xd1f9e91]
inc cx
not esi
rol si, 0x22
inc bp
xor esp, esi
call fcn.00b364a0
xor ebx, ecx
btr edx, edx
cdq
shl edx, 0x6e
adc ebp, ecx
sal byte [esp + eax - 0x61afb20a], 0x82
jb 0xbcdf8b
sub dword [esp + eax - 0x61afb20c], 0x7ebcd981
movzx ecx, byte [edi + eax - 0x61afb208]
neg dx
imul edx, eax
xadd word [esp + eax - 0x61afb20b], ax
xor cl, bl
sar word [esp + edx], 0x23
cwde
add word [esp + eax - 0x4325], ax
adc cl, 0x84
bt eax, 0x14
not cl
add ax, ax
sbb byte [esp + eax - 0x864a], 0x85
bts eax, eax
sbb cl, 0x8f
bt ax, 5
or eax, edx
bt dx, 0x1d
ror cl, 1
xor bl, cl
lea ecx, [esp + ecx + 4]
xor dl, byte [eax + ecx - 0x964c]
ror dword [esp + eax*2 - 0x12c98], 0x16
xor eax, eax
mov word [esi + eax*8 - 2], dx
mov edx, eax
movzx ecx, byte [edx + edi + 5]
ror dl, 0xc1
lea edi, [eax + edi + 6]
inc al
sar edx, 0xbc
jns 0x7e7101
Function at 0xb5b15f
Capabilities:
Encrypt data using speck

Disassembly:
adc ebp, edx
push eax
mov si, word [esi + eax*2 - 0x700604b2]
bt ecx, 0xb8
pop edx
pop ecx
pop eax
pop edx
jae fcn.007e2cc2
xor eax, 0xeb828fb2
bt cx, cx
not eax
shr cl, 0xa7
adc cl, byte [esp + edx - 0x4501237d]
bswap eax
shl ecx, 0xa1
xor dword [esp + edx - 0x45012380], 0xca2cd4bf
neg eax
not edx
dec cl
bts ecx, 0x3b
xor ebx, eax
sar word [esp + 2], 0x2e
seta byte [esp]
add esi, eax
mov edx, dword [edi]
xchg byte [esp + 3], ch
not byte [esp]
movzx cx, byte [edx]
mov edx, 0xdcb52717
jmp 0xbb939a
add edi, 2
ror dword [esp], 0xc3
mov eax, 0x3401a302
mov word [edi + eax*2 - 0x68034604], cx
neg dword [esp + eax - 0x3401a302]
sar word [esp + eax - 0x3401a301], 0xcf
mov dword [esp + eax - 0x3401a302], esi
ret

Function at 0xb5e062
Capabilities:
Encrypt data using speck

Disassembly:
mov ax, word [esi + eax - 0x31b93df0]
mov cl, byte [esi + ecx - 0x73b1ef54]
jne 0xc73de9
add esi, 4
shld dx, ax, cl
mov eax, 0x79989b9a
movzx ecx, byte [esp + eax - 0x79989b96]
mov word [esi + ecx*2 - 0x1a], dx
mov dword [esp + eax - 0x79989b9a], edi
ret 4
Function at 0xb66468
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
xor eax, ebx
sub eax, 0x971008be
rol eax, 1
mov dword [esp], edx
inc edx
inc eax
ror eax, 1
add byte [esp + 2], dh
movsx ecx, dl
xor edx, dword [esp]
xor ebx, eax
add dl, 0x31
or dword [esp + edx*8 - 0x10001a0], ecx
adc ebp, eax
movzx edx, byte [edi + edx - 0x200034]
add edi, 1
xor dl, bl
movsx eax, cl
dec dl
pop ecx
xor dl, 0x22
sub dl, 0xd
rol eax, cl
adc al, al
and ecx, ecx
ror dl, 1
sal ax, cl
bt ecx, 0x99
sbb ecx, eax
xor dl, 0xb8

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

Disassembly:
add esi, 4
xor edx, edx
jmp 0xc5f53f
push eax
neg edx
idiv al
xor edx, 0x229e2ca0
sub edx, 0x833e6c16
not cl
ror edx, 1
push eax
mov byte [esp + eax*2 - 2], 1
pop ecx
xor ebx, edx
sub byte [esp + ecx*2 - 2], cl
mov dword [esp + ecx*2 + 2], ecx
pop eax
adc edi, edx
shr byte [esp + ecx*2 - 1], cl
cdq
mov cl, byte [ecx + esi - 1]
mov al, byte [eax + esi - 0x23]
neg edx
not dl
and edx, 0x7be9b16
lea esi, [esi + edx*2 - 0x2a]
imul cl
shr dword [esp + edx - 0x16], 0x87
inc edx
jae 0x8b1603
mov eax, dword [esi]
mov ecx, dword [esi + 4]
jmp 0x7a4bac
jmp 0xc64575

Function at 0xb745d6
Capabilities:
Encrypt data using speck

Disassembly:
mov word [esi + eax - 0x5f4c241b], dx
mov dword [esp + eax - 0x5f4c241b], ebp
ret 8
mov dword [esp], 0x5f12f71b
mov edx, dword [edi]
ror word [esp + 1], 0xae
jae 0xba63ee
push edi
push 0xe53e098b
pushfd
mov edi, 0xe13cce3b
mov edi, dword [esp + edi + 0x1ec331cd]
mov dword [esp + 8], 0xcd555b59
push dword [esp]
popfd
lea esp, [esp + 8]
call fcn.00799864
adc edi, 4
movzx ecx, word [esp]
neg byte [esp + ecx - 0xdc1a]
xor edx, ebx
or al, ah
cbw
shr cl, 3
dec edx
inc eax
or eax, 0x4293df85
neg edx
push eax
not dword [esp + ecx*2 - 0x1b806]
lea edx, [edx + ecx + 0x32b7a3a5]
cbw
ror cx, cl
sar ecx, 0x1e
bswap edx
shl ecx, 0x48
inc edx
xor ebx, edx
inc word [esp + ecx + 6]
add ebp, edx
push eax
mov dx, word [esi + ecx*4]
neg ecx
xchg dword [esp + ecx*8 + 8], eax
xor cl, byte [eax + esi - 0x5f4c2419]
dec ax
shr dword [esp + eax - 0x5f4c2414], 0x6d
inc eax
lea esi, [esi + eax - 0x5f4c2419]
shr dx, cl
jmp 0x7ac317

Function at 0xb74616
Capabilities:
Encrypt data using speck

Disassembly:
xor bl, al
pop edx
mov edx, dword [esp + 4]
neg dx
lea eax, [esp + eax + 0xc]
mov dword [eax], ecx
not dx
mov eax, dword [ebp]
js 0xc4f1d9
Function at 0xb7950c
Capabilities:
Encode data using xor

Disassembly:
ret
mov dword [esp], 0xe861ce1c
call fcn.00c2283e
mov ecx, 0x33bace94
mov ecx, dword [ecx + ebp - 0x33bace94]
push 0x22e5022
mov edx, 0xa2a514b9
add dl, 0xbe
adc ebp, 3
xor ecx, ebx
inc ecx
shl edx, 0x9a
neg ecx
shl dword [esp], 0xa6
fld st(1)
and al, 0
cmpsb byte [esi], byte es:[edi]
jp 0x79513d
sar edi, 0x81
sar dword [edx], 1
cmc
das
or ebp, eax
ret
adc ecx, 0xb2ff53a
call fcn.00735619
cdq
push ecx
and byte [ebx + ebp*4 - 0x58], dh
jmp 0xb79593
mov word [edi - 0x3d], fs
xchg esp, eax
ja 0xb79549
inc esi
pop edi
sub al, 0xe
mov dh, 0x51
xor esp, dword [edi - 0x4a]
push ds
mov bl, 0x2a
adc byte [edx - 0x46], ah
push ds
mov bl, 0x2a
adc bl, ch
ja 0xb7953f
mov ebx, 0x18d13a6a
push 0xadd156af
add eax, 0x72f54249
push ecx
and byte [esp + esi*2 + 0x77], dh
jmp 0xb795fa
int3
mov byte [0xcf75fffb], al
adc byte [edi + 0x33fe81], 0xd7
pop ebp
jae 0xb795dd
xor edx, dword [eax - 0x58cc6ae6]
or dword [ebp + 0x70], ebp
sub dword ss:[esi - 5], esp
pop ebp
jb 0xb7959d
lcall 0x55d5, 0xe738a23
mov al, 0x6b
stc
movsd dword es:[edi], dword [esi]
add ch, cl
out 0x5a, eax
xchg edi, eax
dec ecx
invalid

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

Disassembly:
jmp 0xbc5fd2
lea esp, [esp + 0x10]
je 0xb8c1e6
push ebx
Function at 0xb8b93c
Capabilities:
Encode data using base64
Encrypt data using speck
Parse credit card information

Disassembly:
cbw
inc ecx
pop ebp
dec ecx
adc ebx, edi
inc ecx
xadd bl, cl
inc ecx
sar ebp, 0x65
inc edx
xor al, byte [edi + ebx - 0x3174]
dec eax
mov dword [esp + ebp - 0xce01], esi
dec eax
lea edi, [edi + ebp*4 - 0x33811]
inc esp
sub al, byte [esp + ebp*2 - 0x19c00]
inc cx
sar eax, cl
sal dword [esp + ebp - 0xce01], cl
inc ecx
xor al, ah
dec ecx
lea edx, [esi - 0x30e75652]
not al
inc ecx
bts ebx, 0x80
pop esi
rol al, cl
inc ecx
add al, ch
dec esp
imul eax, edx
inc cx
not edx
rol al, cl
inc cx
neg eax
inc cx
adc edx, esi
inc esp
xor ah, al
sal dx, 0x4e
inc ecx
push ebp
inc esp
xadd byte [esp + ebp - 0xce00], ch
dec eax
lea eax, [esp + eax + 8]
inc esi
sub byte [esp + ebx*4 - 0xc596], al
inc esp
movsx edi, dh
inc ecx
push ebx
dec eax
mov esi, dword [eax + ebp*2 - 0x19c02]
ror byte [esp + ebp*8 - 0x67008], 0x21
dec ecx
mov dword [ecx + ebp - 0xce11], esi
dec esi
lea ecx, [ebp + ecx - 0xce11]
pop ecx
inc ecx
pop edx
jnp fcn.008a1785
inc esp
xor dword [esp + ebp*4 - 0x337fc], edi
xor cx, 0xbc26
dec esp
mov dword [esp + ebp - 0xce01], ebp
dec esp
mov esp, dword [esp + ebp*2 - 0x19bfa]
and ax, 0x9a1c
dec ebp
arpl di, di
je 0x784e38

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

Disassembly:
and dx, dx
lea eax, [esp + eax + 8]
xor cx, word [eax + edx*2]
movzx eax, byte [esp + edx + 4]
shl word [esp + eax*4 - 0x268], 0xe5
lea edi, [edi + eax - 0x9d]
mov word [edi + edx*2], cx
movsx ecx, dx
xadd dword [esp + edx + 4], ecx
sal eax, 0x97
pop eax
pop ecx
jae fcn.007ab350
push 0xaf99f635
mov eax, dword [esp]
xadd dword [esp], eax
mov edx, dword [edi]
call fcn.00793d3b
Function at 0xb8d4a4
Capabilities:
Encrypt data using speck

Disassembly:
add esi, edx
xor al, 0x21
mov edx, 0xebadaf1d
bswap eax
mov ecx, dword [edi + eax*2 - 0x42000000]
mov dword [esp + eax - 0x21000000], edx
mov edx, dword [eax + edi - 0x20fffffc]
bswap eax
rol eax, 0x94
not ecx
setne al
push eax
not edx
idiv al
shr ax, 0x82
neg eax
or ecx, edx
cdq
mov eax, ecx
ror dl, 0x83
mov edx, dword [edi + 8]
add eax, edx
mov edx, dword [esp + 4]
bt dx, 0x98
mov ecx, 0x7e071388
mov dword [edi + ecx - 0x7e071380], eax
shl edx, cl
xchg byte [esp + ecx - 0x7e071381], dh
call fcn.00c6befa

Function at 0xb915fc
Capabilities:
Encrypt data using speck

Disassembly:
mov eax, 0x1f3a9b94
sub byte [esp + eax - 0x1f3a9b90], 0xa3
lea ebp, [ebp + eax - 0x1f3a9b90]
movsx edx, al
xchg word [esp + eax - 0x1f3a9b8e], dx
ror dword [esp + eax - 0x1f3a9b90], 0x35
xor ecx, ebx
bswap ecx
sub ax, word [esp + eax*4 - 0x7cea6e4c]
ror ecx, 2
mul dword [esp + eax - 0x1f3ad394]
not ecx
shl dl, 0x62
rol eax, 0x81
bswap ecx
not edx
neg ecx
cdq
lea eax, [edx - 0x6c0535d]
sar word [esp + 3], 0x42
sbb ecx, 0x8dae3fa5
ror al, 0x61
neg dl
xor ebx, ecx
sal edx, 9
setp dl
not dl
add edi, ecx
pop edx
pop edx
jmp edi
shr dword [esp + ecx - 0x1a7ff], 0xc
xor ebx, eax
mov byte [esp + ecx - 0x1a7fe], dl
add ebp, eax
ror dword [esp + ecx - 0x1a800], cl
pop eax
pop edx
jae fcn.007ce4d4
clc
adc esi, 6
push 0x123b5e3c
sal word [esp + 2], 0xb
neg word [esp]
shld eax, edx, cl
mov ecx, dword [esp]
not dword [esp]
mov dword [esi], eax
push ecx
or ecx, ecx
mov ecx, dword [ebp]
ja 0x73a699
inc si
mov dword [esp + edi*4 - 0x63], edx
call fcn.00c611d7
call fcn.00b3b11f
pop ecx
dec eax
mov ebp, dword [esp + ebp - 0x2603]
dec eax
mov edi, dword [esp + eax*2 - 0xd6d461a]
jmp 0xbb661b
inc ecx
pop eax
dec eax
mov edx, dword [esp + eax*4 - 0x1ada8c54]
dec esp
lea ecx, [eax*2 - 0x21d2b143]
dec esp
mov ebx, dword [esp + eax - 0x6b6a2f5]
pop eax
dec eax
mov ecx, dword [esp + ecx - 0x1f3]
dec edx
mov esi, dword [esp + ecx*4 + 0x5195ac54]
dec esi
mov ecx, dword [esp + ecx + 0x14656b41]
dec esp
mov esi, dword [esp + 0x40]
inc ecx
mov eax, 0x1d3baa80
dec ebp
lea eax, [eax + 0x11193c94]
inc ecx
pop eax
dec eax
mov eax, dword [esp + 0x40]
inc ecx
pop eax
dec esp
mov esp, dword [esp + 0x40]
push 0x97a8acb6
inc ecx
mov eax, 0x7316f48d
call fcn.007f534d
mov edx, 0xd8ad819e
lea edx, [edx + edx*4 + 0x11a7c513]
lea eax, [edx + edx - 0x5efbf6ca]
mov eax, dword [eax + esi - 0x3b1aa388]
shr edx, 0xde
mov edx, dword [esi + edx*2 + 2]
mov cl, byte [esi + 8]
jae 0x8cd515
xor eax, 0x13329331
push ecx
jmp 0x818893

Function at 0xb92884
Capabilities:
Encrypt data using speck

Disassembly:
setp dl
mov word [ecx + esi - 0x54dd96e6], ax
mov dword [esp + ecx - 0x54dd96e6], edx
lea eax, [edx*8 - 0xa6929d3]
mov dword [esp + eax - 0x51b1862d], eax
mov ecx, dword [edi + eax - 0x51b1862d]
mul dx
pop eax
lea edi, [edi + edx - 0x4b832d0f]
xchg dx, ax
not edx
dec eax
xor ecx, ebx
sar eax, 0x64
call fcn.007d6960
inc ebp
mov edi, dword [ecx]
mov ecx, 0xf3a9be3f
mov ebp, 0x830cf2ba
inc esp
movzx esi, bp
inc edi
mov edx, dword [ecx + esi - 0xf2b6]
inc ebp
or edi, edx
dec ecx
btr esi, ecx
inc ecx
not edi
inc esp
movsx edx, cl
jae 0x8960a8
Function at 0xb99c81
Capabilities:
Encode data using xor

Disassembly:
push 0xbaab1a19
lea esp, [esp + 8]
je 0x7f6792
call fcn.00807db7

Function at 0xb9b97a
Capabilities:
Encrypt data using speck

Disassembly:
inc esp
movsx ebx, cx
inc ecx
xor esi, esp
inc ecx
mov esi, 0x240676b7
inc dx
neg dword [esp + edi*2 - 0x1b45ab76]
adc esi, ebp
inc ecx
shl bh, 0x85
inc ecx
not bh
inc ecx
xor dl, bl
not esi
inc ecx
pop esi
inc edx
lea esi, [esi + edi*4 + 0x481f0919]
rol esi, 3
dec esi
dec edx
rol dword [esp + edi*2 - 0x1b45aa3e], 0xb1
call fcn.00c59083
mov dword [esi + 0xc], eax
call fcn.008cb211
Function at 0xb9b99e
Capabilities:
Encrypt data using speck

Disassembly:
or ax, cx
mov eax, dword [ebp + eax - 0x4f9fffaf]
or dx, cx
neg ecx
lea ebp, [ebp + ecx*2 - 0xa2]
bswap edx
ror cx, 0xc1
xor eax, ebx
ror cx, 0xe9
dec eax
neg eax
lea ecx, [edx*2 + 0x69a69528]
btr ecx, edx
btc ecx, ecx
bswap eax
shr edx, cl
neg cx
adc ecx, edx
lea eax, [eax + edx - 0x6772fc36]
sub cl, 0xbf
ror cx, 5
mov eax, dword [ecx + esi - 0x2b121a8c]
mov cl, byte [esi + ecx*2 - 0x56243514]
sar dl, 0x22
shl dl, 0xc1
lea esi, [edx + esi - 0x1ac4]
jbe 0xc25bd8
push 0x7636ac8e
mov edx, 0x1981ac9b
mov eax, dword [esi + edx - 0x1981ac9b]
bt edx, edx
shr byte [esp + edx*4 - 0x6606b269], 7
jb 0xb5dcfc
xor bl, dl
bts cx, 0xa2
neg cl
not cl
add edx, esp
mov byte [edx + ecx*2 - 0x3c0c0006], al
lea eax, [ecx + ecx*4 - 0x72cc09d8]
inc ecx
jle 0x734123
mov edx, dword [esi + ecx*4 - 0x7818000f]
inc ecx
jg 0xba9516
xor edx, ebx
not ecx
sar eax, cl
rol edx, 3
rol eax, 0x64
ror ecx, cl
dec edx
xor cx, ax
lea eax, [ecx + ecx*2 - 0x166a486b]
sub al, 0x1d
rol edx, 2
add cl, 0x2c
dec ax
lea edx, [ecx + edx - 0x55f0135a]
sar eax, 0x42
cbw
xor ebx, edx
bts eax, ecx
jae 0xc3268a
sbb esi, 8
call fcn.00723c4f
dec al
add ebp, ecx
not dword [esp + edx*4 - 0x644f04e0]
mov dword [esp + edx - 0x1913c138], ebp
ret
lea edi, [edi + edx*2 - 0x3588]
xor ecx, ebx
movsx eax, dx
push edx
inc dword [esp + edx - 0x1ac6]
bswap ecx
lea edx, [edx + 0x1912a69b]
xchg byte [esp + edx*2 - 0x322582c0], dl
xor ecx, 0xbd9dd8b5
lea ecx, [ecx + eax*8 - 0x7c9ac555]
sub dl, byte [esp + edx - 0x1912c100]
bts edx, 0x90
neg ecx
dec word [esp + edx - 0x1913c139]
cbw
and eax, edx
inc ecx
dec edx
rol eax, 0x58
neg ax
xor ebx, ecx
cwde
jmp 0x8127ce
xor dl, 0x2c
neg cl
xor eax, eax
xor bl, dl
add edx, esp
lea ecx, [eax + eax*2 - 0x3b780fdc]
xor al, byte [edx + eax*2]
neg ecx
mov word [edi + ecx*2 - 0x76f01fb8], ax
movzx edx, cl
setnp dl
jmp ebp
mov ecx, dword [esi + edx - 0x1981ac97]
shr edx, 0x54
not dx
mov dword [esp + edx*8 - 0x7f338], ebx
mov ebx, edx
shl edx, 0xc9
cpuid
ja 0xc3bc54
call fcn.00b6e6d8
mov ecx, 0x2b121a8c
movsx edx, cx
jmp 0x753447
jge 0x76309c
shr eax, cl
lea ecx, [edx*4 + 0x78311786]
mov dword [esi + edx*2 - 0x358c], eax
mov ecx, dword [edx + edi - 0x1ac6]
jmp 0x847f0f
adc eax, 0xb6a2a916
adc ebp, edx
btr ecx, ecx
movzx edx, byte [esi + ecx - 0x7e7ffe5f]
not cx
mov eax, dword [0x66818001]
not ecx
sub cx, cx
lea esi, [esi + ecx - 0x7e7efffa]
lea eax, [ecx + ecx + 0x1e8c8983]
sub ecx, 0x8216c509
sal ecx, cl
xor dl, bl
neg cl
adc dl, 5
xchg cx, ax
shr ecx, 0xae
shr ecx, cl
neg dl
xadd al, ch
sbb dl, 0xe
shr cx, 0x8a
shr ax, 7
jp 0x8b9f74
test al, 0x7c
add byte [esi + 0x33], 0x21
jo 0xc32698
cmp dword [edx - 0x67c7decc], 0x2134bac1
clc
call 0x21f7e18d
add byte [ecx + ebp*8 + 0x502134ba], 0x7c
inc ecx
mov edx, 0xd8182134
xchg ecx, eax
mov edx, 0x34c82134
adc dword [edx - 0x6677decc], edi
cmp dword [esi + 0xe], 0xffffffc1
dec ebx
adc esi, dword [ebp + esi*8 - 0x292f3e9f]
ret 0x48e
ja 0x7bc98e
call fcn.00743660
Function at 0xb9c0fd
Capabilities:
Encrypt data using speck

Disassembly:
adc eax, eax
pop ecx
pop eax
ja fcn.007a41b7
inc ebx
leave
arpl word [0x2eb3541f], cx
jmp 0xb3d19405
lea esp, [esp + 4]
jmp 0xb9b982
call fcn.00753ecf
inc al
lea edi, [edi + eax - 0xe69295]
mov word [edi + eax*8 - 0x7349498], cx
jno 0x7d74cc
mov dword [esp + 0xc], 0xc1371521
add ebp, ecx
lea esp, [esp + 0x18]
push 0x7ba7e715
jmp 0x8a1605

Function at 0xb9ccb2
Capabilities:
Encode data using base64

Disassembly:
dec ebp
mov edi, dword [ecx]
dec ecx
mov ecx, dword [ecx + 8]
dec ecx
mov dword [edi], ecx
dec eax
mov dword [esp], 0x5c986501
mov ecx, dword [edi - 4]
dec eax
add edi, 0xfffffffc
inc ecx
mov ebx, 0xfd9bc58b
call fcn.00b6a0a6

Function at 0xba5b25
Capabilities:
Encrypt data using speck

Disassembly:
lea edi, [edx*8 + 0x698d4c1b]
mov esi, ecx
inc eax
adc dh, 0xa7
inc ebp
xor esi, esp
call fcn.00bdc541
not eax
adc ebp, 1
xor dl, bl
or word [esp + 2], ax
btr ax, ax
neg dl
cwde
call fcn.00853d71
sbb edx, edx
ror ecx, 1
call fcn.0083202c
dec esp
jo 0x888542
fnstenv [ebx - 0x1f]
jae 0x888488
mov dl, ch
mov esi, ds
mov bl, 0x9f
cli
aad 0x8c
fiadd word [ebx - 5]
retf 0x8cd5
mov ah, 0x22
xor eax, dword [ebp + 0x22f486e2]
xor eax, dword [ebp - 0x69bde0fa]
invalid
dec eax
add ecx, ebx
jmp ecx
mov dword [esp + ecx*2 - 0x794b2f4c], ecx
mov cx, word [esi + ecx*2 - 0x794b2f4c]
movzx eax, dx
or dword [esp + edx - 0x851c], 0x781c7533
or dl, dh
lea esi, [esi + edx - 0x859b]
cbw
and ax, 0x7cb8
movzx edx, byte [edx + ebp - 0x859d]
sar ax, 0xe3
ja 0x8884c9
inc ecx
and bl, 1
inc edi
mov edi, dword [ecx + edx*2 - 0x335d0834]
inc ebx
mov cl, byte [ecx + edx - 0x19ae8414]
inc cx
neg eax
inc ecx
neg ebx
dec edi
lea ecx, [ecx + ebp - 0x7ad13eff]
inc ecx
inc ebp
dec eax
lea eax, [esi + 0x59302499]
shl ax, 0xc1
inc ebp
shrd esi, edi, cl
inc ecx
div ebp
inc edi
mov dword [ecx + edx*2 - 0x335d0838], esi
inc ecx
movsx ecx, bl
jmp 0xb5d902

Function at 0xba9079
Capabilities:
Encrypt data using speck

Disassembly:
inc edx
add eax, dword [esp + ecx*2 - 0x96c]
xor ebx, edx
add ebp, edx
ror ecx, 0x1b
pop ecx
pop eax
pop ecx
jae fcn.007e2cc2
Function at 0xbaa4c3
Capabilities:
Encrypt data using speck

Disassembly:
dec ebp
mov edx, ecx
dec ebx
lea edx, [esi + edi + 0x103347ac]
imul si
dec edi
lea ecx, [ecx + esi*4 - 0x250]
dec esi
mov dword [esp + esi - 0x92], edi
inc esi
and byte [esp + esi - 0x90], dh
dec edi
mov dword [ecx + esi - 0x92], edx
inc edx
sub esi, dword [esp + esi - 0x90]
call fcn.007d408b
inc ecx
movsx ecx, ax
inc cx
neg eax
dec esi
mov esp, dword [esp + esi - 0x8a]
inc ecx
sal ch, 0x66
dec eax
arpl dx, dx
dec edi
lea eax, [ebx + ebp*4 + 0x4c90e90b]
dec eax
adc ebx, edx
inc ecx
pop ebx
sar ax, 0xab
js 0x73c190
mov eax, 0xf401702a
lea ecx, [eax*8 - 0x37f06944]
cbw
mov ecx, dword [ebp + ecx - 0x681b180c]
cdq
shr eax, 0x9f
lea ebp, [eax + ebp + 3]
sbb dl, al
neg edx
rol dx, 0x4a
xor ecx, ebx
add ecx, eax
neg eax
ror eax, 0xe1
xor ecx, eax
neg ecx
bts eax, edx
not edx
add ecx, eax
push edx
shr al, 0x85
dec byte [esp + 2]
xor ebx, ecx
cdq
and al, 0x86
adc edi, ecx
mul edx
mov si, word [esi + eax*2 - 0x1f4]
pop ecx
jb fcn.0075bcd3
xor byte [esp + ecx - 0x53f8f108], ch
xor al, bl
call fcn.00712962
xor bx, cx
add al, al
cwde
mov word [esi - 2], cx
mov edx, dword [edi + 2]
lea ecx, [eax + eax - 0x3965207c]
shl eax, 0x98
rol eax, 0xa1
xor edx, ebx
sal ax, 0xaa
dec edx
call fcn.007954ae
call fcn.00b98cec
dec esi
mov dword [esp + esi - 0x92], eax
inc edx
xor dword [esp + esi - 0x8a], edx
jmp 0x7a4023