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

Disassembly:
dec eax
mov dword [esp + ebp - 0x178ccc27], edx
dec ecx
sar eax, cl
inc bp
mov dword [ecx + edx - 0x19579d80], ebp
inc sp
sub dword [esp + edx - 0x19579d7b], esp
dec esi
lea edx, [edx + edx - 0x19579d84]
inc ebp
mov esi, dword [edx + edx - 0x19579d80]
js 0xd882f3
dec ebp
mov eax, dword [ecx]
inc ecx
mov esi, 0x440d768b
inc di
mov esi, dword [esi + ecx - 0x440d7683]

Function at 0x928a33
Capabilities:
Authenticate hmac
Encrypt data using chaskey
Encrypt data using speck

Disassembly:
dec edx
mov dword [esp + esi*8 - 0x2d170], ebx
inc ebp
movsx ebx, bp
dec edx
mov dword [esp + esi - 0x5a2f], 0x1d898d82
inc edx
xor dword [esp + esi*4 - 0x168b4], eax
dec edx
mov ebx, dword [esp + esi - 0x5a27]
inc cx
sar edi, 0xc7
dec eax
arpl ax, ax
inc ecx
pop eax
dec esi
mov dword [esp + eax - 0x1d898d82], edi
jbe 0xd5a0e1
dec eax
add edi, eax
dec ebx
mov ecx, dword [eax + ecx - 0x1d898d80]
call fcn.00debe64
mov ecx, 0x5395f239
shl ecx, cl
mov eax, dword [edi + ecx - 0x72000004]
lea edx, [ecx + ecx + 0x2e029311]
setne cl
xor eax, ebx
shl dl, 1
or dl, 0xb3
call fcn.00a8ecfc
not dword [esp]
add esi, edx
mov eax, dword [esp]
movzx edx, ax
not eax
pop edx
pop eax
pop ecx
pop ecx
jmp fcn.00a61cb3

Function at 0x928a73
Capabilities:
Authenticate hmac
Encrypt data using chaskey
Encrypt data using speck

Disassembly:
dec eax
mov dword [esp + esi*2 - 0x28022cfe], 0x5a23af0b
inc esp
mov esp, dword [esp + esi - 0x14011674]
inc eax
and al, ch
inc ecx
pop ebp
dec ecx
dec eax
inc cx
mov dword [ecx + esi - 0x14011689], eax
xor esi, edx
dec edi
lea ecx, [ecx + edi*4 + 0x382]
inc ecx
movsx eax, bh
inc dx
rol dword [esp + edi + 0xfd], 0xcf
pop ebp
pop ebp
pop eax
pop edx
ja fcn.00d6eae8
sal ecx, cl
dec dword [esp + ecx - 0x7ffffff8]
xor edx, 0x2911241e
xadd dword [esp + ecx - 0x7ffffff8], eax
xor ebx, edx
shl cl, 0xc1
je 0xd87d3f
ror dl, 1
inc dword [esp + eax - 0x720f4]
call fcn.00d9d149
lds esi, [ecx]
fsub dword [eax]
push ss
imul esp, ecx, 0x69
outsd dx, dword [esi]
inc byte [ebx]
call 0x6af6a3a5
lahf
std
inc ecx
ret 0xe870
adc ebp, edx
or cx, 0x900a
movzx edx, byte [edi + eax - 0x72089]
not cl
sal al, 0xe3
lea edi, [edi + eax*4 - 0x1c83ea]
xor dl, bl
dec dl
sub cl, cl
lea ecx, [ecx + 0x233cd597]
jle 0xa21e88
call fcn.00e4d709

Function at 0x928adc
Capabilities:
Encrypt data using speck

Disassembly:
inc esi
mov esp, dword [esi + edx - 0x30]
dec edx
sub dword [esp + ebp - 0xb5], 0xcb09d606
dec edi
lea edx, [edx + ebp*2 - 0x1b1]
shr ecx, 0xaa
inc ecx
shl ebx, 0x5d
inc esp
xor esp, ebx
inc esi
xchg dword [esp + ebp - 0xb2], ebp
call fcn.009b62e5
Function at 0x92bd11
Capabilities:
Authenticate hmac
Encode data using base64
Encrypt data using speck

