joyce8/EMBER2024-capa huggingface dataset:
Function at 0xa755e4
Capabilities:
Authenticate hmac

Disassembly:
movzx eax, byte [edi + edx - 0x7a72c8]
jne 0xa4fd7e
inc ecx
mov ebp, eax
jmp edi
sbb edx, 0x9b897210
lea edi, [edi + edx - 0x64f100b6]
call fcn.00d87600
dec eax
not dword [esp + edx*2 - 0x732619fb]
xor edx, 0x378274b6
ror ecx, 0xfb
not eax
ror eax, 3
dec ecx
bswap eax
not edx
mov dword [esp], edx
xor ebx, eax
add ebp, eax
call fcn.00a59e1a
xor edx, ebx
rol eax, 0xb3
xor edx, 0xb096ca84
ror edx, 1
push eax
not edx
or eax, dword [esp + ecx - 0x43c08e39]
pop ecx
xor edx, 0x6503553b
xor ebx, edx
add dword [esp], eax
call fcn.00dfb4eb
dec ecx
sub edx, 4
inc ecx
mov esi, dword [edx]
inc ecx
mov ebx, 0xd8235031
inc ebp
mov ebp, ebx
jmp 0xdd12a5
xor esi, ebx
dec ecx
lea ecx, [ebp + 0x40234129]
inc cx
not ebp
inc esi
inc ecx
mov ebp, ebp
dec eax
sal ebp, cl
inc ecx
setne ch
rol esi, 1
dec esi
inc esp
movzx edi, cl
inc ecx
movzx eax, di
bswap esi
push ebx
dec edi
lea ebp, [ebx + edi*2 - 0x204499de]
inc edx
xor dword [esp + edi - 0x5a], esi
pop ebx
dec eax
arpl si, si
inc esp
movzx eax, al
dec eax
add edi, esi
dec ebx
mov esi, dword [edi + ecx - 0x5a]
sal cl, 0x43
inc ebx
mov ebp, dword [ecx + edi*2 - 0xac]
dec ecx
ror edi, 0xdb
inc esp
movsx esi, ax
dec eax
rol ecx, 0xdf
dec esi
lea ecx, [eax + ecx - 0x4e]
mov dword ss:[esi + eax*8 - 0x2d0], ebp
jb 0x91b159
jae 0x9a5471
movsx eax, dl
sal eax, 0x31
lea ebp, [ebp + eax - 0x37fffc]
shr edx, 0xa7
shr dword [esp + edx*4 - 0x1e9cb20], 0xa3
jns 0x923b9c
les edi, [edi + 7]
inc ecx
fist word [esi]
shr byte [ebx + ecx*2 - 0x3fb96015], 0xac
dec ebx
xchg dword [edi + 0x4bacc066], ebp
invalid

Function at 0xa756ab
Capabilities:
Encrypt data using speck

Disassembly:
lea edx, [esp + edx + 0x14]
call fcn.00a88365

Function at 0xa7853c
Capabilities:
Encrypt data using speck

Disassembly:
pop ecx
xor edx, ebx
mov ecx, 0x9c3f9fb6
neg edx
rol cl, 0x41
sbb cl, byte [esp + eax - 0x50e7d9ff]
lea edx, [edx + eax*4 - 0x580b50d3]
call fcn.009a02a8

Function at 0xa7b424
Capabilities:
Encrypt data using speck

Disassembly:
dec eax
mov dword [esp + edx - 0x6f311f5b], 0x829d2114
dec eax
arpl cx, cx
dec eax
dec ebp
dec esi
lea esi, [eax + ebx*2 + 0x6b919c87]
dec eax
adc edi, ecx
inc ecx
rol dh, 0x46
inc ebp
mov ecx, dword [ecx + edx - 0x6f311f6b]
jae 0xd98e2a
rol bp, 5
pop ebp
inc ecx
pop ebx
inc ecx
pop esi
pop edx
jae fcn.00d6eae8
xlatb
dec esi
sub ch, al
jb 0x9a8730
add ah, al
jno 0x9a872e
mov bl, byte [ebx - 0x3ec2054e]
das
invalid
mov eax, dword [0xc2d2e7e5]
invalid
out 0xd2, eax
ret 0xd7dc
inc ecx
rol esp, 0xfb
push ebx
call fcn.00d693df
xor dword [esp + edx - 0x6f311f53], ecx
dec esp
lea ebx, [eax*4 - 0x584d33d4]
dec eax
or ebp, ebp
dec eax
mov ebx, dword [esp + edx - 0x6f311f53]
dec esp
lea edi, [ebp*2 - 0x24e1035f]
jne 0x9a86a3
inc ecx
pop esi
jmp fcn.00d6eae8
inc esi
mov ebp, dword [edx + edx - 0x51700000]
movzx ebp, dx
inc esp
xor ebp, ebx
xchg dh, dl
dec esp
lea edi, [ebp*4 - 0x476307c3]
inc ecx
rol ebp, 1
inc ecx
inc ebp
inc eax
movsx eax, ch
inc esp
movsx esp, ch
inc ecx
bswap ebp
dec ecx
xadd esp, eax
jle 0xe20737
inc ecx
ror ebp, 2
shl edx, 0x86
inc ecx
dec ebp
jmp 0xa78522
Function at 0xa7d1e8
Capabilities:
Authenticate hmac
Encrypt data using speck

