joyce8/EMBER2024-capa huggingface dataset:
Function at 0x743f18
Capabilities:
Authenticate hmac
Encode data using base64
Encrypt data using speck
Parse credit card information

Disassembly:
ror eax, 0xb6
xor ebx, edx
mov dword [esp + eax - 0xfe92239], ecx
bt eax, 0x8e
or byte [esp + eax - 0xfe92236], 0xa1
adc edi, edx
lea edx, [eax*8 + 0x5d0bf18c]
and word [esp + eax - 0xfe92239], 0x380a
mov esi, dword [esi + eax*8 - 0x7f4911c8]
and edx, dword [esp + eax - 0xfe92239]
pop ecx
pop edx
jno fcn.008001e8
mov eax, 0xc2246302
add ax, 0xbb32
mov eax, dword [edi]
mov edx, 0x129dda2a
inc edx
neg dx
mov ecx, dword [edi + edx*2 - 0x253a4ba6]
sal edx, 0x8e
bt dx, dx
lea edi, [edx + edi - 0x49753ffc]
lea edx, [edx + 0x3ea537ae]
dec edx
not eax
not ecx
adc edx, 0x8c202aad
or edx, edx
or eax, ecx
btc dx, dx
mov dword [edi + edx*2 - 0x28754cb4], eax
lea ecx, [edx + edx*8 - 0x17770b46]
sbb cx, dx
mov ecx, dword [esi + edx*2 - 0x28754cb4]
lea edx, [edx + edx + 0x77293413]
lea eax, [edx*2 - 0x1472a1f8]
imul dx
lea esi, [eax + esi - 0x2aca4d96]
imul al
xor ecx, ebx
bts edx, eax
xchg edx, eax
jb 0xb6970b
mov edx, 0xfb3a07bf
sub dx, dx
movzx ecx, dl
mov eax, dword [ebp + ecx*2]
inc cx
lea ebp, [ebp + ecx*8 - 4]
neg dx
xor eax, ebx
btc dx, 0x21
bswap edx
bswap eax
call fcn.00bc3ebd
neg edx
bswap edx
and cx, 0xfc0a
neg edx
ror edx, 2
movzx eax, cx
inc eax
add cx, cx
not edx
sbb cl, 0x12
or ecx, eax
dec edx
not edx
and ax, cx
shr ecx, cl
xor ebx, edx
add edi, edx
movzx edx, word [ebp + ecx*2 + 4]
inc cx
or eax, 0x66109205
xor dx, bx
rol dx, cl
add ecx, eax
neg dx
imul ecx, eax
not dx
lea ecx, [ecx*8 - 0x396e8cff]
rol eax, cl
or cl, cl
dec dx
inc ecx
xor bx, dx
bts cx, cx
ror ecx, cl
mov word [esi + eax*2 - 0x48359844], dx
movzx eax, byte [eax + ebp - 0x241acc1b]
adc ecx, 0xd9022036
movzx edx, cx
lea ebp, [ebp + edx - 0xfa2a]
xor al, bl
rol dl, 0xe7
dec al
and dx, dx
ror dl, 0x22
ror al, 1
sub al, 0x38
dec cx
neg al
lea ecx, [edx*2 - 0x549937e]
not al
imul edx, ecx
sub dl, ch
rol al, 1
xor bl, al
sar dx, 0xc4
xor ecx, edx
adc eax, esp
sub cl, 0x3a
jp 0x7989b4
mov ecx, 0xc91922b1
movsx eax, cx
mov eax, dword [eax + ebp - 0x22b1]
not cx
rol cx, 6
btr cx, cx
mov edx, dword [ebp + 4]
not eax
sal cl, 0x46
not edx
sbb ecx, ecx
not ecx
sets cl
and eax, edx
mov dword [ecx + ebp + 3], eax
movsx edx, cl
shr edx, cl
mov eax, 0x66aaf89f
mov ecx, dword [esi + ecx*2 - 6]
lea esi, [esi + edx*2 - 4]
shl ax, 0x2f
btr dx, 0x99
xor ecx, ebx
shr ax, 0xc6
shr eax, 0x68
not ecx
mul ax
and dl, ah
inc ecx
cwd
xor ecx, 0x82057886
and dl, dl
jns fcn.007953b0
dec ecx
cbw
shl dl, 0xe7
btc dx, 0xd
bswap ecx
neg eax
or edx, eax
xor ebx, ecx
push edx
add edi, ecx
call fcn.00c4c6a7
mov ecx, dword [eax + edx - 0x45e7f8a3]
lea eax, [edx*4 - 0x7546234d]
rol al, 0xc1
mov dword [esi + edx - 0x45e7f8a9], ecx
setge al
push eax
lea esi, [esi + edx - 0x45e7f8a9]
mov ecx, dword [esp + edx - 0x45e7f8a3]
pop edx
jns fcn.008001e8
mov ecx, 0xd3852996
shl ecx, 0xf8
movzx eax, cx
xor al, byte [eax + edi]
movzx edx, cl
sar dx, 0xca
lea edi, [edi + edx*4 + 1]
call fcn.00884527
ror ecx, 2
neg ecx
bswap ecx
shl edx, 0x78
neg ecx
dec edx
neg eax
add eax, eax
xor ebx, ecx
ror edx, 0xae
add ebp, ecx
movsx ecx, ax
ror eax, 1
bswap ecx
jmp ebp
Function at 0x74415e
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
mov ecx, dword [esi + edx - 0x573b4c9f]
mov dword [esp + edx - 0x573b4c9f], edx
mov eax, edx
shr dword [esp + edx - 0x573b4c9f], 0xdb
xor ecx, ebx
push eax
not ecx
bswap ecx
push eax
not edx
rol ecx, 1
and eax, dword [esp + eax - 0x573b4c97]
sbb ecx, 0x982aef8d
xor ebx, ecx
cwde
add dword [esp + eax*2 - 0xd], eax
adc edi, ecx
lea ecx, [eax + edx - 0x415a2270]
mov eax, ebp
push edx
pop edx
btc edx, 0x8c
lea ebp, [ebp + ecx - 0x676a90fc]
xor dword [esp + ecx - 0x676a90f4], 0xfc024433
btr edx, 0x84
inc edx
mov word [ebp + ecx - 0x676a90fa], ax
lea eax, [ecx + ecx*4 + 0x462a249e]
pop eax
pop edx
pop eax
jno fcn.008c0304