Disassembly:
inc ecx
sub ebp, 0x351dd087
call fcn.00a6576a
inc ebp
mov eax, dword [edx]
inc cx
dec esi
mov edx, eax
inc esp
xor eax, ebx
inc ecx
push esi
inc esp
movsx ebp, al
inc ecx
bswap eax
inc edx
shr byte [esp + ebp - 0x57], 0x82
inc ecx
not eax
inc ecx
pop edi
inc ebp
movzx ebx, di
inc ecx
neg eax
ror dl, 0x86
inc ebp
movzx esp, ch
inc ecx
sbb eax, 0xc0be3523
inc ecx
xor eax, 0x6923aa99
inc edi
lea eax, [eax + ebp - 0x3180198a]
call fcn.00d584e3
dec ecx
add ecx, 2
shr dx, cl
push 0xab0bf713
inc cx
mov dword [ecx], edx
inc ecx
pop eax
dec edi
lea edx, [edx + eax + 0x54f408e9]
inc ebx
mov edx, dword [edx + eax + 0x54f408ed]
inc ebp
mov esi, eax
inc ecx
mov ebp, 0x1624cda4
xor edx, ebx
inc ecx
xor ch, 0x88
inc ebp
movzx edi, ax
bswap edx
inc ecx
movsx eax, bp
inc edx
lea edx, [edx + eax*2 - 0x52bdc1b9]
not edx
bswap edx
ja 0xd85bb5
dec eax
inc eax
pop ebx
jle 0xd6c227
inc ebp
movsx ebx, al
dec ebp
xchg esi, edi
dec eax
arpl dx, dx
call fcn.00dc4e4f
dec dword [esp + edx - 0x14f93be9]
sub dword [esp + edx - 0x14f93be5], edi
dec esp
mov dword [esp + edx*2 - 0x29f277da], ebx
jb 0x9bff63
dec eax
adc edi, edx
inc ebp
movsx ebp, ah
jmp fcn.00d6eae8
inc ecx
push ebp
inc ecx
pop ebp
inc edx
lea edx, [edx + ebp*8 + 0x1784a6df]
neg edx
push ebx
dec ebx
lea ebx, [ebp + ebp + 0x392ff2b9]
inc edx
xor dword [esp + ebp - 0x1624cd2c], edx
dec ax
jle 0xa75147
dec ecx
sub edx, 4
jmp 0xda8c74
mov esi, 0xe2309c31
inc ecx
mov ecx, dword [edx]
inc esp
movzx edi, si
xor ecx, ebx
inc ecx
movsx eax, bh
inc ebp
movsx esi, di
rol ecx, 1
dec eax
lea edx, [eax*2 - 0x3f779ff4]
call fcn.00e41ae5

Function at 0x92d06c
Capabilities:
Encrypt data using speck

Disassembly:
inc edi
mov edi, dword [edx + esi - 5]
inc esp
xor edi, ebx
dec ecx
shr ebp, cl
dec ecx
not esi
inc edi
lea edi, [esi + edi - 0x5cb0f539]
dec esp
mov dword [esp + ecx*2 - 0x1ff56], esp
inc ebp
xor edi, esi
inc dx
rol dword [esp + esi + 2], cl
inc si
xadd dword [esp + esi*2 + 8], esi
inc edi
lea edi, [esi + edi - 0x29147808]
ja 0xdaf492
Function at 0x937225
Capabilities:
Encode data using xor

