joyce8/EMBER2024-capa huggingface dataset:
Function at 0x745b96
Capabilities:
Encode data using xor

Disassembly:
neg eax
xor ebx, eax
add edi, eax
lea esp, [esp + 0x18]
jmp 0xc962cb
push ebx
mov ebx, 0xf7a627a8
pushfd
add ebx, 0x4ca27291
mov ebx, dword [esp + 4]
mov dword [esp + 4], 0x8bbb7c4e
push dword [esp]
popfd
lea esp, [esp + 4]
call fcn.007a92df
mov ecx, 0x279dd6ad
mov eax, dword [edi + ecx*2 - 0x4f3bad5a]
movzx edx, cx
mov edx, dword [ecx + edi - 0x279dd6a9]
sub ecx, 0x64a2d7bc
btc ecx, ecx
mov cl, byte [edi + 8]
call fcn.00d0fe2c
xor byte [ecx], cl
in al, 0xcb
adc dword [ebx + 0x7a69d71], edx
cmpsd dword [esi], dword es:[edi]
add eax, 0x49fd49a7
mov dh, dl
pop ecx
stosb byte es:[edi], al
sub eax, 0xad79a68f
jne 0xc962fb
push edx
les esi, [eax - 0x742e48f1]
xchg esp, eax
cmp dword [edi + 0x29], edx
invalid
pop ds
cmpsd dword [esi], dword es:[edi]
leave
pop ecx
push es
pop eax
rcr ah, 0x24
dec ebx
and dword [esi - 0x59561623], esp
mov edi, 0xa6c17cc0
xchg eax, ecx
ja 0xc9639d
mov eax, dword [0x6f55bb04]
das
loop 0xc963b4
sbb ah, cl
cdq
sub eax, 0x53e557e1
mov byte [0x937e716], al
inc edi
sbb eax, 0xb8aaf880
push ebx
sbb bl, cl
mov ebp, 0x465314a7
adc al, 0x1d
sub eax, 0xbcec80df
push cs
nop
test eax, 0x46d82c0b
invalid
xchg esi, eax
push ebx
cmp bh, byte [esi + 0x32cb861]
into
sbb dword [0xc41d0b8f], ebp
adc eax, dword [edx]
stosb byte es:[edi], al
mov edi, 0x2c51bd77
stc
sub al, 0xf9
int1
enter 0x16b5, 0xffffffffffffffcb
inc eax
jg 0xc96403
mov dword [ebp + 0x701eb36f], ecx
mov eax, dword [0x3f4416cf]
xchg esi, eax
pop ss
xor eax, edi
dec esi
les esi, [esi + 3]
cmpsd dword [esi], dword es:[edi]
dec edi
mov ah, 0x26
jg 0xc9637e
mov al, byte [0x6f76fe7]
cld
mov al, byte [0x880337d6]
inc eax
dec ecx
lodsb al, byte [esi]
invalid
dec ebx
jb 0xc9645f
mov bh, 0x9d
ljmp 0x3b3e
invalid
salc
fnsave dword [edx + edx*8]
wait
in eax, 0x57
dec edx
push cs
add al, 0x9f
and dword [ebx], esp
inc esi
arpl word [edi], ax
push ebx
popal
in al, dx
jbe 0xc9647a
or al, 0x4b
push ds
test dword [eax - 0x45], eax
push 0xf5dcb99b
in eax, 0xe3
push esp
mov al, 0x57
je 0xc96432
in al, dx
mov al, 0xf4
int3

Function at 0x749b69
Capabilities:
Encrypt data using speck

Disassembly:
not edx
jae 0x7edc37
push eax
dec edx
not edx
or ax, ax
inc edx
lea eax, [ecx + 0x742a3123]
xchg byte [esp + ecx - 0x2fa43820], al
ror edx, 3
rol ecx, 0x93
pop ecx
btc cx, 0
xor ebx, edx
sar ecx, 0xbc
sar eax, cl
adc ebp, edx
xadd cl, ch
mov ecx, dword [esi + ecx*2 - 0x606]
ror eax, 0xb5
mov eax, dword [esi + 4]
mul ecx
mov ecx, 0xec92b431
lea ecx, [ecx + ecx*2 + 0x1e82b481]
shr ecx, 0x61
mov dword [ecx + esi - 0x721d688a], edx
lea edx, [ecx + ecx + 0x38bfa4ac]
shr ecx, cl
mov dword [esi + ecx*4 - 0x721d64], eax
neg cl
jmp ebp
xor ebx, edx
dec dword [esp + 8]
jge 0x89250d
jg 0x8d0aec
add ebp, edx
lea esp, [esp + 0xc]
jmp 0x8ec492
call fcn.00856ccb

Function at 0x75063a
Capabilities:
Encrypt data using speck

Disassembly:
mov dword [esp + 4], esi
lea esp, [esp + 4]
mov esi, 0x42bc271a
movzx esi, byte [edx + esi - 0x42bc271a]
jmp 0x850fea
jmp 0xc17121
call fcn.0090574f
Function at 0x76187e
Capabilities:
Encode data using xor

