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

Disassembly:
dec ecx
adc edi, eax
mov dword [esp + ebx*2 - 0xf4], ebx
or dl, al
mov ecx, dword [ebx + esi - 0x8a]
dec edx
lea esi, [esi + edx*4 - 0x191941a2]
jb 0x14256fc
and byte [esp + ebx*2 - 0xe8], dh
inc ecx
xor ecx, edi
bswap ecx
xchg dword [esp + ebx*2 - 0xe7], eax
inc cx
inc ecx
dec eax
sub ebx, ebp
inc ecx
sal eax, 0xfc
inc cx
inc ecx
rol ecx, 1
inc esp
movzx ebx, bp
dec ecx
call fcn.00b8718b
mov eax, 0xe38cbe25
call fcn.00c74fd4

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

Disassembly:
lea edi, [edi + eax*2 - 0xd304]
mov esi, edx
and eax, 0x8d9c58b2
movzx edx, ax
bswap edx
ja 0x1513583
inc ebp
xor eax, edi
dec eax
not dword [esp + eax - 0xdea]
dec eax
mov dword [esp + ebx - 0x23], ebx
inc edi
lea eax, [eax + ebx + 0x39f98e9c]
inc ecx
neg eax
shr word [esp + eax*2 - 0x1be0], 0xe2
inc esp
mov edx, dword [esp + eax - 0xdea]
neg bl
inc esp
add eax, ebp
mul word [esp + eax*4 - 0x37bc]
inc ecx
not eax
pop ecx
jae 0xc9110d
mov ecx, 0x7b026984
mov edx, ecx
mov edx, dword [edx + edi - 0x7b026984]
movzx eax, cx
jmp 0xce726f

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

Disassembly:
add dword [esp + eax*2 - 0x3fff7ffe], eax
xor edx, ebx
neg edx
call fcn.012e2c40
test byte [eax], dh
cld
mov dh, 0xc6
cwde
mov eax, edx
mov word [ebp + eax*2 - 0x3fff7ffe], cx
mov dword [esp + edx*2 - 0x3fff7ffe], 0x2c002927
lea edi, [edi + edx*2 - 0x3fff8002]
or ax, word [esp + edx - 0x1fffbfff]
mov edx, dword [edx + edi - 0x1fffbfff]
jp 0x136eb11
add ecx, dword [edx - 0x33e4bb4a]
jl 0x142c923
out dx, al
push ebx
les eax, [esp + esi*2]
push cs
pop eax
lahf
add ebx, dword [ebx]
invalid

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

Disassembly:
sub dl, dl
mov eax, dword [edi + eax - 0x14]
setne cl
xor ecx, 0xcbaad709
shl dx, 0x48
xor eax, ebx
neg cl
lea ecx, [edx*4 + 0x49357c1f]
dec eax
btr ecx, ecx
xor cl, ch
neg eax
imul ecx, ecx
imul dx, cx
sub ecx, ecx
xor eax, 0x1f9165b4
lea edx, [edx + edx*8 - 0x575512c9]
or edx, edx
lea eax, [edx + eax - 0x1fc89aa8]
neg cx
call fcn.00c9b85c
ror edx, 3
rol cx, 0xa1
adc ecx, ecx
xor ebx, edx
jmp 0x12d54d0
dec edx
pop eax
mov eax, 0x4481829a
rol ax, 0x29
rol edx, 1
shr ecx, cl
bswap edx
lea edx, [edx + ecx + 0x143a259e]
sets cl
je 0x13f82bf
movzx cx, byte [ebp]
mov eax, 0x9a86c11c
mov al, byte [ebp + 2]
mov edx, 0xdfa32606
bswap edx
lea ebp, [ebp + edx*2 - 0xc4d47bc]
not cl
add edx, edx
sub edx, 0x7bab4210
btc edx, edx
not al
xchg dh, dl
sal dx, 0x61
or cl, al
bswap edx
sar edx, 0x28
mov word [ebp], cx
lea ecx, [edx + edx*2 - 0x1c6ffed2]
and dl, ch
movsx eax, cl
lea edi, [edi + eax - 0x18]
xor cl, dl
jge 0x133925b
Function at 0x142df1c
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
inc esp
movsx eax, cx
inc ecx
dec ebp
dec eax
mov dword [esp + ecx*2 - 0x6903fd56], ecx
inc ecx
mov ebx, eax
inc ebp
movsx ebx, cx
inc ecx
neg ebp
inc ecx
bswap ebp
shr eax, cl
dec ecx
sbb eax, 0xcf19bfb3
dec esp
mov dword [esp + ecx*2 - 0x6903fd56], edi
inc ecx
or al, 7
inc ecx
rol ecx, cl
inc esp
xor dword [esp + eax*4 - 0x44f248], ebp
inc sp
add ecx, ebp
sar dl, 0xe3
inc ecx
pop edi
sal ebx, 0x8c
sal eax, cl
dec ebp
arpl bp, bp
dec ecx
adc edi, ebp
dec eax
lea esi, [ecx + esi - 0x3481feaf]
inc ecx
dec al
inc esp
mov edx, dword [esi + ecx*2 - 0x6903fd56]
push edx
jne 0x1439d2a

