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

Disassembly:
rol dword [eax], 0xf7
push esp
and al, 1
not dword [esp + 1]
ror byte [esp + 6], 0xa7
xor ecx, edi
call fcn.1188a9e4
pop ds
push eax
adc cl, al
imul ebp, dword [eax + 0x170110b2], 0xa012b910
sbb al, ch
sub dh, bl
in eax, dx
jle 0x10dd4683
in eax, dx
mov byte [edx], cl
cmp eax, 0xbc221b02
push ss
xchg esi, eax
insb byte es:[edi], dx
xor eax, 0xbb5ba328
salc
in eax, 0xd4
sbb esp, dword [eax - 0x3002563c]
lodsd eax, dword [esi]
pop esp
mov word [edi], es
pop es
cmpsd dword [esi], dword es:[edi]
je 0x10dd46f4
mov word [bx + di + 0x67], ss
mov cl, 0xae
aad 0x1d
push es
cmp bh, byte [eax]
xlatb
xlatb
stosd dword es:[edi], eax
invalid
push esi
inc byte [ebx]
loop 0x10dd46c6
invalid
xor edi, ecx
and edi, 0xff
push 0x2214f809
sar dword [esp], 0xf4
mov edi, dword [edi*4 + 0x11b39c9c]
sar dword [esp], 0x6e
adc dword [esp], 0x819fd580
mov dword [esp + 4], 0xbc3fef91
shr ecx, 8
jmp 0x10dd4685

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

Disassembly:
push 0x48040229
mov dword [esp + 4], 0x42384ebb
mov dword [esp + 4], edi
lea esp, [esp + 4]

Function at 0x118b2ae7
Capabilities:
Authenticate hmac

