joyce8/EMBER2024-capa huggingface dataset:
Function at 0x10124d90
Capabilities:
Enumerate pe sections

Disassembly:
sub esp, 0x14
xorps xmm0, xmm0
push ebx
push ebp
mov ebp, dword [esp + 0x20]
lea ebx, [ebp + 0x318]
movups xmmword [ebx], xmm0
push esi
movq qword [ebx + 0x10], xmm0
movzx ecx, word [ebp + 0x98]
mov eax, dword [ebp + 0x9c]
shl ecx, 4
add ecx, eax
push edi
cmp eax, ecx
jae 0x10124f7d
cmp dword [eax], 0x42444620
jne 0x10124dd5
mov esi, dword [eax + 0xc]
test esi, esi
jne 0x10124de9
add eax, 0x10
cmp eax, ecx
jb 0x10124dc6
pop edi
pop esi
pop ebp
mov eax, 8
pop ebx
add esp, 0x14
ret
push dword [eax + 8]
mov edi, dword [esp + 0x30]
push edi
call fcn.100dd640
add esp, 8
test eax, eax
jne 0x10124f7d
cmp esi, 8
jb 0x10124f7d
push ebx
push esi
push edi
call fcn.100dcd50
add esp, 0xc
mov dword [esp + 0x20], eax
test eax, eax
jne 0x10124f7d
mov eax, dword [ebx]
lea ecx, [eax + esi]
mov dword [ebp + 0x31c], ecx
mov ecx, eax
movzx edi, byte [ecx + 2]
movzx eax, byte [ecx + 3]
movzx edx, byte [ecx + 5]
shl edi, 8
or edi, eax
movzx eax, byte [ecx + 4]
shl eax, 8
or edx, eax
movzx eax, byte [ecx + 6]
shl edx, 8
or edx, eax
movzx eax, byte [ecx + 7]
movzx ecx, byte [ecx + 1]
shl edx, 8
or edx, eax
mov eax, dword [ebx]
movzx eax, byte [eax]
shl eax, 8
or ecx, eax
cmp ecx, 1
jne 0x10124f65
cmp edx, 8
jb 0x10124f65
lea eax, [edx - 8]
shr eax, 2
cmp eax, edi
jb 0x10124f65
lea eax, [edx + 1]
cmp eax, esi
ja 0x10124f65
mov eax, dword [ebx]
sub esi, edx
mov dword [esp + 0x14], 0
mov dword [esp + 0x18], 0
mov dword [ebp + 0x328], edi
mov dword [ebp + 0x324], esi
lea ecx, [eax + edx]
mov dword [ebp + 0x320], ecx
lea edx, [eax + 8]
lea eax, [edx + edi*4]
mov dword [esp + 0x10], eax
cmp edi, 2
jb 0x10124f21
lea esi, [edi - 2]
xor ebx, ebx
shr esi, 1
inc esi
xor ebp, ebp
movzx ecx, byte [edx + 2]
sub edi, 2
movzx eax, byte [edx + 3]
shl ecx, 8
or ecx, eax
lea eax, [ecx + ecx*4]
movzx ecx, byte [edx + 6]
lea ebx, [ebx + eax*2]
shl ecx, 8
movzx eax, byte [edx + 7]
add edx, 8
or ecx, eax
lea eax, [ecx + ecx*4]
lea ebp, [ebp + eax*2]
sub esi, 1
jne 0x10124ed5
mov dword [esp + 0x18], ebp
mov ebp, dword [esp + 0x28]
mov dword [esp + 0x14], ebx
mov esi, dword [ebp + 0x320]
lea ebx, [ebp + 0x318]
jmp 0x10124f23
mov esi, ecx
test edi, edi
je 0x10124f40
movzx ecx, byte [edx + 2]
movzx eax, byte [edx + 3]
mov edx, dword [esp + 0x10]
shl ecx, 8
or ecx, eax
lea eax, [ecx + ecx*4]
lea edx, [edx + eax*2]
jmp 0x10124f44
mov edx, dword [esp + 0x10]
mov eax, dword [esp + 0x14]
add eax, dword [esp + 0x18]
add eax, edx
cmp eax, esi
ja 0x10124f65
mov eax, dword [esp + 0x20]
pop edi
pop esi
mov byte [ebp + 0x32c], 1
pop ebp
pop ebx
add esp, 0x14
ret
push ebx
push dword [esp + 0x30]
call fcn.100dd600
xorps xmm0, xmm0
add esp, 8
movups xmmword [ebx], xmm0
movq qword [ebx + 0x10], xmm0
mov eax, 8
pop edi
pop esi
pop ebp
pop ebx
add esp, 0x14
ret
Function at 0x735ff5
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
lea esp, [esp + 0xc]
je 0x761bf0
jmp 0xc6d419
jmp 0xc9edf6
call fcn.009c46bf
mov ecx, 0x5d1d7b05
movzx ax, byte [esi + ecx - 0x5d1d7b05]
sub ecx, 0x5a8a5caf
bt ecx, 0xa5
mov cl, byte [ecx + esi - 0x2931e54]
mov edx, 0x9b10c9a9
ror dl, 0xa4
adc esi, 1
call fcn.00cbca75

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