Disassembly:
add esi, eax
shr cx, 7
mov ebp, dword [ebp]
mov dword [esp], ecx
not cx
pop eax
jae fcn.00a61cb3

Function at 0xa7e26f
Capabilities:
Authenticate hmac
Encode data using base64
Encrypt data using speck
Get number of processors

Disassembly:
inc esp
xor dh, bl
inc ecx
push ebp
jmp 0x9b262f
call fcn.00a6b5f8
mov ecx, 0x7f0a759a
movzx cx, byte [ecx + ebp - 0x7f0a759a]
mov edx, 0xbe18e000
and dl, dl
setne dl
xor dl, byte [ebp + 2]
mov eax, 0x8f35772e
push eax
ror ax, 0x84
add cl, dl
xor dword [esp], eax
neg ax
mov word [ebp + 2], cx
movzx edx, al
movsx ecx, ax
dec word [esp + edx - 0x8e]
lea eax, [ebp + edx*2 - 0x11a]
add dword [esp + ecx*4 - 0x6238], edx
ror byte [esp + edx*2 - 0x119], 0x46
pop edx
mov dword [edx + ebp - 0x90eb], eax
lea eax, [ecx*4 - 0x1bd7137c]
ja 0xda0a86
mov edx, 0x27145703
add dl, 0xb1
mov eax, dword [edi + edx - 0x271457b8]
jle 0xd89a08
adc esi, eax
push edx
call fcn.00e46114
xor ebp, ebx
dec eax
shr dword [esp + eax - 0x30ac158a], 0xff
lea ebp, [ebp + eax*4 + 0x338262da]
jp 0xa68476
mov edx, 0xe196623f
movzx ecx, dl
movzx eax, byte [edi + ecx*2 - 0x7f]
call fcn.00999702
shr eax, cl
lea ebp, [ebp + edx - 0x90eb]
cmove edx, eax
setb al
mov edx, dword [edi + edx - 0x90e9]
lea edi, [ecx + edi - 0x188a]
jp 0xdc52bd
mov edx, 0xa4ab9236
movsx ebp, dl
dec esp
lea ebp, [ebp + 0x327000]
inc bp
mov ebx, dword [ecx + ebp - 0x36]
movsx ecx, dx
dec ebp
lea ecx, [ecx + ebp*2 - 0x6a]
dec esi
lea edx, [ebp + edx - 0x37]
inc esi
movzx esi, byte [ebp + edx - 0x36]
inc ecx
sar ch, 0x23
jb 0x921f1d
dec eax
xor edx, ebx
jmp 0xe63181
rol edx, 3
dec edx
xor edx, 0xca27b88
call fcn.00e0374c

Function at 0xa7eb23
Capabilities:
Encrypt data using speck

Disassembly:
shl ecx, 0xf4
dec al
ror edx, 0x9d
neg al
bswap ecx
xchg dx, cx
not al
mov dword [esp + ecx*2 - 0x1a3e2], edx
xor bl, al
lea eax, [esp + eax + 4]
xor dword [esp + ecx - 0xd1f1], 0x54331121
sar byte [esp + ecx - 0xd1ef], 0xe3
adc dword [esp + ecx - 0xd1f1], edx
movzx dx, byte [ecx + eax - 0xd1f1]
xor byte [esp + ecx*8 - 0x68f88], 0xbb
neg byte [esp + ecx*2 - 0x1a3df]
mov ax, dx
movzx ax, al
not cx
sal cl, 0x65
mov cl, byte [esi + ecx - 0x2ec0]
neg dword [esp]
shr al, cl
mov word [esi], ax
pop edx
mov eax, dword [edi - 5]
dec edx
sar dl, 0xa5
sbb edi, 5
jmp 0xd5523c
mov ecx, 0x55abac23
jmp 0xdb2015
xor eax, ebx
xor ecx, 0xe1bfe08
or dx, cx
rol eax, 3
sub cx, dx
bswap edx
bswap eax
sar cl, 0xa7
rol eax, 3
call fcn.00a3af0f
Function at 0xa7ed38
Capabilities:
Authenticate hmac