Disassembly:
dec ecx
pop ecx
mov dword [eax], edx
mov edx, dword [edi + 1]
xor byte [esp + 1], 1
mov eax, dword [esp]
or al, 0x1f
xor edx, ebx
call fcn.00913d0a
not cl
mov dword [esp + eax - 0x7ae39eb0], 0x2ba4e7bb
movsx edx, ax
xor bl, cl
or dl, byte [esp + eax - 0x7ae39eaf]
pop edx
lea edx, [edx*8 - 0xc77f9d2]
adc ecx, esp
dec edx
movzx dx, byte [ecx + eax - 0x7ae39eb0]
mov word [esi + eax - 0x7ae39eb2], dx
call fcn.00a8bd4a
mov dword [0x9c41491e], eax
push ebp
mov eax, dword [0xc0b04be2]
jns 0x93720d
loop 0x9372b9
xchg esp, eax
dec esp
add eax, 0xb84be2a1
call 0x4c7613ab
invalid
jbe 0x9372dd
mov ebx, 0x3eec446d
salc
dec esp
out 0x6e, eax
outsb dx, byte [esi]
mov dh, 0xc8
push esp
mul byte [edx + esi*2 + 0x75d10545]
in al, 0x72
enter 0xfffffffffffff654, 0xffffffffffffffa4
jb 0x937306
add eax, 0x72e475d1
add dword [ecx - 0x57], ebx
jne 0x9372af
jb 0x937346
sub dword [ebp + 0x6d72e475], edi
cmp ebp, edx
jne 0x9372bb
jb 0x9372de
sbb eax, 0x72e47581
jb 0x937330
push ecx
sub eax, 0x6ecfd75
sbb dword [ebp + 0x6b], esi
push ebp
hlt
push edi
dec esi
push 0x5b32092b
push esi
sub dword [ecx], esi
adc al, 0x12
wait
inc ebx
enter 0x1f03, 0x3e
push 0x42
retf
push cs
add ah, byte [eax + 0x2c]
les ecx, [ebp + 0x26e55963]
pop ss
out 0x5e, eax
aaa
pop ds
stosd dword es:[edi], eax
js 0x9373ab
arpl di, ax
inc edi
into
out 0x46, al
push ss
ror byte [edx + 0x74], 0xb1
mov al, byte [0x42d72c00]
popal
aaa
stosb byte es:[edi], al
bound esp, qword [edx + 0x70]
invalid
or eax, 0x6c2c8d5d
int1
sub dword [ebx + 0x49], esi
loopne 0x9373fb
add dword [edi], 0x7524b521
jb 0x937422
test dword [0x7468af1e], 0x3c783dde
xor edi, dword [edx]
or bh, byte [esi]
cmp dword [0x3e1e1b48], 0xffffff83
cmp eax, 0x3e3a0e21
cmp dword [0x3e2e287f], 0xffffff83
cmp eax, 0x607c6772
sbb ebp, esp
and eax, 0x4d50cd81
sbb eax, 0x5dd678d9
push ecx
mov ecx, edx
scasd eax, dword es:[edi]
rcl ebp, 1
adc dword [ecx + 0x29], esi
scasd eax, dword es:[edi]
shl ecx, 0x79
jno 0x93742a
scasd eax, dword es:[edi]
test eax, 0x83df3085
aas
fnstsw word [ecx + 0x73348724]
xor bh, bl
cmp dword [edi], 0xffffffdd
mov ecx, 0x73348724
stosd dword es:[edi], eax
test byte [edx + 0x2a], bl
insb byte es:[edi], dx
ret
out 0xe4, al
out 7, al
cmc
xchg ecx, eax
push eax
loopne 0x9374a7
jl 0x9373fc
ror byte [ebx + 0x4b], 1
dec ebx
dec ebx
cmp bh, byte [esi + 0x21]
inc esi
mov eax, 0xa2fe63ef
push ds
ja 0x937445
idiv dword [ebx - 0xd775674]
jge 0x937464
and edi, dword [eax + 0x252e48d3]
fist dword [ebp - 0x7f]
adc dh, byte [0xdd58b755]
dec eax
and eax, 0x128155db
xor eax, 0xdd58b755
pushal
mov ebx, 0xb5d99758
push ebp
scasb al, byte es:[edi]
xor al, byte [ebx + 0x16]
xchg byte [esi], cl
inc ecx
inc esp
adc ah, byte [ebx + 0x48]
jle 0x937404
lahf
test eax, 0x57b4ebf8
dec edx
xchg byte [ebp + 0x3bb4ea2c], cl
mul byte [edx]
hlt
fstp qword [eax + eax*4]
adc byte [ebx + 0x2a0f2b5d], ah
cmp edi, dword [ecx + 0x54]
fsqrt
ljmp 0x1347
Function at 0x937904
Capabilities:
Encrypt data using speck

Disassembly:
mov eax, edx
add edi, 4
mov dword [esp], edx
xchg dword [esp], edx
xor ecx, ebx
ror dword [esp], 0x45
and eax, 0xe9921130
sete byte [esp]
ror ecx, 1
sub ecx, 0x3633450b
rol edx, 5
setb al
neg ecx
dec al
sub ecx, 0xe28e659f
xor ecx, 0x1896118c
xor ebx, ecx
sub dl, 0xa8
jnp 0xe50fce
inc ecx
bswap edi
inc ecx
neg edi
dec ecx
inc ebp
dec ecx
bswap eax
inc ebp
sub edi, ebp
rol cl, 0x61
inc ecx
mov eax, ebp
dec ebp
xadd esp, eax
push ebx
inc esp
sbb al, cl
call fcn.00d8a3f9
adc eax, 0xfff520b7
jmp eax
dec byte [esp + edx - 0x6605200d]
adc esi, ecx
xadd dl, dh
dec edx
jbe 0xe2651e
mov cx, word [edx + ebp - 0x66050d2c]
push edx
ror eax, 0x52
jb 0x935dd9
lea ebp, [ebp + eax*2 - 0x805486]
not edx
xadd dword [esp + eax*2 - 0x805484], edx
add word [esp + edx - 0x2d5981fe], 0xb13d
movzx edx, byte [edi + edx - 0x2d5981ff]
lea edi, [eax + edi - 0x402a43]
sar al, 0xa4
xchg word [esp + eax - 0x402a02], ax
xor dl, bl
call fcn.00da109c
xor byte [eax + 0x1f05ae9c], 0x6c
inc esp
and byte [ecx + 0x7450edd2], 0xec
mov eax, dword [0x7c3cedd2]
in eax, dx
vmread dword [ebp + 0x36], edi
adc dword [esi], 0x52
fisubr dword [ebx - 0x15ac9fa7]
inc edx
retf

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