Disassembly:
sbb ebp, 7
call fcn.0074a6be
mov eax, 0x3fb3ad90
movsx edx, al
bt eax, eax
lea eax, [esp + eax*2 - 0x7f675aec]
not edx
mov ecx, dword [edx + eax - 0x6f]
mov eax, edx
mov dword [edi + edx - 0x73], ecx
cdq
movzx ecx, word [edx + esi - 2]
push edx
jb 0x9afe93
lea esp, [esp + 0x1c]
ret
sbb word [esp + edx*8 + 1], dx
xor cx, bx
cdq
xor dl, al
not dword [esp + eax*2 - 0xde]
sbb cx, 0xd98e
not cx
ror cx, 1
inc dx
mul dl
inc cx
dec al
lea edx, [edx + eax*8 + 0x208c9938]
ror cx, 1
and eax, eax
mul al
xor byte [esp + edx*2 - 0x411c3c3f], al
xor bx, cx
idiv ax
mov word [edi + edx*2 - 0x411c81b0], cx
push eax
lea edi, [edi + edx*2 - 0x411c81b0]
call fcn.00852541
mov ebx, dword [esp + 0x18]
jmp 0x8a6d37

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

Disassembly:
movzx ecx, byte [edx + ebp - 0x680dff2]
ror edx, 0x52
mov dword [esp + edx*2 - 0x6ff68340], eax
xor cl, bl
sub cl, 0x3f
mul edx
rol cl, 1
pop edx
shr ax, 0x86
inc cl
sub al, dh
neg cl
and edx, edx
xor bl, cl
shl ax, 0xc5
rol eax, 0xfa
mov word [edx + esi - 0x848], cx
lea edx, [eax + 0x39a11001]
movzx eax, byte [ebp + eax*2 - 0x4c5b9d2]
lea ebp, [ebp + edx*2 - 0x7807d9d4]
sar dword [esp + edx*2 - 0x7807d9ce], 0xab
jb 0x931ebb
xor al, bl
xor dword [esp + edx - 0x3c03ece7], edx
dec al
ror dx, 0xed
imul dx, dx
jae 0xcd148b
xor al, 0x17
movsx ecx, dx
and dl, byte [esp + edx - 0x3c03c181]
or ecx, dword [esp + edx - 0x3c03c181]
neg al
neg edx
not al
xor bl, al
neg edx
neg dword [esp + edx*2 - 0x78078302]
lea eax, [esp + eax + 4]
movzx cx, byte [eax + edx*2 - 0x78078302]
lea edx, [edx*4 - 0x4840c7d4]
lea eax, [edx + edx - 0x3fdda0f4]
mov word [eax + esi - 0xfbedb6e], cx
movsx ecx, byte [esp + eax - 0xfbedb6c]
jl 0xca600a
lea esi, [esi + eax - 0xfbedb6e]
pop edx
jge fcn.007ab5dc
mov ebx, dword [esp + 0x10]
mov dword [esp + 0x10], 0xd687783b
mov edx, 0xd8c73b8
sal edx, 0x7c
Function at 0x73f70c
Capabilities:
Encode data using base64