Disassembly:
dec eax
mov dword [esp + ecx - 0x96], 0x2e3ba730
dec eax
mov ebp, dword [esp + ecx - 0x8e]
dec ebp
arpl di, di
dec esp
mov dword [esp + eax*4 - 0x250], eax
dec esp
xadd ebx, eax
inc ecx
pop ecx
dec ebp
adc ebx, edi
call fcn.00882a36
stc
cmp eax, esp
lcall 0xff8f, 0xb1149945
xchg edi, eax
mov dh, 0x5e
and al, ch
jecxz 0x7618d3
adc al, 0x9d
and byte [ecx - 0x16], dh
das
xor al, byte [eax + 0x573db119]
rcl dword [eax + 0x22], cl
jbe 0x76190e
mov word [esi], ss
push edi
mov dword [eax + 0x1d93f473], eax
pop esp
insb byte es:[edi], dx
insb byte es:[edi], dx
cmpsd dword [esi], dword es:[edi]
mov byte [0xd0f93a0b], al
adc dword [ebx], edx
invalid
hlt
stosb byte es:[edi], al
inc esp
xor dl, byte [eax]
jae 0x7618f8
jge 0x76193b
rcr dword [0xf64b846a], cl
jl 0x7618cd
dec ebx
idiv byte [esi + eax*8 - 5]
sti
mov ebp, 0xfbf0cb4a
add byte [eax], al
add byte [eax], al
sbb cl, byte [edx - 0x12dee24a]
invalid
add byte [eax], al
add byte [edx], bl
mov dh, byte [esi - 0x3912dee3]
lcall 0x1559, 0xecacf08b
lds edx, [edi + ecx*2 + 0x142dceab]
pop ss
clc
dec esi
scasd eax, dword es:[edi]
adc ecx, dword fs:[esp + edx*2 - 0x2a]
jmp 0x761946
adc dh, byte [eax + 0x59]
cli
push 0xffffffffffffff9d
or byte [edi + 0x1e], al
test dword [eax], eax
push ds
mov dword [0x6e2a20e], eax
xor al, 0x85
xor dword [ebx], edx
insd dword es:[edi], dx
mov edx, 0xede64c79
stc
add al, 0
add byte [eax], al
add byte [ecx + 0x4ad0cf77], cl
loope 0x7618f7
test al, 0x5b
sbb ebp, dword [ecx + edx*8 + 0x25]
sbb eax, 0xc9d59514
sub byte [ebx + 0x2c], ch
popfd
test eax, 0x22d9ee9c
jge 0x761903
imul edx, dword es:[edx - 0xe], 0xffffffcf
add al, 0x5b
salc
jmp 0x7619fb
cdq
or dword [esi + 0x33], edx
add edi, edi
pop ds
ret 0xb7bc

Function at 0x769b60
Capabilities:
Encrypt data using speck

Disassembly:
jmp 0xd78127
mov eax, dword [edi + eax - 0x3d24]
sub cl, 0x3e
add ecx, 0x848d6fba
dec dword [esp + edx - 0x1e8a]
xor eax, ebx
add ecx, ecx
xadd cx, dx
push ecx
ror eax, 1
neg eax
dec eax
rol eax, 3
lea eax, [eax + edx*2 - 0x6a160519]
neg cx
jno 0xcede40
mov dword [ebp + 0xc], eax
mov dword [esp], 0x2faa5319
shl dword [esp], 0x18
mov dword [ebp + 8], ebx
mov ebx, 0xa3137b35
sar byte [esp + 1], 0x66
mov dword [ebp + 4], ecx
push ebx
mov dword [ebp], edx
push ebx
lea ecx, [ebx*4 - 0x6ac7aeed]
mov ebx, dword [esp + ecx*2 - 0x430c7bc2]
shl dword [esp + ecx - 0x21863de1], 0xbf
add cl, ch
movsx eax, cx
lea edi, [ecx + edi - 0x21863d28]
movsx edx, ax
ror edx, 0xe1
jno 0x8f33a1

Function at 0x76e308
Capabilities:
Encrypt data using speck

Disassembly:
jmp 0x865f06
mov dword [esp], eax
shl edx, 2
mov eax, ebp
add eax, edx
rol byte [esp], 0x62
mov dword [ebp - 4], eax
jae 0x7d15b4
mov edi, edx
mov ebp, esi
rol al, 0xc4
setbe cl
jae 0xd26689
push 0x6b1cff9f
mov eax, dword [ebp]
call fcn.00c662d2
jae 0xd4f56d
push 0x9c06c48e
lea esp, [esp + 8]
je 0x7b2d1a
mov eax, 0x830097bf
mov eax, dword [ebp + ebx*4]
call fcn.00bf0f72
sar dword [esp], 0xb4
test ebx, ebx
jmp 0x72787c
Function at 0x77756b
Capabilities:
Encode data using add xor sub operations
Encode data using xor