Disassembly:
lea esp, [esp + 0x28]
ret
lea eax, [eax + ecx - 0x5cea2065]
shr cl, 0xc3
rol eax, 2
neg dl
inc ecx
ja 0x11c4ed36
xor eax, 0x450ca482
rol eax, 2
lea ecx, [ecx + edx*4 - 0x7ef805f6]
lea eax, [eax + ecx - 0x2fde433c]
xor ebx, eax
push edx
mov byte [esp + ecx - 0x6586ecc0], 0xc
add edi, eax
movsx eax, word [esp + ecx - 0x6586ecc0]
mov dword [esp + eax*4 - 0x10030], edi
ret
lea esi, [esi + ecx - 0x570e3687]
not dl
pop ecx
not al
or dl, al
mov eax, 0x9311886
sal al, 0x81
btc ax, ax
mov word [esi + eax*2 - 0x12621018], dx
movsx ecx, al
lea ebp, [ebp + eax - 0x9310810]
dec eax
rol eax, cl
mov eax, dword [ebp + eax*2 - 0x21016126]
and cl, 0xb4
jg 0x119a7f21
mov eax, 0x27178b05
mov esp, edi
movsx edi, ax
push eax
mov ecx, dword [esp + eax - 0x27178b01]
mov edi, dword [esp + eax*2 - 0x4e2f1602]
movsx ebx, al
movzx ebp, ax
mov dword [esp + ebx + 3], ebx
mov edx, dword [esp + eax - 0x27178af9]
xor bp, 0x5989
jl 0x11915843
mov eax, dword [esi + edx*2 - 0x6376]
call fcn.10cd25c6
push dword [esp + 0x10]
popfd
not bl
push ebp
mov eax, dword [esp + eax*2 - 0x4e2f15f2]
jmp 0x11a155d0
xor eax, ebx
lea edx, [ecx + ecx*4 - 0x2061bf7d]
or ecx, 0x6605f18f
jne 0x1186f8bf
jmp 0x11847a45
mov ebp, dword [esp + ebx - 0xde]
mov esi, dword [esp + ebx*2 - 0x1d4]
mov ebx, dword [esp + ebx - 0xd6]
jmp 0x119db8fd
not edx
ror ecx, 3
imul edx, edx
bt eax, edx
btr edx, 0x27
xor ecx, 0xe7057c0a
lea eax, [eax*8 - 0x3bc690de]
inc ecx
call fcn.10e508c2
inc ecx
pop edx
dec ecx
or ecx, 0x83bad198
dec ecx
rol edi, 0xc3
dec eax
arpl ax, ax
dec ecx
sal ecx, 0x8b
dec esp
add ebx, eax
sal bp, 0x47
inc ecx
push eax
btc bp, dx
dec esi
mov dword [esp + eax - 0xaa07], ebx
ret
Function at 0x118e092b
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
and ecx, ecx
lea edi, [edi + eax - 0x5a592004]
sar dword [esp + ecx - 0x5cb4591d], 0xa7
rol dword [esp + ecx - 0x5cb4591e], 0xe2
xchg dword [esp + ecx - 0x5cb4591f], ecx
mov dword [edi + eax - 0x5a592000], edx
ja 0x1194d832
mov eax, dword [esi + eax - 0x5a592000]
mov edx, ecx
adc esi, 3
or dword [esp + 4], 0x8aa7c6a6
adc dword [esp + 3], 0x9112d20f
xor eax, ebx
sub edx, ecx
not dword [esp + edx*8]
jne 0x11b87351
bswap eax
not eax
dec edx
not word [esp + 5]
neg eax
inc dl
dec cl
bswap edx
mov dword [ebp - 4], eax
jb 0x11b87373
test ebx, ebx
call fcn.11b83b1c
or edx, eax
push edx
dec ecx
rol ecx, 1
sal edx, 0xb3
xor eax, 0x67111d14
inc ecx
lea edx, [eax*8 + 0x592a8d13]
mov dword [esp + edx - 0x20a19fa3], edx
not eax
rol ecx, 3
dec eax
push eax
xor ecx, 0x418e670c
ror ecx, 3
btr eax, 0xac
setae al
xor ebx, ecx
dec word [esp + eax - 0x67110cff]
add esi, ecx
mov ebp, dword [ebp + eax - 0x67110d00]
bswap eax
pop eax
pop edx
jmp fcn.10ce4867
bswap ecx
xor dl, bl
add ecx, eax
push ecx
push eax
dec dl
xor dl, 0x10
add ax, word [esp + eax*2 - 0x7968b240]
adc dl, 0x8e
ror dl, 1
btr ecx, eax
xor bl, dl
shl eax, 0xe7
jae 0x11849892
Function at 0x11950fb7
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
ror edx, 2
neg ecx
xor ebx, edx
shr dword [esp + eax - 0x8821114], 0x81
adc ebp, edx
movzx edx, byte [esi + eax*4 - 0x22084460]
push eax
sar ecx, cl
ror byte [esp + eax - 0x882110f], cl
lea esi, [esi + eax - 0x8821117]
xor dl, bl
bswap eax
xor dl, 0x85
mov dword [esp + eax - 0x18118204], eax
or ecx, dword [esp + eax - 0x18118205]
rol ecx, cl
sbb dl, 3
neg dl
or dword [esp + eax - 0x18118202], ecx
bts eax, ecx
xadd dword [esp + 8], ecx
dec dl
cwde
pop eax
dec ecx
xor bl, dl
lea edx, [esp + edx + 8]
movzx cx, byte [edx + ecx*4 - 0x3023ae04]
xadd dword [esp + eax*2 - 0x1104222d], eax
rol eax, 0x6d
movsx edx, byte [esp + eax - 0x703bf173]
lea edi, [edi + eax - 0x703bf179]
dec al
setnp al
mov word [eax + edi - 0x703bf101], cx
bswap eax
btr edx, edx
pop edx
pop eax
jb fcn.11a5b900

Function at 0x11954772
Capabilities:
Authenticate hmac

Disassembly:
mov dword [esp + 0xc], 0xd1316c34
sbb edi, 4
sal ecx, 0xd4
neg ecx
movzx edx, byte [esp + ecx*2 + 0xc]
mov dword [edi + ecx*2], eax
pop eax
pop edx
pop edx
pop ecx
jbe fcn.118812d1

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

Disassembly:
xor edi, edx
and edi, 0xff
call fcn.10da7a6a
mov edi, 0xc5812cb5
ror edi, 0x96
movzx edi, byte [eax + edi*2 - 0x965ae2c]
jae 0x10cd2352
lea esp, [esp + 0xc]
jne 0x118abe2a
mov ecx, 0x7136003c
mov eax, ecx
pop edi
mov eax, 0xfda9d48b
dec eax
rol al, 0x21
not edx
mov dword [edi], edx
movsx ecx, al
xor cl, ah
mov edx, 0x35196fbe
jmp ebp

Function at 0x119903b1
Capabilities:
Encode data using xor

Disassembly:
add word [esp + 0xc], 0x422b
mov dword [esp], 0xd239a8b0
xor ebx, edx
ror word [esp + 4], 0xe
neg word [esp + 9]
jg 0x11a2be8a
add esi, edx
lea esp, [esp + 0x10]
jmp 0x11a79774