Disassembly:
ror si, 0x61
dec ax
pop edx
dec ebp
lea edi, [ebx + 0x46183c9f]
xor bx, ax
inc ebp
movsx ebp, bh
dec eax
add eax, esp
dec ecx
lea ecx, [ebp - 0x5ecf9dcd]
dec ebp
mov ebp, dword [ebp + eax - 0x36]
inc ecx
inc bl
inc ecx
push ebx
setle byte [esp + ebp - 0x4bfffffb]
dec ebp
mov dword [ecx + ecx + 0x5ecf9d8f], ebp
jne 0xe2cb0e
inc esi
mov esp, dword [ebp + edx - 0x4c000006]
inc ebp
movsx esi, bh
inc ecx
push edi
mov edx, 0xea3bc329
inc esp
xor esp, ebx
inc esp
movzx eax, word [esp + ebp - 0x4bfffff6]
inc ecx
xor esp, 0x14a4582e
dec ecx
lea eax, [eax + ecx*2 - 0x7ac7f7ce]
inc eax
sar ch, 0x21
sar dword [esp + ebp - 0x4bfffff8], 0x3c
inc ecx
rol esp, 1
shr word [esp + ebp - 0x4bfffffe], 0x87
inc ecx
inc ecx
push edi
inc ecx
sbb esp, 0xb7b66623
dec eax
sar eax, cl
inc ecx
bswap esp
inc edx
mov byte [esp + esi - 0x30], 0x22
inc esi
mov ebp, dword [esp + esi - 0x28]
inc edi
lea esp, [esp + esi - 0x3cb1a2e4]
dec edx
mov dword [esp + esi*4 - 0xc8], ebx
inc esi
xor dword [esp + esi - 0x26], esp
sar eax, 0xcf
inc ecx
rol ch, 0x25
dec edx
mov ebx, dword [esp + esi - 0x26]
dec ebp
arpl sp, sp
push ecx
dec eax
mov dword [esp + ebp - 0x4bffffe8], 0x70a2b236
dec ecx
adc edi, esp
dec bp
inc ecx
seto ch
rol ax, cl
inc esi
movzx ebx, byte [ebp + edx - 0x4c010006]
dec edi
lea edx, [edx + eax*4 - 0x2608b]
dec eax
sar dword [esp + ebp - 0x4c00ffeb], cl
dec esi
xchg dword [esp + esi - 0x28], ebp
inc esp
xor bl, bl
jmp 0xd589ab

Function at 0xa833e8
Capabilities:
Encrypt data using speck

Disassembly:
inc cx
mov esi, eax
inc ebp
adc ebp, ebp
inc ebp
movzx ebx, byte [edx - 1]
call fcn.00a32ad8

Function at 0xa833f9
Capabilities:
Encrypt data using speck

Disassembly:
sal ax, 0x8b
movzx ax, byte [esi + eax - 0x6634f7fe]
mov dword [esp], edx
jp 0xd6c308
push edx
sub ecx, 0x362ea809
neg dx
ror ecx, 2
and dword [esp], edx
xor ebx, ecx
add ebp, ecx
mov ecx, dword [esi]
xchg dword [esp], edx
mov eax, dword [esi + 4]
inc dl
or ecx, eax
not ecx
and edx, edx
movzx eax, word [esp]
js 0x9addc3
call fcn.00a90008
lea ecx, [edx*8 - 0x7d903e0]
mov dl, byte [esi + 4]
and al, dl
not al
mov byte [esp + 7], 0x3c
mov word [esi + 4], ax
sub esi, 0xfffffffc
lea edx, [ecx*8 + 0x2b31f728]
pop edx
pop ecx
jmp ebp

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

Disassembly:
inc ecx
mov ecx, dword [ecx + edx*2 - 0x23d7752a]
inc ecx
sar esi, 0x18
inc ecx
push esi
dec ebp
lea ecx, [ecx + edx*2 - 0x23d77526]
dec ebp
lea ebp, [edi + esi*4 - 0x4dce9a74]
inc ebp
mov dh, byte [edx + edx*4 - 0x47aeea61]
dec esp
xadd dword [esp + edx*4 - 0x47aeea5c], ebx
inc esp
movzx esp, dh
dec esi
lea edx, [edx + edx - 0x11ebba9c]
dec eax
ror dword [esp + edx - 0x11ebba87], 0x79
dec esp
mov dword [esp + edx*2 - 0x23d77516], ebx
inc esp
xor dh, bl
inc ecx
neg dh
inc ecx
rol dh, 1
dec eax
not dword [esp + edx - 0x11ebba97]
dec eax
lea eax, [esi*4 - 0x4cf490cc]
call fcn.00a1f5da
dec ecx
sub edx, 4
inc ecx
mov esi, 0x85af7218
dec ebx
lea eax, [esi + esi*2 + 0x2904311]
jmp 0x92bd1d
Function at 0xa90199
Capabilities:
Encrypt data using speck