Function at 0x142f430
Capabilities:
Encode data using xor

Disassembly:
sbb dx, 0x5082
and al, ah
neg ax
sub eax, 0xf220f63c
neg dx
xor dx, 0x40ad
inc dx
ror cl, 0x85
xor dx, 0x7612
call fcn.01371597
wait
mov ebp, 0xa482acf5
xchg esi, eax
in al, 0xff
jnp 0xd34d02
and byte [ebx + 3], ah
adc al, 0xcf
mov eax, ds
mov byte [edx - 0x34], cl
iretd
sahf
ficom word [edi]
cdq
nop
sub ch, cl
stc
mov edx, 0x584514b7
and bh, byte [ebx]
add byte [eax + 0x46], 0x58
sbb dh, byte [edx + 0x5a]
inc eax
inc esi
pop eax
or byte [ebx + 0x251e2f7b], 0xb8
pop esi
inc edi
test dword [eax - 0x5b], ebx
xchg ebx, eax
lahf
imul ecx, dword [ebp - 0xbfe32], 0x78
invalid
pop esp
rol edx, 0xf2
neg ecx
div byte [esp + eax - 0x7c0b85aa]
mov ah, 4
push esi
jp 0x13e5403
xor dword [ebx], 0xffffffd2
xor edx, edx
not ecx
call fcn.0159a6a8
sbb eax, dword [eax]
xor dx, bx
add al, ah
xadd eax, ecx
jb 0xd34c75
shl eax, cl
mov ecx, 0xc834eaa2
neg cl
inc dword [esp]
mov dword [ebp + 2], eax
movzx eax, dl
jno 0xcde145
pop eax
test al, 0x83
mov ebp, dword [ecx]
add eax, dword [edx + 0x23]
ja 0x13e540a
cmp al, 0xa3
push 0x73
jg 0x13e5410
cmp al, 0xa3
bound esi, qword [ecx]
jl 0x13e54a6
fcmovbe st(0), st(5)
shr dword [ebx - 0x649ed3a8], cl
xor dword [ebp + 0x44], ebx
sahf
cmc
jb 0x13e5417
lahf
mov dl, 0xa7
sbb ch, ch
jae 0x13e5404
invalid
mov ebx, 0x5e541979
test byte [ebx - 0xb78e49a], al
aas
imul esi, eax, 0x44
add eax, 0x98759baf
jl 0x13e550d
mov eax, dword [0x3bac1ff8]
retf 0x321b
or dh, byte [eax - 0x12]
sahf
xchg ebx, eax
sbb al, 0x5c
mov cl, byte [ebp + 0x3b]
stosb byte es:[edi], al
xor byte [edx + 0x1a9ca18f], cl
invalid
add esi, ecx
mov eax, dword [ebp + edx*4 - 0x23650c]
mov dword [esp + edx*8 - 0x46ca18], 0x3a0ab823
not dword [esp + edx - 0x8d943]
mov cl, byte [ebp + edx*2 - 0x11b282]
ror dx, 0xec
sal edx, 0xec
js 0x13e5427
mov ecx, 0x20006f0b
movsx edx, cl
mov edx, dword [esi + ecx*2 - 0x4000de16]
jmp 0x14f2b62
movsx eax, cl
call fcn.012fd54e
xor ecx, ebx
push 0x14b59494
sub word [esp + 2], 0xd8d
Function at 0x1431d87
Capabilities:
Encode data using xor

