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

Disassembly:
push eax
sbb ecx, 0xd81ca53d
shr dword [esp + eax - 0x580020], 0x81
inc dx
rol ecx, 1
rol al, 5
ror dword [esp + eax*2 - 0xb00008], 0x79
rol dword [esp + eax - 0x580004], 0x9a
sbb ecx, 0x94975ea3
ror dx, 0xa
xadd ax, dx
xor dword [esp + eax*4 - 0x1624b00], edx
xor ecx, 0x58bfae02
and edx, 0x69b0f5b3
xor ebx, ecx
add ebp, ecx
call fcn.00c81f34
call fcn.0139de51
mov eax, 0xb0807737
lea edx, [eax + eax*4 + 0x48b99c36]
shr eax, 0x89
mov ecx, dword [esi + eax*4 - 0x16100ec]
ror al, 5
adc al, 0x92
bt edx, 0x3a
lea esi, [esi + eax*2 - 0xb080d4]
jae 0x1375ce7
shr ax, 0xe9
xor ecx, ebx
btc edx, edx
jae 0xc974bb

Function at 0xcdbd1f
Capabilities:
Authenticate hmac

Disassembly:
xor esi, ecx
push 0x9534f9a6
call fcn.01568c21
sar dword [esp + 0xb], 0x59
dec eax
lea esp, [esp + 0x14]
jne 0x14d5e7f
mov eax, 0x2a3d9f39
pop esi
not ecx
mov edx, 0x673c20b4
neg dx
xor edx, 0xb9836908
mov dword [ebp], ecx
movsx ecx, dl
shr edx, cl
jmp esi
mov esi, 0x690194a2
movzx esi, byte [edx + esi - 0x690194a2]
push 0x409618b5
neg word [esp + 2]
js 0xc90379
mov eax, 0xad2a3f18
movsx ecx, ax
xadd eax, ecx
mov edx, dword [edi]
mov ecx, dword [edi + 4]
or eax, eax
ror eax, 0x5f
neg al
lea edi, [edi + eax - 0x5a54fc9b]
rol eax, 0x67
or edx, ecx
lea ecx, [eax + eax + 0x75b73280]
lea ecx, [ecx + ecx*8 - 0x7747c367]
imul cx, ax
not edx
mov dword [edi + eax*2 - 0x54fc9f5a], edx
sar eax, cl
movsx edx, ax
mov ecx, dword [esi + eax*4 - 0x153f27c]
bts ax, dx
xor edx, 0x279ce1a4
bswap eax
adc esi, 4
imul ax, dx
and eax, eax
sub eax, eax
xor ecx, ebx
lea ecx, [edx + ecx - 0x10cf7a34]
bswap ecx
not ecx
neg eax
call fcn.01330ece
mov eax, 0xa8bfd583
inc eax
dec eax
sub ebp, 4
call fcn.014fd0c7
mov eax, 0x134c2a4
call fcn.013149f4
not dl
bswap eax
jmp 0xc4fdd0
Function at 0xce7288
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
mov esp, edx
push edi
mov edi, 0xfda93006
lea edi, [edi - 0x14fe6c7f]
push esi
pushfd
xor edi, edi
mov esi, eax
jg 0xb7f073
and edi, edi
jp 0x14c0f0e
mov eax, dword [esi]
mov ecx, 0xab5ca90
movsx edx, cx
mov edx, dword [esi + ecx - 0xab5ca8c]
add eax, edx
mov edx, ecx
or ecx, 0xb697fcab
mov dword [edx + esi - 0xab5ca8c], eax
movzx eax, cl
mov eax, dword [ebp + edx*2 - 0x156b9524]
lea ebp, [ebp + edx - 0xab5ca94]
sub dl, ch
xor eax, ebx
bswap eax
rol cx, 0xac
rol ecx, 0x18
xor eax, 0xbf99afab
neg eax
ror dx, 0x21
rol edx, 0x87
setae cl
ror eax, 3
imul dx, dx
inc dx
xor ebx, eax
add edi, eax
lea eax, [ecx + ecx - 0x56f85c6c]
cdq
mov ecx, dword [esi + 4]
mov dl, byte [esi + 8]
bts eax, eax
sbb esi, 0xfffffff6
mov byte ss:[ecx], dl
or ax, ax
cdq
dec dx
jmp edi
or edi, edx
push 0xe8a9214
call fcn.00c98396
pop ecx
pop eax
pop edx
pop ecx
jb fcn.01497d09
add ebp, ecx
lea edx, [edi + eax*2 - 0x808c002]
not ax
sar al, 0xe4
mov dword [edi + eax*2 - 0x8094000], edx
lea edi, [edi + eax - 0x404a001]
sub eax, eax
jp fcn.01556dc6
mov ecx, dword [esi]
add esi, 4
mov edx, 0xba3d660c
xor ecx, ebx
lea eax, [edx + 0x69188a0c]
cwd
bt dx, dx
rol ecx, 2
imul edx, edx
xor ecx, 0x532085b3
mul dl
add edx, edx
inc ecx
or dx, 0xd535
rol dx, 3
shl eax, 0xcc
rol ecx, 1
lea ecx, [edx + ecx + 0x48a3e81]
xor ecx, 0x7d2f2c8d
xor ebx, ecx
neg eax
lea edx, [eax + eax + 0x75139f8b]
add edi, ecx
movzx ax, byte [ebp]
mov cl, byte [ebp + 2]
imul edx, edx
rol edx, 0x55
adc ebp, 2
bt dx, 0x13
shr al, cl
movsx ecx, dx
sal edx, cl
or cx, 0xc081
mov word [ebp + ecx*8 - 0x6cdf8], ax
xor dl, 0x3e
shr dl, 0xe3
jmp edi

