joyce8/EMBER2024-capa huggingface dataset:
Function at 0x1318887
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
rol cl, 1
sub word [esp + edx*2 - 0x416000e3], ax
xor bl, cl
cwd
ror dword [esp + edx*2 - 0x4161fffa], 0xe9
lea ecx, [esp + ecx + 8]
mov eax, dword [edx + ecx - 0x20b0ffff]
mov ecx, eax
mov edx, dword [ecx + edx*2 - 0x4161fffe]
mov dword [esi - 4], edx
mov eax, 0xc73b352f
sbb esi, 3
lea edx, [eax + eax - 0x1bd181de]
lea eax, [edx*8 - 0x19e2efcf]
or dword [esp + edx - 0x72a4e87c], 0xf6bd0080
pop edx
pop edx
jnp fcn.013c73b8
xor cl, bl
mov dword [esp + edx - 0x20b00074], eax
neg cl
dec dword [esp + edx - 0x20b00070]
dec cl
neg cl
and eax, eax
jg 0xc3e689
mov eax, 0x71012116
call fcn.0135940a
salc
insb byte es:[edi], dx
pop ss
pop esp
pop esp
push ds
sahf
or dword [edx], 0xa61a5cd2
mov dword [edx], ecx
rcr byte [edx + eax - 0x62], cl
test dword [edx], ecx
rcr byte [esi + ebp*8 - 0x17], cl
outsd dx, dword [esi]
pop esp
xor esp, dword [0x55e43f00]
cmp byte [edi], ah
in al, 0x85
pop ebp
jae 0xd46be4
cmp ecx, esp
adc ecx, dword [ecx - 0x34]
imul ebx, ecx, 0x1c
adc word fs:[edi - 0x74], si
adc dword [eax], 4
insd dword es:[edi], dx
xor eax, 0x982cd488
or cl, byte fs:[ebx + 0x45d9964d]
inc eax
or eax, 0xa343317
jb 0xd46bac
retf 0x71d2
aas
push ss
retf
imul cx, cx
add edi, eax
movzx ecx, byte [ebp + ecx - 0x7426405]
rol dx, 0x2c
lea eax, [edx + edx + 0x54169692]
lea ebp, [edx + ebp - 0x7420b05]
rol edx, 0xc
jae 0xd46b6a

Function at 0x1328e20
Capabilities:
Authenticate hmac

Disassembly:
add dx, dx
adc eax, ecx
mov dword [ebp + edx - 0x6e21d62e], eax
lea edi, [edi + edx - 0x6e21d632]
mov ecx, dword [edi + edx - 0x6e21d62e]
xor ecx, ebx
lea eax, [edx - 0x61706f6d]
xor ecx, 0x8b2aa4a8
lea edx, [edx + 0x24111d92]
dec edx
dec edx
dec ecx
not ecx
bswap ecx
btc edx, eax
btc eax, 0xa
xor ebx, ecx
shl al, 0xe5
call fcn.013b0d00
call fcn.00d0dc9e
bswap eax
sub cx, cx
setne dl
jg 0xc9507a
lea eax, [edx + eax - 0x14e12c48]
pop edx
or dword [esp + ecx - 0x38820000], 0xbd2fcda4
xor ebx, eax
movsx edx, cx
inc edx
neg ecx
add edi, eax
inc dx
sal edx, 0xf
movzx ecx, byte [esi + edx*2 - 0x20000]
push edx
je 0x135e9b6
lea esi, [edx + esi - 0xffff]
lea edx, [edx + 0x7a0aa42b]
call fcn.014c5a82
mov eax, dword [ebp]
mov edx, 0x3710b58b
mov ecx, dword [edx + ebp - 0x3710b587]
bt edx, edx
adc edx, edx
lea ebp, [ebp + edx - 0x6e216b12]
inc edx
jne 0xb88c83
lea edx, [ecx*4 - 0x3dff71f1]
call fcn.00c0e2ba
movsx edx, al
mov edx, dword [edi + eax*2 - 0x5f6a9238]
neg eax
movzx cx, byte ss:[edx]
lea edx, [eax*8 - 0x7e7be756]
lea edi, [edx + edi - 0x3d9cfc8]
mov word [edi + edx*2 - 0x7b39f94], cx
lea esi, [esi + edx*2 - 0x7b39f98]
lea edx, [edx*8 - 0x5f5ff3f0]
js 0x153b8c4
Function at 0x133114c
Capabilities:
Encode data using xor