Function at 0x1199ee5b
Capabilities:
Encrypt data using rc4 ksa

Disassembly:
xor bl, al
push edx
sal edx, 0x82
or dword [esp + edx*2], ebp
rol dx, 0xed
mov ebp, edx
lea edx, [edx - 0x6de35f5c]
push esi
imul ebp, ebp
sar ebp, 0xf1
push ebx
lea ebx, [edx + ebp*8 - 0x41fb4b54]
xor ebp, edi
rol dl, 0x61
btr bx, dx
sbb edx, 0xc425112f
mov ebx, eax
lea eax, [edx + edx + 0x4da2b79f]
mov edx, ebx
sal edx, 2
call fcn.119e2e66
mov dword [esp + 4], 0xe2999068
lea esp, [esp + 4]
call fcn.11cf66ab
mov edx, 0x1e23e311
lea eax, [edx - 0x2ed952fa]
movzx eax, byte [ebp + edx*2 - 0x3c47c622]
and dx, 0x99ba
sal dx, 8
bt edx, edx
lea ebp, [ebp + edx - 0x1e230fff]
xor al, bl
rol dx, 0x68
sal edx, 0x1a
sets dl
sbb al, 0x11
rol dx, 0xd
rol edx, 0xf3
xor al, 0x17
imul edx, edx
xor dl, dl
neg edx
rol al, 1
shl dl, 0x24
imul edx, edx
not al
rol al, 1
shl edx, 0xff
jp 0x10d28dff
dec ebp
sbb cl, byte [edx - 0x12]
nop
cwde
insd dword es:[edi], dx
sub al, 0xf
dec edi
push edx
nop
invalid
Function at 0x119a7f36
Capabilities:
Authenticate hmac
Encode data using xor

Disassembly:
jmp 0x119c8b42
lea esp, [esp + 0x10]
je 0x11cbf88a
mov eax, dword [ebp + ebx*4]
push eax
call fcn.11ce9742
movzx eax, byte [esi]
add esi, 1
mov ecx, 0x661ad51d
neg ecx
xor al, bl
movsx edx, cx
inc al
neg al
neg dl
rol eax, 3
neg eax
sal dl, 0x85
not eax
lea eax, [eax + edx - 0x489d0c91]
sar ecx, 0x4c
dec dl
inc edx
xor ebx, eax
add ebp, eax
xor edx, edx
add edx, ebp
jmp edx
mov eax, 0x60a87b9c
mov eax, dword [eax + ebp - 0x60a87b9c]
call eax
mov ebp, dword [ebp - 4]
mov ecx, 0xe412b9a7
lea esi, [ecx + ecx*4 - 0x20d7204d]
movzx edx, cx
mov dword [esi + ebp - 0x53867ff6], eax
lea eax, [ecx*8 - 0x5b78e900]
neg si
cdq
mov edi, ebp
movsx ebp, al
pop ebx
pop ebp
pop esi
bts cx, 8
xchg ecx, eax
mov eax, dword [esi]
adc esi, 3
rol edx, cl
imul edx, ecx
xor eax, ebx
bt cx, 0x33
jb 0x11aaa8cf
inc ecx
mov ebp, 0x7788ce33
mov eax, 0x40b93c31
inc ecx
movzx edx, word [esi + eax - 0x40b93c31]
dec ebp
lea esi, [esi + eax - 0x40b93c2f]
jmp 0x1192df3b

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

Disassembly:
xor eax, ebx
shr cx, 0xc8
pop edx
lea edx, [ecx + ecx*2 + 0x3c9e1986]
sbb eax, 0xe3af6fb1
bts ecx, 0xb6
btc edx, ecx
bts cx, 0x2f
not eax
call fcn.119a1e50

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