Disassembly:
dec esi
mov dword [esp + edx - 0x473efff8], edi
inc esp
xor dword [esp + ebp*2 - 0x49049d62], esp
dec esi
mov edi, dword [esp + edx - 0x473efff8]
inc ecx
push edx
dec ebp
arpl sp, sp
cwde
cwde
dec ecx
ror ebp, 0x89
dec ecx
add edi, esp
inc bp
bt eax, ebp
dec eax
mov dword [esp + eax*4 - 0x11f7c], 0x4ca0a3a0
dec edx
mov dword [esp + edx - 0x473efff0], ebp
movzx ecx, byte [esi + eax*2 - 0x8fc8]
inc cx
dec ebp
inc ecx
not eax
xor ax, word [esp + eax - 0x47d7]
dec ecx
lea esi, [edx + esi - 0x473f0006]
inc esi
xor al, byte [esp + edx - 0x473efff8]
dec eax
sal edx, 0xa
inc ecx
xor cl, bh
inc ebp
add edx, ecx
dec eax
or ebx, 0xa32ca92c
inc ebp
movsx esp, bx
not cl
call fcn.00d3443b
jbe 0x1431dbc
mov al, byte [0xac894a4c]
adc al, 0x10
add cl, al
mov eax, 0x468cb60f
cmp byte [eax - 1], dh
jmp dword [esi + 0x41]
invalid
Function at 0x143642f
Capabilities:
Encode data using xor

Disassembly:
dec eax
mov dword [esp + 8], 0x56d2f1cc
dec eax
lea esp, [esp + 8]

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

Disassembly:
mov dword [esp + eax - 0x13], 0x7f9f7e86
shl edx, cl
mov dword [eax + esi - 0x15], edx
cbw
or ax, ax
lea esi, [esi + eax*2 - 0x28]
or ax, 0x3000

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

Disassembly:
adc esi, 4
neg dword [esp + 4]
jns 0x14897c2
mov ecx, 0x1a9fc407
lea eax, [ecx*4 + 0x7c043189]
mov dx, word [ebp + ecx*4 - 0x6a7f101c]
shl ax, cl
and cx, ax
sub cx, 0x7420
mov cl, byte [ecx + ebp - 0x1a9f4bde]
sbb eax, eax
bswap eax
lea ebp, [ebp + eax + 2]
adc ax, 0x6abe
jae 0x14cf4d2
mov dword [esp + 4], 0xb203a239
jae 0xc682eb
mov dword [ecx + edi - 0x7c83701b], eax
mov edx, dword [esi + ecx - 0x7c83701b]
movsx eax, cl
lea esi, [ecx + esi - 0x7c837017]
rol cl, 0x64
and cl, ah
cwde
xor edx, ebx
sub eax, 0x210bdf88
jb 0x1504590
jl 0x155ee1c
div ecx
pop ecx
mov ecx, 0x3a8ad7b0
mov dword [esi + ecx*2 - 0x7515af60], edx
dec word [esp + ecx*2 - 0x7515af5e]
mov edx, ecx
mov dword [ecx + esi - 0x3a8ad7ac], eax
neg ecx
lea ecx, [ecx + ecx - 0x217ac761]
mov dword [esp + edx - 0x3a8ad7b0], edi
ret
shr dx, cl
movzx ecx, ax
add ecx, ecx
sets cl
mov word [ebp + eax*2 - 0xd57c], dx
adc eax, ecx
sub cl, al
lea edi, [edi + eax*4 - 0x4fefc]
mov edx, 0xa21f6aa6
or eax, eax
mov edx, dword [edi + eax*4 - 0x4fef8]
inc al
sal cx, 0x44
sar cl, 4
xor edx, ebx
neg edx
lea edx, [edx + eax + 0x559c6be4]
neg eax
add eax, ecx
dec ecx
not edx
dec ecx
add cl, ch
rol eax, 0xad
xor edx, 0x2fb066b5
sal eax, cl
bts ax, ax
rol ecx, 0x71
bswap edx
xor ebx, edx
sal ecx, 0x12
cbw
shr eax, 0xc9
adc esi, edx
add ecx, esi
jmp ecx
Function at 0x14462c5
Capabilities:
Encode data using base64