Function at 0xce738e
Capabilities:
Encode data using base64

Disassembly:
dec eax
xor ebx, ecx
add esi, ecx
pop edx
jmp esi
not al
mov dword [esp + ecx*2], ecx
sete byte [esp + ecx]
lea ecx, [ecx*4 - 0x7c744c54]
sbb al, 0xd
xor bl, al
lea eax, [esp + eax + 4]
mov word [eax], dx
sal byte [esp + 3], 0x85
sar cl, 6
sbb edi, 3
push ecx
mov eax, dword [esp + 4]
mov ecx, dword [edi + eax*2 - 2]
xor ecx, ebx
pop edx
sar dword [esp + eax - 1], 0xcc
imul byte [esp + eax*2]
lea ecx, [ecx + eax + 0x7039a38f]
ror dx, 0xa4
xchg word [esp + eax*2 + 2], dx
neg ecx
sar edx, 0x35
xor ecx, 0xd038243f
jmp 0x14a6f8b
cbw
xor eax, 0xd7911a15
bswap ecx
lea ecx, [edx + ecx - 0x39f7ef1c]
rol word [esp + 2], 8
jnp 0xca9f32
imul esi, dword [edx], 0x6b6b6cd8
insd dword es:[edi], dx
outsd dx, dword [esi]
adc byte [ebx], ch
leave
ror cl, 0xa3
ror eax, 1
rol cx, 0x25
not edx
xor eax, 0x573d6304
sub dx, cx
ror edx, 0x71
ror ecx, 0xdf
dec eax
neg edx
not dword [esp + ecx]
shl edx, 0xb
not eax
lea ecx, [ecx*8 - 0x26ddc371]
xor ebx, eax
or dl, dl
adc dword [esp + edx - 0x6c000800], 0x260e77b1
add edi, eax
movsx eax, dl
add al, byte [esi + eax*2]
and ecx, 0x8d9c4304
adc dl, byte [esi + edx - 0x6c0007fe]
or al, dl
movzx edx, cl
xadd cl, ch
not al
sub cl, 0xa2
mov word [edx + esi - 2], ax
xchg word [esp + edx - 2], cx
mov eax, dword [esi + edx*2 - 6]
jno 0x1333d69
Function at 0xcebb48
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
mov dword [esp], 0xc212c6a2
shr dword [esp], 0x8e
and edi, 0xff
sar dword [esp], 0xeb
sal byte [esp + 1], 0x21
mov edi, dword [edi*4 + 0xc5190c]
call fcn.0142a0c1

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

Disassembly:
inc ebp
xor ebx, edi
inc ecx
mov ebp, 0x142e1a91
inc ebp
movzx edx, bp
inc ecx
movzx ebp, ch
inc ecx
sub ebx, 0xf59ab1a3
inc ecx
rol ebx, 1
movzx eax, bp
dec edx
mov dword [esp + ebp - 0x142e1a91], ebp
inc ecx
movsx edx, bp
inc ecx
neg ebx
dec edx
sar dword [esp + ebp - 0x142e1a91], 0x64
inc ecx
ror ebx, 2
inc ecx
inc ebx
dec esp
lea eax, [eax*4 - 0x23e5746a]
inc ecx
push ebp
inc ecx
ror ebx, 2
dec esi
mov dword [esp + ebp - 0x142e1a81], edi
inc esi
xor dword [esp + ebp*2 - 0x285c3512], ebx
inc edx
sar byte [esp + ebp - 0x142e1a84], 0x21
inc ecx
push edx
dec esi
mov edi, dword [esp + ebp*2 - 0x285c350a]
dec ebp
arpl bx, bx
inc ecx
pop edx
dec ecx
adc edi, ebx
inc esi
xor dword [esp + ebp - 0x142e1a89], ebp
inc ebp
movzx esp, ax
dec ecx
lea esi, [ebp + esi - 0x142e1a92]
inc bp
inc edx
movsx ebx, byte [esp + ebp - 0x142e1a8e]
inc edx
mov bl, byte [esi + edx*2 - 0x3522]
inc ecx
xor bl, bh
dec edx
mov dword [esp + ebp*2 - 0x285c3512], eax
inc cx
inc ebp
xor bl, 0x1a
dec edx
lea ecx, [edx + ebp*4 + 0x5c13ce06]
inc esi
add dl, byte [esp + ebp*2 - 0x285c351a]
inc edx
shl dword [esp + ebp*2 - 0x285c351e], 0x6d
dec bl
inc edx
or byte [esp + edx*2 - 0x357a], 0x2c
dec ecx
shr eax, cl
inc ecx
push eax
xor bl, 0x21
neg dl
sbb bl, 0x84
inc si
and eax, dword [esp + ebp - 0x142e1a77]
inc esp
xor bh, bl
dec edi
lea esi, [ebp + esi - 0x142e1a94]
inc ebp
movsx ecx, dx
shl bp, 0x43
inc bx
mov dword [esi + edx*4 - 0x6afc], ebx
inc bp
bts eax, eax
pop ebx
inc ecx
pop edx
pop eax
inc ecx
pop esp
jae fcn.012e2664