Disassembly:
rep stosd dword es:[edi], eax
adc ecx, ecx
jmp 0x119a8fdc
mov dword [ebp - 0x2c], edi
je 0x119a8fe4
mov ecx, eax
mov eax, 0x400
and di, bp
mov edi, edx
bts edx, ebp
movzx edx, ax
mov eax, edx
jmp 0x11d22113
jl 0x11934dd8
mov dword [ebp - 8], ecx
and ch, 0x88
shrd ecx, edi, 0xba
movsx cx, ah
lea esp, [esp]
bsr di, dx
movzx edi, di
sub edi, edi
cmp ecx, dword [ebp - 0x40]
jmp 0x11a3db40
shl esi, 8
inc edi
test di, 0x2421
or esi, edx
jmp 0x11cf4351
mul byte [esp + eax*2 - 0x610d1ec5]
adc edi, ecx
mov ecx, edx
imul cx
lea ebp, [eax + ebp - 0x30860001]
imul al
adc eax, dword [esp + eax - 0x3085fff8]
movzx edx, byte [ebp + eax - 0x59a000b8]
xor dl, bl
xor dl, 0x92
not dl
pop eax
shr ecx, cl
and dword [esp + ecx - 4], ecx
ror dl, 1
add dword [esp + ecx*4 - 0x1c], 0x6fbff41e
sar word [esp + ecx*4 - 0x20], 0xc4
xor dl, 0xb7
rol byte [esp + ecx - 8], 0x63
mov eax, dword [esp + ecx*2 - 0xc]
xor bl, dl
lea esi, [esi + ecx*2 - 0x14]
jmp 0x11c7bf7d
rep stosw word es:[edi], ax
sub cl, 0x12
rol ecx, cl
mov ecx, dword [ebp + 8]
lea eax, [ecx - 1]
mov dword [ebp - 0x40], eax
stc
test esp, edi
xor esi, esi
or eax, 0xffffffff
jmp 0x11934dd6
je 0x10d5fc54
movzx edx, byte [ecx]
stc
jmp 0x11948175
sal dword [esp + ecx*2 - 0xc], cl
btc ecx, eax
mov dword [esi + ecx - 0x48], edx
imul ecx, dword [esp + eax - 0x6fbff422]
movsx edx, cl
xchg ecx, eax
pop edx
pop eax
jo fcn.10e07d72
test esi, edi
add eax, 0x736
jmp 0x11d2f917
inc ecx
cmp edi, eax
stc
cmc
cmp edi, 5
jmp 0x10d392ab
shl edx, 0x10
stc
cmc
or eax, edx
test si, 0x44a8
test cx, cx
stc
shr ecx, 1
jmp 0x10ca40b7
mov dword [ebp - 0x28], edi
jmp 0x11d463de
mov dword [ebp - 0x24], edi
jmp 0x10d11c08
Function at 0x119bf967
Capabilities:
Hash data using murmur3

Disassembly:
neg eax
shl ecx, 0xd1
xor ecx, 0xb386c8a1
lea eax, [edx + eax + 0xe6e1bb0]
add dword [esp], 0x9f01cda9
ror dl, 0x46
xor edx, ecx
xor ebx, eax
ror dword [esp + edx - 0x6c8e55bb], cl
and dword [esp + edx - 0x6c8e55bb], 0x22b8b6a3
push edx
adc edi, eax
mov edx, dword [edx + ebp - 0x6c8e55bb]
movzx ax, byte ss:[edx]
xor ecx, ecx
sar word [esp + ecx], 0x81
lea ebp, [ebp + ecx*2 + 2]
shr cl, 0x41
mov word [ebp + ecx*2], ax
xor ecx, 0x19a2198e
mov dword [esp + ecx - 0x19a2198e], edi
ret 4
inc eax
neg edx
neg eax
xchg dl, cl
lea eax, [eax + edx - 0x399d7258]
lea ecx, [ecx*8 - 0x2961b679]
neg eax
inc edx
sub dx, dx
xor ebx, eax
call fcn.10e3fc14
jmp fcn.10e143d3
jmp 0x118731ae
lea eax, [eax + ecx*4 - 0x4b0d33c3]
mov dword [esp + ecx*2 - 0x401235be], ecx
sal word [esp + ecx*2 - 0x401235be], 7
jne 0x10d3887c
rdtsc
mov ecx, 0x893e933b
bts ecx, ecx
jb 0x11a24ac2
mov eax, 0x6026528b
shr eax, 0x92
lea ebp, [eax + ebp - 0x180a]
neg eax
movzx edx, byte [ebp]
inc eax
xor dl, bl
bt eax, eax
sub al, 0x1d
rol dl, 1
inc eax
sub dl, 0x32
shl eax, 0xd8
sar eax, 0x7a
ror dl, 1
lea eax, [eax + eax*2 + 0x40aef1b9]
and eax, 0x3b2ad839
sar eax, 0xde
inc dl
bswap eax
xor bl, dl
push ebp
sal eax, 0xf1
jbe 0x11a3b8f4
add esi, edx
imul dword [esp + eax*4 - 0x2c74]
mov ax, word [ebp + edx*8 - 0x10d8]
rol edx, cl
xadd ecx, edx
neg ecx
mov cl, byte [edx + ebp - 0x7baeff7f]
and edx, 0x4eaf78a3
ja 0x1189168d
adc esi, eax
mov dword [esp + ecx - 0xd8ce], esi
ret
sbb esi, 7
add cx, cx
and cl, 0x94
or ecx, ecx
mov dword [esi + 4], eax
mov dword [esi], edx
sbb ebp, 4
movzx edx, cx
sal edx, cl
mov eax, dword [ebp + edx - 0x61400000]
xor eax, ebx
neg ecx
jne 0x11d5228a
push edi
btr eax, 0xba
movzx ebp, ax
push ebx
movsx ebx, al
lea eax, [eax + ebx*4 - 0x59e10fda]
cwde
add ebp, esi
or ebx, edx
movsx edx, ax
dec dx
mov edx, ebx
dec al
imul eax, eax
not eax
sal edx, 2
cwde
xchg ah, al
mov eax, ebp
add eax, edx
mov dword [ebp - 4], eax
jmp 0x1192e338
jno 0x10e1bae6

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