Disassembly:
bswap eax
neg eax
dec ecx
rol ecx, cl
push ecx
sub eax, 0x7f16dd0d
or word [esp + 1], 0xe82b
or cl, ch
xor ebx, eax
xchg dword [esp], edx
neg cl
call fcn.00d733d4

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

Disassembly:
dec edx
mov dword [esp + edi - 0x8a], 0xa7095aa7
inc edx
xor dword [esp + edi*4 - 0x220], eax
inc esi
movzx ebx, word [esp + edi*4 - 0x228]
inc ecx
ror ah, 0xc1
inc ecx
movzx ebx, ah
dec edx
mov ebx, dword [esp + edi - 0x82]
dec eax
arpl ax, ax
dec ecx
cmovae edx, esp
dec esp
lea eax, [ecx*2 - 0x254ea73]
dec eax
adc edi, eax
inc ecx
pop edi
dec ecx
or ebx, 0xab8c4f02
dec edi
mov ebp, dword [ecx + esi*8 - 0x43e]
inc ecx
setbe bh
inc cx
sub ecx, edi
dec edx
mov dword [esp + esi - 0x88], ebp
dec ebx
mov ecx, dword [edi + ebp + 0x58f6a600]
dec esi
add dword [esp + esi - 0x88], esi
mov eax, dword [esp + edx*2 - 0x84]
dec edi
mov ebx, dword [ecx + edi + 0x58f6a60a]
jg 0xdff0c6
dec ebx
mov dword [ecx + esi - 0x7e], ecx
call fcn.009214c3
inc edx
or dword [esp + edi + 0x58f6a604], 0xe93056af
dec ecx
adc ecx, ebx
inc esi
movsx ebp, word [esp + edi + 0x58f6a604]
sal eax, 0xc3
jns 0x9ae6d0
mov eax, 0xda907299
dec ecx
sub edx, 4
call fcn.00deb735
mov edx, 0xb3334cab
mov eax, dword [esi]
mov cl, byte [esi + 4]
shr eax, cl
lea ecx, [edx*4 - 0x41c19ad7]
lea edx, [ecx + edx*2 + 0x5038e622]
mov dword [esi + edx - 0x41ab174b], eax
movsx eax, cl
inc cl
mov eax, dword [edx + edi - 0x41ab1751]
rol cx, 0xe4
sal edx, cl
lea ecx, [edx*8 + 0x4084c814]
xor eax, ebx
xor eax, 0xb096ca84
ror eax, 1
add ecx, 0x932fa798
not eax
call fcn.00daac69
xchg edx, eax
xor ebx, ecx
add ebp, ecx
sub edi, 1
shr edx, 0x37
movzx eax, byte [edi + edx*2 - 0x3fe]
xor al, bl
sub al, 0x3d
jmp 0xa4e154
Function at 0x9382c0
Capabilities:
Authenticate hmac
Encrypt data using speck

Disassembly:
inc ebp
mov ebp, edi
dec esi
lea ebx, [esp + ebx + 0x10]
inc ecx
inc esi
dec esi
mov dword [edx + ebx - 0x47be], eax
inc cx
shr esp, 0xe
call fcn.00e3d59a
xor eax, ebx
inc edx
lea eax, [eax - 0x3fe27d38]
dec edx
mov dword [esp - 0x7a0cb654], edx
jmp 0xe26aca

Function at 0x93dec2
Capabilities:
Encode data using base64
Parse pe header
Resolve function by parsing pe exports

Disassembly:
jl 0xd57518
mov ecx, dword [edx + edi]
mov dword [esp + edx*2], edx
lea edi, [edi + edx*4 + 4]
xchg dx, ax
inc ax
xor ecx, ebx
sar al, 5
inc edx
xchg dword [esp + edx - 1], edx
xor ecx, 0xb30e4b2c
neg ecx
inc word [esp + edx*2 + 2]
lea ecx, [edx + ecx - 0x338cff8e]
pop edx
neg ecx
sar dx, 0xa2
jns 0xd969a5

Function at 0x93e033
Capabilities:
Parse pe header
Resolve function by parsing pe exports