Disassembly:
lea edi, [edi + edx - 0x79fa0004]
push edx
xor ecx, ebx
bswap ecx
push edx
lea edx, [eax + edx*8 + 0x410416a8]
ror ecx, 2
jmp 0xde17ce
not ecx
jne 0xdb81e7
ror cl, 1
inc cl
ror al, 0xc1
neg cl
not cl
lea edx, [eax + eax*4 - 0x4b643467]
call fcn.00a0f79b
shl al, 0x67
and dword [esp], eax
and ecx, edx
neg dword [esp]
ror ax, 0xc1
mov dword [esi + 8], ecx
mov ecx, eax
adc esi, 8
mov ecx, dword [edi - 4]
pop edx
jmp 0x9acd03
mov eax, 0x8e09fc3c
mov eax, dword [esi]
mov dword [esp], 0x1a195e31
mov edx, 0x7039d22c
movzx ecx, dx
lea ecx, [esp + edx - 0x7039d1ec]
and dword [esp + edx - 0x7039d22c], edx
not dx
mov dword [edx + ecx - 0x70392dd3], eax
not edx
mov ecx, dword [esi + 4]
movsx eax, word [esp]
xchg dword [esp + eax - 0x5220], edx
mov edx, dword [edx + esi - 0x10195218]
sar al, 0x81
jne 0xa3b0e7
lea eax, [eax + eax*4 - 0x9f29452]
not edx
jns 0xa4ac2a

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

Disassembly:
mov ecx, 0x4e01280f
lea edx, [ecx + ecx*8 - 0x386f1e60]
mov edx, dword [edi + ecx - 0x4e01280f]
xor edx, ebx
sub ecx, ecx
lea edx, [edx + ecx - 0x12a45abc]
rol edx, 1
movzx eax, cl
bswap eax
lea edx, [edx + ecx - 0x2ea8cd81]
rol edx, 1
call fcn.00d536c3
call fcn.009b5927
xor word [esp + 2], 0x61bd
ror word [esp + 2], 0x41
xor ebx, ecx
inc eax
lea edx, [eax + eax*4 + 0x2db12eb6]
jl 0xe1fdab
sub edi, 4
jmp 0x912930
xor edx, 0xa41bcd0c
dec edx
sal word [esp + 2], 0x6d
rol edx, 3
push 0x4bbf6993
add edx, 0xf29c104
mov eax, 0x46bf8194
lea ecx, [eax + 0x1c96229e]
xor ebx, edx
add esi, edx
mov eax, dword [ebp + ecx - 0x6355a432]
jmp 0x938a54
xor edx, ebx
dec edx
jmp 0x93de12
add edi, 4
jmp 0x99e4f8
dec ax
lea ecx, [esp + ecx + 4]
mov dword [esp], 0xfc8e1f0b
mov byte [ecx], dl
jge 0xa2a73e
mov eax, dword [edi]
add edi, 4
shr dword [esp], 0xe6
xor eax, ebx
mov ecx, 0xbc92a812
lea ecx, [ecx - 0x6874e849]
sub cl, 8
ror eax, cl
sar ecx, 0x42
call fcn.00d9372f
add ebp, ecx
xor dword [esp + edx - 0x2daf4ebb], 0xcf246082
pop ecx
push eax
mov dword [esp + edx*2 - 0x5b5e9d76], ebp
ret

Function at 0xd4e9ae
Capabilities:
Encrypt data using speck

Disassembly:
call fcn.00d7b5de
inc ecx
not ebp
inc ecx
mov esi, esi
inc ecx
inc ebp
dec eax
xadd ecx, esi
inc ecx
neg ebp
call fcn.00a85370
Function at 0xd4fe94
Capabilities:
Encode data using xor