Disassembly:
mov ax, word [edi + ecx - 0x4438ad8b]
mov dword [esp + ecx - 0x4438ad8d], ecx
xchg word [esp + ecx - 0x4438ad88], cx
setnp cl
mov cl, byte [edi + ecx - 0x443837fd]
adc edi, 3
shld dx, ax, cl
mov word [edi], dx
call fcn.01359e4d
or eax, 0x986408b4
pop ebp
xlatb
xor dword [ecx], eax
fsubr dword [edx + 9]
xlatb
xor dword [ecx], eax
in al, dx
pop esi
sub edi, edx
xor dword [ecx], eax
sub al, 0x96
adc edi, edx
xor dword [ecx], eax
test dword [edx + 0x7c], edx
fcom dword [esi + edi*8]
jl 0x1331190
nop
xchg ebp, eax
shr dword [eax - 0x7a], 1
das
xchg esp, eax
xchg esi, eax
invalid

Function at 0x133f3a7
Capabilities:
Encode data using base64

Disassembly:
mov dword [esp], 0x3b0a3b21
mov dword [esp], eax
dec ebx
jne 0x156d32b
Function at 0x134745a
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
mov dword [esp + 4], 0xe601a115
mov ecx, dword [esp + 4]
mov dword [ebp], eax
call fcn.00c71944

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

Disassembly:
not ecx
movzx edx, al
jmp 0x14bf14f
push 0x20334b8b
lea esp, [esp + 8]
jne 0x14624c7
pop esi
mov eax, 0x9601822c
jmp 0xc6b882
xor ebx, edx
shr cx, 0xae
adc ebp, edx
call fcn.00b8ca00
inc esp
movzx ecx, word [esi + ecx - 0x111d2783]
inc bp
xor ecx, edi
inc bp
add ecx, ebx
inc ecx
inc ebx
inc ecx
movsx edx, bl
inc cx
not ecx
setp dl
inc cx
rol ecx, 1
xadd bx, dx
inc cx
inc ecx
inc esp
sub ebx, ebx
dec ebp
lea eax, [ebx + ebx*2 + 0x4e994413]
dec ecx
bt ebx, 0x2a
inc bp
xor edi, ecx
inc cx
btr eax, 0x23
inc eax
mul ch
div bx
dec esp
add ecx, esp
inc ecx
sar bl, cl
inc ecx
sub al, 0x94
dec esi
mov dword [ebx + ecx - 0x400404b1], edx
inc esp
btr ebx, ebp
jb 0x1407e13
mov eax, 0x8a35e011
mov ecx, 0x5286e9b
movzx edx, ax
lea ebp, [ebp + edx*8 - 0x7008c]
mov eax, dword [ecx + ebp - 0x5286e9b]
bt edx, ecx
sar ecx, cl
xor eax, ebx
sub eax, 0xbf34a739
call fcn.00d3e1a1
mov esi, 0xad148728
movzx esi, byte [eax]
mov dword [esp], 0xfdb2c03d
xor esi, ecx
and esi, 0xff
mov esi, dword [esi*4 + 0x1459d7c]
shr ecx, 8
xor ecx, esi
jmp 0x143778d
dec esp
lea edx, [edx*2 + 0x429419a4]
jmp edi
shr dword [esp], 0x72
inc eax
not word [esp]
xor ecx, 0xd5b9dc88
dec edx
jmp 0xca3912
lea edx, [eax*4 - 0x29dfe8f3]
mov dword [edi + edx*2 - 0x5c4c3f72], ecx
lea edi, [edi + edx - 0x2e261fb5]
push eax
imul edx, eax
pop eax
mov edx, dword [esi + edx*2 - 0x50d0dcf8]
mov ecx, eax
sar eax, cl
not cl
sbb esi, 0xfffffffc
sub eax, ecx
dec ecx
rol ecx, cl
xor edx, ebx
inc cl
inc edx
lea eax, [eax*4 + 0x7c938097]
not edx
shl ecx, 0x46
and ax, ax
ror edx, 1
dec cl
not edx
shl eax, 0x14
jbe 0xcce5b8
movzx eax, byte [edi]
inc edx
call fcn.00cde8e3
xor eax, ebx
call fcn.0148696a
Function at 0x1349db6
Capabilities:
Encode data using base64