Disassembly:
mov ebp, dword [esp + eax + 3]
neg cl
pop ebp
inc esp
xor dl, cl
inc eax
movsx edi, ch
dec eax
add ecx, esp
dec edi
lea esp, [eax + eax - 0x3fed495b]
jmp 0x11c3b811
push dword [esp + 4]
popfd
mov dword [esp + ecx*2 - 0x80aee8], ecx
sub dx, 0x8e18
mov ecx, dword [ecx + esi - 0x405776]
neg dl
not byte [esp + 5]
adc esi, 3
add eax, 0xb18bdc81
xor ecx, ebx
call fcn.11d015b3
inc ecx
mov eax, 0xa9035e3e
dec ebx
lea esi, [eax + eax*2 - 0x16fa8be6]
inc ecx
push eax
inc ecx
movzx ecx, byte [esi]
inc byte [esp + 4]
movzx eax, byte [esp + 4]
dec esp
add esi, eax
inc ecx
xor cl, dl
dec byte [esp + eax*2 + 3]
setno al
inc ebp
mov esp, eax
add cl, al
inc ebp
movsx ecx, ah
not cl
sar dword [esp + eax*4], 0x5f
adc cl, al
inc bp
bt eax, ecx
ror cl, 1
dec eax
not esi
jmp 0x10de529b

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

Disassembly:
push edx
mov edx, dword [esi]
ror byte [esp + 2], 0xa6
jae 0x10ce254f
Function at 0x11a021f5
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
xadd byte [esp + eax + 4], al
xor ecx, 0xeaa18a31
neg edx
add dx, ax
sbb ecx, 0xf38469b3
btc edx, 0x29
and dword [esp + eax - 3], edx
rol ecx, 3
shr byte [esp + eax - 2], 0xa6
xchg edx, eax
sbb eax, edx
xor ebx, ecx
btc eax, 0xa1
mov dword [esp + edx*4 - 0x20], 0x227fe12
adc edi, ecx
ror eax, 0xd
mov eax, dword [edx + esi - 8]
setae byte [esp + edx - 1]
ror edx, 0xa7
mov ecx, dword [esi + edx - 0xffffffc]
mov dword [esp + edx*8 - 0x7ffffff8], ebx
cpuid
call fcn.10c8a804

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

Disassembly:
mov dword [esp], 0x68b45221
call fcn.11c38f01
btc bx, bx
movzx ebx, byte [edx]
jae 0x11888a66
mov eax, 0x2e28a422
and ax, 0x8ba2
lea edx, [eax*8 - 0x295cd16d]
mov eax, dword [ebp + edx - 0x47e72fa3]
movsx ecx, dx
mov edx, dword [ecx + ebp - 0x2f9f]
setno cl
rol cl, 0x23
lea ebp, [ecx + ebp - 0x2f04]
add cx, cx
call fcn.10dd5bea
inc ecx
mov eax, dword [esi]
mov edx, 0x1d2d6791
call fcn.10cc83a3
inc esp
cli
ja 0x11a0895e
dec dword [edi]
xchg ecx, eax
rol eax, 0xc1
and ecx, dword [ebp - 0x2f03d654]
invalid
add dword [edi - 0x66434f24], 0x4b
pop edx
inc edx
inc esp
invalid

Function at 0x11a1fc8b
Capabilities:
Encode data using xor