Disassembly:
inc ecx
xor edx, edi
inc ecx
sub cl, 0x85
rol edx, 1
dec edx
mov dword [esp + ecx*2 - 0x2f138f6c], ecx
pop ecx
dec esi
lea edx, [ecx*8 + 0x7a1b45b8]
dec edx
mov eax, 0x9b31e13d
dec eax
lea ebx, [eax + ecx*8 - 0x21f5c9dc]
xor edx, 0xb1218a07
inc edx
ror dword [esp + ecx*2 - 0x2f138f69], 0xc9
not edx
movsx ebp, bx
inc edx
or ch, byte [esp + ecx*2 - 0x2f138f68]
dec eax
sbb ebx, 0xbfb31a02
dec esi
mov dword [esp + ecx*2 - 0x2f138f6c], edi
inc edx
xor dword [esp + ecx*4 - 0x5e271ed8], edx
inc ecx
pop edi
inc eax
xchg ch, cl
sar ax, 0xa2
setbe bl
dec eax
arpl dx, dx
dec eax
adc edi, edx
dec eax
or ebp, ebx
inc cx
or edx, 0xf641e624
loope 0x144638b
mov ebx, dword [esi + ecx*2 - 0x2f138f6c]
dec esp
lea ebx, [ebp*2 - 0x6fd54f66]
inc ecx
shr dl, 0x65
dec esi
lea esi, [ecx + esi - 0xc731]
dec edx
lea esi, [esi + ecx*2 - 0x2f138f6d]
cwde
dec edi
lea esp, [edx + ebx - 0x21409a6a]
inc ebp
xor dl, ah
inc esi
movzx ebx, byte [esi + ecx*2 - 0x2f138f6c]
call fcn.00d44d43
jae 0x14463a3
not byte [ecx + 0x61]
jl 0x1446390
ljmp 0x244c:0x8927048b
dec esp
and al, 0
fmul dword [ecx + 0x5bec1494]
mov ecx, 0x54a4c1ca
aam 0xb7
jb 0x1446347
stosd dword es:[edi], eax
adc ebp, eax
mov ecx, dword [edx + edi - 0x3546a418]
mov eax, edx
cbw
movzx dx, byte ss:[edx + ecx - 0x3546a418]
lea edi, [edi + eax - 0x35460016]
mov word [eax + edi - 0x35460018], dx
mov dword [esp + eax - 0x35460018], ebp
ret 4

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

Disassembly:
call fcn.00c47348
push 0xc40b8010
mov edx, dword [esp]
ror edx, 0xa5
mov eax, dword [ebp]
movzx ecx, word [esp]
and dx, dx
rol edx, 0x21
mov cl, byte [ebp + edx*2 - 0x18816ffe]
jbe 0x12a729f
not edx
add edx, edx
adc ebp, 1
dec edx
call fcn.00d45dd4
add eax, 0x15bd4232
xor ebx, eax
ror word [esp + 9], 0xce
mov dword [esp + 0x10], 0xc3231d27
adc edi, eax
lea esp, [esp + 0x18]
jmp 0x153834d
push 0xe1ac0a92
dec eax
not dword [esp]
push 0x47a9d6a1
bswap eax
push 0xcf059013
jmp 0x13acf84
jmp 0xc6b0a1
Function at 0x144bb78
Capabilities:
Encode data using base64

Disassembly:
add ebp, eax
jmp 0x14e568f
not ecx
rol ecx, 1
rol eax, 0xad
or dl, ah
lea ecx, [ecx + eax*2 - 0x2e13643]
ror dx, 0xe5
xor ecx, 0xe30ff3a2
bswap ecx
cdq
not ecx
inc eax
btc eax, 0xb6
inc eax
xor ebx, ecx
jmp 0x149a7a3
and dl, al
neg cx
mov word [edi + ecx*4 - 0x67b65392], dx
mov eax, ecx
add eax, ecx
mov dword [esp + ecx - 0x19ed94e5], ecx
mov eax, dword [esi + ecx*2 - 0x33db29ce]
pop ecx
movsx edx, cx
imul dx, dx
lea esi, [esi + ecx*2 - 0x33db29ce]
xadd dl, ch
jp 0x12f82e4
xor eax, ebx
inc eax
not cl
shl dl, 0x25
not eax
inc eax
or ecx, 0x32bc01bc
ror eax, 1
ror edx, cl
xor cx, cx
shr dx, 0x49
xor eax, 0xa2120181
sar ecx, 0x81
or cl, dh
bt cx, cx
lea eax, [eax + ecx*4 - 0x7a16ddae]
btc edx, edx
shr cl, 0x21
bts edx, ecx
neg eax
bswap edx
ror ecx, 0x9f
sal ecx, 0xcd
rol eax, 1
dec eax
bts edx, ecx
shl dl, 0x67
xchg ch, dl
not eax
add dl, dl
bswap edx
lea eax, [eax + ecx - 0x96730ff]
xadd dl, dh
xor ebx, eax
sub cl, 0xa0
push edx
jbe 0xc885a8
mov eax, 0x903b4511
sub esi, 4
movsx edx, ax
mov ecx, 0x3f3f90b6
mov ecx, dword [esi + edx*2 - 0x8a22]
shr al, 0xc4
jae 0x149c3ed
sal al, 0x61
add esi, ecx
push edx
ror edx, 0x61
add edx, dword [ebp + eax - 0x408c7064]
sub dword [esp + eax - 0x408c7064], eax
mov al, byte [ebp + eax - 0x408c7060]
mov ecx, 0xecb6d69a
adc ebp, 5
mov byte es:[edx], al
xor byte [esp + 2], cl
mov edx, dword [esp]
pop edx
jmp esi
cwd
xor ecx, ebx
inc eax
not ecx
inc ecx
cwde
add dx, ax
ror ecx, 2
rol eax, 0x9b
inc ecx
bswap eax
ror ecx, 1
jmp 0x150b66f
dec ecx
movzx dx, byte [edi + edx*2 - 0x1fc5254]
sar dword [esp], 0x2f
jb 0x1589d69
mov al, byte [edi + 4]
and dl, al
not dl
xor word [esp], cx
mov word [edi + 4], dx
mov eax, ecx
adc edi, 4
shr dword [esp], 0xff
shr cx, 0xf
pop eax
or eax, ebp
jmp eax
movzx cx, byte [eax + esi - 0x2b51]
not ax
mov dl, byte [eax + esi - 0xd4ac]
Function at 0x144c11a
Capabilities:
Encode data using xor