Disassembly:
inc ecx
movzx ecx, bl
call fcn.00a8192e

Function at 0x93e03c
Capabilities:
Parse pe header
Resolve function by parsing pe exports

Disassembly:
push esi
mov dword [esp + 0xc], 0xa5fdfee2
lea esp, [esp + 0xc]
call fcn.00d589de
Function at 0x93e083
Capabilities:
Parse pe header
Resolve function by parsing pe exports

Disassembly:
mov ecx, dword [edi]
xor ecx, ebx
xor ecx, 0xff2d7723
mov dword [esp], eax
or word [esp + 1], ax
not ecx
xchg word [esp + 2], dx
neg ecx
rol edx, 0xfc
xor eax, dword [esp]
lea ecx, [ecx + eax + 0x1daf4c1a]
jg 0xdbb900
je 0xe63249
mov esi, dword [ebp + 0xc]
stc
test esi, esi
jmp 0xe63235
jne 0xe63249
mov ecx, dword [eax + 0x78]
cmc
cmp sp, 0x6d12
mov dword [ebp - 4], ecx
test ecx, ecx
je 0xe63249
mov eax, dword [eax + 0x7c]
push ebx
cmc
push edi
mov dword [ebp - 0x10], eax
mov dword [ebp - 8], 0xffffffff
jmp 0xdda075
mov eax, dword [ebp - 0xc]
bts ecx, ebx
dec cl
mov ecx, dword [ebp + 0x10]
rcr esi, 0x2b
lea esi, [edi + ebx]
cmp eax, 0xf19f513f
stc
sar esi, 1
test ch, 0x2e
stc
mov eax, dword [eax + esi*4]
cmp dh, 0x3c
jmp 0xda6099
jmp 0xe2f65b
ret
mov edx, dword [ebp - 4]
mov eax, dword [ebp + 8]
test edx, esp
mov ecx, dword [edx + eax + 0x24]
bswap edx
jmp 0xd9ebd9
movsx ecx, byte [esp + eax - 0x4686ffff]
mov ecx, dword [esi + eax - 0x4686ffff]
adc word [esp + eax - 0x4686fffd], dx
neg dl
shr eax, 0x92
mov dx, word ss:[ecx + eax - 0x11a1]
lea esi, [esi + eax*2 - 0x2340]
mov word [esi + eax*2 - 0x2342], dx
mov dword [esp + eax*8 - 0x8d08], ebp
ret
lea edx, [ecx + esi*2]
movzx eax, word [edx + eax]
cdq
mov ecx, dword [ebp - 4]
sar dh, 0xb9
mov edx, dword [ebp + 8]
jmp 0xde20ac
push ecx
add ecx, eax
rcl ch, 7
mov ecx, dword [ebp + 0xc]
test dx, ax
add eax, edx
call fcn.00911efc
lea esp, [esp + 4]
jmp 0xdddd87
mov eax, dword [edx + 0x3c]
lea eax, [eax + edx]
cmp dword [eax], 0x4550
jmp 0x99efd3
neg ecx
xor ebx, ecx
dec eax
add ebp, ecx
ror al, 0x81
jb 0xd8bc62
inc ecx
dec esp
dec ecx
add edi, ebp
call fcn.009b607b
je 0xde20af
mov eax, dword [ecx + edx + 0x20]
dec edi
cmc
add eax, edx
cmp esp, edx
xor ebx, ebx
test ebp, 0xaf28d618
mov dword [ebp - 0xc], eax
test edi, edi
jl 0xde20af
jmp 0xa26ddc
jmp 0xde20af
cmp esi, 0xffff
ja 0xe65707
mov eax, esi
sub eax, dword [ecx + edx + 0x10]
jmp 0xdb2952
test eax, eax
jge 0xe2f64a
lea edi, [esi - 1]
jmp 0xa58d91
jle 0xd6d037
lea ebx, [esi + 1]
shld dx, si, 0xb2
not dx
cmp ebx, edi
movsx edx, si
mov edx, dword [ebp + 8]
jmp 0xe51acf
jle 0xa26dd4
mov ecx, dword [ebp - 4]
jmp 0xdd741a
je 0xe63249
mov eax, 0x5a4d
cmp word [edx], ax
je 0xdb6604
sub eax, eax
not esi
pop esi
mov esp, ebp
pop ebp
jmp 0xd536dd
mov edi, dword [ecx + edx + 0x18]
test edi, edi
jmp 0xdc5e93

Function at 0x9a3ccd
Capabilities:
Encrypt data using speck