Function at 0x74d24e
Capabilities:
Encrypt data using speck

Disassembly:
push 0xd2a9ff33
mov dword [esp + 4], eax
shr word [esp], 0xad
sar byte [esp + 2], 0x47
jp 0xc639db
push esi
mov esi, 0x513b7089
bswap esi
movzx esi, byte [ecx]
call fcn.00b5ae5a
jmp 0x8824da
dec ebx
call fcn.00714e18
jmp 0xc60586

Function at 0x74eca9
Capabilities:
Encrypt data using speck

Disassembly:
mov eax, dword [ebp + ebx*4]
mov dword [esp], 0x6d013023
jmp 0x8cdb8b
mov dword [esp], eax
push 0x68379e80
shr byte [esp], 0x82
js 0x7c1215
dec ebx
push 0x7ad5db1
lea esp, [esp + 8]
jne 0xc3bc6f

Function at 0x74ed2f
Capabilities:
Encrypt data using speck

Disassembly:
mov dword [esp + 4], eax
mov dword [esp], 0x2232a19d
dec ebx
lea esp, [esp + 4]
jne 0x7f13e8
mov eax, dword [ebp]
call eax
mov edx, 0x741ac807
mov ebp, dword [ebp + edx - 0x741ac80b]
call fcn.0080ad3a
mov eax, 0x4a1d933d
sal eax, 0x21
mov eax, dword [ebp + ebx*4]
call fcn.0088a45e
or byte [edx + ebx*2 - 0x25], ch
jp 0x7f1415
cwde
dec ecx
sub al, 0x4a
cwde
dec ecx
inc esi
push esi
cmp bl, byte [eax + 0xa3c6749]
imul edx, dword [ebx + ebx*8 - 0x19], 0xf7bdc8f6
push cs
enter 0xfffffffffffff7bd, 0xe
inc bl
int 0x5d
cli
aad 0xee
xchg bh, cl
in al, 0x4f
adc eax, 0x8e94dff
mov ecx, 0x8e65bcf
pop eax
invalid

Function at 0x750f19
Capabilities:
Encrypt data using speck

Disassembly:
lea eax, [edx + ecx*8 - 0x7b5142ef]
dec word [esp + edx*2 - 0x674]
pop ecx
pop ecx
jle fcn.007e2cc2
mov edx, 0x4b800839
add dx, dx
jno 0x8b7687
mov edx, 0x370b5116
mov edx, dword [ebp + edx*2 - 0x6e16a22c]
mov eax, 0x60b6cd2d
btc eax, eax
movsx ecx, ax
lea ebp, [eax + ebp - 0x60b6ed29]
xor edx, ebx
push eax
xchg byte [esp + eax - 0x60b6ed2b], al
neg edx
lea edx, [edx + eax + 0x23cffb50]
inc dword [esp + eax - 0x60b6edb6]
call fcn.00c6946d
push edx
adc ebp, eax
or dword [esp + 3], ecx
not dx
mov si, word [esi]
pop eax
pop eax
jl fcn.007ce4d4

Function at 0x7535fb
Capabilities:
Encrypt data using speck

Disassembly:
pop ebp
pop eax
movsx edx, bx
lea edx, [ebx*8 - 0x2f6d6d6f]
pop edx
call fcn.008a9616
Function at 0x75360d
Capabilities:
Encrypt data using speck