Disassembly:
call fcn.0086e1d7
mov dword [0x8d9af5df], eax
jl 0x777545
or edi, dword [ebx + 0x7fca3128]
fldl2t
dec esi
lcall 0xd5aa, 0x519ba847
inc esp
wait
push ecx
stosb byte es:[edi], al
aad 0x44
test byte [0x78c52259], ch
mov word [ebx], ss
popfd
mov byte [edx + 0x71], dl
sub byte [edx], dh
popal
cmp esp, dword [edx]
cmpsb byte [esi], byte es:[edi]
push eax
rol ebx, cl
mov ecx, 0x865e4171
xor al, 0x12
xchg dword [ebx - 0x69], esi
lock xchg byte [ebx + 0x6c], bl
or dl, byte [eax + ebp*2]
lahf
pushfd
xor al, 0x84
or cl, byte cs:[ecx + 0x71afebff]
add bh, bl
dec eax
sbb eax, 0x268d718d
push ebp
cmc
push 0x1e0dc4b8
loope 0x777583
xchg cl, bh
push edi
or dword [eax + eax], eax
add byte [eax], al
add byte [eax], ch
pushfd
adc byte [edi + 0x50], al
push esp
xor eax, dword [eax + eax]
add byte [eax], al
add bh, bl
retf

Function at 0x77a23d
Capabilities:
Execute anti-debugging instructions

Disassembly:
stosd dword es:[edi], eax
or al, 0x8f
invalid
call fcn.0076290b
cwde
jbe 0x77a1e6
dec esp
invalid
Function at 0x77a2ae
Capabilities:
Execute anti-debugging instructions

Disassembly:
dec eax
mov dword [esp + ebx - 0x6018e0], 0x3f8d2633
inc ecx
movzx eax, word [ebp + ebx*2 - 0xc031c0]
sar esi, 0xc9
dec eax
inc ebx
dec ebp
lea ebp, [ebp + ebx*2 - 0xc031c0]
inc ecx
pop esi
xor ax, bp
btr edi, ebx
inc ecx
not esp
adc ax, 0x7b8a
sal bx, 8
xor ax, 0x308e
dec ecx
dec esi
inc bp
add ecx, eax
inc ecx
mov edx, esp
sbb ax, 0xac0d
inc cx
and ebx, edi
inc cx
not esp
ror ax, 1
inc ecx
and esi, eax
jae 0xce8bb3
mov ecx, 0x5e1523bb
movzx edx, cl
lea edi, [edi + ecx - 0x5e1523bf]
push edx
xchg dword [esp + edx - 0xbb], ecx
mov eax, dword [edi + ecx*2 - 0x176]
xor eax, ebx
shl edx, cl
inc eax
btr edx, edx
sub word [esp + ecx - 0xbb], 0x4193
mov dword [esp + ecx - 0xbb], ecx
not eax
ror ecx, cl
imul ecx, dword [esp + ecx - 0x1760]
sbb ecx, edx
dec eax
shr ecx, 0xda
shl dword [esp + ecx - 0xa], cl
neg eax
sar ecx, 0x41
sal cl, 0xc2
lea eax, [eax + ecx - 0x2db5ac4d]
not eax
sal dx, 2
btr edx, 0x17
dec eax
neg eax
or cx, 0x1e01
ror edx, 0x88
ror byte [esp + ecx - 0x1e14], 0xc3
xor ebx, eax
add ebp, eax
rdtsc
lea esi, [esi + ecx*8 - 0xf0b0]
sub dword [esp + ecx - 0x1e15], 0x89a1b5a0
mov dword [ecx + esi - 0x1e11], eax
mov dword [ecx + esi - 0x1e15], edx
shr cl, 1
inc dword [esp + ecx - 0x1e0a]
mov eax, dword [esp + ecx*4 - 0x7828]
pop edx
jnp fcn.00d0b40c
mov eax, 0x7c1594ab
cdq
lea ecx, [edx*2 + 0x3b41ab8]
rdtsc
shl ecx, 0xd3
neg cx
sbb ebp, 8
add cx, cx
rol cl, 0xe6
mov dword [ebp + 4], eax
mov dword [ebp], edx
sbb edi, 4
movzx edx, cl
mov eax, edx
mov ecx, dword [edi + edx*4]
not eax
xor ecx, ebx
lea ecx, [ecx + edx*4 - 0x631a2c34]
bt eax, 0x8f
xor ecx, 0x7f00b9b7
lea ecx, [edx + ecx - 0x2923ac13]
ror dl, 0xc2
and dl, 0xa4
neg ecx
rol ecx, 2
xor ebx, ecx
sub eax, edx
setge dl
adc esi, ecx
inc eax
or edx, 0x673401b0
ja fcn.00d48c98
pop eax
mov edx, dword [esp + edx*4 - 0x3fff8]
call fcn.007d83fa
mov ecx, 0xe40db506
not ecx
call fcn.008dbb7c
mov eax, 0xc3fd501
btc eax, eax
movsx ecx, ax
mov edx, dword [edi + eax - 0xc3fd503]
jb 0xcd4954
bt eax, eax
mov al, byte [edi + eax*4 - 0x30ff5408]
ror ecx, 0x94
xor cl, cl
call fcn.00896674
mov eax, dword [ebp]
adc ebp, 4
mov edx, ecx
xor eax, ebx
lea edx, [edx + ecx*8 + 0x233468af]
bt ecx, 0x99
xor eax, 0xda27c9b5
bswap eax
and dx, cx
push edx
xor dx, cx
xor eax, 0xde036437
lea edx, [edx + ecx - 0x4d77e2ea]
sub dl, 0xbf
inc edx
lea eax, [eax + edx*4 - 0x7df9d29d]
xchg word [esp + edx - 0x42c08682], dx
rol eax, 3
not cl
sal cx, 0xe7
not edx
inc eax
rol dl, 0x47
sal byte [esp + 6], 0x62
inc dword [esp + 0xc]
neg eax
bts dx, dx
bswap eax
rol byte [esp + 0xf], 5
add cl, 0xbb
xor ebx, eax
ror dl, 0x26
sar edx, cl
add edi, eax
bswap ecx
pop edx
pop ecx
pop edx
pop eax
jmp fcn.008157bf
sbb ax, 0xd208
dec ecx
btc eax, esi
inc bl
xor bp, ax
inc ecx
sal cl, 0xc2
dec eax
adc eax, esp
inc eax
xor bl, dh
inc bp
or esi, esi
not di
dec eax
mov dword [eax + ebx*4 - 0x1800004], ecx
dec ecx
add esi, ebx
jmp esi
Function at 0x77c034
Capabilities:
Encrypt data using speck