Disassembly:
inc edx
mov eax, dword [esp + edi - 0x348f]
dec edx
lea edx, [esp + edi*2 - 0x68e0]
dec esi
mov dword [esp + edi - 0x348a], esp
dec edi
lea esp, [esp + edi*2 - 0x6c61e6e8]
inc edx
not dword [esp + edi - 0x348e]
inc esi
mov dword [edx + edi - 0x34a2], esi
dec edx
mov dword [esp + edi*2 - 0x6944], 0xb8bdf6a4
movzx ecx, ax
dec edi
mov esp, dword [edi + edx - 0x34ae]
call fcn.00a74fc6
sbb al, 0x92
push cs
inc ecx
daa
out dx, al
sub eax, 0x4beb4ba5
xchg edx, eax
sub eax, 0xc76f4ba5
mov gs, word [0x7f534ba5]
mov dh, 0x2d
movsd dword es:[edi], dword [esi]
dec ebx
jg 0xd4ff54
stosb byte es:[edi], al
push 0xd9244baf
mov dword [esp + ecx*2 + 0x1f], eax
test al, 0xec
push esi
pop ds
or eax, 0xd88deb64
pop ebp
xchg ebx, eax
int1
dec eax
push ebx
mov esi, 0x7000bafe
dec eax
int1
fdiv qword [ebx - 0x771a6820]
sbb ecx, dword [edx - 0x4f]
sub dword [edi - 0x53], esi
cmc
mov dword [eax + edi - 0x2b964c7f], ebp
adc esp, dword [esp + ebp*8]
inc eax
dec ebp
int 0xac
fmulp st(4)
into
stosd dword es:[edi], eax
cmp al, 0xfe
int 0x73
pop ebx
mov ebx, 0x9cce9c11
loopne 0xd4ff9c
pushal
jp 0xd4ffb6
invalid
pop edi
push 0xffffffffffffff94
mov ch, 0xc6
xchg edi, eax
arpl sp, bx
loope 0xd4ffc5
lodsd eax, dword [esi]
jne 0xd4ff7a
cld
xchg edi, eax
popfd
invalid
test byte [eax], dh
xchg esi, eax
out 0xca, eax
sbb dl, dl
mov dh, 0x31
push ss
or al, 0x46
add byte [esi + 0x45], ah
and dword [edi - 0x22], 0x910a6842
fisub word [edi]
ljmp 0xcf1d
aam 0x1a
pop esp
mov ebx, 0xc1b3eec
das
xchg esp, eax
jo 0xd4ffe1
test dword [eax], edi
mov ah, 0xd0
cmp dh, byte [esi + 0x1f]
arpl word [edx - 0x39925f96], ax
add eax, dword es:[esi + ebp + 0x370b61ae]
insd dword es:[edi], dx
invalid
add eax, dword [esi + ebp + 0x370b61ae]
stc
or dword [ebp - 0x67], eax
add dword [esi], ebp
mov esi, 0x6aa6a857
mov ebp, 0xc91d3140
out 0x4e, eax
invalid
test al, 0xa6
push 0xffffffffffffffbd
inc eax
xor dword [0x8f4ee7c9], ebx
movsd dword es:[edi], dword [esi]
jl 0xd4ffb3
popal
stc
stosd dword es:[edi], eax
invalid
xabort 5
mov ebp, 0x31ac363c
jmp 0x92b644ca

Function at 0xd50f73
Capabilities:
Encrypt data using speck

Disassembly:
lea esp, [esp + 0x10]
jne 0xd70766
push 0x9dbe3fa3
mov eax, dword [ebp]
push 0xf18a217
lea esp, [esp + 8]
call eax
mov ebx, 0x8d1e762d
movsx ecx, bx
movzx edx, bx
mov ebp, dword [ebp + ecx*2 - 0xec5e]
mov dword [ebp + ecx*2 - 0xec5a], eax
movsx eax, cx
lea edx, [eax + eax*4 + 0x6d8b63a8]
mov eax, 0xf0091512
mov eax, dword [ebp + ebx*4]
push 0x7c1bc63f
mov dword [esp], eax
push 0x4cbc5802
call fcn.00d749ed

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

Disassembly:
mov dword [esp], eax
push 0xce867d22
dec ebx
lea esp, [esp + 4]
jne 0x9b7ed7
Function at 0xd5a2ae
Capabilities:
Encrypt data using speck

Disassembly:
inc ebp
lea ebp, [ebp + ebp*2 - 0x3efa3dac]
dec edx
ror dword [esp + esi - 0x71b9d830], 0x75
inc ecx
not ebp
inc edx
sal byte [esp + edi - 0x22801594], 0x41
inc edx
movzx eax, word [esp + edi - 0x22801595]
inc ecx
ror ebp, 2
dec eax
neg dword [esp + ebp - 0x72095030]
dec edx
mov dword [esp + edi - 0x22801597], ebp
inc edi
lea ebp, [ebp + edi - 0x332c0caf]
inc ecx
add eax, edi
call fcn.00de5b8b
lea eax, [ecx*4 + 0x5d0e4530]
lea ecx, [esp + ecx*8 + 8]
sub eax, eax
mov byte [eax + ecx], dl
mov edx, dword [eax + esi]
pop eax
adc esi, 4
movzx ecx, byte [edi - 5]
shr dword [esp], 0x89
jnp 0xe230e0
dec ecx
sub edx, 4
inc ecx
mov edi, 0x22801597
mov ebp, 0x72095030
inc edi
mov ebp, dword [edi + edx - 0x22801597]
jmp 0xdfb980
inc ecx
mov esi, 0x71b9d830
inc ecx
push edi
inc esp
xor ebp, ebx
jmp 0x92206c
sub edi, 5
pop eax
lea eax, [eax + eax*8 + 0x241cdb9e]
not ax
xor cl, bl
inc cl
rol cl, 1
ror ax, 0xce
not ax
add cl, 0xb1
neg ax
call fcn.009bac7e