Disassembly:
dec ecx
adc edi, ebp
call fcn.012bf2a2
sub esi, 4
mov ecx, dword [esi]
mov edx, 0x9c361b9c
lea eax, [edx + edx*8 - 0x7ee684d5]
btc edx, eax
xor ecx, ebx
not dx
lea ecx, [eax + ecx - 0x2f6a8f0e]
not ax
neg ecx
or eax, eax
push eax
dec ecx
rol ecx, 2
xchg byte [esp + 3], dl
xor ebx, ecx
neg edx
sal dword [esp + edx - 0x63c91b01], 0x93
lea edi, [edi + edx - 0x63c91b05]
xchg byte [esp + edx - 0x63c91b00], dl
sbb dword [esp + edx - 0x63c91b00], 0xa5205f09
mov dword [edi + edx - 0x63c91b00], ecx
lea esi, [edx + esi - 0x63c91b04]
mov ecx, dword [edx + esi - 0x63c91b00]
xor ecx, ebx
mul dword [esp + edx - 0x63c91b00]
call fcn.0142f891
pop ebp
js 0x137ad4e
jmp esp
clc
pop esp
out 0x55, eax
ret
dec esi
mov edi, dword [esp + ebx - 0x5a8d768c]
dec edx
mov dword [esp + ebx - 0x5a8d768c], ecx
inc esp
btc ebx, eax
dec ebp
arpl bp, bp
inc esp
mov dword [esp + ebx - 0x1f6], edx
jae 0x137ad0c
neg ecx
lea edx, [edx*2 + 0x59adff96]
lea eax, [edx*4 + 0x732c7806]
sar al, 1
dec ecx
not ecx
inc ecx
mov dword [esp + 8], eax
xor ecx, 0xe8cfc3b
mov dword [esp + 0x14], 0x8a0bd328
bt dx, 0x20
ror ecx, 3
or edx, eax
bswap ecx
sub word [esp + 0x15], dx
add byte [esp + 0xd], dl
xor ebx, ecx
shr dx, 0x23
add esi, ecx
bts eax, 0xb4
pop ecx
pop ecx
pop edx
pop eax
pop eax
pop edx
jmp esi

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

Disassembly:
lea ecx, [esp + ecx + 4]
push edx
add dx, word [eax + ecx - 0x353831c9]
movzx ecx, byte [ebp + eax*2 - 0x6a706394]
shr eax, 0x71
shl word [esp + eax*8 - 0xd4df], 0x63
xor cl, bl
not ax
call fcn.0159dbae

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

Disassembly:
lea esp, [esp + 0xc]
je 0xca3922
push esi
call fcn.0134748e
jb 0x13850c1
rol dword [esp], 0x4a
sbb ebp, 8
jmp fcn.00d120ea

Function at 0x1463001
Capabilities:
Authenticate hmac