Disassembly:
movzx ecx, dl
adc edx, dword [esi + eax*4 - 4]
inc ecx
cwde
mov ecx, dword [eax + esi]
shl eax, 0xe3
btc ax, ax
not edx
not ecx
sub eax, 0xab30ba01
shr dword [0xab30ba01], 1
and edx, ecx
shl eax, 0xf2
mov dword [esi + eax*2 - 0x30000000], edx
mov dword [esp + eax*2 - 0x30000000], eax
jp 0x87228e
pop ss
and byte [ebx], bl
inc ecx
movsd dword es:[edi], dword [esi]
add eax, edi
pop ebx
out dx, eax
mov esi, 0x3ced2a85
push 0x50
inc ecx
and byte gs:[ecx], ah
cmp al, 0x6a
push eax
inc ecx
adc al, ah
xor al, 0xfe
mov esi, 0xf794805f
or eax, 0xa45264db
mov al, byte [0xdd9a57e5]
lcall 0x8518, 0xa6f0c69e
push ds
into
inc esi
stosb byte es:[edi], al
sbb byte [ebp - 0x1153f2e2], al
sbb byte [ebp - 0x1a2a51e2], al
jne 0x73f786
in eax, 0x75
add cl, dh
int1
jno 0x73f783
mov esi, 0x963c1501
sti
mov esi, 0xb4858ad9
cmpsd dword [esi], dword es:[edi]
inc esp
inc ecx
mov al, byte [ebp + 0x4144a7b4]
in eax, dx
mov eax, 0x44a7e091
inc ecx
cmp esi, esi
jl 0x73f722
xor ebp, dword [edx - 0x236cba1]
jmp 0x73f791
mov eax, dword [eax + edi - 0x18000008]
adc byte [esp + 1], 0xbd
mov edx, 0xce9bec0d
not dx
sbb edi, 8
xor eax, ebx
dec eax
xor edx, edx
shr byte [esp + edx + 2], 0xa5
ror eax, 2
not eax
shr dword [esp + edx], 0x90
sal dl, 0xa1
ror eax, 1
lea ecx, [edx + edx*8 - 0x65febd6]
inc eax
dec byte [esp + edx*8]
dec dl
xor ebx, eax
or dword [esp + edx - 0xff], ecx
call fcn.0093b7a3

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

Disassembly:
lea esp, [esp + 0x10]
jne 0x77cbe7
mov eax, 0x980ab8ac
mov eax, dword [ebp]
call fcn.00cf22c9
mov eax, 0xbb89d23
bts eax, eax
dec ax
mov eax, dword [ebp + ebx*4]
call fcn.0098aa9c
mov ecx, 0xc3b638ba
mov ecx, dword [ebp]
mov edx, 0xfe1c01b3
bswap edx
movzx eax, dx
lea ebp, [ebp + eax - 0x1cfa]
sal dl, 0x46
xor ecx, ebx
rol ax, 0xc
inc al
adc eax, 0x54900a3f
lea ecx, [ecx + eax + 0x425527d]
xchg dh, dl
xchg edx, eax
mul ax
xor ecx, 0x6e347916
lea ecx, [ecx + edx + 0x6629d016]
rol ecx, 2
neg ecx
cwde
xor ebx, ecx
cwd
add edi, ecx
mov si, word [edx + esi - 0x54900000]
jmp fcn.00c67487
Function at 0x7474ec
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
bswap edx
xor ecx, ebx
mov dword [esp], 0x3c80f6bc
shr byte [esp + 1], 5
xor ecx, 0x620a3318
neg ax
ror dl, 0xa7
ror ecx, 1
jmp 0xcd8e7c

Function at 0x747583
Capabilities:
Authenticate hmac

Disassembly:
jae 0x7aaaff
mov ecx, 0x2e3fc133
imul ecx, ecx
sbb edi, 3
movzx edx, cx
inc cx
mov eax, dword [edi + edx - 0xf029]
xor eax, ebx
or ecx, 0xda2b125
adc dl, dh
and dx, 0x6ba2
xor eax, 0xce0afabf
neg eax
inc eax
xchg dh, cl
btr ecx, 0x16
neg cx
neg eax
xadd edx, ecx
xor ebx, eax
add ebp, eax
movzx cx, byte [esi + ecx - 0x2f00]
push edx
add dx, word [esp + 1]
js 0x76c2d0
mov al, byte [esi + 2]
sal dx, 0xe1
adc esi, 1
bswap edx
not cl
and edx, 0xe283633d
not al
not dx
rol dx, 0xe1
or cl, al
lea eax, [edx + edx*8 - 0x15e8a6e1]
call fcn.00858c1e
sbb edx, 0xcd055637
not cl
not edx
rol ecx, cl
xadd eax, ecx
xadd cx, ax
inc edx
xor ebx, edx
push ecx
shl eax, cl
adc ebp, edx
shl ecx, 0x8c
mov ax, word [eax + esi - 0x1dc0084]
pop ecx
lea edx, [ecx + 0x6003bae]
and cx, word [esp + ecx*2 - 0x1007e]
mov dx, word [esi + ecx]
adc esi, ecx
add ax, dx
pop ecx
add ecx, 0x6a5c
jmp ecx
Function at 0x74765b
Capabilities:
Encode data using xor