Disassembly:
jmp 0x7ca322
xor esi, ecx
jmp 0x8dee11
lea eax, [edx*2 - 0x3376a66a]
sub ax, 0xe3d
inc ecx
bswap ecx
rol edx, 0xfd
sar dx, 0x45
dec ecx
ror ecx, 1
add dl, 0x2f
lea eax, [edx*2 + 0x58b53927]
xor ebx, ecx
add ebp, ecx
mov eax, esi
lea esi, [edx + esi - 0x2080003b]
lea edx, [edx + edx*4 - 0x67fde95f]
rol edx, 0x33
movsx ecx, dx
mov dword [esi], eax
mov eax, ecx
neg al
jle fcn.007e2cc2
jmp 0x826ce3
dec edx
lea edi, [edi + edi - 0x34]
inc ebp
movzx ebx, bp
inc ecx
mov edx, dword [edi + edi - 0x30]
inc ecx
xor edx, esp
neg edx
inc ecx
mov eax, edi
sub edx, 0xdb01fa20
inc esp
sub bh, al
sal al, 0xe4
inc eax
movsx ebp, dh
rol edx, 2
inc ebp
mov eax, edi
not edx
inc edx
inc esp
movsx edx, bp
inc ecx
push esp
inc ecx
or dh, al
call fcn.008d73da
mov ecx, 0x4126083a
movzx edx, cx
sar ecx, 0xe2
mov ecx, dword [edi + ecx - 0x1049820e]
btc edx, edx
dec edx
lea edi, [edi + edx*4 - 0x100020e0]
xor ecx, ebx
jmp 0x788f73
and esi, 0xff
push 0x7c27fb14
mov esi, dword [esi*4 + 0xc3e4c0]
push 0x81052198
shr ecx, 8
call fcn.00844ef5
jmp 0x71ae82
jmp 0x848adf

Function at 0x758fae
Capabilities:
Encrypt data using speck

Disassembly:
and word [esp + 6], ax
imul dword [esp + 4]
mov dword [esi - 4], ecx
lea eax, [esi - 4]
mov ecx, edx
mov dword [esi - 8], eax
adc esi, 0xfffffff8
pop eax
pop eax
jmp fcn.007e2cc2

Function at 0x75a49b
Capabilities:
Encrypt data using speck

Disassembly:
lea ebp, [ebp + edx*2 - 0x7419ffff]
mov dword [esp + edx - 0x3a0d0000], edx
bts edx, 0x1a
xor al, bl
sar edx, 0x9e
ror dx, 0x44
ror al, 1
jmp 0x8ebeed
push eax
pop ecx
jmp fcn.007e2cc2
imul dx, word [esp + edx*2]
btr dx, 0x2e
dec al
bt edx, 0x83
not word [esp + edx*2 + 4]
ror edx, 0x31
rol al, 1
xor dword [esp + edx*2 + 1], 0xb73d1534
ja 0xc26338
mov ax, word [edi]
call fcn.00c76be1
mov eax, 0x9e0dc695
mov ecx, dword [edi]
shr ax, 0xc1
bts ax, 0x17
ror eax, 0x13
adc edi, 3
rol al, 0xe1
adc eax, eax
movzx edx, ax
xor ecx, ebx
inc ecx
xchg ah, al
shr edx, 0x3b
inc dl
not ecx
shl al, 0xe1
not eax
idiv ax
dec ecx
add eax, 0x41bee804
neg ecx
cdq
rol ecx, 2
inc eax
shr dl, 0x64
sbb ecx, 0xc62d9a98
xor al, ah
xor ebx, ecx
add eax, eax
imul ax
dec eax
add ebp, ecx
idiv eax
lea ecx, [eax*8 + 0x4b102000]
mov esi, dword [esi + eax - 0x54f30]
jmp 0x79f359
shr edx, 0xc9
dec al
xadd dword [esp + edx*4 + 1], edx
shl dx, 0xa5
sbb edx, 0x410fa68e
xor bl, al
call fcn.00845689
lea ecx, [edx + 0x36a87398]
inc al
mov dword [esp + edx - 0x6d7d7ff8], edx
shl dl, 0xe2
xor bl, al
lea eax, [esp + eax + 0xc]
sub dword [esp + edx - 0x6d7d7ff8], 0x5aa46b97
shr ecx, 0x19
jns 0xc60426
mov ecx, dword [ecx + eax - 0x52]
shl dword [esp + edx - 0x6d7d7ff8], 0xe7
lea eax, [edx*4 - 0x5df04550]
dec eax
mov dword [edx + esi - 0x6d7d8008], ecx
lea esi, [esi + eax - 0x5805bab7]
sbb word [esp + edx - 0x6d7d7ff9], ax
mov ecx, dword [esp + edx - 0x6d7d7ff8]
mov ecx, dword [edx + ebp - 0x6d7d7ffb]
xchg dword [esp + edx - 0x6d7d7ff8], eax
push edx
btc edx, 0x22
lea ebp, [ebp + edx - 0x6d7d7ffb]
rol word [esp + edx - 0x6d7d7ff9], 1
push eax
xchg dword [esp + eax - 0x6c8a34bd], edx
xor ecx, ebx
xor eax, dword [esp + edx*2 - 0x5f80018f]
call fcn.0081fdb7
Function at 0x76071a
Capabilities:
Authenticate hmac
Encrypt data using speck