Disassembly:
adc esi, 4
dec word [esp + 3]
movzx edx, word [esp + 2]
inc byte [esp + edx - 0x9bf9]
xor eax, ebx
ror edx, cl
rol eax, 1
add word [esp + edx - 0x9bfef], 0x490d
sub cx, dx
or edx, edx
lea eax, [eax + edx*4 - 0x4c4c53e6]
bswap eax
xchg cx, dx
jns 0x145d37f
mov edx, 0x4f2db4be
dec eax
lea esi, [esi + edx - 0x4f2db4c2]
mov ebx, dword [esi + edx - 0x4f2db4be]
inc ecx
mov eax, 0x11bb792c
inc ebp
movsx ecx, al
dec ecx
lea eax, [ecx + edx + 0x33b72009]
inc ecx
xor ebx, edi
inc cx
xadd ecx, edx
inc ecx
movzx ebp, al
dec esp
lea ebx, [ebp + ebp*8 - 0x6762f07c]
dec ebx
not ebx
cdq
dec edi
lea ecx, [eax + eax*2 + 0x230a7e21]
inc ecx
push ecx
xor ebx, 0x7a0dca9d
pop eax
xor ebx, edx
inc esp
movsx edx, ch
inc ecx
push edi
inc ebp
and dl, al
inc edx
xor dword [esp + eax - 0x11bb792c], ebx
inc eax
sal ch, 0xa1
inc cx
not ecx
inc ecx
pop edi
inc ebp
movsx ebp, bx
cdq
dec ebp
lea ecx, [eax - 0x467d69ef]
dec eax
arpl bx, bx
jnp 0x1464a23
and dl, cl
or eax, eax
not dl
mov dword [esp + eax - 0x70ffd29c], eax
lea ecx, [eax*4 - 0x25ecc6b]
cwde
mov word [ebp], dx
xchg word [esp], cx
xchg dword [esp + 3], eax
mov eax, dword [esi]
jae 0xd43ab2
mov edx, dword fs:[ecx + eax*4 - 0xc7b9058]
xor dword [esp + eax - 0x31ee416], eax
movzx ecx, al
mov dword [ebp + eax - 0x31ee416], edx
sub word [esp + eax - 0x31ee414], 0x5523
lea edi, [edi + eax - 0x31ee41a]
sub eax, 0x58881c14
neg al
xchg word [esp + ecx*8 - 0xb0], ax
mov ecx, dword [ecx + edi - 0x16]
setns byte [esp + 1]
xor ecx, ebx
sub eax, dword [esp]
sub dword [esp], eax
mov dword [esp], eax
xor ecx, 0x60361689
cwde
movsx edx, al
mul dword [esp]
dec ecx
jmp 0x13c1c18
shr edx, 0xbf
adc dword [esp + edx - 1], eax
neg ecx
xor ecx, 0xc0b067af
add word [esp + eax - 0x26c59881], 0x8b4
shl edx, 0x13
xor ebx, ecx
add esi, ecx
dec dword [esp + eax*2 - 0x4d8b3102]
movsx ecx, dl
mov dword [esp + eax*2 - 0x4d8b3102], esi
ret
lea eax, [eax + edx + 0x6a36eb12]
adc edx, ecx
neg eax
sal edx, cl
xchg ecx, edx
xor ebx, eax
push ecx
add edi, eax
push ecx
movzx eax, word [esp + 0xc]
xadd eax, ecx
mov dword [esp + ecx*4 - 0x3ff48], edi
ret 0xc
dec eax
adc edi, ebx
dec ebp
mov edx, dword [esi + edx]
inc ecx
movsx ebx, ax
dec eax
cdq
dec ebp
lea esp, [ebp - 0x30dab44f]
inc bp
mov eax, dword [edx + edx*4]
dec ecx
inc ebp
dec esp
cmovnp ebp, edx
dec ebp
lea esi, [esi + edx + 6]
dec ecx
cmove edx, ecx
inc bp
mov dword [esi + edx*2], eax
call fcn.01450bec

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

Disassembly:
inc ebp
lea edx, [edx + ebx + 0x591b6d2a]
inc ecx
not edx
call fcn.0156a6e9
mov bx, ax
movsx ebx, bp

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

Disassembly:
mov dword [esp], 0xd303bfcb
call fcn.014c1c08

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

Disassembly:
add edx, edx
xor cl, bl
mov dword [esp + edx*4 - 0x6f800000], edx
xor edx, 0xd398a814
sal byte [esp + 2], 0x64
not cl
add word [esp + 2], dx
btr edx, 0x86
call fcn.00d9f88e
mov esi, fs
outsb dx, byte [esi]
invalid
Function at 0x135d461
Capabilities:
Authenticate hmac
Encode data using base64
Encrypt data using speck

Disassembly:
div eax
cdq
xor bl, cl
lea ecx, [esp + ecx + 8]
lea edx, [eax + edx*2 - 0x5ed558cd]
neg ax
btr dx, 6
mov eax, dword [ecx + eax*2 - 0x1fffe]
movzx ecx, dx
call fcn.00c55800