Function at 0xd5c962
Capabilities:
Authenticate hmac

Disassembly:
call fcn.00a27de6
jmp 0xe28180
dec dword [esp + ecx*2 - 0x31f0726]
add ebp, edx
mov dword [esp + ecx - 0x18f8395], ecx
mov edx, dword [esi + ecx*2 - 0x31f072a]
lea eax, [ecx + eax + 0x232db830]
sar byte [esp + ecx*8 - 0xc7c1ca1], 0x85
mov eax, dword [edx + ecx - 0x18f8395]
movzx ecx, byte [edi + ecx*2 - 0x31f072f]
mov edx, 0xa4bca3bd
adc edi, 0xfffffffb
xor cl, bl
inc cl
not edx
rol cl, 1
shr edx, 0x2b
jne 0xe0ab63
add cl, 0xb1
neg cl
add dl, dl
add edx, dword [esp + edx - 0xb68d2]
dec cl
jmp 0x93af9e
mov eax, 0x2239f700
mov esp, esi
pop edi
lea esi, [eax*2 + 0x4d2fee35]
pop ebp
mov edx, esi
mov ecx, edx
pop esi
movsx ebx, cx
pop ebx
sub al, dl
sal ecx, cl
popfd
lea ecx, [ecx*8 - 0x18d4fbd3]
pop eax
pop ecx
pop edx
call fcn.00e157dc

Function at 0xd5d37f
Capabilities:
Encrypt data using speck

Disassembly:
dec eax
mov dword [esp + ecx - 0x25b8e488], 0x7437ceac
js 0xe44852

Function at 0xd61a9d
Capabilities:
Encrypt data using speck

Disassembly:
push ebp
mov dword [esp + 8], 0xe19afb00
lea esp, [esp + 8]
call fcn.00dabf93

Function at 0xd62af5
Capabilities:
Encode data using xor

Disassembly:
inc ebx
mov eax, dword [edx + eax*2 - 0x796a3500]
inc ebp
movzx edi, al
dec esi
mov dword [esp + eax - 0x3cb51a80], eax
xor eax, ebx
inc esi
mov ebp, dword [esp + eax - 0x3cb51a7d]
inc ecx
sal al, 0x24
inc cx
ror ebp, 0x83
bswap eax
inc ecx
pop ebx
xor eax, 0xe41aa31e
inc ebp
mov esi, edi
jmp 0xe37c60
mov ecx, 0x3a272917
inc edx
lea eax, [eax + eax + 0x59565b26]
call fcn.00a3da3d
pop ebp
add byte [eax], al
add byte [ecx], al
inc ebp
test dword [eax + 0x6b], edx
dec edi
xchg esp, eax
xchg esp, eax
insb byte es:[edi], dx
shr dword [ebx], cl
dec edi
mov esp, 0x2bd320a4
dec edi
invalid
Function at 0xd6adde
Capabilities:
Parse pe header
Resolve function by parsing pe exports

Disassembly:
neg dword [esp + ecx - 0x73477ffb]
lea eax, [ecx + ecx - 0x2d740ddd]
lea ecx, [esp + ecx - 0x73477fdc]
sub eax, eax
jae 0xe4efe6
dec esp
mov dword [esp + ecx - 0x1f891434], ebx
dec eax
mov ebx, dword [esp + ecx - 0x1f89142c]
dec eax
and dword [esp + ecx - 0x1f891434], edx
inc eax
neg ch
dec eax
arpl ax, ax
dec eax
add edi, eax
inc ebp
and bl, al
dec esi
mov eax, dword [ecx + ecx - 0x1f891434]
dec esp
mov dword [esp + ecx*2 - 0x3f122860], ebx
inc ecx
mov cl, byte [ecx + ecx - 0x1f89142c]
inc edx
and byte [esp + ebx*2 - 0x6a], 0xb1
inc edx
movsx eax, word [esp + ebx*8 - 0x1a7]
dec edi
lea ecx, [ecx + ebx*4 - 0xd6]
call fcn.00dd8af2
mov eax, dword [esi]
mov edx, 0x7512e83f
mov cl, byte [esi + edx - 0x7512e83b]
and edx, 0xbd0b5d39
shl eax, cl
call fcn.00e0c67d
sal edx, 0xa1
mov dx, word [edx + esi - 0x1000e]
jg 0xa20947

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