Disassembly:
sbb eax, 0x848bf682
shl cl, 0x42
xor eax, 0xa38600a6
and ecx, ecx
inc cx
not eax
xadd dx, cx
not edx
call fcn.012d002c
xor ebx, eax
shr cl, 1
dec cx
shl word [esp + edx*2 - 0x6020243f], 0x27
adc esi, eax
shr edx, 0x6e
je 0xcf78e9
mov edx, dword [edx + ebp - 0xc040]
movzx cx, byte [edx]
mov eax, dword [esp]
mov edx, dword [esp]
mul dword [esp]
lea ebp, [ebp + eax*2 - 0x40800006]
xor edx, 0x82b54be
mov word [ebp + eax - 0x20400004], cx
mov dword [esp + edx - 0x407a55bc], esi
ret
xor ebx, edx
cbw
add edi, edx
sar al, 3
jae fcn.013c73b8
sub esi, 4
mov eax, dword [esi]
call fcn.012ec8be
cwd
dec cl
call fcn.012ede04
mov eax, dword [esp + eax - 0x2c10da68]
push 0x748a802e
push 0x653a053a
call fcn.012bd29b
pop ss
dec esi
ljmp 0x661a
and eax, eax
jae 0xcc5c94
dec dword [esp + edx + 8]
xor bl, cl
bt edx, eax
mul ax
lea ecx, [esp + ecx + 0xc]
imul edx
adc edx, dword [esp + eax*2 + 6]
call fcn.0132c9bb
mov eax, dword [esi]
mov ecx, 0xddab982a
add esi, 4
movsx edx, cx
xadd dx, cx
xor eax, ebx
sal cl, 0x21
jnp 0xb7ed42
jmp 0x1523d36
neg cx
jg 0x135ea7c
mov eax, dword [esi]
add esi, 4
mov edx, 0x501ae1bc
movsx ecx, dl
ror ecx, cl
xor eax, ebx
sal cl, 0xc6
bswap eax
sete dl
ror eax, 1
jmp 0x14d6f76
Function at 0x1463cdb
Capabilities:
Authenticate hmac
Encode data using base64
Execute anti-debugging instructions
Parse pe header

Disassembly:
xor ebx, ecx
cdq
cdq
add ebp, ecx
ror word [esp + edx + 1], 0xa8
ror ecx, 2
inc ecx
bswap ecx
neg ecx
rol ecx, 3
xadd eax, edx
ror dl, 0x64
mov dword [esp], 0xe2c6329
inc ecx
not al
sal eax, 0x31
cdq
rol ecx, 1
rol eax, 0x64
cdq
jae 0x12ba740

Function at 0x146d1c0
Capabilities:
Encode data using base64

Disassembly:
cwde
rol dx, 1
call fcn.01584cc8

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

Disassembly:
movzx cx, byte ss:[edx + eax - 0x19]
mov word [ebp + eax - 0x1b], cx
ror eax, 0x4a
lea ebp, [ebp + eax - 0x6400002]
mov ecx, eax
jns fcn.00c21eff
xor edx, ebx
shr cl, cl
lea ecx, [eax + eax*2 - 0x6d66204c]
pop eax
inc edx
movzx eax, cl
sar al, 0xe3
neg edx
add eax, 0x1d3d5a8f
dec edx
bswap edx
sub eax, 0xf7afb080
lea eax, [eax*2 - 0x5c658c66]
bts eax, eax
inc edx
or al, cl
shl eax, cl
xor edx, 0x46ba1bbd
lea edx, [edx + ecx*2 - 0x4cd6d03c]
xor ebx, edx
and ax, cx
adc edi, edx
bswap ecx
imul cl
mov ecx, ebp
shl al, 0xa6
not eax
mov edx, eax
mov dword [ebp - 4], ecx
shr eax, 0x1b
mov edx, dword [ebp + eax*2 - 0x36]
jnp 0x137b53d
push 0x6c2ab53b
shl word [esp + 2], 0x4c
movzx dx, byte [edi]
call fcn.012ed152
sar ecx, 0x2e
mov word [edi], dx
xor byte [esp + 2], al
pop edx
jmp ebp

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

Disassembly:
not ecx
btc eax, eax
neg edx
not edx
call fcn.00c58725
call fcn.00b912bb
xor ecx, ebx
ror ecx, 1
inc eax
inc ecx
cwde
call fcn.00d29f92
push 0xd6100f96
push 0xcf942826
inc edx
xor ecx, 0x5939a229
call fcn.0141f4d0
sub edi, 4
mov eax, 0x462280be
mov edx, dword [edi + eax - 0x462280be]
movzx ecx, al
or ax, 0x3a12
shl ecx, 0xeb
xor edx, ebx
rol al, 0xc1
xor edx, 0x9cbfb72b
dec cl
and cl, 0xbb
or eax, ecx
not edx
not cl
setle cl
xor edx, 0x131de123
rol al, 0xc4
lea eax, [ecx + eax*8 + 0xebc7e36]
bt ecx, 0xb9
dec edx
btr ecx, 0x3a
rol edx, 1
bt ax, ax
sar cx, 0x8f
not edx
shl cl, 0x61
inc edx
jmp 0x13280ee
xor ecx, esi
jmp 0x1382834