Function at 0x1364228
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
lea edi, [edi + eax*2 - 0x5ac3404]
adc al, cl
mov dword [esp + eax*2 - 0x5ac35fe], eax
cwde
xor edx, ebx
call fcn.012e8068
sbb esi, 0xfffffffa
xor cl, bl
bt eax, eax
not cl
ror al, 0x84
xadd dl, ah
adc cl, 0x9e
sar edx, 0xee
cwde
xor cl, 0x97
rol ax, 0x8b
sar eax, 0x6c
inc cl
neg cl
ror eax, 0x76
xor bl, cl
xadd dl, ah
add ecx, esp
mov dx, word [ecx]
btr eax, eax
lea ecx, [eax*4 - 0x78d5a6e8]
mov word [ebp + eax - 0x7ffff003], dx
shr ecx, cl
lea ebp, [ebp + ecx*2 - 0x10e8]
movsx edx, al
bt eax, eax
jae fcn.0149336d

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

Disassembly:
dec esp
mov dword [esp + edx], edi
inc esi
xor dword [esp + edx + 0x53d73b43], esp
inc cx
inc eax
inc ecx
pop edi
ror edx, 0xa5
inc ebp
movzx ebp, bx
dec ebp
arpl sp, sp
inc cx
btc eax, 0x9c
dec eax
lea ecx, [edx + edx - 0x605bfb6b]
dec ecx
adc edi, esp
dec ecx
btr ecx, eax
cbw
dec edx
lea ebx, [ebx*8 - 0x406baf70]
dec ebp
mov ebp, dword [esi + eax - 0x747bfff5]
dec ecx
dec ecx
inc ecx
imul ebx
jo 0x12d16f2
inc dx
setle dl
lea eax, [edx + eax - 0x2e13b946]
btc cx, cx
inc cl
rol edx, cl
ror eax, cl
btc ecx, ecx
not eax
neg eax
sub dx, dx
lea eax, [eax + edx - 0x6c7c305e]
and ecx, 0xf619842d
rol eax, 1
rol cl, cl
xor ebx, eax
btc ecx, ecx
not edx
shr cl, cl
add ebp, eax
lea edx, [edx*2 - 0x6cfe5568]
lea ecx, [ecx + edx*8 + 0xf3007b4]
mov dl, byte [edi + edx - 0x15dbaa96]
btr ecx, ecx
movsx eax, cl
neg ax
mov al, byte [edi + 2]
adc edi, 1
dec cl
bts ecx, ecx
imul dl
imul cx, cx
sal ecx, cl
mov word [edi], ax
bts cx, 0x9a
lea eax, [ecx*8 - 0x1daec79]
movsx edx, cl
or edx, ebp
jmp edx
mov eax, 0x9fa2e883
movsx ecx, al
mov eax, dword [esi]
sub cl, 0x86
mov ecx, dword [esi + 4]
ja 0xc80ab3
mov edx, 0x1a2d0314
push ebx
mov ebx, edx
cpuid
jno 0x14d77ee
inc ecx
dec esp
dec edx
mov dword [esp + eax - 0x722d7eb4], 0xac28c4bd
dec esi
xchg dword [esp + eax - 0x722d7eb4], edx
dec esp
xadd dword [esp + eax - 0x747b26f5], eax
inc ecx
xor esp, 0xe521332d
inc cx
shl eax, 1
inc ecx
not esp
jl 0xc28c7f
jmp 0x136a735
Function at 0x1371597
Capabilities:
Encode data using base64