Disassembly:
mov dword [ebp - 4], eax
sar word [esp + 5], 0xb
test ebx, ebx
push 0x41a92694
call fcn.007c9394
mov edx, 0xeca723bb
sub edi, 1
movsx ecx, dx
movzx ecx, byte [edi + ecx*2 - 0x4776]
lea eax, [edx*8 + 0x180db3be]
xchg edx, eax
xor cl, bl
shr edx, 0x2c
dec cl
bt edx, eax
push edx
setae dl
xor cl, 0x35
ror cl, 1
ror al, 0x81
cbw
sub cl, dl
shr eax, 0xc4
xor cl, 0x86
sub cl, 0x8b
rol dl, 5
not dl
neg cl
imul eax
dec cl
mov word [esp + edx - 0xdac62b], 0x61be
call fcn.00d02a9f

Function at 0x77df0b
Capabilities:
Encrypt data using speck

Disassembly:
not cl
mov dword [esp + edx - 0x22f74000], edx
ror cl, 1
dec cl
cwde
push eax
xor bl, cl
sar word [esp + edx*2 - 0x45ee8000], 7
lea ecx, [esp + ecx + 0xc]
sal edx, 0x2e
ja 0xc16a6d
rol dx, 0x81
mov eax, dword [ecx]
shl edx, 0x99
and word [esp + edx*2 + 8], dx
setne byte [esp + edx + 4]
lea edi, [edi + edx - 4]
movzx ecx, word [esp + edx]
dec edx
mov dword [edi + ecx*2 - 0x1ff86], eax
setl cl
mov edx, dword [ecx + esi - 0xff01]
lea eax, [ecx + ecx*4 - 0x63e91d78]
lea esi, [ecx + esi - 0xfefd]
idiv al
xor edx, ebx
dec edx
push ecx
shr word [esp + ecx*8 - 0x7f808], 0x6a
dec ecx
rol edx, 2
inc eax
inc dword [esp + ecx*2 - 0x1fdf4]
Function at 0x77f79d
Capabilities:
Encrypt data using speck
Execute anti-debugging instructions
Manually build aes constants