Function at 0xcf8792
Capabilities:
Encode data using base64

Disassembly:
mov ecx, dword [edi + eax*2]
movsx edx, al
lea eax, [edx*8 - 0xaec8d75]
xor ecx, ebx
sub al, 0xb0
cdq
add al, dh
ror ecx, 1
not al
add al, dh
neg ecx
bswap ecx
and dx, 0xffab
add eax, 0x3e3fcb03
add edx, edx
dec ecx
sub dl, dl
jbe 0x131b0e0
jmp 0x14bfdd0
xor ebx, ecx
not edx
add esi, ecx
lea ecx, [edx + 0x4910cf11]
mov edx, dword [ebp + eax - 0x33533d27]
dec al
inc eax
mov cl, byte [ecx + ebp - 0x4910d00c]
lea eax, [eax + eax*4 - 0x13fb29c8]
btr eax, 0x3d
adc ebp, 5
dec ax
jg 0x129bc04
mov dword [esp + 4], ebp
mov dword [esp], ebx
mov ebx, 0x33326526
push eax
movzx eax, bl
pushfd
or ebx, 0x363f3f3e
ror eax, 0x42
mov dword [esp + ebx - 0x373f7f2e], ecx
movzx ecx, bx
jnp 0x15180d8
mov ecx, 0x6fa34304
movzx eax, cx
sar eax, 0xf8
lea edi, [edi + eax*4 - 4]
jns 0xb7f851
push esi
shl eax, 0xfb
sar eax, cl
movsx esi, cx
push edx
movsx edx, al
push ebp
mov edx, 0
jnp 0x1546ae8
inc dx
not ecx
xadd al, ah
cwde
add edx, 0x11347b3a
bswap ecx
lea eax, [edx + edx - 0xbdad569]
btr edx, edx
or dl, dh
dec ecx
xor ebx, ecx
add edi, ecx
jmp edi
push esi
sete al
mov dword [esp + ebx - 0x373f7f22], edx
mov esi, dword [esp + ebx - 0x373f7f1a]
Function at 0xcfe37c
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
mov dword [esp], ecx
neg dx
not dx
btc eax, ecx
or eax, 0x35383b8a
xor dx, 0x84bb
or al, byte [esp + eax - 0x7fffff8a]
xor bx, dx
pop eax
sar al, 3
sbb ebp, 1
mov word [ebp], dx
mul ecx
ror eax, cl
mul cx
sbb edi, 3
inc eax
mov edx, dword [edi]
xor edx, ebx
dec edx
push eax
not cx
ror edx, 3
inc byte [esp]
inc edx
dec word [esp + 2]
lea eax, [ecx - 0x777146ea]
neg edx
lea edx, [edx + ecx - 0x5fef5e7c]
dec word [esp]
sub al, 0x1a
jnp 0x150ae92
shr dx, 0xa4
adc ebp, 3
ror dx, 0xec
not eax
xchg dh, dl
sub dx, dx
sal edx, 0x5f
not ecx
bswap edx
jae 0x1520e8c
pop edi
pop ebp
mov ecx, edx
call fcn.01312feb
mov edx, 0x37225012
movsx eax, dx
lea ecx, [edx + 0x32313009]
mov ax, word [esi + eax - 0x5012]
sub edx, edx
xor dx, word [edx + esi + 2]
bt ecx, ecx
jb 0x147d881
call fcn.0157c2b1
cbw
bswap ecx
dec esi
lea esp, [ebx*2 - 0x41d1ce61]
dec eax
neg ebp
dec eax
cwde
neg ecx
inc esp
xchg al, al
ror ecx, 3
dec ecx
inc al
dec eax
inc edx
not ecx
dec eax
and ebp, 0x3104ceb9
inc cx
dec ecx
inc ecx
inc ecx
push edi
dec edi
lea eax, [edx + edx*4 + 0x44a67fa0]
inc ebp
add edx, ebp
inc ecx
not cl
inc edx
xor dword [esp + ebx - 0x10], ecx
inc eax
not ch
inc ecx
pop edi
dec ecx
bts esp, 0x94
neg bp
ror bl, 0x46
dec eax
arpl cx, cx
inc ecx
seta dl
inc ecx
push edx
inc ecx
seta ch
dec eax
adc edi, ecx
dec esi
lea esp, [ebp + eax*8 - 0xa70f8da]
btc edx, 0xba
inc dx
sal dword [esp + ebp*8 - 3], 0xec
pop ebp
jp fcn.012e2664
lea esi, [esi + ecx - 0x69538019]
rol ecx, cl
and ax, dx
mov edx, 0xb9196e31
not ax
mov word [esi], ax
mov eax, dword [edi]
add edi, 4
inc ecx
not edx
xor eax, ebx
and cl, dh
neg eax
xor dx, 0x7ad
bswap eax
not cl
btr ecx, 0x37
lea eax, [eax + edx - 0x5678d3f0]
rol edx, cl
add dx, dx
bswap ecx
ror eax, 1
neg ecx
sal dx, cl
xor ebx, eax
and cx, cx
not cl
btc cx, dx
adc ebp, eax
bt ecx, 0xb3
xadd dl, cl
jmp ebp
xor edx, 0xbf170993
sub edx, 0x6b931e8b
shr ecx, 0x78
and eax, ecx
inc ecx
ror edx, 1
push eax
neg ax
sub dword [esp + eax - 0xff82], 0xb2a8fd9d
xor ebx, edx
xchg dword [esp + eax - 0xff80], ecx
shl byte [esp + eax*8 - 0x7fc1e], 0x21
adc esi, edx
lea edx, [ecx*2 + 0x4626338e]
pop ecx
pop eax
jmp fcn.01310689
and eax, ecx
mov dword [ebp + edx], eax
movzx ecx, dl
lea edi, [edi + edx*4 - 4]
shr ecx, 0x82
shl ecx, 0xa
mov eax, dword [edi + edx]
dec dl
xor edx, edx
xor eax, ebx
inc eax
xor dl, dl
xchg dh, dl
bswap eax
inc edx
bts cx, 0xb8
shr edx, 0x5d
neg eax
xor eax, 0xf5082613
xor ebx, eax
add esi, eax
ror edx, 0x85
xor edx, esi
jmp edx

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