Disassembly:
pop eax
pop eax
jmp ebp
mov ecx, dword [edi]
cbw
mov dword [esp], eax
not word [esp + 2]
mov eax, dword [ecx]
mov ecx, 0x8c105899
mov edx, dword [esp]
mov dword [esp + edx - 0x3c5e0000], ecx
mov dword [edi + edx - 0x3c5e0000], eax
ror edx, cl
adc edx, 0xd12c1989
mov edx, dword [esi + edx*2 - 0x58334e]
push ecx
btc ecx, ecx
ror byte [esp + 7], 0xc6
adc esi, 4
shr cx, 0xa7
xor edx, ebx
xchg dword [esp + 3], ecx
dec edx
jmp 0x11c78a68
movsx eax, byte [esp + ecx - 0x10589988]
dec cl
xor edx, 0x3e04dea0
not eax
rol dword [esp + ecx*2 - 0x20b13312], 0xf7
ror edx, 1
or cx, ax
neg edx
cwde
rol word [esp + ecx - 0x1058fffa], 0xea
lea edx, [ecx + edx - 0x204465]
add eax, eax
xadd byte [esp + ecx - 0x1058fffb], cl
rol edx, 1
xadd cl, ah
btc ecx, 0xaf
xor ebx, edx
xor eax, dword [esp + ecx*2 - 0x20b0fe0d]
neg ecx
mov word [esp + 6], 0x7030
add ebp, edx
mul cl
jb 0x10d69c46
Function at 0x11a2a6cc
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
lea ecx, [eax - 0x7ec79943]
xor ecx, ecx
xor dl, bl
xchg cx, ax
inc dl
add ecx, eax
rol dl, 1
shl ecx, 0xbd
add ax, cx
inc dl
rol ax, 0x64
sal cx, 0x49
neg cl
not dl
shl cx, 0x2b
dec dl
neg cx
xor bl, dl
add ax, cx
cwde
lea ebp, [ebp + eax - 2]
sub cl, ch
xchg cx, ax
cwde
mov word [eax + ebp], dx
movzx edx, cx
xor edx, dword [edi + eax*4]
lea edi, [edi + eax*2 + 4]
bt eax, ecx
sbb ax, ax
shl al, 0xe5
xor edx, ebx
xor ecx, eax
btr ecx, eax
neg ax
ror edx, 3
xor edx, 0x12bd1c89
neg ax
lea edx, [edx + eax*2 + 0x24281489]
neg edx
or eax, 0x17968494
dec cx
bts eax, eax
xor ebx, edx
neg cl
btr ax, ax
sub ecx, ecx
adc esi, edx
cbw
btr ecx, eax
jae fcn.1185bae6
xor bl, al
lea eax, [esp + eax + 0x14]
xchg dword [esp + 8], edx
sar dl, 0x65
mov dword [esp + edx*2 - 0x667ffffc], edx
mov byte [eax + edx - 0x33400000], cl
mov dword [esp + edx - 0x33400000], esi
ret 0x10
sar edx, 0xa
ror al, 1
rol word [esp + 9], 0xc1
push edx
not al
ror dx, 9
or edx, 0xaa387f85
neg al
and dx, word [esp + 0x12]
imul dx, word [esp + 0x12]
jo 0x119cf616
movzx edx, byte [edi]
mov eax, 0x4da9b220
lea edi, [edi + eax - 0x4da9b21f]
jmp 0x10cb9d40

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