Disassembly:
shr eax, 0xb2
shl edx, 2
shl ax, 0x64
and al, 0xa0
btc eax, eax
mov eax, ebp
shr word [esp], 0xa3
adc eax, edx
push 0x7c2e8715
mov dword [ebp - 4], eax
ror word [esp + 5], 0x88
jb 0xd14003
jae 0x73294a
mov ecx, 0xdd2f3691
movzx edx, cl
lea edi, [edx + edi - 0x95]
bts ecx, edx
mov ecx, dword [edx + edi - 0x91]
xor ecx, ebx
lea ecx, [edx + ecx + 0x49a4720d]
ror ecx, 3
call fcn.00765738
rol dword [esp], 0xbb
shr eax, 8
sar byte [esp + 2], 0xc6
jb 0x7e224b
shr byte [esp + 1], 0x85
xor eax, edi
mov dword [esp], edx
mov edx, ebx
mov eax, dword [esp]
jle 0x7413e3
sub edi, 4
mov edx, 0x80186f37
mov ecx, edx
mov ecx, dword [edi]
dec dl
movsx eax, dx
xor ecx, ebx
jmp 0x8ccab3
xor eax, ebx
xor eax, 0x71bdb100
neg edx
bswap eax
lea ecx, [edx*8 - 0x45e4258]
sti
rol dword [esp], 0x88
ror eax, 1
dec cx
ror dword [esp], 0xa8
xor dword [esp], edx
bswap eax
sal byte [esp + 1], 0x62
lea eax, [eax + ecx - 0x7a17b208]
neg eax
sub eax, 0x9d2f6617
xor ebx, eax
sar dword [esp], cl
jne 0x8778d3
dec ebx
je 0x7e22f7
cmp dword [ebx + ebp*8 - 0x50], 0xffffffa3
wait
dec ecx
jns 0x7e225c
sbb dword [ebp - 0x573f4cc], esp
outsb dx, byte [esi]
push eax
invalid
push ebx
ja 0x7e2347
xlatb
lodsb al, byte [esi]
invalid
stosd dword es:[edi], eax
leave
xadd dl, ah
push edx
rol ecx, 1
dec ecx
mul dword [esp + eax - 0x3636]
cwde
dec ax
not ecx
adc ecx, 0xde0c328f
not dword [esp + edx*2 - 0x3640]
xor ebx, ecx
xchg byte [esp + edx*2 - 0x3640], dl
shr dword [esp + edx*2 - 0x36b4], 0xc7
adc ebp, ecx
movsx ecx, dx
push ecx
add word [esp + eax*2 - 0xb598], dx
mov si, word [esi + edx*2 - 0x36b4]
cwde
pop ecx
pop edx
jge fcn.008059a4
movzx eax, cl
inc esp
movsx eax, dh
xor edi, ebp
bts ecx, ecx
lea edi, [ebx + edi - 0x33e7908b]
dec esp
lea edi, [eax*2 - 0x2cfed268]
jb 0xd66113
bswap edi
dec esp
lea ecx, [ecx + eax - 0x285960d9]
dec esp
btr ecx, eax
dec eax
sal esi, 0xef
dec edi
inc ecx
not cl
btc ecx, 0xab
dec eax
ror edx, 0x39
xor edi, 0x9b8d441e
dec ecx
dec eax
neg edi
rol edi, 1
dec eax
btc ecx, 0x98
dec edi
inc bp
and edi, edi
inc ebp
movsx esi, ax
rol edi, 3
not edi
neg si
inc cx
sar ecx, 0x49
neg edi
push ebp
add ecx, eax
dec ecx
xor eax, 0xdc006f1e
inc ecx
inc edi
xor dword [esp + edx - 0x5e00], edi
inc ecx
movsx ebp, di
pop ebp
inc ebp
bts esi, eax
inc ebp
sbb edi, edi
dec eax
dec ecx
dec eax
arpl di, di
dec esp
add ebx, edi
dec esi
mov ecx, dword [edx + edx - 0x5e00]
inc esi
mov al, byte [edx + edx - 0x5df8]
dec ebp
lea edx, [edx + edx*8 - 0x2eff6]
inc ebp
mov byte [ecx + edx*4 - 0x17800], al
xchg ebx, eax
inc ecx
mov edi, esi
inc ecx
jmp ebx
inc esi
mov eax, dword [edi + edx - 0x43116cb3]
inc ecx
sal edi, cl
inc eax
movsx esi, bh
dec ebp
lea edx, [edx + ecx - 0x6caf]
jnp 0xc5247f
inc ebp
mov esp, edi
jne 0x77f449

Function at 0x782bad
Capabilities:
Encrypt data using speck

Disassembly:
mov dword [esp], 0x889b4503
call fcn.00c8421e
clc

Function at 0x787c35
Capabilities:
Encode data using xor

Disassembly:
push 0x34393e32
lea esp, [esp + 0x14]
je 0xcbf8fc
push esi
Function at 0x78b6c8
Capabilities:
Check http status code

Disassembly:
xor edx, 0xa321bd0d
sub cl, 0x92
call fcn.00d08007
push 0x112c2232
mov dword [esp + 4], 0xee15a039
and ebx, 0xff
not byte [esp + 6]
ror word [esp + 5], 0xcd
mov ebx, dword [ebx*4 + 0xd09408]
neg byte [esp + 2]
shr edx, 8
jmp 0xd3b05f
mov al, 0x9b
invalid
lodsd eax, dword [esi]
jns 0xd3af93
invalid
xchg esp, eax
xor dword [0x89bdf68d], eax
mov word [eax + 0x2bbdf68d], cs
enter 0xffffffffffffb48d, 0xe
add al, 0x8d
idiv byte [ebp - 0x2ccc2609]
and ecx, ecx
lea edx, [ecx + edx - 0x40619c6a]
and dword [esp], 0xeeb7b70a
jp 0x756df2
xor edx, ebx
call fcn.0075949a
jno 0xd3b005
push 0xffffffffffffff9a
mov dword [0x2dbe2434], eax
sbb eax, 0x8cd29f44
movsb byte es:[edi], byte [esi]
pushal
or ecx, dword [esi]
xchg ebx, eax
sahf
aad 0xcc
push ds
mov esi, 0x8a0ecbe2
add byte [ecx + 0x26], bh
inc eax
inc eax
call [ebx - 0x3f]
push eax
jns 0xd3b085
mov esp, 0x597ca1d9
inc edi
mov al, byte [0x1698e911]
inc esp
cmp al, 0x1f
lcall 0x9dd0, 0xbeb84e22
call 0x2374000a
xchg edi, eax
xor eax, 0xbc2da326
add cl, cl
loop 0xd3b0bf
push 0x2c
add edx, dword [ecx]
dec ebx
mov esi, 0xbab4df8e
mov ebp, 0xee83348c
out dx, al
pushfd
call 0x351e2747
jmp 0x7395c035