Disassembly:
push edi
movzx esi, di
pushfd
pop esi
mov dword [esp + edi - 0x7256f134], esi
mov esi, edx
shr edi, 0xe2
dec dword [esp + edi - 0x1c95bc4e]
mov edi, eax
cld
push 0x1eb9dc32
neg byte [esp + 2]
jne 0x8e74e1
mov edx, 0xeab6d1aa
movsx ecx, dx
mov ecx, dword [edi]
add edi, 4
mov eax, edx
not dl
xor ecx, ebx
or eax, edx
xchg edx, eax
neg ecx
ror ecx, 1
sal edx, 0x49
neg ecx
cbw
btc dx, ax
shl eax, 0xfd
rol ecx, 2
dec edx
not ecx
dec edx
xor ebx, ecx
cwd
add esi, ecx
mul edx
inc ax
mov ebp, dword [ebp + eax - 1]
sbb dl, 0xa0
cwde
cdq
jno fcn.007ddd9d
rep movsb byte es:[edi], byte [esi]
mov edi, 0x3fa8a381
shr dword [esp + edi - 0x3fa8a37d], 0x7c
push dword [esp + 8]
popfd
call fcn.0089a33a

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

Disassembly:
jmp ebp
lea esp, [esp + 8]
ja 0x73a069
mov eax, 0x74304a08
mov eax, esp
mov ecx, 0x103829a8
dec cx
lea ecx, [ecx - 0x1038293b]
jp 0x776c84
mov edx, 0x442bef83
bts edx, edx
lea edx, [edx + esi - 0x442bf00b]
and edx, 0xfffffffc
call fcn.008b9fa1

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

Disassembly:
mov dword [esp], edx
call fcn.0070cf6c
Function at 0x76562e
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
mov dword [esp], eax
add esi, 4
cdq
xor ecx, ebx
sub ecx, 0x12ab098e
dec word [esp + 2]
xor ecx, edx
shl dword [esp], 0xff
neg ecx
xor dword [esp], eax
ja 0xb33521
xchg byte [esp + edx - 0x701b], dh
movzx ax, byte [ecx + edx*4 - 0x78]
mov word [ebp + edx*4 - 0x7a], ax
shr dword [esp + edx*2 - 0x3c], 0x74
mov ecx, dword [edx + edi - 0x1d]
or dword [esp + edx - 0x1e], edx
xor ecx, ebx
inc ecx
btc edx, 0x21
movzx eax, dl
xor ecx, 0xe8a5979a
ror ecx, 3
pop eax
or al, ah
neg ecx
xor ebx, ecx
add esi, ecx
mov ecx, 0x18274ab0
btr eax, edx
mov dl, byte [edi + edx*4 - 0x6b]
dec eax
not eax
bt ecx, 0x96
lea edi, [edi + ecx*2 - 0x304e955a]
jae 0xb9eb5d
mov ax, word [esi + 2]
add byte [esp + 3], 0xb9
adc esi, 1
pop edx
shl dx, 0x67
rol edx, 2
not cx
btr edx, 0xbb
lea edx, [edx*8 + 0x30ae70bb]
btr dx, dx
not ax
sub edx, 0xb20bea03
bts edx, 0xa4
setb dl
or cx, ax
sar edx, 0xbe
mov eax, edx
or dl, 0x36
mov word [edx + esi - 0x36], cx
movzx ecx, dx
btr eax, edx
mov edx, dword [edi + edx*2 - 0x6c]
call fcn.007d8801
dec edx
lea edi, [edi + esi - 0x349b2004]
inc ebp
movzx ebx, dh
inc ebp
xor edx, esp
inc ecx
mov edx, esi
inc ecx
movsx ecx, dh
dec ebp
add esi, ebx
inc ecx
dec edx
movzx ebp, dl
inc ecx
not edx
dec esp
xor esi, ecx
dec eax
lea esi, [ecx + ebp*4 + 0x3e30b627]
and si, 0x3910
inc ecx
neg edx
inc ecx
not edx
inc ecx
push esp
inc eax
ror ch, 0xc5
inc esp
movzx edi, si
dec eax
bts ebp, ebp
inc esi
xor dword [esp + ebx], edx
inc eax
movsx eax, dh
inc ecx
pop esp
inc eax
or dh, cl
dec eax
add ecx, esi
dec ebp
arpl dx, dx
neg dl
sar dx, 0x48
cbw
dec ecx
adc ebx, edx
dec ecx
and esi, 0x86058236
cbw
xchg dh, cl
inc edi
adc ebx, dword [esi + ecx - 0x4010000]
not si
inc ebp
movzx edx, di
inc ebx
mov esi, dword [ecx + esi*2 - 0x801fffc]
inc esp
movsx eax, cl
inc eax
shl ch, 0xa1
inc cx
adc edx, edx
inc esp
and ebx, esi
inc ecx
mov esi, edi
bswap edx
inc ecx
not ebx
inc ebp
movzx ebp, si
dec ecx
ror edx, 0x8a
inc edi
mov dword [esi + ecx - 0x400fffc], ebx
dec esp
xchg ebp, edi
inc eax
xor ch, ch
btc dx, ax
dec ebx
lea edx, [esi + ecx - 0x400fffc]
dec ebx
mov dword [ecx + esi*4 - 0x10040004], edx
push ecx
dec edi
lea ecx, [esi + ecx - 0x4010004]
inc ecx
pop ebp
jae fcn.008a1785
add cl, 0x15
neg dl
ror ax, 0x44
rol dl, 1
not cl
xor bl, dl
add edx, esp
movzx ax, byte [edx + ecx*2 - 0x100e95b4]
mov word [ecx + ebp - 0x8074ade], ax
lea ebp, [ecx + ebp - 0x8074ade]
jmp fcn.007ddd9d
xor dl, bl
cwde
and ecx, 0x698f4e19
rol dl, 1
sub dl, 0x24
jmp 0xb56798