Function at 0x1486666
Capabilities:
Authenticate hmac

Disassembly:
inc cx
dec edx
ror eax, cl
push eax
mov dword [esp + eax*4 - 0x140001a4], eax
rol edx, 2
sar ecx, cl
adc edx, 0xb9b28590
and byte [esp + eax*2 - 0xa0000cb], ch
sub ecx, dword [esp + eax - 0x5000069]
xor dword [esp + eax*2 - 0xa0000cc], ecx
bswap edx
xor ebx, edx
call fcn.0149a82f
inc ecx
ror eax, 2
inc ecx
push edi
rol bx, 0x6d
call fcn.01474b18

Function at 0x1486a7c
Capabilities:
Encode data using base64

Disassembly:
ror eax, 0xc1
mov dword [esp + ecx - 0x7cc315a0], 0x5a969590
adc dl, 0xa4
ror dl, 1
and eax, 0x30b97595
add cx, word [esp + eax - 0x97415]
call fcn.0149bce9
rol ecx, cl
dec eax
sar cl, 0x61
adc cx, cx
not eax
bswap ecx
call fcn.01327561
Function at 0x1486adf
Capabilities:
Encode data using base64

Disassembly:
lea esi, [esi + edx*2 - 0x145e1a62]
xchg dword [esp + edx - 0xa2f0d27], edx
not dword [esp + 7]
mov edx, dword [esi]
xor edx, ebx
mov eax, dword [esp + 7]
xor eax, eax
add al, byte [esp + eax + 5]
sbb edx, 0x82ba3c00
and dword [esp + eax*2 - 0xe4], eax
xor edx, 0xdf8a3a33
neg eax
and eax, dword [esp + 8]
movsx ecx, ax
neg edx
neg ecx
sbb edx, 0xe324d62a
btc ax, cx
xor ebx, edx
mov byte [esp + eax*2 + 9], ah
not cx
neg ax
add ebp, edx
pop edx
pop edx
pop eax
jmp fcn.01556dc6
mov dword [esp], edx
and edx, 0xf6a82197
xor bl, cl
push edx
xor edx, 0x9e2f2d2f
lea edi, [edi + edx - 0xa2f0d31]
mov word [edi + edx*2 - 0x145e1a5e], cx
ja 0x13b88cd
mov edx, 0x80a7728d
mov edx, dword [esi]
jmp 0x13cb0e7

Function at 0x1489cbf
Capabilities:
Authenticate hmac