Disassembly:
push ebp
mov ebp, esp
bswap edx
movsx edx, di
cmp di, 0x5cb2
mov edx, dword [ebp + 8]
jmp 0xd9a028
sub esp, 0x114
jmp 0xe181c7
push esi
cmc
test edx, edx
jmp 0x93e0b1

Function at 0xd6d190
Capabilities:
Encrypt data using speck

Disassembly:
or edx, edx
adc edi, 0xfffffff8
movzx ecx, word [esp + 0xb]
add edx, edx
neg dx
xor eax, ebx
xor eax, 0xb096ca84
ror eax, 1
pop ecx
dec word [esp + edx*2 - 0x47fa5b67]
not eax
dec byte [esp + edx*2 - 0x47fa5b68]
xor eax, 0x6503553b
mov dword [esp + edx*2 - 0x47fa5b6a], edx
movsx ecx, dx
xor ebx, eax
mov edx, eax
shl dword [esp + ecx - 0x2db3], 0xa2
mov cx, word [edx + ecx*4 - 0xb6d8]
jb 0xdd1b30
clc
Function at 0xd6f701
Capabilities:
Encrypt data using speck

Disassembly:
dec eax
mov dword [esp + ecx*2 - 0x15a28], ecx
inc eax
sbb dh, dh
dec ebp
arpl bp, bp
call fcn.00d666e0
inc esp
xor dword [esp + ecx - 0xad10], ebp
jmp 0xde207b
mov dword [ebp - 4], eax
shl byte [esp + 7], 4
mov word [esp + 1], 0x2400
test ebx, ebx
not byte [esp + 6]
lea esp, [esp + 8]
je 0xd4eaa4
mov eax, 0xe42142bf
mov eax, dword [ebp + ebx*4]
push 0x8890cc1b
mov dword [esp], eax
dec ebx
jne 0xd4ea8c
mov eax, 0x930f8987
mov eax, dword [ebp]
call eax
mov ebp, dword [ebp - 4]
mov dword [ebp], eax
pop ebx
mov ecx, 0x3f949587
not ecx
pop esi
rol ecx, cl
pop edi
jae 0xe4573b
inc eax
xor dh, byte [esp + ecx - 0x23f9]
inc ecx
inc esp
xchg word [esp + esi - 0x60f1245d], si
inc cx
neg esi
inc ecx
rol esp, 2
inc ecx
shr bl, 0xa4
dec ecx
rol eax, 0xf1
dec eax
mov dword [esp + ecx*2 - 0x4800], ebx
inc esp
xor dword [esp + esi - 0x60f1a500], esp
pop ebx
inc esp
movsx edi, dh
inc ecx
sar al, 0x21
inc ecx
push esi
dec ebp
arpl sp, sp
sar si, 0x2c
dec ecx
adc edi, esp
dec eax
xchg dword [esp + ecx*8 - 0x12000], ecx
xadd dword [esp + esi - 0x60f1fff7], esi
inc si
mov ecx, dword [esi + ecx]
jl 0x99ad6b
mov edx, dword [esp + esi*2 + 2]
inc ecx
ror ch, 0x61
pop ebp
jno fcn.00d6eae8
lea esi, [edx + esi - 0x399ef451]
neg edx
neg dx
add ax, cx
movzx ecx, dl
mov word [esi + ecx*8 - 0x298], ax
lea edi, [edi + ecx - 0x57]
lea eax, [ecx*2 - 0x264b1974]
and al, 0x9f
mov ecx, dword [ecx + edi - 0x53]
not dl
shr al, 0xc6
xor ecx, ebx
dec eax
sar eax, 0x2b
rol ecx, 2
shr al, 0x65
inc ecx
not ecx
add dx, 0xd9a
add eax, eax
bswap ecx
sal al, 0x81
inc ecx
add eax, eax
xor ebx, ecx
call fcn.00d9b371
inc esi
pop esi
inc edi
lea edi, [edi + eax - 0x2c00ae9]
dec eax
inc edx
inc dx
xor dword [esp + eax*2 + 0x5d801c90], esi
dec edx
mov dword [esp + eax + 0x2ec00e48], ebx
inc esi
xor dword [esp + eax*2 + 0x5d801c90], edi
movzx ebx, dx
call fcn.00a50110
mov ecx, 0xd3120596
call fcn.00d9a890
dec edi
lea ecx, [ecx + ebx*2 + 0xc]
call fcn.00e3e2c4
mov ebx, edx
mov dword [esp], 0x47b29702
mov eax, dword [esp]
mov edx, ebx
mov dword [esp + eax - 0x47b296fe], eax
sal edx, 2
xchg dword [esp + eax - 0x47b29701], eax
dec ax
and eax, eax
mov eax, ebp
adc eax, edx
jmp 0xd4ea6c
dec eax
sal dword [esp + ecx*2 - 0x15a30], 0xae
dec eax
mov ebx, dword [esp + ecx - 0xad10]
jne 0x928e80
lea edx, [ecx + ecx*8 + 0xb9c7224]
jmp esi