Disassembly:
call fcn.00a8b684
inc ecx
mov ebx, 0xc52d01ae
inc ecx
movzx ebp, byte [edx - 1]
inc eax
xor ch, bl
dec edi
lea edi, [ebx + ebx*8 + 0x6036b38e]
inc ecx
mov ecx, edi
inc eax
add ch, 0xb1
inc ecx
push edi
inc ecx
not bh
inc eax
ror ch, 1
inc esp
xor byte [esp + ecx - 0x4ecbc2a6], bh
ja 0xdb6a2c
inc ebp
adc ebx, ebx
inc eax
xor ch, 0x8e
call fcn.00a78b90
Function at 0x9a4deb
Capabilities:
Encrypt data using speck

Disassembly:
neg eax
inc dl
neg dl
not dl
xor bl, dl
xadd byte [esp + eax*8 - 0x22030a05], cl
lea edx, [esp + edx + 8]
sub word [esp + eax*2 - 0x880c27f], ax
jbe 0x99f01c
movzx ax, byte [edx + eax - 0x4406141]
mov word [ebp + 6], ax
sbb ebp, 0xfffffffa
jmp 0xa6868e
mov eax, dword [esp + 4]
lea edi, [edi + eax - 0x7aaf9ab7]
mov dword [esp + eax - 0x7aaf9abd], eax
xor dl, bl
add dword [esp + eax - 0x7aaf9abb], eax
ror dl, 1
or eax, ecx
jae 0x92f52f
movzx edx, byte [esp + 4]
jmp 0xd534dd

Function at 0x9a6019
Capabilities:
Authenticate hmac

Disassembly:
dec edi
add ebx, dword [edx + ebx - 0x14]
inc ecx
movzx esi, si
dec edx
mov dword [esp + edi*2 + 0x20], esi
dec edi
lea edx, [edi + edx - 0x14]
inc ecx
movsx eax, bh
inc bp
xchg eax, ebp
dec esp
xor ebx, ebx
inc esi
or dword [esp + edi*4 + 0xb], ebp
inc edx
or byte [esp + edi + 0x27], dh
inc ecx
setp dh
dec ecx
dec ebx
dec ebx
lea edx, [eax + edi*2 + 0x17ab818a]
inc ecx
neg esi
dec ecx
bswap ebx
dec edi
lea ebx, [ebx + edi*2 - 0x6a53d352]
dec edx
not dword [esp + edi + 0xf]
dec ecx
xor ebx, 0x33283316
and ax, 0xa137
inc edx
ror dword [esp + edi + 0x1e], 0xa6
dec edi
lea ebx, [ebx + edi*2 + 0x52de0655]
dec ecx
not ebx
dec ecx
xor ebx, ebx
call fcn.00e60de0

Function at 0x9a6087
Capabilities:
Authenticate hmac

Disassembly:
inc cx
rol esp, 0xa
rol bp, 0xa8
xor bx, dx
dec ecx
rol ebp, 0xb4
dec ebp
lea eax, [esi + ebp*8 - 0x1248caff]
dec eax
lea edx, [esp + edx + 0x10]
dec ebp
xor ebp, esi
adc bp, 0x7bb5
dec ecx
sbb ebp, eax
dec esp
mov eax, dword [edx + ebp + 0x220cd80e]
inc ecx
push ebx
dec ebp
mov dword [ecx + ebp + 0x220cd80e], eax
dec ebp
mov esp, dword [edx + ebp*2 + 0x4419b00e]
inc ecx
setb bh
dec eax
mov dword [esp + ecx*2 - 0x68acf5f8], 0x3a1bb0a8
dec edi
lea edx, [edx + edi*2 - 0x7a014e10]
inc edx
movsx edx, word [esp + edi - 0x3d00a6ff]
inc ecx
adc edx, esi
dec esp
xor esp, ebx
jmp 0xda8469
dec ecx
dec esp
dec eax
sar eax, 0x2d
inc dx
or dword [esp + edi - 0x3d00a6ef], esi
dec ecx
bswap esp
adc al, dl
inc ecx
pop ebp
dec edi
lea esp, [esp + ebp*2 - 0x6a544cd6]
jp 0x9bda43
ror dl, 1
call fcn.009a40e0

Function at 0x9a621e
Capabilities:
Encode data using xor