Disassembly:
add eax, edx
call fcn.10d39399
movzx ebx, al
mov ebx, edx
lea eax, [eax + eax + 0x73a5b02c]
ror al, 0x61
sub ax, ax
mov edx, ebx
and ax, ax
shl edx, 2
dec eax
mov eax, ebp
jg 0x10e17436
jg 0x11a7306f
mov edx, 0xc212ec12
mov eax, 0x73074c2d
or eax, eax
movzx ecx, word [esi + eax - 0x73074c2d]
dec ax
lea esi, [esi + eax - 0x73074c2a]
xor cx, bx
ror ax, 0x25
jb 0x11a52f06
sbb cx, 0x3887
mul dx
btc eax, 0x2b
shl edx, 0x98
xor cx, 0x1b2a
imul edx
rol cx, 1
inc al
add cx, 0x29ab
shr edx, 0x18
cdq
xor cx, dx
xadd edx, eax
inc edx
rol cx, 1
shr ax, 0xc9
sal edx, 0xf2
not cx
ror eax, 0x89
or dx, dx
xor cx, 0xec1d
not ax
xor bx, cx
btr eax, 0x19
adc dx, dx
lea edi, [edi + edx - 0x40005]
cmovnp ax, dx
mov dword [edx + edi - 0x40001], ecx
cdq
rol al, 0xa1
cwd
mov ecx, dword [esi + edx*2]
xor eax, 0xf21ec10a
cwd
lea esi, [esi + edx*2 - 0x1fffa]
bts dx, 0x8d
xadd ax, dx
xor ecx, ebx
btr dx, 0x81
cdq
bswap ecx
inc al
lea eax, [edx*8 + 0x3724deb1]
rol ecx, 3
bswap edx
neg al
sbb edx, eax
inc ecx
lea eax, [edx*8 - 0x2748c4ff]
btc eax, eax
ror ecx, 1
btr edx, eax
xor ebx, ecx
xchg edx, eax
add ebp, ecx
mul eax
rol dx, 0x8b
jb fcn.11a5b900
jmp ebp
xor bl, dl
sub eax, 0xf7b0919e
or eax, 0x209b63ba
mov dword [esp + eax - 0x27ff6ffb], edi
push esi
neg eax
btr eax, eax
cwde
push ebx
jae 0x10da99fa
jmp fcn.11cf5004
jp 0x10d8ef38

Function at 0x11a4daa4
Capabilities:
Authenticate hmac

Disassembly:
not dword [esp + 0xc]
lea esp, [esp + 0x18]
jne 0x11cbfb47
pop ebx

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

Disassembly:
push 0x4132fe23
mov dword [esp + 4], 0x4c096893
dec edx
lea esp, [esp + 0x10]
jne 0x11888a86
pop esi
Function at 0x11a59437
Capabilities:
Execute anti-debugging instructions

Disassembly:
shr cx, 1
rcr eax, cl
movzx ecx, dl
mov dword [esp + edx - 0x5d5e5309], 0x83b4f129
mov dword [ecx + esi - 9], eax
movzx eax, dx
lea ebp, [ecx + ebp - 0xd]
and ecx, 0x54b9aba4
bts ecx, edx
bt ax, 0x33
mov edx, dword [edx + ebp - 0x5d5e5309]
mov dword [esp + ecx*8 - 0xff8], eax
not byte [esp + ecx*2 - 0x3f5]
bts ecx, 0xa6
xor edx, ebx
rol edx, 2
and ecx, dword [esp + ecx*2 - 0x478]
neg edx
and word [esp + ecx - 0x1f9], ax
dec edx
or ecx, ecx
xor edx, 0x3103dc26
ror edx, 1
btc ecx, 6
neg ecx
cwde
xor ebx, edx
call fcn.11c70ebb
mov edx, dword [esi]
add esi, 4
xor edx, ebx
mov ecx, 0x598b4f9e
mov eax, 0x6cafc387
inc cx
neg edx
shl ecx, cl
sbb ecx, ecx
bt cx, cx
lea edx, [edx + eax + 0x4bf36f13]
xor edx, ecx
sub al, ch
shr eax, 0x41
inc eax
adc edx, ecx
dec ecx
jg 0x11c692c4
jle 0x11cc4c72
adc edx, 0x7a1fd8bb
xor eax, ebx
and edx, ecx
call fcn.10d5eb00
xor ebx, edx
bswap eax
inc ecx
add ebp, edx
add cl, 0xba
xadd eax, ecx
mov eax, dword [edi]
bt cx, cx
adc ecx, 0xce0d629f
mov cl, byte [edi + 4]
mov edx, 0x5a38d299
ror dl, 0x61
bt dx, dx
lea edi, [edi + edx - 0x5a38d2c6]
sbb dx, 0xd6b6
or edx, 0x2ea7641c
not edx
mov byte es:[eax], cl
mov ecx, 0xf6ab9b12
neg ecx
not edx
jmp ebp
Function at 0x11a74e27
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
bswap eax
not cx
shr cl, 0x61
xor ebx, eax
add ebp, eax
movzx eax, cl
mul eax
movzx ecx, word [ecx + esi - 0x5cb0b149]
not al
seto dl
pop edx
lea esi, [esi + eax*2 - 0x285a]
xor cx, bx
ror cx, 1
idiv al
movsx edx, al
or eax, eax
sbb cx, 0x65b5
shr ax, 0x42
lea edx, [edx + edx*2 - 0x22eab5de]
jnp 0x11d86ba1
ror cx, 1
not cx
neg cx
mul edx
jb 0x11c76c1c
mov eax, 0xe1309821
fsub qword [edi]
movzx ecx, ax
mov edx, eax
mov ecx, dword [esi + ecx*8 - 0x4c108]
add esi, 4
sar dl, 0x87
xor ecx, ebx
or ax, ax
xor ecx, 0x6e11d30c
not edx
rol ecx, 1
sal eax, 0xbf
xor ecx, 0x1019670d
lea ecx, [edx + ecx - 0x4507189b]
inc eax
and dx, ax
adc ax, 0x9626
xor ebx, ecx
call fcn.1190dcbe
mov eax, 0x6e147c37
bts ax, 0x9c
mov ecx, 0x280c72ba
lea edi, [edi + eax - 0x6e147c3b]
shr eax, cl
ror eax, 0xc5
jb 0x11b3fa02
mov edx, dword [edi + ecx*2 - 0x5018e574]
xor edx, ebx
xchg ah, cl
not edx
call fcn.11c96d88
sal dl, 0x24
sal edx, 0xe7
rol cl, 1
push eax
sub cl, 0x89
xor al, dh
xor bl, cl
push eax
mov word [esp + eax - 0x723089f6], 0x8d3a
not byte [esp + eax - 0x723089eb]
lea ebp, [ebp + edx - 4]
btc dx, dx
pop edx
mov dword [eax + ebp - 0x723089f8], ecx
setae dl
mov edx, dword [eax + edi - 0x723089f8]
sub eax, dword [esp + eax - 0x723089f1]
mov ecx, eax
adc ax, 0xdda5
lea edi, [edi + eax - 0x7330e39a]
xor edx, ebx
ror ecx, 0x59
bts ax, 0x29
neg cl
bswap edx
pop ecx
not edx
xor ecx, eax
add ecx, ecx
ror edx, 2
add ecx, 0xc532e417
dec al
not edx
shr cx, 0xa9
jae 0x11b76128
mov ecx, dword [edi]
mov eax, dword [edi + 4]
push 0xe999d02e
sub dword [esp + eax - 0x7330e39c], 0x1b9d8624
xor ebx, edx
xchg ch, cl
push eax
add esi, edx
xor byte [esp + eax - 0x7330e393], 0x2a
pop eax
pop eax
pop eax
jae fcn.1185bae6
sar dx, 0x2e
sbb cx, 0x73b
not cx
lea edx, [edx*2 + 0x1136cb16]
xor bx, cx
xor dx, dx
bts dx, 0x2c
not edx
sbb edi, 2
sub eax, edx
mov word [edi + eax*4 - 0x28497de4], cx
rol edx, 0x48
lea ecx, [eax*2 + 0x332bb49b]
jne fcn.11d4d591