Disassembly:
add byte [edi], cl
mov edi, 0x8dac8dca
adc bh, ch
invalid
or dx, 0x2da7
adc edi, eax
add dx, dx
mov eax, 0x3acbb11
xadd edx, eax
mov ecx, dword [ebp + eax*2 - 0x7649fe9c]
sar edx, 0x77
jne 0x791274
mov dword [esp], 0xfe8b6bb9
mov edi, esi
shr edx, 8
xor edx, edi
call fcn.00837cbb
aad 0xde
or byte [ecx], al
jg 0x747603
and cl, byte [edx]
or al, 0x4b
fbstp tbyte [eax]
and cl, byte [edx]
mov word [eax], gs
ja 0x747639
and cl, byte [edx]
sbb al, 0x11
lahf
xor byte [edx], ah
dec edx
add byte [eax - 0x22dec100], cl
jnp 0x747661
mov esi, 0xbe3e58b7
add dh, ah
xor esi, dword [ebp + 0x41]
adc dword [ebx], ebx
enter 0x64, 0xffffffffffffffbf
call 0xc0c8a88a
push 0x3e02a510
in al, dx
xor ebp, dword [ecx + 0x1121]
add byte [eax], al
pop eax
sar byte [edi], 1
sar dword [eax + 0x2d], 0x50
invalid
lea ebp, [edx + ebp - 0x79]
cdq
xor ecx, ebx
or eax, edx
dec al
xor ecx, 0x26238192
bswap ecx
xchg edx, eax
ror edx, 0xb2
bswap eax
rol ecx, 1
xadd eax, edx
lea ecx, [ecx + eax*2 + 0x5d7d3100]
adc al, ah
cwd
xadd edx, eax
xor ebx, ecx
btc edx, eax
btr dx, dx
mul edx
lea esi, [edx + esi - 4]
and dx, dx
xor edx, edx
mov dword [esi + edx*2], ecx
lea ecx, [edx + 0x218d9a11]
jbe fcn.00cfe987
pop edx
cli
jmp 0x14fd3af
jp 0x78239a
mov ecx, 0xb160333
lea edx, [ecx + ecx*8 + 0x27bb8808]
mov edx, dword [ecx + ebp - 0xb160333]
lea ebp, [ecx + ebp - 0xb16032f]
xor edx, ebx
shl cx, 0x81
sub cl, 0x89
inc ecx
xor edx, 0x5103e908
call fcn.007c4fff
push 0xd5adf309
mov eax, dword [esp]
mov ecx, esi
lea edx, [eax*2 + 0x2831704]
and eax, 0x9087202a
adc al, ah
sbb esi, 4
or al, byte [esp + 2]
and al, byte [esp + 2]
neg word [esp + 1]
mov dword [esi], ecx
sbb ebp, 3
mov ecx, 0xf3b23221
mov eax, dword [ebp]
sar dword [esp], cl
xor eax, ebx
lea eax, [edx + eax - 0x6cbf2a0e]
xchg dword [esp], edx
and ecx, 0xcaa7132f
bswap eax
xor dword [esp], ecx
ror dword [esp], cl
or ecx, 0x783f7aa9
dec eax
and dx, 0xbb21
adc word [esp + 2], cx
shl dx, 0xe5
not eax
xor ebx, eax
or ecx, edx
adc byte [esp + 2], 0x92
and byte [esp], ch
adc edi, eax
pop ecx
jmp fcn.00c570a1
Function at 0x7477dc
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
movzx edx, byte [eax + esi - 0x2b392bcb]
lea esi, [esi + eax*2 - 0x5672578f]
xor dl, bl
xor dl, 0xa2
ror dl, 1
mov dword [esp + eax*2 - 0x56725788], ecx
dec dl
cbw
sal al, 0x21
dec eax
rol dl, 1
shl ecx, 0x68
js 0xc90f1c
not cl
xor ebx, eax
rol edx, cl
sub byte [esp + ecx*2 - 0x109d], 0x12
add esi, eax
not dword [esp + ecx - 0x850]
inc edx
lea ebp, [ecx + ebp - 0x851]
and cl, 0xaa
movzx eax, byte [ebp + ecx*4 - 0x2000]
not cx
rol ecx, 0xb4
xor byte [esp + edx*2 - 0x115e0002], 0x3c
xor al, bl
ror al, 1
shl cl, 0x82
sbb al, 0x15
xor ecx, edx
xor byte [esp + ecx - 0x775f003b], 0xb8
xchg byte [esp + ecx - 0x775f003d], dh
xor al, 0xbc
pop edx
dec al
or cl, cl
ror al, 1
neg al
btr cx, dx
or dl, dh
adc al, 0x14
ror dl, 0xc1
sbb edx, edx
xchg ecx, edx
rol al, 1
shr edx, 0x73
xor bl, al
sub ecx, 0x44bb95b9
push edx
lea eax, [esp + eax + 4]
not edx
shr ecx, 0x6b
mov cx, word [eax + ecx*8 - 0xbb4468]
sbb edi, 2
rol dl, 0x61
inc dword [esp]
mov eax, edx
mov word [edi], cx
pop edx
jno fcn.00c9bff2
Function at 0x7478b1
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
mov dword [esp + ecx*2 - 0x16800000], ecx
xor bl, al
rol dl, 0x41
sbb dword [esp + ecx - 0xb400000], 0x7508b71e
adc cx, dx
lea edi, [edi + ecx - 0xb410000]
neg word [esp + ecx*2 - 0x1681fffc]
xchg edx, ecx
mov word [edx + edi - 0xb40fffe], ax
xchg ecx, edx
and cl, cl
lea eax, [ecx + edx - 0x19e88b70]
lea ebp, [ebp + ecx - 0xb410002]
sal word [esp + ecx - 0xb40fffe], 0xc2
adc eax, 0x26b07a8c
mov edx, dword [ebp + ecx - 0xb40fffe]
cwde
imul ax, cx
sub dword [esp + ecx - 0xb40fffe], 0x15230484
xor edx, ebx
lea edx, [ecx + edx + 0x2b76159e]
bswap edx
dec cx
ror edx, 3
sal eax, 0x52
jb 0x8d74e5
and eax, dword [esp + ecx*4 - 0x2d03fff4]
neg edx
xor ebx, edx
add eax, dword [esp + ecx - 0xb40fffd]
neg ecx
add esi, edx
mov edx, ecx
sar dword [esp + eax*2 - 0x429aff0], 0xa9
pop edx
jb fcn.00c9bff2
in al, 0xd1
or byte [ecx], al
invalid
add cx, 0xb9af
dec al
not cx
cwde
imul dword [esp + eax - 0x35]
sar edx, 0xdd
dec cx
shl dword [esp + edx*2 + 7], 0x27
rol cx, 1
imul dword [esp + edx*2 + 7]
lea edx, [eax + eax - 0x2aeb214d]
xor cx, 0xd72f
or al, al
xor bx, cx
add dl, dh
add dword [esp + eax*2 - 0x48e105f8], eax
mov word [edi + eax - 0x24708302], cx
sal dword [esp + eax - 0x247082ff], 0x8b
lea edi, [eax + edi - 0x24708302]
pop ecx
pop eax
pop edx
jbe fcn.0087275e
test al, 0x2a
movsd dword es:[edi], dword [esi]
aaa
je 0x78ccf9
add dword [ecx + 0x4cb068ff], 0xff81814e
invalid
add byte [edi], bl
jno 0x78cd26
aas
jecxz 0x78cc70
out dx, eax
dec byte [edi]
cdq
imul dword [eax - 0x40]
lds esp, [ecx + esi*4 - 0x3a3f9729]
mov word [ebp - 0x3a335bdf], es
cwde
test edx, edx
mov cl, 0xd7
push 0x858cc5c0
and dword [esp + ecx*8 - 0x2d7a673b], esp
aam 0x45
hlt
aas
cmp al, byte [eax]
sub ah, byte [ebp - 0x7e0d63c9]
cmp edi, 0x96583ae4
add dword [ecx - 0x239de701], 0x16e232d
mov gs, word [eax + 0x22]
inc byte [ebp - 0x22ac0e9d]
sub byte [esi + 0x626686e8], dh
adc eax, 0xaee061cc
popal
loopne 0x78ccaa
scasd eax, dword es:[edi]
sbb edi, dword [edx]
sub al, 0x16
js 0x78ccbb
fadd st(5)
scasb al, byte es:[edi]
pushfd
clc
jnp 0x78cccf
pop ecx
mov al, byte [0xf104e580]
push esi
mov dl, 0x9b
std
pop ecx
cmp cl, byte [eax - 0x4df0e191]
push 0xcff768bd
sbb dword [eax], eax
cdq
cld
scasb al, byte es:[edi]
in eax, 0x8e
inc ebp
cmp bl, cl
xchg esi, eax
stosd dword es:[edi], eax
popfd
dec edi
outsb dx, byte [esi]
dec ecx
cli
mov cl, 0x47
rcr byte [eax], 0xf5
imul ebx, eax, 0x1c
stosd dword es:[edi], eax
push ss
dec ecx
or al, 0x6e
lcall 0x17c3, 0xdb6c5dc5
and al, 0xd4
pop ss
sbb edi, dword [eax + 0x14f903b2]
mov ecx, 0x49fcdf8d
aam 0xe1
invalid
bts eax, eax
call fcn.0081b1a4
xchg dword [esp + edx*2 - 0x719b24e], edx
movzx ecx, word [esi + edx - 0x7b000008]
idiv ax
xchg edx, eax
sal edx, 0x72
lea esi, [eax + esi - 0x7b004066]
shl eax, 0x30
adc dword [esp + eax - 0x405dfff8], 0x1b90bbf
xor cx, bx
or dword [esp + eax - 0x405dfff9], 0x8dbb893a
and dword [esp + eax - 0x405dfff8], 0xa421aa1b
xchg byte [esp + eax - 0x405dffff], al
xor cx, 0xf111
jmp 0x78cc1e
Function at 0x74bd0d
Capabilities:
Execute syscall