Disassembly:
lea ecx, [esp + ecx + 0x10]
setb dl
xor edx, dword [esp + edx - 0x6ddf3bf4]
shr dx, 0xc3
mov dword [ecx + edx - 0x5f210425], eax
and word [esp + edx - 0x5f21041b], 0xe73a
mov dword [esp + edx - 0x5f210421], edx
inc word [esp + edx - 0x5f21041d]
movzx eax, byte [edx + edi - 0x5f210420]
sub edx, edx
call fcn.00d55e2a
mov dword [0xb441400e], eax
insd dword es:[edi], dx
mov cl, 0xeb
dec ebx
mov esp, 0xebb13188
dec ebx
xor al, 0xc0
jns 0x9a6223
xchg edx, eax
ret 0x9433
jmp 0x9a62bf
push esp
int 0x3c
pop ss
cmp dword [edi], edi
fcmovbe st(0), st(6)
insb byte es:[edi], dx
je 0x9a62bf
clc
cmc
dec ax
mov esi, 0xd8379e
aas
push esp
rcr dword [edi], 1
and esi, dword [esi + 0x7a]
rol byte [ecx - 0x7cbe2d83], 1
mov dl, 0x50
salc
retf 0x5a55
Function at 0x9a6e12
Capabilities:
Encrypt data using speck

Disassembly:
mov dword [esp + ecx + 0x4ecb8a66], eax
mov dword [esp + ecx + 0x4ecb8a62], ecx
movzx edx, cx
pushfd
pop eax
mov dword [esp + ecx + 0x4ecb8a62], eax
mov ecx, 0
push edx
push edx
dec dl
mov dword [esp + edx - 0x7599], ebx
xchg byte [esp + edx*8 - 0x3ace7], dl
mov dword [esp + edx*2 - 0xeaea], esi
movsx ebx, dx
sar bx, 0xc8
rol dx, 0x67
push ebp
movzx ebp, dl
movzx eax, bp
lea esi, [esp + edx*2 - 0x1757c]
cmovae bx, bp
or ebx, eax
call fcn.009b2024

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

Disassembly:
dec ecx
mov ecx, dword [edx + ecx*8 - 0x2affff8]
pop edx
and dword [esp + eax*8 - 0x7f4], eax
mov dword [esi + eax*2 - 0x1fe], ecx
jg 0xe2745f

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

Disassembly:
inc ecx
not al
xor edx, 0x82ab811f
dec esi
mov dword [esp + esi - 0x7a0ca20a], esi
inc ecx
xor bl, al
dec eax
ror esi, 0x43
dec esi
lea eax, [esp + eax + 0x18]
dec esi
mov dword [esp + esi - 0x7a0ca212], esp
call fcn.00e6693f

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

Disassembly:
inc ecx
ror ecx, 3
inc eax
pop eax
call fcn.00e0a694
inc ecx
mov esi, ebx
inc cx
xor ebp, 0x1ce854bd
sub dword [edi], eax
inc eax
ror ch, 5
ror al, 1
xor al, 0x8e
sub al, 0x9b
jmp 0xe132af
dec eax
lea eax, [esp + eax + 0x10]
dec ecx
or edi, 0xbbabff2a
dec ebp
xadd esi, eax
inc esi
mov esi, dword [eax + ebp - 0x6409dbaf]
sar bp, 0x6a
jne 0xe50b23
mov ecx, 0xb7293798
mov ecx, dword [edi]
mov eax, 0x61935438
sub eax, eax
add al, 0xaf
lea edi, [eax + edi - 0xab]
bswap eax
xor ecx, ebx
push eax
shl al, 5
xor ecx, 0xa61d231a
dec eax
rol dword [esp], 0xd8
ror ecx, 3
neg word [esp + 2]
jne 0x93db47
not byte [esp + 2]
sub eax, 0x12a45abc
movzx edx, cx
rol eax, 1
rol edx, 0xb0
sbb eax, 0x2ea8cd81
call fcn.00a11877
dec ecx
add ebp, 0x95ac2cae
dec ecx
ror esp, 0xe7
dec ecx
xor ebp, 0x33283316
not ebp
dec ebp
lea ebp, [ebp + ebp - 0x3481f074]
inc ecx
ror al, 0x23
sub dl, 0xbb
dec ecx
not ebp
inc edx
sar byte [esp + edi - 0x78a00000], 0xc2
push edx
dec ecx
xor ebx, ebp
jmp 0xe46312
dec ebp
lea ebx, [edi + esi*8 + 0x5e248d28]
rol al, 1
inc ebp
xchg esp, ebp
xor bl, al
mov edx, ecx
jmp 0xdd29ee
dec edi
mov dword [ecx + edi - 0x789ffff8], ebp
call fcn.00a5130a

Function at 0x9b7239
Capabilities:
Get number of processors

Disassembly:
shl ecx, 0xc
xor ebx, edx
call fcn.009120cd

Function at 0x9ba1a3
Capabilities:
Encode data using xor