Function at 0x79c910
Capabilities:
Encrypt data using speck

Disassembly:
mov eax, dword [eax + ebp - 0x169120bb]
call fcn.00bf5d8a
xor edx, 0xd70c3800
dec eax
lea esp, [esp + 0x14]
jne 0xd7606d
mov ecx, 0x325ac38
call fcn.0072ddc9
push 0xcbaaa406
adc eax, edx
push 0x8c0044a2
mov dword [ebp - 4], eax
dec dword [esp + 4]
push 0xf79ad490
test ebx, ebx
lea esp, [esp + 0xc]
je 0x77fe7b
mov eax, 0x49852091
lea eax, [eax + eax*4 + 0x1c8fe63c]
mov eax, dword [ebp + ebx*4]
push eax
dec ebx
push 0x870da907
lea esp, [esp + 4]
jne 0x77fe5a
mov eax, 0x169120bb
jmp 0x738e45
not dword [esp + edx*2 + 7]
bt dx, dx
neg al
ror al, 1
dec dl
sal byte [esp + edx - 0xf9], 7
pop edx
adc al, 0xad
mov edx, 0xaabfb62a
pop edx
neg al
xor bl, al
mov dword [esp], edi
or dl, 0x10
not edx
push ebp
lea ebp, [edx*4 - 0xc7e6080]
push ebx
sub edx, 0x1cb00b04
mov ebp, esi
sar dx, 0x49
mov ebx, eax
sar edx, 0xe
xor dl, 0x33
shr edx, 0x18
mov edx, ebx
mov eax, 0xe3a13023
xor ax, ax
shl edx, 2
sal al, 0x67
mov eax, ebp
jp 0x88ad93
jmp 0x7b01bd
jmp 0x760ba8
jns 0x77fe35
mov ecx, 0xd70ac703
sub edi, 4
mov edx, dword [edi]
sal ecx, 0xf0
movzx eax, cl
adc ecx, 0xfebf7738
xor edx, ebx
rol edx, 2
not edx
call fcn.0084a058
mov ecx, 0x9900452f
push ecx
lea eax, [ecx + ecx*8 + 0x279342a3]
mov ax, word [esi]
add dword [esp], ecx
rol ecx, 0xf
lea edx, [ecx - 0x63c8685f]
mov dx, word [esi + ecx*2 - 0x452f98fe]
bswap ecx
mov dword [esp], ecx
mov cl, byte [esi + 4]
sar word [esp + 1], 1
call fcn.007b092f
movzx esi, byte [ecx]
push 0x1897b72a
mov byte [esp + 3], 1
call fcn.007474a8
Function at 0x7a746a
Capabilities:
Encrypt data using speck

Disassembly:
xor ebx, edx
sub ax, ax
adc ebp, edx
movsx edx, ax
pop edx
movzx edx, cl
movzx cx, byte [ecx + edi - 0x36df8]
not edx
add al, byte [edi + eax + 2]
neg dx
jb 0xc7f3b6
mov edx, 0x718f2086
mov edx, dword [ebp + edx - 0x718f2086]
mov ecx, 0x228c1da5
lea ebp, [ecx + ebp - 0x228c1da1]
jmp 0xcbd257
adc edi, 1
or cl, al
mov eax, 0xff87298f
inc edx
not cl
shr dx, 0xaa
mov word [edi], cx
movzx ecx, al
sal ax, 0x6e
jmp ebp
mov eax, 0xc2210737
xchg cx, ax
xor edx, ebx
sub cx, cx
jbe 0xc8e011
ror eax, cl
push eax
lea edx, [edx + ecx - 0x1d886e45]
adc byte [esp + ecx - 0x7a03], 7
xor edx, 0xd09fe50e
sar byte [esp + ecx*8 - 0x3d02c], cl
setb al
neg edx
cbw
neg dword [esp + ecx*8 - 0x3d02c]
rol edx, 3
pop ecx
cwde
xor ebx, edx
dec cx
setg byte [esp + eax*4 + 1]
sar eax, cl
adc esi, edx
mov dword [esp + eax], esi
ret