Function at 0xd70781
Capabilities:
Encrypt data using speck

Disassembly:
inc ebp
lea eax, [eax + esi*2 - 0x5cb1315c]
dec edx
dec dword [esp - 0x508bffe2]
inc dx
not dword [esp + ebp - 0x508c00c4]
inc ecx
not eax
inc ecx
push edi
call fcn.00e05186
Function at 0xd74926
Capabilities:
Encrypt data using speck

Disassembly:
lea esi, [esi + ecx - 0x507dadea]
dec esp
lea esp, [ecx + eax*4 - 0x65c9ed5d]
xor esi, 0xec3c231c
dec edx
mov dword [esp + esi*2 - 0x3a], ebx
inc sp
or esp, eax
inc sp
sub edi, ecx
inc cx
rol esi, 0x6d
inc edx
xor dword [esp + esi - 0xa003], esi
dec eax
sar eax, cl
inc ecx
add ch, bh
inc ecx
bswap esp
pop ebx
dec eax
arpl si, si
call fcn.0099ea78
wait
and eax, 0xb9a4410d
sbb eax, 0xbbdb4cad
dec edi
cmp bl, al
cwde
mov ch, 0xb2
sti
pop ecx
mov ah, 0x2e
push ds
cmpsd dword [esi], dword es:[edi]
pop ecx
mov ah, 0x1e
push edx
cmpsd dword [esi], dword es:[edi]
loope 0xd749ce
mov bl, 0xa3
inc ah
or byte [ebx], bl
invalid
cmp esp, ebx

Function at 0xd750b9
Capabilities:
Encrypt data using speck

Disassembly:
mov dword [esp], 0xa154501f
call fcn.00dabf93
dec eax
mov dword [esp + edx*8 - 0x19bb0aa8], edx
dec eax
mov esi, dword [esp + edx - 0x337614d]
inc ecx
movzx ebx, al
push dword [esp + 0x10]
popfd
dec eax
mov dword [esp + edx*4 - 0xcdd8544], 0x773ed69e
dec eax
mov edi, dword [esp + edx*2 - 0x66ec292]
dec esp
mov eax, dword [esp + edx - 0x3376135]
dec esp
mov edx, dword [esp + edx - 0x337612d]
dec eax
mov edx, dword [esp + edx*2 - 0x66ec27a]
dec eax
mov ebp, dword [esp + ebx - 0x4f]
dec eax
mov ebx, dword [esp + ebx*4 - 0x1dc]
jmp 0xe2f549
call fcn.00a8d24b
xlatb
inc edi
xor edi, eax
jl 0xe2f594
xor cl, ch
pushal
inc ebp
xchg edi, eax
cwde
mov edx, 0x2fc13dfa
invalid
inc esp
and al, 0
invalid

Function at 0xd77fba
Capabilities:
Execute anti-debugging instructions

Disassembly:
movzx ax, byte ss:[ecx + edx*4 - 0x42af8]
mov word [edx + ebp - 0x10ac0], ax
call fcn.00dd6588

Function at 0xd7e2ef
Capabilities:
Authenticate hmac

Disassembly:
xor edx, edx
call fcn.00e644e3
xor cx, 0x878d
mov cl, byte [ebp + ecx - 0x8689]
js 0xd942d9
mov dword [ebp + ecx*4 + 4], eax
mov eax, ecx
adc eax, 0x168bd512
mov edx, dword [ebp + ecx*2 + 4]
mov dword [esp + ecx], ecx
jbe 0xdd8c23
mov eax, dword [ebp + ecx + 8]
shl dword [esp + ecx + 4], 0x42
sal cl, 0x85
shl word [esp + ecx*2 + 6], 0x6d
adc edx, eax
lea eax, [ecx + ecx*4 + 0x410a092f]
call fcn.00d64fbc
add edi, 4
movsx ecx, dl
xor eax, ebx
jmp 0xdd6e02
call fcn.00d61478
xor eax, 0xfc20b1b9
push edx
not eax
dec dword [esp + ecx - 0x2a]
add esi, edx
xchg ch, cl
mov dword [esp + ecx - 0x20195eeb], eax
sar dword [esp + ecx - 0x20195ee7], cl
mov eax, dword [ebp + eax - 0x8b532e]
sbb ecx, ecx
mov ecx, dword [ebp + 4]
add ebp, 4
jmp 0xa7b99f