Disassembly:
mov byte [ecx], dl
push eax
movsx ecx, ax
movzx ecx, byte [ebp - 6]
cbw
mov edx, 0x2fa66427
imul edx
sbb ebp, 6
xor cl, bl
neg dword [esp + 8]
neg byte [esp + 1]
not eax
xor cl, dl
add cl, dl
mov byte [esp + eax - 0x5f4cc842], al
xor cl, 0x83
inc al
inc dword [esp + eax - 0x5f4cc84e]
neg cl
rol cl, 1
shr eax, 0x54
mov dword [esp + eax*8 - 0x2f9c], 0xd68a892e
not edx
xor bl, cl
idiv al
cwd
lea ecx, [esp + ecx + 0xc]
inc dword [esp + eax*2 - 0xfa]
xor dl, byte [ecx + eax*4 - 0x204]
movzx ecx, word [esp + eax - 0x79]
xchg byte [esp + eax*2 - 0xf7], al
lea eax, [esp + eax - 0x39]
xor word [esp + ecx - 0x8bfe], 0x24ac
js 0x8ba20a
xchg dword [esp + ecx - 0x8bf6], ecx
mov byte [eax], dl
shl byte [esp + 5], 0x44
pop eax
pop ecx
pop eax
jmp edi
jo 0x93c6bb
sysenter
call fcn.00cc2b2c
and edx, eax
shl dl, 0x83
movzx eax, byte [edx + edi - 0x200]
lea edx, [edx + edx*8 + 0x73077399]
mov ecx, 0x89168232
adc edx, 0x213a45ba
xor al, bl
xadd dl, ch
shr edx, cl
rol al, 1
dec dl
neg al

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