Disassembly:
rol ecx, cl
ror dx, 1
shr eax, cl
xor bx, dx
call fcn.0138b720
xor dx, 0xf781
and ecx, eax
movzx eax, dx
not ecx
mov dword [edx + esi - 0x1e47], ecx
bts edx, 2
lea ebp, [ebp + edx*8 - 0xf23c]
mov eax, dword [ebp + edx*2 - 0x3c8e]
neg dl
xor edx, edx
movsx ecx, dl
xor eax, ebx
bts edx, edx
ror edx, 0x54
call fcn.014d4525
xchg byte [esp + 3], dh
xor al, bl
add al, 0xa4
sub byte [esp + 1], 0x31
ror al, 1
movzx ecx, dx
mov dword [esp + ecx*2 - 0xfe28], ecx
add al, 0x3d
rol al, 1
and dx, 0x44b4
sbb al, 0xa
shr cl, 5
and cl, dl
pop ecx
neg al
imul dx, dx
bswap ecx
xor bl, al
shr cl, 0xa1
adc eax, esp
imul ecx, edx
xor cl, byte [eax + ecx - 0x66700000]
inc edx
je 0x132e965
jno 0x129c4f8
dec eax
lea eax, [esp + eax + 0x28]
dec esp
mov ebx, dword [eax + ecx - 0x18000000]
dec eax
inc dword [esp + ebx*2 - 0x314c80b2]
inc ebp
movzx esp, al
dec dl
dec ebp
mov dword [esi + ebx*4 - 0x62990164], ebx
inc esp
mov esp, dword [ebx + esi - 0x18a6405f]
dec eax
lea esi, [esi + ebx*2 - 0x314c80b8]
setns bl
dec eax
xchg dword [esp + ecx - 0x17ffffe0], ebp
inc ebp
xor esp, edi
dec esp
lea edx, [ebx + ebx*4 + 0x34b5528d]
jmp 0x13aca69
sar edx, 0x2c
sbb eax, 0x6134dea4
mov dword [esp], 0x5333e4b1
xor dword [esp], 0xe217759d
rol eax, cl
not ecx
shl ecx, 0x52
lea edx, [ecx - 0x33efe5c9]
bswap eax
not dl
xor ebx, eax
call fcn.014c133f
mov eax, 0x54a96a2d
cbw
rol al, 0xe1
movzx ecx, byte [ebp + eax - 0x54a9005b]
mov edx, eax
jae 0xd25e87
mov edx, 0x893270a4
dec edx
mov ecx, dword [ebp + 4]
push edx
call fcn.013270f8
inc ecx
bt eax, edx
dec edi
lea esi, [esi + ebp - 7]
inc ecx
ror ah, 1
inc esp
and edx, eax
inc ecx
not edx
dec esp
xchg dword [esp + 8], esp
dec ecx
add esp, 0x272dd
inc ecx
jmp esp
btr eax, 0x92
mov dword [esp], eax
ror dx, 1
sar ax, 0x4d
sbb dx, 0x208f
jmp 0x12c3a83
inc ebp
inc ecx
ror esp, 3
inc ebp
lea esp, [esp + ebx*2 - 0x18c8b4d2]
inc ecx
movsx eax, ax
inc ecx
rol esp, 1
sar dword [esp + ebx*4 - 0x6298fff6], 0xcf
inc ecx
inc ecx
inc ecx
bswap esp
inc esp
movsx ebp, dl
inc ebp
lea esp, [esp + ebx*2 + 0x29b43d29]
imul word [esp + ebx*2 - 0x314c7ff5]
sal eax, 0x8a
rol ax, 0xcb
inc ecx
xor esp, 0x98ead99
call fcn.00d3141b

Function at 0x1380e25
Capabilities:
Authenticate hmac

Disassembly:
push ecx
mov cx, word [esi + eax*8 - 0x7fd76]
mov dword [esp + eax - 0xffab], eax
or dx, cx
push eax
inc eax
not dx
mov ecx, eax
dec word [esp + eax - 0xffb0]
mov word [eax + esi - 0xffae], dx
mov edx, 0xf6863108
mov eax, dword [eax + esi - 0xffae]
cmovs ecx, edx
dec cl
mov cl, byte [esi + 6]
or edx, edx
shr edx, 0xfd
shl eax, cl
mov dword [esi + edx - 3], eax
movzx eax, dx
call fcn.013eab97
Function at 0x13892db
Capabilities:
Authenticate hmac