Disassembly:
inc ecx
bts ecx, edx
inc ebp
lea edx, [edx + edx - 0x110256d1]
dec esp
lea esp, [ecx - 0x115b59f2]
inc ebp
xor edx, ecx
inc ebp
add edx, ecx
inc ebp
sub bl, ch
dec eax
bswap edx
inc ecx
ror edx, 1
inc ecx
bts ebx, 0x1f
inc ebp
btr esp, esp
inc ebp
xor edx, ecx
inc ecx
neg edx
dec eax
mov dword [esp + ecx*2 - 0x5466000], edx
inc cx
add ebx, 0x9fe8bead
sub ebp, dword [ebx]
cmp ebx, ebp
ja 0xcfe5c3
je 0xcfe5d8
push 0x4f5f6975
Function at 0xd0518b
Capabilities:
Encode data using base64

Disassembly:
not al
mov ax, word [edx + eax - 0x8000904]
call fcn.00c40c86
mov dword [esp + eax - 0x797830d], edx
mov dword [esp + eax*4 - 0x1e5e0c34], edx
inc ecx
or dword [esp + edx - 0x634d85aa], edx
setns dl
neg ecx
xchg ah, dl
not ecx
imul dx, ax
xor ecx, 0x52039eb4
xor ebx, ecx
idiv al
btr ax, ax
add ebp, ecx
lea esi, [edx + esi - 0x634d4aa8]
btr ax, 0x9d
cwde
movzx edx, byte [eax + esi - 0x904]
movsx ecx, al
xchg byte [esp + eax*2 - 0x1205], cl
xor dl, bl
add dl, 0x9e
xor dl, 0x3a
dec dl
rol dl, 1
not cx
btr ecx, ecx
neg dl
pop ecx
btc ecx, eax
inc dl
not al
not dl
ror ecx, cl
bts eax, eax
add cx, ax
xor bl, dl
sal cx, 0x41
adc edx, esp
xor cl, cl
jae 0xc42bb4
bts edx, ecx
sbb eax, 0x35092526
not eax
neg eax
or ecx, 0xb58c7630
cmovg edx, ecx
xor ebx, eax
xor ecx, edx
sub dl, cl
adc ebp, eax
jmp fcn.00cec8a7

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