Disassembly:
push edx
dec eax
arpl ax, ax
dec ecx
bt eax, 0x2e
dec eax
adc edi, eax
dec eax
sar ebx, 0x9b
inc ecx
pop eax
jns fcn.012e2664
mov eax, 0x4a2bf627
lea ecx, [eax + eax*8 - 0x2f560ad0]
and cl, al
mov ecx, dword [ebp + eax - 0x4a2bf627]
call fcn.00da17da
xadd ebx, ebp
inc ecx
pop edi
dec edi
lea ebx, [ecx + edx*4 + 0xc0727bf]
jge 0xc7c9bc
dec edx
shr dword [esp + eax*2 + 8], 0x70
inc ecx
pop esp
dec esi
lea ebx, [esp + ebx + 0x10]
inc ebx
mov ebp, dword [ebx + eax*4]
dec edi
lea esi, [eax + esi - 4]
dec ecx
sal eax, cl
inc ebp
movsx ecx, ax
inc ebx
mov dword [eax + esi], ebp
dec ecx
lea esi, [eax + esi - 4]
inc edx
mov eax, dword [esi + eax]
inc dx
xchg dword [esp + eax*2 + 0xd], ecx
inc ecx
xor eax, edi
rol eax, 1
dec edx
xor dword [esp + eax + 8], ebx
inc ecx
movsx ebp, bp
dec edi
lea edx, [ebp + ecx*2 - 0x6cd7d6f9]
bswap eax
inc ecx
lea eax, [eax + eax - 0x4384e2a2]
dec eax
or dword [esp + ebx - 0xb9a], ecx
inc ecx
cmovno ecx, edx
inc edx
sets byte [esp + eax + 3]
not eax
inc esi
adc byte [esp + eax*2 + 3], cl
inc edx
not byte [esp + eax*4 + 8]
lea eax, [eax + ecx*2 - 0x64b7a2a0]
inc sp
or eax, edx
inc ecx
pop edx
not eax
dec eax
bt bx, cx
inc ebp
xadd al, ch
ror eax, 1
dec edx
ror dword [esp + eax*4 - 0x20ca8], 0xab
not eax
neg eax
dec ecx
and ebx, ebp
inc ecx
xadd dl, cl
bswap eax
dec esi
mov dword [esp + eax*2 - 0x10654], edi
inc cx
neg ecx
inc edx
xor dword [esp + eax - 0x832a], eax
inc eax
add ch, bl
ja 0xcbecde
sub ebp, 8
xor ecx, ebx
mov edx, 0x5515c39f
movzx eax, dl
xor ecx, 0x93a277bd
not ecx
ror ecx, 3
neg ecx
xor ebx, ecx
add al, ah
inc edx
adc edi, ecx
jmp fcn.013c73b8
Function at 0x148d7a6
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
inc ecx
movzx ebp, bl
sal cx, 1
dec eax
adc ebx, esp
dec ecx
inc ebx
inc ebp
mov edx, esp
inc sp
movzx eax, byte [ebx + ecx*4 - 0x1b8]
dec esi
lea esi, [ecx + esi - 0x70]
movzx eax, cl
inc bp
mov dword [esi + ecx*2 - 0xdc], eax
cmovne bp, cx
inc eax
movsx edx, ch
dec eax
lea esi, [ecx + esi - 0x72]
dec eax
inc ebp
div al
and ebp, ecx
mov ebx, dword [ecx + esi - 0x6e]
dec ebp
lea ecx, [ebx + edx*8 + 0x693325ab]
inc ebp
movzx eax, sp
inc cx
btc edx, ebp
inc ecx
xor ebx, edi
sub ebx, eax
inc esp
add bl, cl
bt edx, 0xbe
bswap ebx
call fcn.0141c02e
push 0x83035d10
lea esp, [esp + 0x14]
jmp 0x131a583
call fcn.00c38a83
inc sp
xor edi, ebx
jmp 0xc129b5
shl dl, 0xe1
not ecx
not dl
call fcn.00d1d1c6
neg edx
not edx
mov dword [esp + 4], 0x7d22290f
xor ebx, edx
shl dword [esp + 5], 0x9e
jnp 0x136e80e
adc ebp, edx
jmp 0xcb5a6f

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

Disassembly:
xor ebx, edx
add edi, edx
mov eax, dword [esi + eax - 0x2d6f3a38]
lea edx, [ecx*2 - 0x56e794e9]
push edx
lea esi, [esi + ecx - 0x2e000034]
xor eax, ebx
xor edx, edx
sar ecx, cl
inc eax
sal byte [esp + ecx*2 - 0x5b], 2
xor eax, 0x41fee12
push ecx
sub eax, 0xaf1eb228
or dword [esp + ecx*4 - 0xb4], 0x6206e2b4
call fcn.014092c4
call fcn.01490383
mov edx, 0xa9bab79c
movsx eax, dx
rol eax, 0x4f
mov edx, dword [esi]
lea ecx, [eax*4 + 0x2e34a694]
bts ecx, eax
inc eax
adc esi, 3
xor edx, ebx
rol edx, 1
sal ecx, 0xf5
not edx
dec ecx
sbb edx, 0x488116ba
shl cl, 4
xor cl, 0x38
shr eax, 0x46
rol edx, 3
neg ecx
xor eax, ecx
bt ecx, 0xb5
inc edx
jmp 0xc26272
mov dword [esp], 0x469b4b09
mov eax, 0x240a9527
lea ebp, [ebp + eax*2 - 0x48152a52]
and eax, eax
xor dword [esp + eax*2 - 0x48152a4e], eax
mov eax, dword [ebp + eax*2 - 0x48152a4e]
mov edx, dword [esp]
xor eax, ebx
mov ecx, dword [esp + edx - 0x6291de2e]
sub dl, cl
bts ecx, 0x24
sbb eax, 0x7abd3d96
shr dword [esp + ecx - 0x6291de3e], 0x1c
neg eax
inc cx
not edx
sub edx, 0x8518c30a
rol eax, 1
lea eax, [edx + eax + 0x292ef349]
add ecx, 0x713126bc
setno cl
xor ebx, eax
add edi, eax
sar cl, 0x84
mov eax, dword [edx + esi - 0x18555ef5]
mov cx, word [edx + esi - 0x18555ef1]
not byte [esp + edx*2 - 0x30aabde7]
lea esi, [esi + edx - 0x18555ef3]
shr cx, 1
jmp 0x13f3ac5