Disassembly:
dec ecx
not ebp
dec ebp
or eax, edi
dec ecx
xor ebx, ebp
dec eax
mov dword [esp + ebp + 0x17c361b0], 0xf23f82bd
inc esp
mov ebx, ecx
xadd ecx, ebp
dec esi
mov dword [ebp + ecx - 0x5e7f9806], ebp
dec edi
lea ecx, [ecx + esi - 0xc0cc047]
call fcn.00913168
popal
mov ebp, 0xac1ed973
mov al, 0x48
invalid
Function at 0x9bc00c
Capabilities:
Authenticate hmac
Encode data using base64
Encrypt data using speck

Disassembly:
inc dx
or esi, dword [esp + esi - 0xffba]
dec eax
mov dword [esp + ecx*8 - 0x7f80], edi
ret 0x10
shl edx, 2
mov eax, ebp
add eax, edx
push 0xc6a98d3a
rol dword [esp], 0x2a
push 0xf9bbeeab
mov dword [ebp - 4], eax
jae 0xa1f640
mov dword [esp], ebx
add al, 0x38
push edx
mov ebp, esi
adc dx, ax
movzx ebx, word [esp]
adc ebx, edx
mov ebx, ecx
adc al, dl
jb 0xe13292
lea edx, [edx + eax*2 - 0x7507d5ad]
shr eax, 0x9f
and cl, 0x9b
ror edx, 3
xor eax, eax
je 0xd600c4
imul ebp, dword [ebx], 7
fnstcw word [esi - 0x4e]
neg ebx
and edx, esi
test eax, 0x1bd3f340
salc
test eax, 0xeffcb40
js 0x9bc059
rcl ch, 1
hlt
insd dword es:[edi], dx
invalid
test ebx, ebx
lea esp, [esp + 8]
je 0xdddc54
dec edx
mov ebx, dword [esp + esi - 0x3c]
inc cx
neg esi
dec edx
mov dword [esp + esi*2 - 0x1ff70], esi
dec ebp
arpl bp, bp
dec dword [esp + ecx - 0xfeb]
dec ecx
add edi, ebp
inc ecx
push esi
jmp 0x93a259
sub eax, eax
xor ebx, edx
mov dword [eax + ebp], edx
neg al
dec al
jmp esi
mov edx, ebx
pop eax
jo 0x9b8904
mov edx, 0xcd293e2f
call fcn.00dad6d9
shr cx, 4
jp 0xd57a0c

Function at 0x9bf537
Capabilities:
Authenticate hmac

Disassembly:
add ebp, eax
lea edi, [edi + ecx - 0x43c08e3d]
pop edx
mov eax, 0xd48f7897
mov edx, 0xab0e943d
mov edx, dword [edi + ecx - 0x43c08e39]
sal word [esp + ecx - 0x43c08e38], 1
jns 0xa7560b
xor edx, 0x506259b
inc dword [esp + ecx - 0x38170ca6]
rol edx, 3
push ecx
xor ebx, edx
sub dword [esp + ecx - 0x38170ca6], ecx
xor ecx, 0x2f91e706
movzx eax, word [esp + ecx - 0x1786eb99]
adc ebp, edx
xor eax, dword [esp + ecx*2 - 0x2f0dd73b]
shl eax, cl
movzx eax, word [edi + ecx*4 - 0x5e1bae8a]
jg 0xe476df
xor ax, bx
lea edx, [ecx*8 + 0x43260abe]
dec word [esp + ecx - 0x1786eb98]
not ax
sal ecx, cl
neg dl
neg ax
sub edx, ecx
neg dword [esp + ecx*2 - 0x5e1bae7e]
or cx, 0x249d
dec ax
lea edx, [edx*4 - 0x7842d8e0]
xor cl, byte [esp + ecx*2 - 0x5e1befb5]
call fcn.00a5382b

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

Disassembly:
dec edx
mov eax, 0x1197c896
xor edx, 0x18b67e2f
xor ebx, edx
mov ecx, dword [esp + eax - 0x1197c886]
add esi, edx
sub al, ah
shr dword [esp + eax*4 - 0x465f2328], cl
sar dword [esp + eax - 0x1197c8bf], 0x75
pop ecx
pop edx
pop edx
pop edx
pop eax
jns fcn.00a61cb3

Function at 0x9c00cc
Capabilities:
Encrypt data using speck

Disassembly:
sar eax, 0xbf
lea ecx, [eax + ecx - 0x7507d5ab]
rol dl, 0x45
call fcn.00dfcb04
stc

Function at 0x9c1ee1
Capabilities:
Authenticate hmac

Disassembly:
lea esp, [esp + 0xc]
call fcn.00d589de