Disassembly:
xor bl, dl
lea edx, [esp + edx + 4]
btr ecx, 0xac
sub eax, eax
and word [esp + ecx - 0x7998c780], ax
xor ax, word [edx + ecx - 0x7998c780]
imul ecx, dword [esp + ecx - 0x7998c780]
lea edi, [edi + ecx - 0x44800002]
lea edx, [ecx + ecx*2 + 0x890ed95]
sub byte [esp + ecx - 0x447ffffe], dh
jnp 0x14b332b
mov edx, dword [edi]
mov ecx, 0x5fa62a25
mov eax, dword fs:[edx + ecx - 0x5fa62a25]
call fcn.0152ee7d
inc esp
mov esp, dword [esp + ebx - 0x6c98ea8b]
inc ecx
not ebp
inc ecx
shl esp, 0x90
dec esi
lea edx, [ebx*4 - 0x38ed677f]
dec ecx
btr esp, 0x18
inc edi
lea ebp, [ebp - 0x26f06933]
dec eax
lea edx, [ecx + ebx*8 - 0x45fa051]
ror ebx, 0x33
jae 0x14b27e9
inc edx
dec dword [esp + eax - 0x7213d00c]
not cl
jl 0xc81585
bound esp, qword [0x69566a6a]
jg 0x12e32fb
sbb dh, byte [ebx]
leave
jle 0x1366b14
jmp 0x14f6ac6
movsx eax, cx
shr eax, 0xbd
xor dl, bl
mov dword [esp + eax], ecx
inc dl
or dword [esp + eax], eax
rol dl, 1
not dl
btr ax, cx
dec dl
sub ecx, dword [esp + eax*8]
sub ecx, dword [esp + ecx]
add eax, eax
not dl
jno 0x12e31e2
call fcn.013d08a7
mov eax, 0x5fa26
mov edx, eax
xadd eax, edx
mov edx, dword [esi + eax - 0xbf44c]
jg 0x13a000f
mov eax, dword [ebp]
mov cl, byte [ebp + 4]
push 0x22317f86
shl eax, cl
mov dword [esp], 0x57a9da00
call fcn.0147b63b
mov eax, dword [eax + ebp - 0x7e61e804]
mov ecx, 0xdd3a3e8a
sub ebp, 4
shl dword [esp], 0x9a
xor eax, ebx
pop ecx
lea edx, [ecx - 0x395c61eb]
sal edx, 0x5c
lea eax, [eax + ecx - 0x56dcd960]
adc dl, dl
not ecx
not eax
jg 0x14d558b
inc ecx
neg ebp
inc esp
movsx ecx, bp
dec ebp
lea eax, [ebx + ebp - 0x7e7e8063]
push ebx
dec esp
mov dword [esp + ebx*2 - 0x3aa2db1e], edi
inc esp
mov edi, dword [esp + ebx*2 - 0x3aa2db25]
rol dl, 0x84
inc ecx
setb ah
inc esp
xor dword [esp + ebx - 0x1d516d8b], ebp
dec eax
dec dword [esp + ebx - 0x1d516d93]
js 0x14326f0
dec ecx
ror esp, 0x27
dec esp
mov edi, dword [esp + ebx*2 - 0x3aa2db1e]
setae byte [esp + ebx - 0x1d516d91]
inc ebp
sub eax, esp
dec ebx
lea ebp, [ecx + eax*2 + 0x59824795]
dec ebp
arpl bp, bp
dec ecx
inc esp
dec ecx
adc edi, ebp
push ebp
dec eax
mov dword [esp + ebx*4 - 0x7545b64c], edi
ret 0x10
mov word [edi + ecx - 0x44800000], ax
lea eax, [edx*2 + 0x549efd3f]
xadd dword [esp + ecx - 0x44800000], ecx
pop ecx
jle fcn.0140b7dc
mov dword [esp], 0x219ab138
lea esp, [esp + 0x10]
ret

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

Disassembly:
lea esp, [esp + 0x10]
jne 0x154e337
call fcn.0136b267
sub ebp, 4
mov ecx, dword [ebp]
mov eax, 0xaea1b9a1
xor ecx, ebx
dec ecx
movzx edx, ax
bswap ecx
sal ax, 0x64
inc ecx
shr dx, 1
mul al
rol ecx, 1
sar edx, 0x3b
sub al, dl
xor ebx, ecx
add edi, ecx
inc dx
movzx ecx, ax
cdq
mov ecx, dword [ecx + esi - 0x100]
dec dx
bswap eax
movzx ax, byte [ecx + eax*2 - 0x3435c]
movsx ecx, dl
not cl
ror dx, cl
adc esi, 2
sal ecx, 0x91
mov word [esi], ax
jb 0x12f90b4
xor ecx, edx
jmp edi
xor eax, 0xcbba1abe
dec edx
push 0x240ef5a6
jmp 0xcdd9d2
Function at 0x1396e33
Capabilities:
Encode data using xor

Disassembly:
sub ebp, 4
mov dword [esp], 0x3804c928
xor dword [esp], 0xdb877493
je 0x12c2c2c
mov eax, dword [ebp]
inc word [esp + 2]
xor eax, ebx
mov ecx, 0x8e2ed795
shr ecx, 0x66
lea eax, [eax + ecx*8 - 0x166bd279]
not eax
xchg dword [0xd0f7e994], ebp
movsx edx, cx
ror dx, 0xc6
bswap edx
bswap eax
adc cl, byte [esp + ecx*2 - 0x47176bc]
pop ecx
ror ecx, 0x8a
not eax
xor ebx, eax
add edi, eax
mov eax, dword [esi + ecx - 0x6ef8e12f]
call fcn.01360154
inc esi
wait
shr byte [ebx + 0x1e], 1
dec dword [eax]
popal
mov edx, 0xad723f1b
jecxz 0x1396e65
sbb edi, dword [edi]
inc esp
xchg ebp, eax
mov edx, 0xd0eb3f1b
in al, dx
mov bh, 0x89
xchg edi, eax
invalid

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