Function at 0x7a7598
Capabilities:
Encrypt data using speck

Disassembly:
lea esp, [esp + 0x18]
jne 0x750642
mov esi, 0x721aa60f
pop esi
Function at 0x7ce423
Capabilities:
Encrypt data using speck

Disassembly:
push edx
neg eax
sar dl, 5
adc edx, 0xdf8bf700
setg byte [esp + ecx*4 - 0x67fffddc]
lea eax, [eax + ecx - 0xe77c853]
xor ebx, eax
add ebp, eax
call fcn.00c79c34
sar ax, 0x69
add ax, cx
sbb edx, 0x1d87f43e
shl dword [esp], 0xb9
neg ecx
btr ecx, eax
xor edx, 0xd09fe50e
btc eax, 0x89
shl al, 0xe4
neg edx
add byte [esp + ecx - 0x78177ffd], ah
rol edx, 3
jmp 0xc47849
neg dl
lea edi, [edi + edx - 0x5a91dc78]
mov dword [esp + edx - 0x5a91dc7a], edx
or word [esp + edx - 0x5a91dc79], 0xf1d
shr al, cl
call fcn.00c8a679
mov edx, 0xdebf892a
movsx eax, dl
cdq
mov al, byte [edi + edx*8]
movsx ecx, dl
sub dx, dx
setp dl
or cl, byte [edi + edx*2]
bt edx, 0x8e
lea edi, [edi + edx*2]
xadd dl, dh
and al, cl
add dl, dl
not al
movzx ecx, dx
mov word [edi + edx*2 - 0x204], ax
shr dl, 0x44
mov eax, dword [esi + edx*8 - 0x800]
neg edx
rol ecx, 0x5a
lea ecx, [ecx + edx*4 + 0x11833924]
lea esi, [esi + ecx*2 - 0x33066a4c]
bts cx, 4
bswap edx
xor dl, 0x88
xor eax, ebx
add cl, cl
jb 0xc471ab
or ecx, edx
inc eax
jmp 0xbe04c5
rol eax, 1
jmp 0x75bbd9
mov edx, dword [esi + eax - 0x39b22e27]
shr eax, cl
neg ax
inc ax
mov cx, word [eax + esi - 0x364db]
and eax, eax
rol al, 1
div al
lea esi, [eax + esi - 0x30681]
shr eax, 0x86
mov word ss:[edx + eax*2 - 0x1834], cx
mov eax, dword [eax + edi - 0xc1a]
mov ecx, 0xcfbb232d
add cl, cl
adc edi, 4
movsx edx, cl
xor eax, ebx
dec cx
xor eax, 0x6eb05217
xor edx, ecx
sub ecx, ecx
dec eax
lea edx, [edx + edx - 0x435ed660]
neg eax
bswap eax
xor ebx, edx
add esi, edx
xadd byte [esp + ecx - 0x78177ffe], ch
movzx edx, cl
mov dword [esp + edx], esi
ret

Function at 0x7d8478
Capabilities:
Encrypt data using speck

Disassembly:
neg eax
not eax
sub eax, 0x27a43dbe
sar dword [esp + 0xc], 1
shl byte [esp + 0xe], 0xe2
xor ebx, eax
mov ecx, 0x138764ab
movsx edx, cx
push edx
add ebp, eax
lea eax, [ecx*4 + 0x460ef589]
cdq
mov edx, dword [esi + ecx - 0x138764ab]
sub al, al
xadd cx, ax
xor word [esp + ecx - 0x1387eca9], ax
mov cl, byte [esi + ecx*2 - 0x270fd952]
adc esi, 2
rol eax, 0x26
inc ax
shr edx, cl
rol ax, 0x4e
jae 0xc4720c
and ax, ax
mov dword [esi + eax - 0xb198ab9], edx
shr dword [esp + eax*2 - 0x16331565], 0xf3
lea ecx, [eax + eax*2 - 0x31c4c17e]
mov dword [esp + eax*8 - 0x58cc55c8], ebp
ret 0x14
neg ax
xor ecx, ebx
bswap eax
inc al
jne 0x87da6a
dec ecx
xor ecx, 0x9ab86aac
mov edx, eax
not ecx
add ecx, 0xb51d880c
xor ebx, ecx
or eax, 0x64997611
cwd
adc ebp, ecx
cwde
lea ecx, [edx + eax*8 + 0x61a24d31]
lea edx, [ecx + ecx - 0x7b7728d3]
jmp ebp
sar dx, 0xe
dec dl
xor ebx, eax
sar ecx, 0x33
adc dl, ch
xchg dh, cl
adc ebp, eax
ror edx, 0xc9
call fcn.00d2d899
mov dx, word [esi]
mov cl, byte [esi + 2]
mov eax, 0xac1dc030
add esi, 2
sal dx, cl
lea ecx, [eax*8 - 0x78c28979]
bswap ecx
mov word [esi + ecx*4 - 0x1de0afa0], dx
rol eax, cl
lea edi, [edi + eax*4 - 0x7700c2b4]
sal eax, cl
mov ecx, dword [edi + ecx - 0x7782be8]
cwde
js 0x8093ce
Function at 0x7eae73
Capabilities:
Encrypt data using speck