Disassembly:
cpuid
je 0xd2a318
mov dword [esp], 0x8716123a
sbb ebp, 8
dec dword [esp]
mov dword [ebp + 0xc], eax
push 0x31260333
mov dword [ebp + 8], ebx
mov dword [ebp + 4], ecx
mov ebx, dword [esp + 3]
jge 0x139c7e4
btc bx, 0xae
mov dword [ebx + ebp - 0x16127931], edx
call fcn.012d8940
neg eax
bswap eax
mov ecx, 0xfe33eeac
dec eax
shr edx, 0xf5
xor ebx, eax
btr cx, cx
jae 0x157273d
adc esi, eax
xchg ch, cl
xor edx, 0x6280c000
bt cx, cx
jmp esi
Function at 0xd0e9fc
Capabilities:
Encode data using xor

Disassembly:
dec eax
cdq
inc ecx
ror eax, 1
dec esp
lea edx, [edx*8 - 0x4e73f97c]
inc ecx
push edi
inc esp
xor dword [esp + ebx - 0x5c9476ad], eax
inc esp
movsx ebp, dx
dec eax
xadd ebx, edx
inc ecx
pop edi
dec ebp
arpl ax, ax
adc ax, dx
dec ecx
bts edx, edx
inc ebp
movzx esp, ch
dec ecx
add edi, eax
dec esp
lea ebx, [eax*4 - 0x24dcba5f]
dec eax
lea esi, [eax + esi - 0x7762]
mov ebp, 0xd3358328
dec esp
mov eax, dword [ebx + esi - 0x5c9476ad]
inc esp
movsx ecx, cl
dec ebp
xor eax, edi
dec ecx
neg eax
dec ecx
not eax
dec ecx
neg ebp
call fcn.012a6880
not cl
mov dword [esp + edx*8], edx
bts edx, 0x3e
xor cl, 0x12
xor bl, cl
lea ecx, [esp + ecx + 4]
neg edx
mov word [esp + 2], 0xf92
shl byte [esp + 2], 0xe2
mov dword [ecx], eax
pop edx
sbb dl, dl
movsx eax, dl
movzx edx, word [esi + edx*2 - 0x1e900007]
lea esi, [esi + eax - 7]
xor dx, bx
xor eax, eax
lea ecx, [eax + eax*2 - 0x3461d0c5]
jge 0x154d52d
inc ecx
push ecx
dec eax
lea eax, [ecx + ecx - 0x46fa27d7]
dec esi
mov dword [esp + ebx - 0x544a283], edi
or ecx, 0x322c4d86
inc cx
adc ebx, 0xcd0fedb0
xor dword [esp + edx*2 - 0x464a2ad8], ebx
inc ecx
shl bl, 0xe5
mul bp
inc sp
cmovb ecx, edx
inc ecx
pop edi
dec eax
arpl bx, bx
inc cx
xchg edx, eax
inc ecx
xadd esp, edx
dec ecx
bts esp, edx
dec eax
adc edi, ebx
dec eax
sar ebp, 0x3e
dec ecx
inc eax
dec edx
lea esi, [esi + ebx*2 - 0xa8920c1]
dec ebp
sub edx, ebp
dec esi
lea ecx, [ebp + ebp - 0x584bf2c7]
movzx eax, byte [esi + edx - 0x602ac150]
jp 0xc449ff
inc ecx
xor al, bh
ror al, 1
movzx ebx, dx
dec eax
bswap edx
dec ecx
and ebx, 0x1e37b28e
not al
inc ecx
shl esp, 0xfb
inc ebp
sbb cl, cl
neg al
push edx
call fcn.01498f6b
rol dx, 1
or ecx, eax
xor dx, 0x56b2
inc dx
neg al
cwde
dec cl
not dx
sal cx, 0xac
bt ecx, eax
xor bx, dx
mov word [edi + eax + 2], dx
lea edi, [edi + eax*2 + 2]
xor eax, 0xdf1d2105
dec eax
jmp ebp

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

Disassembly:
inc esp
xor bh, bl
inc cx
sar ebp, 0x23
dec eax
rol dword [esp + edx - 0x2109d8b3], cl
dec eax
lea ebx, [esp + ebx + 0x10]
inc esp
movsx ecx, dl
inc esp
mov dword [ecx + ebx - 0x795deff3], esp
cdq
inc bp
sub edx, ecx
inc esi
mov ecx, dword [esi + eax*8 - 0x6c5dd]
dec esp
mov dword [esp + edx], edx
imul word [esp + edx*4 + 6]
dec eax
lea esi, [esi + edx*4 - 5]
not word [esp + edx + 8]
inc ebp
xor ecx, edi
call fcn.00da3b4f
Function at 0xd20025
Capabilities:
Encode data using xor