Disassembly:
xor ebx, ecx
xor edx, edx
cmovs eax, edx
adc edi, ecx
or edx, dword [edx + ebp]
movzx ecx, ax
call fcn.01359cb5
inc ecx
mov ebx, 0x45876699
inc ebp
sub ebx, ebx
inc di
mov ecx, dword [esi + ebx*4]
inc ecx
movsx edx, bl
inc di
or ebx, dword [esi + ebx + 2]
dec ebp
lea esi, [esi + edx + 2]
mov eax, edx
dec esp
lea edx, [eax*4 + 0x52823527]
inc cx
not ecx
inc cx
not ebx
push eax
inc ecx
mov ecx, edx
inc bp
and ecx, ebx
inc si
mov dword [ecx + esi - 0x52823527], ecx
inc esp
mov ebx, dword [esp + edx*4 + 4]
dec eax
imul edx
rol cx, cl
dec eax
lea esi, [edx + esi - 4]
mov ebp, dword [edx + esi]
inc esp
xchg dword [esp + edx*8 + 3], ebx
not ax
inc esp
xor bl, byte [esp + edx*2 + 2]
inc ecx
xor ebp, edi
shr cl, 7
neg ebp
inc ecx
pop ebp
inc ebp
xchg dl, bl
lea ebp, [edx + ebp - 0x1d93228f]
cwd
xor cx, ax
jg 0x13b82b3
call fcn.014d3cd1
mov eax, 0xbf3d3f2a
mov ecx, 0xd33ec98a
mov ecx, dword [esi]
cdq
bts eax, 6
adc esi, 4
xadd ax, dx
bts ax, dx
or ax, 0x6084
xor ecx, ebx
btc ax, ax
sar eax, 0xd2
xor edx, 0xa8317c31
bswap ecx
jg 0x152cf9c
ror ebp, 1
inc ecx
shl ebp, cl
inc esp
movsx eax, al
inc ecx
adc ebp, eax
neg ebp
inc cx
mul ebp
inc ebp
movzx ecx, ax
inc ecx
dec bl
inc ecx
sbb ebp, eax
neg ebp
bswap ebp
ror ebp, 1
inc ecx
sub ebp, eax
dec ecx
lea eax, [ecx + eax - 0x57fade60]
dec ecx
div edx
rol ebp, 1
shr eax, 0xa2
push eax
dec eax
ror eax, cl
dec esp
mov dword [esp + edx - 0x158d3c9f], edi
mov ebx, 0xdaaaf685
xor dword [esp + edx - 0x158d3c9f], ebp
inc ecx
pop edi
dec eax
arpl bp, bp
neg edx
xor edx, ebx
dec eax
adc edi, ebp
sar ecx, cl
inc ecx
shl ch, 0x47
dec esp
xor ebp, edi
inc ecx
jmp ebp
sub eax, edx
lea ecx, [ecx + eax - 0x3902c8ef]
xadd dl, ah
sal eax, 0x8c
neg ecx
jmp 0x1570ffb
rol ecx, 1
rol eax, 0x23
bswap ecx
jae 0xcab7dd
Function at 0x139c839
Capabilities:
Authenticate hmac
Encode data using base64
Encrypt data using speck