Disassembly:
inc ebp
xor edx, ecx
pop eax
inc esp
movzx eax, cl
push ecx
inc ecx
xor edx, 0x96a5a9a8
inc ebp
movsx esi, ax
dec eax
or ecx, dword [esp + edx - 0x30]
inc ebp
lea edx, [edx + ebx - 0x45455b75]
push edx
jge 0x9af38b
mov edx, dword [esp + 0xa]
pop ecx
pop edx
pop eax
pop eax
jno fcn.0087275e
jae 0xc513f8
inc ecx
xor edx, 0x653d2192
call fcn.008f33e6

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

Disassembly:
push 0xe10d848b
mov dword [esp + 4], esi
push 0x7f1263be
call fcn.007ce592

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

Disassembly:
lea eax, [esp + eax + 0xc]
bts dx, dx
call fcn.0096e2b5

Function at 0x7515fb
Capabilities:
Encode data using base64

Disassembly:
push 0xc98b6faf
lea esp, [esp + 0xc]
je 0xcd9ed8
mov eax, 0x1b0d2b1d
bswap eax
mov eax, dword [ebp + ebx*4]
push 0xb8a88d95
mov dword [esp], eax
jmp 0x83dd45
call fcn.0082626c
call eax
mov ebx, 0xb910720b
mov ecx, ebx
and ecx, 0xbd3f121d
mov ebp, dword [ebp - 4]
mov dword [ebp], eax
movsx esi, cx
pop ebx
sar esi, 0x73
shl si, cl
pop edi
pop esi
lea eax, [ecx*2 - 0x765ac3ec]
sbb esi, 4
mov ecx, dword [esi]
xor ecx, ebx
sal eax, 0xff
movzx edx, al
rol ecx, 1
or al, 0x92
ror eax, 0x9b
bswap ecx
not dx
dec eax
adc ecx, 0xc52e29b5
jmp 0xc43c3b
mov eax, 0xe256e3a
not eax
mov eax, dword [ebp]
jmp 0x8ee8df
shr eax, 0x8e
btc dx, 0xbe
not ecx
neg ecx
xor ebx, ecx
not ax
add edi, ecx
sar dx, 0xf
jmp edi
jmp 0x901fda
Function at 0x751d79
Capabilities:
Encode data using base64