Function at 0x7657e5
Capabilities:
Encrypt data using speck

Disassembly:
lea edi, [edi + eax*4 - 0x6ebb4002]
cdq
mov word [edi + eax*2 - 0x375da000], cx
or edx, dword [eax + ebp - 0x1baed000]
lea ebp, [ebp + eax*4 - 0x6ebb3ffc]
mov dword [esp + eax - 0x1baed000], eax
lea ecx, [eax*2 - 0x535a5c57]
neg ecx
xor edx, ebx
not edx
rol edx, 1
not ax
pop eax
or eax, 0x1c338e02
xor edx, 0x9008909b
shl al, 0xa2
sal cl, 0xc6
rol edx, 1
btr eax, eax
jae 0x82b3c9
shr ax, 0x8e
xor ebx, edx
add esi, edx
sal al, 0xc4
ja fcn.0070334b
Function at 0x769780
Capabilities:
Encrypt data using speck

Disassembly:
mov dword [esp + ecx*4 - 0xb8], ecx
lea edi, [edi + ecx*2 - 0x58]
add dword [esp + ecx*8 - 0x170], edx
sal cx, 0x88
xor eax, ebx
not edx
not eax
push ecx
lea eax, [eax + edx*8 - 0x5df1e760]
not eax
xchg byte [esp + edx - 0x24f62fc9], dh
push edx
neg eax
sub word [esp + edx*2 - 0x49edb79b], cx
dec dl
xor ebx, eax
call fcn.00815ae4
push ecx
ror eax, 3
dec dword [esp + ecx - 0x379d4b10]
dec eax
rol ecx, 0x7a
rol ecx, 0xb7
pop edx
rol eax, 1
add cx, 0xc3b0
cmovae cx, word [esp + edx - 0x379d4b12]
lea eax, [eax + ecx + 0x50e998cf]
xor ebx, eax
or dl, dl
jnp 0x861e1f
not dword [esp + edx*2 - 0x6f3a9628]
adc edi, eax
shl edx, 0xb7
pop edx
xor edx, edi
jmp edx
rol cx, cl
xor eax, 0xc7b153a9
and ecx, ecx
jns 0xb49a8d
mov eax, 0xb7286724
mov ecx, dword [edi]
movsx edx, al
sal ax, 0xe4
jns 0x82fdc8
lea edi, [edi + edx*8 - 0x11c]
idiv eax
or al, 0x81
cdq
xor ecx, ebx
btr edx, eax
lea ecx, [edx + ecx + 0x6c3b5285]
rol ecx, 2
xor ecx, eax
neg dl
push edx
xchg dword [esp + edx - 0x7fffff01], edx
bswap ecx
add dword [esp + edx - 0x7fffff01], 0xa598a929
xor ebx, ecx
add ebp, ecx
sal word [esp + edx - 0x7fffff00], 0xc2
mov dx, word [esi + edx - 0x7fffff01]
inc eax
lea esi, [esi + eax*4 + 2]
jo 0x8a63c1
movsx ecx, al
inc dword [esp + eax]
or cl, byte [edi + eax*4]
mov word [esp + eax + 2], 0x6a12
lea edi, [edi + eax + 1]
shr dword [esp + eax*2], 0xbc
shr al, 0xc1
dec word [esp + eax*8 + 2]
xor cl, bl
sal eax, 0x43
neg cl
inc eax
inc al
ror cl, 1
not cl
sal eax, 0xa4
inc cl
push eax
xor cl, 0x83
sub cl, 0x81
xor bl, cl
xor ax, ax
lea ecx, [esp + ecx + 8]
mov word [ecx + eax], dx
bswap eax
movzx ecx, al
mov dword [esp + eax], ebp
ret 4
jno 0x773d6d
cwde
dec ecx
xadd dword [esp + edx - 0x57448463], eax
shr dword [esp + edx - 0x57448463], 0x22
call fcn.007390fe
sub ecx, ecx
bswap eax
sbb cx, cx
rol eax, 3
bswap edx
not edx
xor ebx, eax
add edi, eax
movzx dx, byte [ebp + ecx*2]
sal cl, 0x64
adc cl, byte [ecx + ebp + 2]
mov eax, 0x1c2cf89c
xchg ah, al
lea ebp, [ebp + eax - 0x1c2c9cf6]
shr dl, cl
movsx ecx, ax
ror eax, cl
adc eax, eax
mov word [ebp + eax - 0x5939f038], dx
jmp edi
xor ebx, eax
lea edx, [ecx + ecx - 0x1d5583f3]
call fcn.008033aa

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