Disassembly:
mov eax, dword [esi + eax*2 - 0x1800]
rol ecx, 0xd7
neg cl
lea edx, [ecx + ecx*4 + 0x33a4e30e]
lea esi, [esi + ecx*2 - 0xcb1923c]
sar ecx, 2
sub cl, cl
xor eax, ebx
rol eax, 1
not ecx
ror cx, 0xcc
xor eax, 0x608341b1
sar ecx, cl
sar cl, 0x61
dec cx
adc eax, ecx
dec dl
push ecx
xor eax, 0xd7b89b36
xchg dx, cx
xor ebx, eax
add ebp, eax
mov dword [esp + edx - 0x5360fffe], ebp
ret
lea eax, [ecx*4 + 0x1a95d91f]
mov edx, dword [ebp + eax*2 - 0x6e562a8e]
xor edx, ebx
pop ecx
rol edx, 1
idiv al
bts eax, eax
adc eax, 0xac0da8b3
xor edx, 0xd126979a
pop eax
push eax
not edx
xchg dword [esp], eax
dec edx
xadd word [esp + 1], ax
and word [esp], 0x4ca4
movzx ecx, word [esp]
xor ebx, edx
add edi, edx
imul eax
mov edx, esi
rol cl, 0x84
bts cx, 0xc
not ecx
sbb esi, 2
call fcn.012f8390
mov eax, dword [edx + eax*2 - 0x20002]
movzx ecx, byte [ebp + ecx - 0x4709f16f]
mov edx, dword [esp]
lea ebp, [ebp + edx - 0x4709fe6e]
or edx, 0xaa9a2ab4
ror dword [esp], 0xe3
neg dx
xor cl, bl
inc dword [esp]
neg edx
shl edx, 0x2f
not cl
shr dl, 1
btr edx, 0xb5
neg cl
and dx, dx
or edx, 0x82b4941d
shl word [esp + 1], 0xc1
dec cl
xor edx, edx
neg cl
add edx, 0x912e37b9
and dl, dh
setno dl
ror cl, 1
shl edx, 0x6a
shr dx, 9
not byte [esp + 3]
neg cl
call fcn.0151ff0f
mov ecx, 0x52157b89
not cl
mov edx, dword [edi + ecx - 0x52157b76]
btc ecx, ecx
lea eax, [ecx + ecx - 0x663a9ea]
mov cx, word [edi + ecx - 0x52557b72]
lea eax, [eax + eax*2 - 0x3edf26d4]
xor al, 0x9c
sbb eax, eax
lea edi, [eax + edi + 2]
shr cx, 1
cbw
bswap eax
rcr edx, cl
ror al, 0xa3
lea ecx, [eax + eax*4 - 0x18f35cc9]
lea ecx, [eax + eax*4 - 0x4e6c3ff4]
mov dword [eax + edi], edx
xadd cl, ah
jae 0xc81be3
idiv bh
xor ebx, edx
mov dword [ebp + eax - 0x540003d0], edx
movsx edx, ax
dec edx
shr edx, 0xdc
mov ecx, dword [ebp + edx*4 - 4]
mov ax, word [ecx + eax - 0x540003cc]
lea ecx, [edx*4 - 0x31d4d3c2]
call fcn.013b43d8
mov eax, 0xf927e5c
daa
ja 0xd20144
cld
jmp [ebx + 0x4ad0bf0f]
in al, 0x9a
rcr byte [esi], 1
js 0xd2014c
pop es
pop es
out 0x9b, al
leave
iretd

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

Disassembly:
mov dword [esp + eax*2 - 0x1002], eax
mov eax, ebp
push 0xfb371994
add eax, edx
sar dword [esp + 4], 0x91
mov dword [ebp - 4], eax
mov word [esp + 4], 0xd500
test ebx, ebx
jmp 0x14da842
call fcn.00c55118
lea esp, [esp + 8]
je 0x13df5f1
mov eax, 0xf68f873e
xor eax, eax
call fcn.014e27aa
mov eax, 0x4335e817
ror ax, 0xea
lea esi, [eax + esi - 0x433505fe]
movsx ecx, al
mov edx, dword [esi + eax - 0x433505fa]
xor edx, ebx
not edx
dec edx
ror edx, 3
bswap ecx
and cl, cl
dec edx
sal al, 1
xor ebx, edx
shr ecx, cl
je 0x13c55d1
cwde
add ebp, edx
mov edx, dword [edi + eax*2 - 0xbe8]
lea eax, [ecx + ecx*8 + 0x6d2a7ebb]
mov ecx, dword [eax + edi - 0x6d2a7ec0]
sub eax, 0x132071a5
lea edi, [edi + eax - 0x5a0a0d1b]
not al
btc eax, 0x8a
sal al, 0x64
and edx, ecx
cbw
lea ecx, [eax*2 - 0x7bd2c8c6]
inc eax
not edx
or cl, ch
mov dword [edi + eax - 0x5a0a0001], edx
jmp ebp

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