Disassembly:
dec dword [esp + 5]
add esi, 4
mov dword [esp], 0x52b7ac8f
xor edx, edx
push 0xf70ceb04
add word [esp + 0xd], 0xf3b0
shr dword [esp + 0xc], 0x8b
test eax, eax
jmp 0xc85cf9
call fcn.008ec0c6
mov eax, 0x272ac488
lea esi, [esi + eax*2 - 0x4e558914]
push eax
sar eax, 0x7d
or dword [esp + eax - 1], eax
mov ecx, dword [esi + eax - 1]
movsx edx, al
xor ecx, ebx
ror ax, 0x2f
and ax, word [esp + eax - 2]
btc dx, ax
adc ecx, eax
xor ecx, 0xd7382c06
rol word [esp + eax + 1], 0x81
jb 0x9a077a
sub word [esp + eax], dx
neg ecx
not ecx
rol ecx, 2
xor ebx, ecx
btr edx, edx
adc dword [esp + eax], edx
add dword [esp + eax], eax
adc edi, ecx
or byte [esp + eax*2 + 1], 0x99
movzx ecx, al
not dl
lea esi, [esi + eax - 1]
bt edx, edx
or cl, byte [esi + edx*2 - 0x1fe]
xor cl, bl
or eax, 0x139c44b5
neg cl
or al, byte [esp + eax - 0x139c44b4]
adc cl, 0xa
dec word [esp + eax - 0x139c44bd]
xor cl, 0xb5
xadd dx, ax
xor cl, al
xor bl, cl
and eax, eax
lea ecx, [esp + ecx + 4]
neg eax
btr ax, dx
sal edx, 0xa7
mov eax, dword [ecx + edx*8 - 0x116f000]
jbe 0x97b26f
lea ebp, [edx + ebp - 0x22de04]
mov dword [ebp + edx*2 - 0x45bc00], eax
lea eax, [edx*8 + 0x4501f63d]
movzx ecx, al
pop ecx
jae fcn.00754c95
add edi, edx
xor eax, eax
adc eax, dword [esi + eax*2]
mov edx, dword [esi + 4]
neg cx
jne 0xd0658c
mov ecx, dword [ebp]
mov edx, 0xc397ce30
mov eax, edx
not edx
lea ebp, [ebp + edx*2 - 0x78d0639a]
xor ecx, ebx
push edx
inc edx
lea ecx, [ecx + edx*2 + 0x475cc001]
push edx
sar eax, 0x2c
neg ecx
add dl, 0x1c
inc ecx
call fcn.009aecc6
push 0xbb17c72c
lea esp, [esp + 0x14]
je 0xcd27bc
jmp 0x8ce2ac
mov ecx, 0x51a2b43e
bt cx, 0x1c
mov eax, ecx
not edx
mov dword [esi + eax - 0x51a2b43e], edx
movzx edx, cx
or ecx, ecx
jmp edi
adc esi, 7
shr ecx, 0x93
mov dword ss:[eax + ecx*2 - 0x2568], edx
movsx eax, cl
ror ax, 0x2e
mov dword [esp + ecx*2 - 0x2568], edi
ret 0xc
Function at 0x752370
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
mul cl
setno al
or cx, word [edi + eax - 0x3b7f0001]
sar eax, 0x91
mov dword [esp + eax*4 - 0x76fc], eax
mov dx, word [edi + eax - 0x1dbd]
push eax
cwde
lea edi, [edi + eax*2 - 0x3b7c]
xchg word [esp + eax*8 - 0xedf1], ax
jb 0x753558
and al, 0x80
or cx, dx
not cx
cwde
and ax, ax
mov word [edi], cx
sal dword [esp + 0xa], 0xf8
ja 0x869285
mov eax, 0x2b017d9f
movzx eax, byte [eax + ebp - 0x2b017d9f]
xor al, bl
push 0xeb89de85
sar dword [esp], 0x41
adc al, 0x23
mov edx, dword [esp]
push edx
jmp 0x9a7f6e
pop edx
btr edx, 0x2e
adc edi, ecx
movsx ecx, dl
and al, cl
shl edx, 0x7c
mov edx, dword [esi + edx + 0x4ffffffc]
adc cx, cx
jns 0xce9321
mov ebx, 0x80a66c8b
movsx eax, bx
btc bx, ax
mov esp, edi
lea ebp, [ebx + ebx + 0x1d08a78a]
popfd
pop eax
push ebx
mov edi, dword [esp + ebp*4 - 0x7955c27c]
push ebx
pop ebx
mov ebp, dword [esp + ebp*4 - 0x7955c278]
jmp 0xcaec28
mov ecx, dword [eax + ebp - 0x2f4e]
xor ecx, ebx
xadd dword [esp + eax - 0x2f4b], eax
movsx edx, byte [esp + 4]
xor ecx, 0xb081a899
lea ecx, [ecx + edx*8 - 0x4495599b]
or edx, 0x472aff9e
jno 0x96a005
rol ecx, 3
pop edx
sub al, ah
ror dword [esp + edx - 0x2f500a], 0x1e
bswap ecx
and dx, word [esp + edx*8 - 0x17a804f]
inc eax
neg ecx
xor ax, 0x15a3
mul eax
ror ecx, 3
sal eax, 0xa
xor ebx, ecx
jmp 0x7afa25
xor al, 0x16
movzx ecx, dl
push edx
ror al, 1
xor cl, dh
inc al
and dword [esp + ecx - 0xa8], ecx
rol dword [esp + ecx*4 - 0x2b1], 0x14
xor bl, al
lea eax, [esp + eax + 0xc]
not word [esp + ecx - 0xa5]
mov edx, dword [eax + ecx*2 - 0x15a]
pop ecx
movzx eax, word [esp + 1]
dec eax
mov dword [esi + eax*2 - 0x5ea2], edx
lea ecx, [eax + eax*8 - 0xc7621ef]
jno 0x8cbc09
out dx, eax
popal
pop ebp
imul eax, dword [edx + 0x615daaab], 0x6f
inc esi
cmpsd dword [esi], dword es:[edi]
stosb byte es:[edi], al
pop ebp
popal
pop ds
pop ss
mov bl, 0xaa
pop ebp
popal
arpl word [ebx + 0x27], bp
aam 0x4d
pushal
sub al, 0x41
pop ds
mov esp, dword [eax - 0x57]
cmpsd dword [esi], dword es:[edi]
neg cl
and eax, 0xbce0d3fe
xor eax, 0x21bb5cb8
int3
mov ecx, dword [esp]
call fcn.00c62f10

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

Disassembly:
inc ecx
not eax
inc ebp
btc edx, esp
dec esp
mov dword [esp + edi*2 - 0x6e], edi
inc esp
xor esi, ecx
inc ecx
xor eax, 0xcc8f3eb3
dec eax
btr edi, 0x36
push ecx
push edi
inc ecx
dec eax
inc ecx
mov edx, esp
jmp 0xc61efb