Disassembly:
movzx edx, byte [esi + ecx - 0x6060e1ff]
shr ecx, cl
sar cl, 0x23
lea esi, [esi + ecx*2 + 1]
mov dword [esp + ecx*8], 0x1591029b
xor dl, bl
ror byte [esp + ecx*4], 0x44
ror dl, 1
dec dword [esp + ecx*8]
sub cx, cx
add word [esp + ecx + 2], cx
xor dl, 0x18
shr ecx, 0xb
neg dl
and cl, cl
xor dl, 0x83
or dword [esp + ecx*8], ecx
call fcn.008b3815
Function at 0x778a5a
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
adc edi, 4
push 0x7239d007
call fcn.0075b368
xor bl, cl
xor eax, edx
push esi
sbb dx, dx
xadd eax, edx
sub dx, ax
push ebp
imul edx, edx
mul eax
cwd
push ebx
mul edx
jo 0xc61a7b
mov ebp, edi
jae 0xc09a56
movzx cx, byte ss:[edx]
call fcn.00756fce
neg eax
sal dword [esp], 0x46
bswap eax
neg eax
imul edx, dword [esp]
ror ecx, 0x7a
shl dword [esp], 0x6c
inc eax
rol eax, 3
pop edx
shl ecx, 0xa
push edx
sbb eax, 0x4ea2a9a4
xor ebx, eax
bts ecx, ecx
jae 0x857591
mov esp, edi
mov eax, 0xeab78c3a
pop edx
lea ecx, [eax + eax*8 - 0x666579e1]
pop ebx
movsx edi, cl
popfd
cwde
call fcn.00b454e6
movzx ecx, byte [esi]
mov edx, 0x85830e
lea esi, [esi + edx - 0x85830d]
xor cl, bl
dec cl
rol cl, 1
add cl, 0xb0
sar edx, 0x27
movzx eax, dx
jb 0xb428b1
not cl
jae 0x75e772
xor edx, ebx
mov ecx, 0x902c4933
bswap edx
xor edx, 0xc42d36a5
rol edx, 1
lea edx, [ecx + edx - 0x4382e8fd]
not edx
dec ecx
sub edx, 0xc4bc7730
not edx
btc ecx, ecx
xor ebx, edx
add ebp, edx
lea edx, [ecx + ecx*8 - 0x2ff86fc5]
mov edx, dword [edi]
ror cx, 0xd
mov ecx, dword [edi + 4]
jae 0x742e0d
adc ebp, eax
or ecx, 0xd9acd53e
mov edx, dword [edi + edx - 0x5bfc0004]
xor byte [esp + 1], cl
mov ecx, dword ss:[edx]
mov dword [edi - 4], ecx
sbb edi, 4
mov edx, dword [esp]
pop ecx
jmp fcn.007a41b7
bt eax, eax
bt cx, cx
xor ebx, edx
btr ecx, ecx
or cl, 0x2a
sar cx, cl
adc esi, edx
movzx dx, byte [ebp]
or cl, al
mov cl, byte [ebp + 2]
bt eax, eax
btr ax, ax
adc ebp, 2
call fcn.00c43196
mov edx, 0x53a24820
mov ecx, dword [esi + edx - 0x53a24820]
or dl, 0x2a
lea eax, [edx + edx*8 - 0x5bc40ec2]
lea esi, [esi + edx - 0x53a24826]
bts ax, 0xaf
movzx edx, byte [ebp + edx - 0x53a2482a]
btc eax, 0x30
adc ebp, 1
sar al, 0x81
xor dl, bl
dec eax
inc dl
ror dl, 1
add dl, 8
or ax, 0x3408
ror dl, 1
inc dl
btc eax, eax
sub al, ah
call fcn.00778b3b
lea ebx, [edx + eax + 0x6882b824]
mov ebx, ecx
adc edx, ebx
inc al
sal edx, 2
div al
bt eax, 0x1a
mov eax, ebp
push 0x83a8b32a
call fcn.0083d51e

Function at 0x779e8e
Capabilities:
Authenticate hmac
Encode data using base64
Encrypt data using speck
Parse credit card information