Disassembly:
cpuid
push 0x4d049c8e
call fcn.01548147
Function at 0xd282b2
Capabilities:
Encode data using xor

Disassembly:
xor edx, ebx
or eax, ecx
rol edx, 1
mov dword [esp], 0xb3ae4d32
add edx, 0x771f089e
shr ecx, 0xc7
setbe al
bswap eax
bswap edx
div byte [esp + ecx - 0x1f8380d]
not byte [esp + ecx*2 - 0x3f0701f]
add edx, 0xde3ca0b8
or ecx, 0x3621b034
xor word [esp + eax*2 - 0x210a252], 0x309c
xor ebx, edx
btr ecx, 0x1b
cwde
adc edi, edx
movzx ecx, byte [esi + ecx - 0x37f9b830]
cdq
xor cl, bl
imul edx, dword [esp + eax*4 - 0x144a4]
call fcn.01564dfb
sal cx, 7
add ecx, 0x5c831e12
mov cl, byte [ebp + 2]
or al, ah
adc ebp, 2
rol eax, 0x27
jae 0x150239a
ror cl, 1
pop edx
xor bl, cl
add ecx, esp
cdq
mov dx, word [ecx]
movsx ecx, ax
dec al
mov word [edi + ecx*8 - 0x794], dx
sub ecx, 0xbd246e22
rol eax, 0xfe
movsx edx, al
lea edi, [edi + ecx - 0x42db92d4]
and cl, 0xb0
js fcn.00cec8a7
inc ecx
mov edx, 0x330e2394
inc ecx
movsx eax, dl
movzx ebp, ax
inc di
movzx ecx, byte [edx + esi - 0x330e2394]
inc esp
movzx ebx, bp
movsx ebx, ax
call fcn.00c3c9db
push 0x48126c8a
mov edx, dword [esp]
mov eax, dword [esi + edx - 0x48126c8a]
xor byte [esp + edx - 0x48126c87], 7
jns 0x159acb7
push ebp
mov bh, ah
invalid
shr dx, cl
mov ecx, eax
jmp 0x152286e
mov word [ebp], dx
shr cl, 4
neg ecx
lea edx, [ecx + ecx*2 - 0x3be123e1]
lea edi, [edi + ecx*4 - 0x405803c8]
shl ecx, 0xb7
bswap ecx
mov ecx, dword [ecx + edi - 0x8078]
xor ecx, ebx
sal eax, 0xbb
inc eax
bswap ecx
jno 0x1589879
mov ecx, 0xbc9532bb
mov edx, dword [esi]
add esi, 4
xor edx, ebx
mov eax, ecx
ror al, 0x61
sbb edx, 0x513da59c
add ecx, 0x6808d50e
sar ecx, cl
xor edx, 0x90394412
or eax, eax
not edx
ror cl, cl
not eax
neg cl
dec edx
xor ebx, edx
add edi, edx
cwde
xor al, ch
cdq
mov edx, ebp
lea ebp, [ebp + ecx - 0x124fa2]
sal ecx, 6
xchg cx, ax
call fcn.014ca12b
shr eax, 0x6f
not edx
inc ecx
ror eax, 0x2b
ror al, 0x44
cdq
ror ecx, 3
cwde
inc ecx
imul edx, edx
xor ebx, ecx
add esi, ecx
mul edx
xor eax, esi
jmp eax
movzx dx, byte ss:[eax + edx - 0x48126c8a]
adc esi, 2
mov word [esi], dx
not dword [esp]
mov eax, 0x2f19769b
lea ebp, [ebp + eax*2 - 0x5e32ed3a]
rol dword [esp + eax - 0x2f19769b], 0x45
xadd byte [esp + eax*2 - 0x5e32ed34], ah
mov ecx, dword [ebp + eax*2 - 0x5e336536]
setl byte [esp + eax*2 - 0x5e336536]
sete al
sete byte [esp + eax*2 - 0x5e3363fe]
xor ecx, ebx
lea ecx, [ecx + eax*4 - 0x56b68cdc]
ror ecx, 1
pop edx
cbw
dec ecx
bt edx, eax
xor dx, 0xb8f
not edx
xor ecx, 0x66398233
bts edx, 0x3f
shl dl, 0xa1
xor ebx, ecx
lea eax, [edx*2 - 0xf4adb6a]
add edi, ecx
call fcn.01444002

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