Disassembly:
lea ecx, [ecx + edx - 0x3e133c13]
ror eax, 0x2d
call fcn.012e7d59
mov ecx, 0xdf20f7a8
lea ecx, [ecx*8 - 0x4cfa58d8]
lea eax, [ecx*8 + 0x303d1e2c]
mov edx, dword [edi]
and ecx, ecx
adc ecx, 0x1fb39f27
shr ecx, 0xcc
mov ecx, dword [edi + ecx*4 - 0x32f03c]
inc eax
js 0x13f3731
lea esi, [eax + esi - 0xaf]
bswap eax
xor ecx, ebx
bswap ecx
jmp 0x1481120
not edx
xor eax, ebx
call fcn.0132b092
cdq
xor cl, bl
btc eax, 0x96
sbb cl, 0xc
ror cl, 1
sal al, 1
shr eax, 0x54
adc cl, 0x33
mul ax
xadd eax, edx
dec byte [esp + edx*8 - 0x16bbc]
xor cl, 0x9d
add eax, dword [esp + edx*8 - 0x16bc4]
xor bl, cl
jmp 0x13d8af9
push 0xb9a1a13c
mov eax, 0xdfbfef34
mov ecx, dword [esi]
add esi, 4
movzx edx, ax
pop eax
xor ecx, ebx
shl edx, 0x31
xor ecx, 0x47a48a03
mov dword [esp + eax + 0x465e5ec4], edx
add dword [esp + eax + 0x465e5ec4], edx
pop eax
rol ecx, 2
lea ecx, [edx + ecx - 0x3aac8c69]
ror al, 0xa4
bswap ecx
xchg edx, eax
xchg edx, eax
dec ecx
neg dl
sub eax, 0xe21b928
sar edx, 0xfc
xor ecx, 0xd1bceeb1
not dx
or dl, dl
dec edx
dec ecx
shr edx, 0x3a
not al
bt eax, 0xa1
ror ecx, 3
xor edx, edx
jns 0x150a8a5
xor ebx, eax
and cx, 0xe898
push ecx
adc edi, eax
push edx
shr edx, 0x9c
or edx, ecx
adc ecx, dword [edx + esi - 0xd]
mov eax, 0xd9085638
bswap eax
idiv eax
movzx edx, byte [ebp + edx*2 - 0x857ebff]
xor dl, bl
or al, 0xc
sbb dl, 0xac
mov dword [esp + eax - 0x34], eax
idiv byte [esp + eax - 0x30]
sal eax, 0x83
not dl
shr byte [esp + eax - 0x3ffe], 0xc1
inc dl
ror dl, 1
neg eax
adc eax, 0xc7143798
neg dword [esp + 0xe]
xor bl, dl
shl al, 0xc2
and dword [esp + 0x10], 0xae169da2
rol byte [esp + 6], 0xc7
lea edx, [esp + edx + 0x14]
sete byte [esp + 9]
sub al, al
neg al
mov dword [edx], ecx
adc al, ah
cdq
movzx ecx, byte [ebp - 6]
adc ebp, 0xfffffffa
jmp 0x1352ea1
mov dword ss:[edx], ecx
mov edx, eax
shr edx, 0x9d
lea ecx, [eax + eax + 0x7c3aea96]
mov eax, dword [esi + edx*2 - 8]
neg dl
jbe 0x129b76c
push 0x133fe4b5
sub esi, 4
mov eax, 0xc8132f9c
movzx edx, ax
push edx
mov ecx, dword [esi + edx - 0x2f9c]
xchg ah, dl
xor ecx, ebx
ror dword [esp + edx*8 - 0x17974], 0xc7
mul edx
inc ecx
push eax
or dword [esp + edx - 0x6c1b30b4], edx
neg ecx
pop edx
sal ax, 1
adc edx, 0x5c28afb3
not ecx
xor ebx, ecx
bt edx, edx
xor eax, 0x868f86af
cwde
adc edi, ecx
lea eax, [edx - 0x177590c2]
jmp edi
jle 0xc7708e
lea ecx, [ecx - 0x1c601155]
mov dword [esp + ecx*4 - 0x48a595f8], ebp
ret 4

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

Disassembly:
adc edi, edx
movsx edx, ax
call fcn.01597a6c
Function at 0x13a4883
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
inc edx
add ebp, eax
shl byte [esp + edx - 0xc0fffd], 0x87
mov eax, edx
mov ecx, dword [esi + edx*2 - 0x1820006]
movzx edx, byte [edx + edi - 0xc0fffd]
dec dword [esp + eax*2 - 0x181ffff]
sal eax, 0x4d
lea edi, [edi + eax - 0x20001ffb]
xor dl, bl
dec dword [esp + eax*2 - 0x40003ffe]
xor dl, 0xaa
btc eax, 0xa4
inc eax
call fcn.00c8f4f0
mov eax, dword [edx + esi - 0x5038d40c]
and ecx, ecx
lea esi, [esi + edx - 0x5038d408]
neg edx
xor eax, ebx
sal dl, cl
not eax
btc edx, edx
neg eax
sub ecx, 0x6388a06
bswap eax
sar ecx, cl
adc ecx, 0x5619ff83
lea eax, [eax + ecx*4 + 0x7ce62ec8]
xor cx, cx
shr cl, 0x25
rol eax, 2
xor ebx, eax
add edi, eax
movzx ax, byte [ecx + ebp - 0x1d0f0000]
rol ecx, 0x5a
sal dl, 0x83
add cl, byte [ebp + ecx - 0x743bfe]
add ebp, 2
sar edx, 0x90
bt edx, edx
dec edx
add al, cl
call fcn.013a42b2
mov edx, 0x90166ba5
mov edx, dword [edi]
call fcn.00c7aaad
cmp edi, 0x399d98b
mov dl, 0x94
shl edx, 0xf0
neg eax
sar dx, cl
xor ebx, eax
jmp 0xc523a0
ror ecx, 0x3d
xor eax, 0xb62660a0
ror eax, 2
sar dx, 0x26
mov dword [esp], ecx
not eax
sub cx, 0xbabf
ror byte [esp + 0xb], 0xc6
xor dl, cl
dec eax
jmp 0x13452f9