Disassembly:
xor eax, ebx
sal dx, 0xe9
lea eax, [eax + edx*2 - 0x4823f52d]
and ecx, edx
xor eax, 0xf69ba784
mov dword [esp + ecx], edx
bswap eax
pop ecx
inc dword [esp + edx - 0xfe00]
rol cl, 0x44
ror eax, 2
sar cl, 0xe6
sal edx, 0xa7
mov byte [esp + ecx - 0xfdff], 0xac
lea eax, [ecx + eax + 0x5f7f2db5]
ror eax, 1
shl word [esp + ecx - 0xfdfe], 0x4b
xor ebx, eax
sar cx, 0xa
setnp dl
lea ebp, [ebp + ecx*2 - 0x20002]
sub dword [esp + ecx - 0xffff], edx
mov dword [ebp + ecx*4 - 0x3fffc], eax
xchg byte [esp + ecx - 0xfffd], dh
not dword [esp + ecx - 0xffff]
pop edx
jbe fcn.007ddd9d

Function at 0x784bf8
Capabilities:
Encrypt data using speck

Disassembly:
sub word [esp + 6], 0x8521
inc edx
mov dword [esp], 0x5b059b39
push 0x442d0508
push 0x7181551a
bswap edx
neg edx
call fcn.008913d3
Function at 0x784c1b
Capabilities:
Encrypt data using speck

Disassembly:
ror ecx, 0xa1
sbb eax, 0x75021417
ror dl, 0x81
bswap eax
dec dword [esp + edx - 0x25a59111]
xor ebx, eax
not dword [esp + ecx - 0x4b4dc76a]
lea ebp, [edx + ebp - 0x25a59121]
inc cl
mov dword [ebp + edx*2 - 0x4b4b223a], eax
mov eax, ecx
pop edx
pop ecx
pop edx
pop eax
jp fcn.008c0304
mov edx, 0x1c14b332
btc edx, edx
mov eax, dword [esi + edx*2 - 0x38216664]
lea esi, [esi + edx*4 - 0x7042ccc4]
add dx, 0x638f
jno 0x85f2be
movsx ecx, dl
xor eax, ebx
jmp 0xbca9ae
neg eax
not dl
or dl, dl
xor eax, 0x2d80eab5
add dx, dx
rol edx, 0xdc
btr cx, 0xaa
inc eax
ror eax, cl
bt edx, 0x97
xor ebx, eax
sar dl, cl
add ecx, ecx
add ebp, eax
xadd cl, dl
mov ax, word [edi]
mov cl, byte [edi + 2]
and edx, 0xe5916237
adc edi, 2
shr edx, 0x8f
adc edx, edx
adc dx, dx
sal ax, cl
mov word [edi + edx - 0x30c08], ax
btc dx, dx
jmp ebp

Function at 0x784c75
Capabilities:
Encrypt data using speck

Disassembly:
add eax, edx
mov dword [esp], 0xb13e5484
mov dword [ebp - 4], eax
test ebx, ebx
not word [esp + 2]
jmp 0xb7c75f
call fcn.00bae494
push 0x6a145133
mov edx, 0xefb549ac
mov ecx, 0x373bea9a
mov ecx, esi
sal word [esp], 0xea
mov eax, edx
lea eax, [edx*8 + 0x4619d9a6]
mov eax, ecx
lea ecx, [edx + edx*2 + 0x770b2711]
mov edx, dword ss:[eax + ecx - 0x462b0415]
lea eax, [ecx*4 - 0x32c2aedf]
not cx
mov dword [esi + ecx - 0x462bfbee], edx
mov edx, dword [esp + ecx - 0x462bfbea]
lea esi, [ecx + esi - 0x462bfbee]
mov eax, dword [edi + ecx - 0x462bfbea]
jbe 0xc07bf6
shl byte [esp + ecx - 0x462bfbe8], 0x46
lea edi, [ecx + edi - 0x462bfbe6]
xchg dword [esp + ecx - 0x462bfbea], ecx
sar dword [esp + ecx - 0x6a00cc00], 0x50
xor eax, ebx
sar byte [esp + edx - 0x6a14cbfe], 0xe4
shr ecx, 0x8e
neg eax
dec eax
bswap eax
jmp 0xbb66a8
setl cl
xor ebx, eax
rol edx, cl
btr edx, edx
add esi, eax
bt ecx, 0xa
shl dx, 0x88
mov edx, dword [edi]
lea eax, [ecx + ecx - 0x4868ec55]
neg ecx
mov cx, word [edi + ecx*4 - 0xa053bf8]
adc edi, 5
call fcn.00820c4c
add edi, 8
xchg edx, eax
rol edx, 0x8b
imul edx, edx
movzx edx, byte [esi + 4]
cwde
or ax, 0x96b3
lea esi, [eax + esi - 0x96ae]
xor dl, bl
dec dl
inc eax
add eax, eax
or ax, ax
rol dl, 1
push eax
jmp 0x833100
Function at 0x78e121
Capabilities:
Authenticate hmac
Encode data using base64
Encrypt data using rc4 ksa
Encrypt data using speck
Parse credit card information