Disassembly:
dec esi
mov dword [esp], eax
ror ebx, 0xd9
dec eax
neg ecx
dec eax
shr ebx, 0x94
not dl
dec eax
xor ecx, 0xb9b15431
inc ecx
not esp
bswap eax
dec eax
lea ecx, [ecx + ebx + 0x2abe5b66]
call fcn.012bb70d
Function at 0xd2a436
Capabilities:
Authenticate hmac
Encode data using base64
Encrypt data using speck

Disassembly:
neg ax
xor ecx, ebx
not eax
neg ecx
inc al
setne dl
dec ecx
call fcn.00d9d8ef
mov ecx, 0xcd808d20
mov eax, dword [ebp]
add ecx, 0x622a9f87
dec ecx
bswap ecx
mov edx, dword ss:[eax]
ror ecx, 6
movzx eax, cl
btc ax, cx
mov dword [ebp + eax*2 - 0x2158], edx
movsx edx, al
mov edx, dword [esi + eax*2 - 0x2158]
call fcn.01425209
push ebx
mov ebp, esi
bt edx, 6
and edx, 0x452aee38
not dx
mov ebx, eax
jg 0x1388701
mov edx, 0xfabea58b
mov ecx, dword [esi]
movzx eax, dx
or al, 0x80
lea esi, [esi + eax*8 - 0x52c54]
or al, al
jle 0xc0e326
btr dx, 0x8d
xor al, 0xa6
mov dword [esp + edx*8 - 0x6fe60], 0xba887aa2
dec al
xor bl, al
mov dword [esp + edx - 0xdfcc], 0xbd01d32f
add edx, edx
not dx
mov dword [esp + edx - 0x14067], ebp
mov ebp, edx
lea ebp, [ebp + edx + 0x63a2919a]
sete dl
push edi
setnp dl
sal bp, 0x4f
jp 0xc15e4d
pop ss
and dword [esi], ebp
imul eax, eax, 0x963ff266
and dword [eax - 0x69c011c6], ecx
and dword [edx + edi*2 + 0x21963fe6], ebp
xchg edx, eax
push edx
dec edx
invalid
ja 0x146c509

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

Disassembly:
jbe 0x12db9a4
adc al, 0x89
mov dword [esp + ecx - 0x9e00], 0xb4863491
xor edx, edx
sal dl, 0xe4
xor bl, al
mov word [edx + ebp + 2], ax
add edx, 0xb5893818
lea ecx, [ecx - 0x1ec8b073]
adc dx, word [esp + 0xa]
sbb ebp, 0xfffffffe
shr ecx, cl
mov edx, dword [edi + ecx - 0x709c4]
movzx eax, word [esp + ecx*2 - 0xe137d]
lea edi, [edi + ecx*4 - 0x1c2701]
shl ecx, 0xfc
xor edx, ebx
dec cl
rol cl, 0x67
lea edx, [edx + eax*2 + 0x4410a451]
rol edx, 1
or ax, word [esp + eax - 0x8633]
and byte [esp + eax - 0x8631], al
xor edx, 0x97b90ebd
btr ecx, eax
rol byte [esp + eax - 0x862d], 0x63
cwde
sbb edx, 0xe99765b8
sal eax, 0xa3
setbe cl
not edx
lea eax, [ecx + ecx*8 + 0x7381fb84]
lea eax, [ecx*4 - 0x7c7701cb]
xchg cx, ax
xor ebx, edx
dec ecx
jl 0x1315a97
xor ecx, ebx
inc dl
ror ecx, 2
idiv ax
rol eax, 0x72
lea ecx, [eax + ecx - 0x1680aa67]
shr edx, 0xf9
not ecx
div eax
ror edx, 0xf0
call fcn.00c68d57

Function at 0xd2f420
Capabilities:
Encode data using xor

Disassembly:
push 0xa014d2b0
lea esp, [esp + 0x10]
je 0xd2f49f
push ebx
mov ebx, 0x23dc6b0
movzx ebx, byte [ecx + ebx - 0x23dc6b0]
push 0xbc863731
sar byte [esp], 0xa6
rol word [esp], 0x43
xor ebx, edx
shr byte [esp], 3
not byte [esp + 3]
mov dword [esp], 0xd28cbb2e
and ebx, 0xff
mov ebx, dword [ebx*4 + 0x158cfa0]
shr word [esp + 2], 0xcf
mov byte [esp + 3], 0x14
shr edx, 8
xor edx, ebx
inc ecx
xor edx, 0x4009283c
ror dword [esp], 0x98
push 0x1bbd05ae
dec eax
lea esp, [esp + 8]
jne 0xd2f430
mov ebx, 0xd0bb0d95
pop ebx
mov eax, 0x85b27d91
not edx
cwde
neg al
mov dword [esi + eax - 0x7d6f], edx
shr eax, 0x67
mov ecx, dword [edi + eax - 0xfa]
imul eax
xor edx, eax
lea edi, [edi + eax*2 - 0x1e844]
add dl, dh
dec al
call fcn.00b7d837