Function at 0x11a97e9c
Capabilities:
Authenticate hmac

Disassembly:
mov ecx, dword [ebp + ecx*2 - 0x5d21977a]
cbw
mov dword [esp + eax*2 - 0x5d21ff7a], eax
xor ecx, ebx
ror ecx, 2
xor ecx, 0xc923e50c
ror ecx, 1
or eax, 0x7f2be53b
rol byte [esp + eax - 0x7fbbffbe], 0x45
lea ecx, [ecx + eax + 0x11e9bb6d]
or al, byte [esp + eax - 0x7fbbffbe]
push eax
sar word [esp + eax - 0x7fbbfffa], 0x8a
neg ecx
btr ax, 0x3d
and ax, 0xd391
or dword [esp + eax - 0x7fbbd38d], 0x2612eb85
bswap ecx
jno 0x11cd3b4c
mov ecx, 0x87836d13
lea eax, [ecx*4 - 0x3c7eba54]
mov ecx, dword [edi]
cwde
mov edx, eax
add edi, 4
xor ecx, ebx
push eax
add ecx, 0x39818faf
lea edx, [edx + edx*4 - 0x4dfd53d5]
sar dword [esp], 0xba
setne al
ror ecx, 1
imul edx, dword [esp]
and eax, edx
or dword [esp + eax - 0x4dfd7101], edx
dec ecx
lea eax, [eax + eax + 0x5f1078ad]
not ecx
jmp 0x11c118ce
cwde
dec dx
dec ecx
push edx
xor ebx, ecx
xchg dword [esp + eax - 0x5aae], edx
bswap eax
call fcn.11a09ac1
not ecx
sar al, 0xa5
rol al, 0x27
sets al
xor ebx, ecx
imul eax, eax
add edi, ecx
jmp edi