Disassembly:
xadd ecx, esi
inc eax
setg dh
inc edi
lea eax, [edx + eax + 0x590beadf]
dec cl
dec edx
lea esi, [ecx + ebx*8 - 0x70f59f7d]
add dx, bp
inc ecx
bswap eax
dec eax
ror edx, 2
inc ebp
lea eax, [eax + ebp*2 - 0x50cf0864]
inc sp
sbb edx, ecx
jno 0xbcfd7e
shl ecx, 0x5d
not al
xchg cx, dx
xchg word [esp + ecx + 2], dx
inc al
xadd byte [esp + ecx + 8], ch
bts ecx, ecx
xor bl, al
xor dl, 0xb2
xadd byte [esp + ecx + 1], dh
add dword [esp + ecx + 5], 0x120b4518
lea eax, [esp + eax + 0xc]
adc edx, 0x6c9ea49c
imul edx, ecx
sal cl, cl
mov dx, word [eax + ecx*4 - 8]
movsx eax, cl
add al, 0x9c
sbb edi, ecx
mov word [edi + ecx*4 - 8], dx
pop eax
pop eax
pop ecx
jmp fcn.007a41b7
push 0x508d9ca2
xor ecx, 0xec03c402
call fcn.007dbb60
inc bp
mov eax, dword [ecx]
inc ecx
mov cl, byte [ecx + 2]
mov ebp, 0xa0862b8e
inc ecx
mov edx, 0x13ab9d37
dec edi
lea ecx, [edx + ecx - 0x13ab9d35]
inc ebp
movsx ebx, dx
movzx edx, bp
mov esi, ebp
inc cx
sal eax, cl
inc di
mov dword [ecx + edx*4 - 0x4eae74dc], eax
dec ecx
lea ecx, [ebx + 0x73813334]
inc eax
or dl, dh
dec ecx
lea edi, [edx + edi - 0x13ab9d3b]
dec eax
not edx
inc cx
btr edx, 0x80
jb 0xc16f91
adc edi, ecx
movzx edx, byte [ebp + 4]
movzx ecx, ax
xor dl, bl
add dl, 0x1e
sub eax, dword [esp + ecx - 0xedee]
not dl
sbb dl, 0xa8
or cl, 0xa2
btr ax, 0xaf
jb 0x8ddb70
xadd dword [esp + ecx - 0x10059], ecx
adc esi, edx
inc dword [esp + ecx - 0x257ffc]
pop ecx
pop ecx
pop edx
pop ecx
pop eax
pop eax
pop eax
pop edx
jns fcn.0070334b
xor dl, 0xa0
or cl, ch
inc dl
ror dl, 1
rol cx, 0x4b
push eax
jb 0xb73f24
mov edi, 0x168a4f89
push edi
mov edx, dword [esi + edi - 0x168a4f89]
jmp 0xb779c7
xor bl, dl
add cx, word [esp + ecx*2 - 0xfedc]
call fcn.008b279b
movsx ebp, di
lea esi, [edi + esi - 0x168a4f85]
dec word [esp + edi - 0x168a4f87]
mov ebp, edx
pop edi
mov eax, 0x873c94a5
mov edi, esi
or al, al
jp 0x806c2b
mov eax, 0x6481efa3
mov edx, dword [eax + esi - 0x6481efa3]
lea ecx, [eax + eax*4 + 0x713553a7]
xadd cx, ax
sub ecx, 0x7283578f
lea esi, [esi + eax - 0x648101d2]
ja 0x75b918
jno 0x721432
inc ecx
push esp
dec esp
xadd ecx, edx
ror cl, 0x47
dec esi
lea ebp, [edx*2 + 0x2eab2bb2]
inc esi
xor dword [esp + edx*4 - 0x501befe0], eax
inc ecx
pop esp
dec ebp
lea edi, [ebx + 0x2b39c69d]
inc cx
not edi
inc esp
xchg ecx, ebx
dec ebp
arpl ax, ax
dec ecx
bswap ebx
dec ecx
sal ebx, 0x14
inc esp
movzx esi, si
dec ecx
add ebx, eax
jmp ebx
inc esi
mov eax, dword [edi + edx*2 - 0x27573a6c]
jae 0xc41c31
inc ebp
xor eax, esp
inc ecx
bswap eax
jmp 0x75798e

Function at 0x790f7d
Capabilities:
Encrypt data using speck

Disassembly:
call 0x724b5d
add ebp, eax
imul edx, ecx
mov esi, dword [esi + ecx*8 - 0x48b1588]
sal ecx, cl
jne fcn.007e2cc2

Function at 0x791909
Capabilities:
Encrypt data using speck

Disassembly:
add edi, 4
jmp 0xc0aaf2
xor ecx, ecx
dec byte [esp + 5]
dec dword [esp + 4]
call fcn.00714506
sar dword [esp + 4], 0xe8
jb 0xc0739c