Disassembly:
sbb edi, 8
jmp 0x7f8fa7
mov dword [edi + 0xc], eax
mov dword [edi + 8], ebx
mov dword [esp], 0xd2120b9e
mov dword [edi + 4], ecx
shr dword [esp], 0xb
mov ecx, 0xd60e2402
push ecx
mov dword [edi], edx
jp 0x841eb6
mov eax, 0xcbb90b8d
movsx ecx, ax
mov eax, dword [edi + ecx*8 - 0x5c64]
sub cx, cx
bswap ecx
or cl, byte [edi + ecx*4 + 8]
add edi, 6
shld edx, eax, cl
mov ecx, 0xdb8b6e99
shl ecx, 0x90
mov dword [edi + ecx - 0x6e990000], edx
movsx eax, cx
add ecx, 0xda8421a2
mov ecx, dword [esi + eax]
movzx edx, al
lea eax, [edx + edx*8 - 0x77428f7a]
lea esi, [esi + edx + 4]
not eax
xor ecx, ebx
div ax
and al, al
sub ax, 0x4d18
xor ecx, 0x71bdb100
rol dx, 0xa1
adc dl, dh
bswap ecx
push eax
ror word [esp + edx + 2], 0xd
ror ecx, 1
cbw
lea eax, [eax*4 - 0x6a7a07e8]
bswap ecx
xadd ax, dx
lea ecx, [ecx + eax - 0x17013425]
neg ecx
sar word [esp + edx - 0xf7bb], 5
mul edx
sbb ecx, 0x9d2f6616
neg dword [esp + edx*2 - 0xddbc]
sal eax, 0xb7
xor ebx, ecx
imul edx
rol dword [esp + edx*8 - 0x1bb0], 0xc1
mul eax
add ebp, ecx
shr byte [esp + eax*2 + 2], 1
mov dword [esp + eax*2], ebp
ret

Function at 0x7ed683
Capabilities:
Authenticate hmac

Disassembly:
bswap eax
sub ecx, dword [esp + edx - 0x6e9f3e12]
setge cl
inc eax
call fcn.008f6d55

Function at 0x7fbc1e
Capabilities:
Encode data using base64

Disassembly:
mov cx, word [edx]
mov eax, 0xe99bcb06
add ebp, 2
movzx edx, ax
call fcn.00c0823b
mov ecx, 0x4c15a70f
mov edx, ecx
mov ecx, dword [ecx + ebp - 0x4c15a70f]
call fcn.00908a6d
mov edx, dword [edi + ecx - 0xe9536ae]
call fcn.008aca8d

Function at 0x801a01
Capabilities:
Encrypt data using speck

Disassembly:
shr al, 0xc2
neg cl
inc cl
mov dword [esp + eax - 0x35a1622e], eax
not cl
neg ax
dec al
call fcn.0084abc8

Function at 0x801a39
Capabilities:
Encrypt data using speck

Disassembly:
mov dword [esp + edx - 0x40053cd8], 0xc934d72d
mov eax, edx
inc cx
rol cx, 1
jmp 0x8c70a9
pop edx
not cx
imul edx, edx
setno al
neg cx
dec edx
cwd
or eax, edx
xor bx, cx
bswap eax
lea edi, [eax + edi - 0x3c25cb]
mov word [eax + edi - 0x3c25c9], cx
dec ax
dec ax
movzx ecx, dx
jne fcn.008b5794

Function at 0x81dcc7
Capabilities:
Encrypt data using speck

Disassembly:
sub ecx, dword [esp + ecx*2 - 0x46c7ce4e]
lea edi, [edi + edx*2 - 0x191c1]
inc cx
movzx ecx, byte [edx + edi - 0xc8e0]
ror word [esp + edx - 0xc8de], 0x64
adc word [esp + edx - 0xc8de], dx
xor cl, bl
shl dword [esp + edx - 0xc8e0], 0xc6
shl edx, 0xdb
bt edx, edx
not cl
dec edx
xor dword [esp], edx
neg cl
jmp 0x8de8e3
mov eax, dword [edi]
pop ecx
xor eax, ebx
pop ecx
mov ecx, 0xca1b0c8a
xor eax, 0xa017e434
inc cx
neg eax
add ecx, 0x270011bc
movzx edx, cx
cmovbe edx, ecx
inc eax
rol eax, 2
sal ecx, 5
jns 0xc3b5f4
xor ebx, eax
add esi, eax
dec edx
push ecx
xadd cx, dx
mov ax, word [ebp + edx*2 - 0x191c0]
rol dword [esp + ecx - 0x2363e726], cl
ror dword [esp + edx - 0xc8e0], 0xba
inc ecx
lea ebp, [ebp + ecx - 0x2363e725]
bt ecx, edx
jb 0x74a97d