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

Disassembly:
adc ebp, 3
call fcn.00840901
mov edx, 0x6a96fb1e
jmp 0x85e7e3
shr dl, 0x26
mov eax, dword [edi + edx - 0x6a96fb00]
sal edx, 0xd
sete dl
adc edx, 0x168dce80
sbb edi, 0xfffffffc
mov ecx, 0xd604c091
ror ecx, 0x37
xor eax, ebx
neg dl
sub edx, ecx
ror eax, 3
xor cx, dx
sbb eax, 0xee284e3c
rol eax, 2
shr dl, 0x85
lea eax, [eax + ecx - 0x41074212]
bswap eax
sar ecx, cl
xor ecx, 0xb4b5899e
adc cl, dh
xor ebx, eax
bts ecx, 0x8d
adc esi, eax
xor ecx, edx
movzx cx, byte [ebp + ecx - 0x58d90347]
movsx eax, dx
mov dl, byte [ebp + 2]
shl eax, 0x36
or cl, dl
xor eax, 0x382106a5
mov edx, eax
not cl
mov word [ebp + 2], cx
lea eax, [edx*2 - 0x3d634bd7]
jno 0xbb76b1
mov eax, 0xc8b1a60b
inc esp
movzx edi, ax
dec edx
lea edi, [edi + edi - 0xa60f]
inc ebp
movsx ebx, di
mov esi, 0x663690b5
inc esi
mov eax, dword [edi + edi*8 - 0x53058]
cwde
mov ebp, esi
inc sp
sub ebx, ebp
inc ebp
xor eax, esp
dec eax
lea eax, [esi*2 + 0x330a7206]
inc ecx
xor al, bh
dec esp
lea ebp, [eax + 0x40a18a0f]
inc ebp
lea eax, [eax + esi*2 - 0x1646a7cd]
bts eax, ebp
inc ecx
xor eax, 0xa126d481
inc ecx
ror eax, 1
dec eax
imul eax
inc esp
movzx edx, bp
dec esp
lea esi, [eax + esi - 0x7fccb7d]
inc ecx
not eax
dec ecx
not edi
dec esp
btc eax, ebx
dec eax
sub ebp, eax
inc ecx
xor eax, 0x3d229d9d
dec ebp
xor ebp, esi
inc ecx
rol bh, 0x81
inc ecx
push esp
inc bp
add ebx, edx
inc esi
xor dword [esp + edi + 0xa617], eax
dec eax
btr edx, eax
inc esp
cmovae edx, eax
dec eax
sal ebp, 0x8f
inc ecx
pop esp
dec ecx
ror ebx, 0xb
cdq
inc ecx
rol ebp, 0xa4
dec ebp
arpl ax, ax
dec ecx
ror ebx, 0xfd
dec ecx
adc ebx, eax
inc ebp
movzx eax, di
inc ecx
movzx ecx, bp
dec eax
xor edx, 0x810db41a
dec ebp
mov edi, ecx
inc ecx
xchg edx, eax
cwd
inc cx
or eax, edx
dec esi
lea ecx, [esi + ecx - 0x663690b7]
sar si, 0x26
dec eax
not ebp
inc bp
mov dword [ecx + eax - 0x7b107d19], edi
dec ecx
bswap edx
ror cl, 0xe5
jbe fcn.008a1785
shr ecx, 0x77
jmp edi
shl edx, 0xab
lea eax, [eax + ebp - 0x35dec171]
call fcn.00c70f02
xor edx, ebx
neg edx
cwde
movsx ecx, al
add eax, ecx
sbb edx, 0x90b6e424
shr dword [esp], 0x96
xchg word [esp + 1], ax
neg edx
and ecx, eax
rol edx, 1
xor edx, 0xb1b65a30
xor ebx, edx
add edi, edx
call fcn.007c15b5
inc ecx
pop esp
dec ecx
and ebx, 0x308a9908
inc ecx
rol al, 0x27
inc eax
add dh, 0x34
dec ebp
arpl di, di
push edx
rol dword [esp + edx - 0x100055], cl
dec ecx
adc ebx, edi
pop esi
jmp fcn.008a1785
Function at 0x70e3fc
Capabilities:
Encrypt data using speck

Disassembly:
btr eax, 0x29
xor ebx, ecx
dec edx
mov dword [esp + eax - 0x7ffffdff], 0xb8b568a0
neg eax
add esi, ecx
dec dword [esp]
movzx edx, byte [ebp]
jle 0x8d384b
inc ecx
mov eax, 0x972293b8
inc ebp
movsx esi, ax
dec ecx
mov ebp, dword [ecx]
inc ebp
movsx ebp, si
dec ecx
mov ecx, dword [ecx + 8]
inc bp
imul esi, esi
inc bp
sbb eax, ebp
inc ecx
sal ebp, 3
dec eax
or ebp, ecx
inc bp
or ebp, eax
js 0xb92f86
rol byte [esp + 5], 0xc4
xor bl, al
pop edx
mov dword [esp + edx*8 - 0x30], esi
shr dl, 0xa2
sub edx, edx
push ebp
push ebx
xor edx, edx
movzx ebx, dl
mov ebp, edi
sal bl, 0x61
adc ebx, eax
shr edx, 8
mov eax, edx
dec eax
add edx, ebx
or eax, 0x7c17a01c
xor eax, eax
sar ax, 0xeb
sal edx, 2
add eax, ebp
add eax, edx
push 0x85212383
mov dword [ebp - 4], eax
dec word [esp]
or dword [esp], 0xbeb11923
test ebx, ebx
jmp 0x770bc7
call fcn.00b4eb75
mov edx, dword [esp + ecx*2]
jnp 0x853137
pop eax
jp fcn.0070334b
mov dword [esp + eax - 0x6f913da1], esi
ret 4
sets byte [esp + 1]
bswap eax
lea ebp, [eax + ebp - 0x102007f]
xor dl, bl
add dl, 0x38
xor ax, ax
sar ax, 0x85
rol dl, 1
lea ecx, [eax + eax*4 + 0x7a99b24]
add ax, 0x67a6
not dl
rol word [esp + eax*4 - 0x4099e97], 0x81
dec dl
inc ax
and al, 4
xor bl, dl
lea edx, [esp + edx + 4]
btr cx, cx
xchg dword [esp + eax*2 - 0x204ce08], ecx
sub ecx, ecx
mov eax, dword [edx + eax*4 - 0x4099c10]
lea edi, [edi + ecx*2 - 4]
mov dword [edi + ecx*8], eax
jns 0x820379
ret 0x9256
dec eax
not ebp
dec ecx

Function at 0x71034b
Capabilities:
Encode data using base64

Disassembly:
neg edx
inc ecx
pop esi
sub edx, 0xa537e9b2
dec cx
neg word [esp + esi*2 - 0x9f4]
xor edx, 0xecaa8f99
inc esp
add dword [esp + esi*2 - 0x9f4], edx
lea edx, [ebp + edx + 0x3d6c0e62]
dec esp
mov dword [esp + esi - 0x4f0], esp
xor dword [esp + esi*2 - 0x9f0], edx
dec esp
mov esp, dword [esp + esi - 0x4f0]
dec esp
lea esi, [ecx*2 - 0x3c1876c]
dec eax
arpl dx, dx
dec esp
mov dword [esp + esi - 0x4f0], ebx
dec eax
add ebx, edx
inc esp
xor dword [esp + esi*4 - 0x13ee], esi
jno 0xc53e67
movzx ecx, byte [esi]
add esi, 1
push 0x290fe7bf
xor cl, bl
not cl
mov edx, 0xd480c313
lea edx, [edx - 0x49d4926a]
sub cl, 0x8e
ror cl, 1
mov eax, dword [esp]
sub edx, eax
jle 0x7a7c21
neg cl
shr edx, 0xf2
xor bl, cl
xor dl, al
inc dword [esp + edx - 0x18d8]
inc eax
mov dword [esp + edx - 0x18d8], esi
ror dl, 0x61
push ebp
movzx ebp, ax
jl 0x7185b1
inc eax
not ch
dec edx
mov dword [esp + edi*8 - 0x570], ebx
ret 0x10

Function at 0x712ada
Capabilities:
Encrypt data using speck

Disassembly:
shld ax, dx, cl
call fcn.00734092
Function at 0x71557a
Capabilities:
Encrypt data using speck

Disassembly:
mov dword [esp + eax*4], 0x381f3592
shr dword [esp + eax + 0xb], 0x63
adc ecx, eax
xadd edx, eax
neg al
div byte [esp + eax - 0xfc]
xor ecx, 0xac225b20
sub eax, edx
rol edx, 0x48
neg ecx
call fcn.0081e6a9
pop ebx
mov ebp, dword [esp + ebp - 0xaf]
mov ebx, dword [esp + 0x14]
push ecx
mov ecx, dword [esp + 0x1c]
push 0x2b90b904
call fcn.00bcacf5
sub dl, dh
xor eax, 0x872756b1
and cl, 2
inc dl
dec cl
rol eax, 3
neg eax
rol dx, 0x86
lea ecx, [edx*4 + 0x2931ed2f]
ror cx, cl
not eax
dec dx
xchg cl, dl
bswap eax
shl dl, 6
shr cl, 2
xor ebx, eax
add ebp, eax
sar edx, cl
movsx eax, cx
call fcn.008837b3
mov edx, 0xa00a3f1a
lea edx, [edx + edx*2 + 0x6eb7f5ba]
movzx eax, byte [edi + edx - 0x4ed6b308]
lea edi, [edi + edx - 0x4ed6b307]
sar edx, 0xa2
xor edx, 0xc4aab133
xor al, bl
sub dx, dx
sar dl, 0xe1
rol dl, 0x84
not al
not dl
and dl, dl
adc al, dl
dec dx
js 0xbb7898
shl edx, 0x6c
ror al, 1
neg al
xor al, 0xba
sal edx, 0x5e
btc edx, edx
sbb al, dl
xor al, 0x12
call fcn.007f2fa3
lea eax, [ecx*8 + 0x48179118]
mov eax, dword [esi + edx - 0x265b8b21]
sbb ecx, 0xc89618c
inc dx
mov edx, dword [esi + edx - 0x265b8b1e]
shl dword [esp], cl
adc esi, 4
bt cx, cx
ror cl, 0x46
not eax
jae 0x7918f3
not edx
dec cx
add ecx, 0xd4994eac
sal cl, 0xe5
and eax, edx
sub cl, cl
movzx edx, cx
neg cl
mov dword [esi + edx*4 - 0x3b400], eax
lea eax, [ecx + edx*2 + 0x3f16971f]
mov dword [esp + edx*2 - 0x1da00], ebp
ret
xor ebx, eax
add ebp, eax
neg dl
movsx eax, dx
mov ecx, dword [esi + edx*4]
shr ax, 3
jae 0xba71b0
push eax
inc dword [esp]
add ebp, 4
xor edx, ebx
movsx ecx, word [esp]
sub edx, 0xb9126324
call fcn.00b7b575
mov edx, 0x50b05036
inc dx
lea eax, [edx + edx*2 + 0x3e949907]
mov eax, dword [edi + edx - 0x50b05037]
movsx ecx, dx
lea edi, [edi + ecx*8 - 0x281b4]
btc ecx, edx
xor eax, ebx
or ecx, ecx
inc eax
neg eax
lea edx, [edx*2 - 0x67d7e245]
lea edx, [ecx*2 + 0x63103627]
bts cx, dx
inc eax
bts edx, 0x1d
rol eax, 1
dec edx
shr ecx, cl
push edx
xor ebx, eax
add byte [esp + edx - 0x6410d692], cl
imul edx, edx
setno byte [esp + edx - 0x265bc58f]
add ebp, eax
rol dx, cl
jb 0x73fbf4
sbb edi, 7
push 0x5fa26135
mov dword [edi + 0xc], eax
push 0x1a295a9f
mov eax, dword [esp + 4]
call fcn.00bb2a0e
mov ecx, 0x6889c95
call fcn.008ce5a1
adc al, byte [esi + edx*2 + 4]
lea esi, [edx + esi + 6]
sub edx, edx
btc dx, dx
lea edx, [edx*4 + 0x459b6329]
mov byte [ecx + edx - 0x459b632d], al
mov eax, edx
movsx ecx, al
jmp ebp
setae dl
adc edi, eax
mov eax, dword [esi + ecx*8 - 0xc8]
bt ecx, 0xa2
call fcn.00865a10
push 0xc2918826
mov edx, dword [esp]
lea eax, [edx*8 - 0x7effb15e]
mov edx, dword [esi]
ror byte [esp + 3], 0x42
adc esi, 3
inc dword [esp]
js 0xc013db
mov edx, 0xe6341cb5
mov eax, dword [esi]
movsx ecx, dx
mov ecx, dword [esi + ecx - 0x1cb1]
sal edx, 0x3a
or edx, edx
adc esi, 8
mov dword fs:[eax], ecx
lea eax, [edx*8 + 0x5b1f3a2f]
mov edx, dword [ebp]
jmp 0x7e0abb
xchg byte [esp + 3], ah
xor edx, ebx
call fcn.008ea7eb
Function at 0x7173b3
Capabilities:
Encode data using base64

Disassembly:
jmp 0xbdc453
xor edx, edx
mov esi, dword [esi + edx]
mov eax, ecx
jno fcn.008001e8
inc ecx
xor ch, 0x30
inc ecx
dec ch
not edx
inc ecx
ror ch, 1
mul ebp
inc ecx
adc ch, 0x3f
dec edi
lea edi, [eax + eax*4 + 0x7d2148ab]
mov esi, ecx
inc ecx
not ch
sal cx, 0x66
dec eax
mul ebp
or ebp, eax
inc ecx
adc ch, 0xa2
inc ecx
ror al, 0xc6
jae 0xc76b4f
mov esi, 0x4d98233d
dec eax
lea edi, [esi + edi - 0x4d982341]
mov ebp, esi
dec eax
lea ebp, [ebp*2 + 0x4e89acaa]
inc esp
movzx edi, bp
mov ecx, dword [esi + edi - 0x4d98233d]
inc ecx
movzx edx, di
inc esp
mov edx, edx
inc ecx
xor ecx, esp
btc edx, 0x1d
dec ecx
call fcn.007648c2
bts edx, edx
neg eax
sal edx, 0x83
shl ecx, 0x7e
rol dl, 0xc7
lea eax, [ecx + eax - 0x99c4f26]
jp 0xb5eed7
ror eax, 1
xchg ecx, edx
rol cl, 0xe6
xor ebx, eax
add edi, eax
jmp 0x79a245
mul ecx
call fcn.00896926
movzx edx, cx
mov eax, dword [ebp + edx - 0x1020]
sal edx, 0xcd
lea ecx, [ecx + ecx + 0xf3a5708]
and ecx, edx
lea ebp, [ebp + ecx + 4]
imul ecx, edx
btr ecx, ecx
bts edx, 0xbb
xor eax, ebx
bts edx, 0x3a
bt ecx, edx
lea eax, [ecx + eax + 0x4b15a831]
jae 0x8c3f2c
inc ecx
mov edx, 0x3d046c09
dec esi
lea ebp, [edx*4 - 0x62e3136c]
inc ecx
movsx edx, ch
inc esi
movzx ebp, byte [edi + edx*2 - 0x7a08d813]
inc ecx
movsx ecx, dx
inc ebp
mov ebx, edx
inc ecx
movzx ebp, bx
inc ebp
xor ch, ah
inc esp
mov eax, ecx
inc ebp
and eax, eax
inc ecx
dec ch
inc ecx
neg ch
inc ecx
ror bl, 0x47
inc ecx
movzx eax, dl
jae 0x80fed7
inc cx
inc edi
inc ebp
xor ebp, esp
inc ebp
movzx esi, ax
inc ecx
xor ebp, 0x4129af36
inc ebp
lea ebp, [ebp + edx*2 - 0x39735a]
inc eax
inc ch
inc ecx
push eax
inc ecx
not ebp
inc eax
xor ch, al
inc ecx
bswap edx
inc ecx
xor ebp, 0xf98eda1
dec eax
cdq
inc esp
bt edx, eax
dec esi
mov dword [esp + edx*2 - 0x12d8087a], esp
inc cx
bt esi, esi
inc ecx
or ebp, edi
inc esi
xor dword [esp + edx - 0x96c043d], ebp
idiv cl
inc ebp
movsx esp, dl
inc ecx
pop esp
dec ebp
arpl bp, bp
cdq
inc eax
ror dh, 3
inc ecx
mul dl
dec ecx
adc ebx, ebp
dec esp
lea ebp, [eax + ebp*2 - 0x2bcafc6f]
inc cx
and esi, ebp
inc ecx
shr esi, 0xe8
inc di
mov edi, dword [ecx + edx*2 - 0x12d8087c]
mul dx
inc esi
movzx eax, byte [edi + edx*2 - 0x12d80880]
dec eax
lea edi, [edi + ecx*8 - 0x1206]
inc bp
xadd dl, cl
inc ebp
xor al, ah
inc ecx
imul edx, ebp
inc bp
bt esi, ebp
inc ecx
adc al, 0
inc ecx
ror al, 1
inc ecx
neg al
inc cx
xchg ebx, ebp
inc ecx
not al
inc ebp
xor ah, al
dec esp
add eax, esp
inc ecx
ror ebp, 9
rol si, 0x8b
inc edi
mov byte [eax + edx*4 - 0x25b010f4], bh
jmp ebx
dec ecx
btr eax, 0x9b
inc ecx
neg ch
inc cx
idiv ebx
inc ebp
xor ah, ch
dec ecx
xor esi, ebx
inc di
mov dword [ecx + edx*2 - 0x7a08d814], ebp
dec esp
lea ebp, [edx*2 + 0x282bbe95]
inc eax
shl ch, 0x86
dec ebp
btr ebp, ebp
inc esi
mov ebp, dword [edi + edx - 0x3d046c0e]
jae 0xc1fb4d
Function at 0x717576
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
xor cx, dx
movzx ecx, byte [esi + edx - 0xcbff]
xor word [esp + edx - 0xcbf9], dx
jo 0x8497a4
xor cl, bl
xor cl, 0x3d
sal edx, 0xd
sbb cl, 0xb8
and edx, edx
jns 0xc08a55
xadd dx, ax
inc ecx
sal edx, 0xd0
cbw
call fcn.007e2cd7
mov dword [esp + edx - 0x197fe000], edx
xor cl, 0x32

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

Disassembly:
not cx
cmovge ax, word [esp + eax*4 + 6]
push eax
xor bx, cx
cdq
mov word [ebp + edx - 6], cx
lea ebp, [ebp + edx - 6]
call fcn.00814554
mov edx, 0x7c01f92f
movsx ecx, dx
mov edx, dword [ebp + edx - 0x7c01f92f]
movsx eax, cl
rol ecx, 0xfb
lea ecx, [ecx - 0x4758a16d]
lea ebp, [ebp + ecx*2 - 0x714ebcb4]
and cl, al
xor edx, ebx
call fcn.00721511

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

Disassembly:
mov dword [esp], 0x8bb8081a
mov edx, dword [edi]
adc edi, 3
movsx ecx, al
shr cx, cl
shr byte [esp + ecx - 0xd], 0x62
xor edx, ebx
sar cx, 8
sbb ax, 0x26be
adc edx, ecx
xor cl, al
btr eax, eax
jb 0x7f8198
not edx
xor dword [esp + ecx - 0x63], 0xbb22de26
rol word [esp + ecx*4 - 0x18c], cl
rol edx, 2
or ecx, ecx
rol ax, 0xa1
xor edx, 0x73020115
sub eax, ecx
neg edx
dec ax
xchg ecx, eax
xor ebx, edx
add ebp, edx
call fcn.008bda32

Function at 0x71f89e
Capabilities:
Encrypt data using speck

Disassembly:
xor dl, 0xa2
mov dword [esp + ecx - 0x2000003d], ecx
inc word [esp + ecx - 0x2000003a]
xor bl, dl
lea edx, [esp + edx + 0x10]
sal cx, 0xa4
jnp 0xb72ef5
mov ecx, 0xdd99a2b8
mov edx, dword [edi]
jmp 0x706a12
movsx eax, cl
add cx, word [edi + eax]
bswap edx
mov dx, word [edi + eax + 2]
lea edi, [edi + eax*8 + 2]
inc eax
inc eax
bts eax, 0xa0
adc cx, dx
inc al
mov word [edi + eax*8 - 0x20], cx
cwde
call fcn.00ba7038
mov eax, 0x28813e1a
mov ecx, ebp
bt ax, ax
mov edx, eax
mov dword [eax + ebp - 0x28813e1e], ecx
push edx
xchg edx, eax
lea ecx, [edx - 0x46725dc]
mov eax, dword [edx + ebp - 0x28813e1e]
lea ecx, [ecx*8 + 0x2887a34]
movzx dx, byte ss:[edx + eax - 0x28813e1a]
call fcn.00706cc0
mov eax, dword [edx + ecx*2 - 0x400007a0]
mov dword [ecx + ebp - 0x200003d8], eax
dec byte [esp + ecx*2 - 0x40000799]
lea ebp, [ebp + ecx*2 - 0x400007a8]
pop ecx
pop eax
pop eax
pop edx
jno fcn.007ddd9d
rol eax, 2
rol dl, 0x67
xor ebx, eax
sub ecx, edx
sal cx, 0x2f
shl ecx, 0xe1
add ebp, eax
lea edx, [ecx*2 + 0x7dad7c85]
jmp 0x7f57a3

Function at 0x7250b5
Capabilities:
Encode data using base64
Encrypt data using speck
Parse credit card information

Disassembly:
sbb esi, 0
sal edx, 0xb0
mov dword [esp], eax
movzx edx, byte [esi]
xor dl, bl
pop eax
bt eax, eax
add al, ah
xor dl, 0x3d
or eax, 0x91a54c9a
rol ax, 0xa4
sbb dl, 0xb8
shl ax, 0x6a
rol eax, 0x99
xor dl, 0x32
bts eax, 0x9b
dec dl
btc ax, ax
ror dl, 1
add ax, 0xa59d
neg al
sbb eax, eax
xor bl, dl
call fcn.00c0def1
Function at 0x729bea
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
lea ecx, [ecx + ecx*2 + 0x72851c15]
mov dword [esp + ecx - 0x4b229d95], 0x619a7085
bswap eax
ror dword [esp + ecx - 0x4b229d94], 0x1c
adc cl, 0x28
xor eax, 0x15387b8e
neg eax
xor ebx, eax
add ecx, 0xa7b12717
movsx edx, byte [esp + 4]
lea ecx, [edx + 0x743100a2]
adc edi, eax
xchg word [esp + edx*2 - 0xc], dx
mov ecx, dword [esi + edx - 0x85]
ror dx, 0x66
jb 0x8b77f0
mov edx, dword fs:[ecx + edx*8 - 0xa010]
mov dword [esi], edx
mov edx, 0x159f5581
movzx eax, dl
inc byte [esp + eax*8 - 0x406]
mov dword [esp + eax*4 - 0x204], edi
ret 4

Function at 0x72b5eb
Capabilities:
Encrypt data using speck

Disassembly:
mov dword [esp], ecx
mov dword [eax], edx
or word [esp + 6], 0x3a07
movzx edx, cx
sub edx, dword [esp + edx - 0x348e]
mov edx, dword [ebp + edx - 0x442894d3]
jbe 0xbba863
jnp 0x8ce45f

Function at 0x73378d
Capabilities:
Encode data using base64

Disassembly:
mov dword [esp], eax
jle 0x757fc6
dec ebx
push 0xcb295785
lea esp, [esp + 4]
jne 0x71b4e1
Function at 0x7345fd
Capabilities:
Encode data using xor

Disassembly:
add ebp, eax
mov eax, dword [esi + ecx - 0x423b5ddb]
xchg dword [esp + ecx - 0x423b5dd7], ecx
and cl, dh
sbb edx, dword [esp + ecx - 0x4435ac3c]
lea esi, [esi + ecx - 0x4435ac3c]
setb dl
mov dword [esp + ecx - 0x4435ac40], ecx
movzx edx, byte [edi + ecx - 0x4435ac40]
not cl
imul ecx, ecx
lea edi, [edi + ecx - 0x73a73680]
call fcn.008c1014
mov ecx, 0xc0933704
lea edx, [ecx + ecx*4 + 0x6587bda3]
mov eax, dword [esi + edx*2 - 0x50cfa16e]
mov cl, byte [edx + esi - 0x2867d0b3]
dec dl
sub dl, dl
xor dl, dh
lea esi, [esi + edx*2 - 0x50cfa19e]
bts dx, dx
shr eax, cl
jmp 0x88e7ad
not edx
dec dx
mov dword [esi], eax
mov eax, dword [edi]
add edi, 4
movzx ecx, dx
mov bh, 0xca
xor eax, ebx
btr ecx, edx
sbb eax, 0xf0b55bb3
call fcn.00876d45
syscall
push ecx
pushfd
dec eax
mov ecx, 0x100c6b9d
mov edi, 0xe8c12797
sbb al, dh
sub eax, 0xf03ca200
mov dword [eax + 0x21], edi
loopne 0x88e7c0
xor dword [ebp + 0x7f], 0x51081821
jne 0x88e874
and dword [eax + 0xc], ebp
dec ecx
jne 0x88e87a
and dword [eax + 0x6c], esi
sbb dword [ebp + 0x7f], esi
and dword [eax + 0x68], eax
cmp dword [ebp + 0x7f], esi
and dword [eax], eax
invalid
jmp [esi - 0x68de808b]
xlatb
xchg esi, eax
jne 0x88e8fd
and dword [edi + 0x7f755e23], ebp
and dword [edi - 0x39], esp
cmpsb byte [esi], byte es:[edi]
jne 0x88e909
and edi, edi
ja 0x88e894
jne 0x88e90f
and dword [edi + 0x45b1b4ce], ebx
mov cl, 0x45
rcr dword [esp + edi*8 + 0x7b], 0xbe
popal
out dx, al
jg 0x88e8b8
sbb dword [ecx + 0x48e], ecx
add dl, dl
pop es
mov dword [esi + 4], ecx
rol byte [edi], cl
adc eax, 0xa38ca505
sbb al, 0x85
bound edi, qword [ebx]
fmul dword [edi + 0x33]
test esi, esi
wait
pop eax
dec edi
xor eax, dword [ebp + 0x4f986302]
xor eax, dword [ebp + 0x4f28abce]
xor eax, dword [ebp + 0x4f3093b2]
xor eax, dword [ebp + 0x4f78a396]
xor eax, dword [ebp + 0x4f20938a]
xor eax, dword [ebp - 0x431adea]
mov dl, byte [ebx - 0x7accb0e0]
push ss
push edx
into
sti
invalid
and al, 0xd6
inc byte [eax]
add byte [eax], al
add ch, cl
cmp edx, dword [esi - 0x5f]
jmp 0x88e988
jle 0x88e89e
and ebx, 0xe
adc ebp, dword [ecx]
daa
sub dword [edi], esp
cmp ah, byte [ebp + 0x1c]
dec esi
bound edx, qword [eax + 0x6a]
adc dword [edx], 0x2d71cebe
sbb dword [esi - 0xb151290], ecx
pop ss
cmpsd dword [esi], dword es:[edi]
xchg ebp, eax
adc dword [edi + 0x62], edi
cmpsb byte [esi], byte es:[edi]
add eax, 0xe4538546
sub ebx, dword [edi + 0x3c]
loop 0x88e8d2
mov ecx, 0xfe9dbd46
inc edi
cmpsb byte [esi], byte es:[edi]
add al, 0xac
cmpsb byte [esi], byte es:[edi]
adc eax, 0x6200fd8c
outsd dx, dword [esi]
outsd dx, dword [esi]
jnp 0x88e909
in eax, dx
not byte [eax + 0x7589a768]
add byte [edx + 0x46], ah
xchg ecx, eax
adc al, 2
pop esi
arpl bp, bp
adc eax, 0x10bfcb28
sahf
pushal
mov al, byte [0x30e5c2fd]
enter 0x6123, 0xffffffffffffffea
jmp 0xaaf134b
jmp 0x88e9b4
fdiv dword [eax - 0x5f7534b1]
stosd dword es:[edi], eax
rol bh, 1
std
jmp 0x88ea16
dec esp
add esp, dword [eax]
invalid
Function at 0x73722a
Capabilities:
Encode data using base64
Encrypt data using speck
Parse credit card information

Disassembly:
xor eax, ebx
rol edx, 0xd6
rol eax, 1
bt dx, 0x96
lea edx, [edx*2 - 0x494a3648]
mov dword [esp + edx - 0x2221ff0e], edx
dec eax
not dword [esp + edx - 0x2221ff09]
shr byte [esp + edx*2 - 0x4443fe17], 0xe4
neg eax
shl edx, 0xa9
dec eax
mov ecx, edx
xadd byte [esp + ecx - 0x43fe1bf6], cl
xor ebx, eax
imul cx, word [esp + edx - 0x43fe1bfb]
sal edx, cl
adc ebp, eax
movzx eax, dx
add dx, word [edi + edx*2]
btr ecx, ecx
inc eax
mov ax, word [eax + edi + 1]
not ecx
mov cl, byte [edi + 4]
shl dword [esp + 2], 0x3c
je 0xc6124e
mov word [esp + 5], 0xd8a8
adc edi, 4
call fcn.0075f92a
mov edx, 0x2e9f678b
lea edi, [edi + edx*2 - 0x5d3ecf14]
neg edx
sal al, cl
lea edx, [edx + edx + 0xda56227]
xor dx, dx
mov word [edi], ax
movzx ecx, dx
adc ecx, dword [ebp + ecx*2]

Function at 0x739a0f
Capabilities:
Encrypt data using speck

Disassembly:
mov dword [esp + eax - 0x40000000], eax
xor edx, ebx
lea ecx, [eax*4 + 0x2c2d5917]
dec cl
lea edx, [edx + eax*2 - 0x64663b49]
neg edx
xor cx, 0x480d
dec edx
shr ecx, 4
neg edx
not eax
xadd byte [esp + ecx*8 - 0x16168886], al
neg ecx
xor ebx, edx
add ebp, edx
mov edx, dword [esp]
lea ecx, [ecx + eax - 0x26d5c4ca]
add dword [esp + edx - 0x40ff0000], eax
mov eax, edi
xchg dword [esp + edx - 0x40ff0000], ecx
lea edi, [edi + ecx*4 - 0x3fbfc02]
add dword [esp + ecx*2 - 0x1fdfe00], ecx
add cl, dh
setnp cl
mov word [ecx + edi - 0xfeff00], ax
dec cx
setg byte [esp + ecx - 0xfefeff]
pop eax
jp fcn.007ab350

Function at 0x739a8d
Capabilities:
Encrypt data using speck

Disassembly:
mov dword [esp + ecx - 0xd130000], eax
not ecx
xor ebx, edx
sar eax, cl
add edi, edx
movzx cx, byte [esi]
mov dl, byte [esi + 2]
sar ax, 0xca
and cl, dl
inc eax
jns 0xb5b4cf
dec ecx
std
push esi
and dh, byte [ebp + 0x1d]
cmp al, 0x67
mov bl, byte [edx + 0x24]
add dword [ebx - 0x38], 0xf5a0c68a
inc ebx
enter 0x4e8a, 0
mov ch, 0x43
enter 0x5e8a, 0x24
imul eax, dword [eax + 0x15], 0x38ae3b8a
test eax, 0x92239455
sub al, 0x9a
scasd eax, dword es:[edi]
div bl
cmc
xor bl, byte [ebp - 0x66]
inc ebp
adc byte [ebp + esi*8 - 0x387f861e], dh
retf
Function at 0x73a653
Capabilities:
Encrypt data using speck

Disassembly:
btr edx, edx
not cl
adc edx, edx
rol cl, 1
and dl, dh
setge dl
dec edx
inc cl
mov dword [esp + edx - 0x100], edx
xor bl, cl
and dl, 0x15
or edx, dword [esp + edx*8 - 0x800]
lea ecx, [esp + ecx + 4]
mov dword [ecx + edx*2 - 0x200], eax
rol edx, 0x63
lea ecx, [edx*4 + 0x56bb0f98]
mov eax, dword [edi + edx*2 - 0x1000]
ja 0xc61a9c
lea eax, [ecx + eax + 0x50d74b19]
add cl, ch
sbb dword [esp + edx*2 - 0x1000], ecx
setge cl
rol eax, 1
inc dl
dec eax
shr edx, 0x47
call fcn.00c6f297
setae al
add ebp, edx
shl ax, 0x6f
lea eax, [ecx - 0x2ac9e765]
mov eax, dword [esi + eax - 0x61ab6e7b]
adc cl, 7
not cx
or cx, 0x36b4
mov ecx, dword [esi + 4]
call fcn.007eb2d5
xor ebx, edx
sub ecx, 0xdda53e35
jnp 0x8ddbb6
lea edi, [edi + edx*4 - 0x1ffc]
xor eax, ebx
shr cl, 0x83
jae 0x7ded51
mov ecx, 0xab75b05
movsx eax, cx
mov edx, dword [esi + ecx - 0xab75b05]
sar cx, cl
shr ax, 2
movzx ecx, byte [edi + ecx*4 - 0x2adc0b60]
xor cl, bl
inc ax
ror eax, 0x7c
jp 0xba5aff
sbb cl, 0x9a
or eax, eax
neg cl
add eax, eax
setl al
rol cl, 1
shr al, 0x45
sbb cl, 1
rol al, 0x67
xor ax, ax
rol cl, 1
and eax, eax
sbb al, ah
xor bl, cl
sub eax, eax
sal al, 0xa1
adc ecx, esp
ror ax, 0xcc
not eax
mov dword [ecx], edx
mov ecx, eax
mov edx, 0xda2f0aa0
sub cl, dh
movzx ecx, word [edi + 1]
sbb edx, eax
setno al
or al, dh
xor cx, bx
sal dl, 0xa6
dec cx
rol cx, 1
sub cx, 0x418
shr eax, 0x4a
neg eax
neg cx
sub dl, dh
ror al, 0x43
cwde
dec cx
or dl, dl
and dl, 0x1a
not cx
shr al, 0x46
neg cx
push edx
inc ax
inc edx
xor bx, cx
push edx
neg dx
mov word [eax + esi + 1], cx
add dword [esp + eax + 1], edx
lea esi, [eax + esi + 1]
shl dl, 0xe5
sal eax, 0xf5
shl al, 0x61
mov ecx, dword [edi + eax*2 - 0x3ffffd]
cwd
sbb dword [esp + eax - 0x1fffff], eax
lea edi, [edi + eax - 0x1ffff9]
xor ecx, ebx
mul al
neg ecx
inc ecx
ror al, 0xc7
and eax, eax
ror ecx, 2
cwd
or ax, ax
xor ecx, 0xcd053b35
not edx
inc eax
add eax, dword [esp + eax - 0x200001]
not ecx
btc ax, ax
xor ebx, ecx
div dl
add ebp, ecx
ror eax, 0x7e
mov dword [esp + edx*2 - 0x4ba1fffe], ebp
ret 4
Function at 0x73c4d4
Capabilities:
Authenticate hmac
Encode data using base64
Encrypt data using speck
Parse credit card information

Disassembly:
bswap eax
push edx
neg eax
sal byte [esp + ecx - 0x360], 0x44
shr cx, 0x63
sub ecx, dword [esp + ecx - 0x6c]
inc eax
ror ecx, cl
neg eax
btr edx, edx
adc dl, byte [esp + ecx*2 - 0x4b4b238b]
mov dword [esp + ecx - 0x25a591c2], 0x4a13229
dec eax
push ecx
not eax
xor ebx, eax
add edi, eax
sal ecx, cl
neg byte [esp + ecx - 0x69647180]
lea esi, [esi + ecx - 0x69647184]
pop edx
mov eax, dword [esi + edx*2 - 0x4b4b2274]
shr cl, 0x22
push ecx
xor eax, ebx
xor eax, 0xbc1e52ae
neg ecx
jnp 0x82f3f8
mov ecx, 0xe029a71f
movsx eax, cx
push ecx
mov dx, word [ebp]
xor cl, al
rol dword [esp], 0xc5
bt eax, ecx
mov ax, word [ebp + 2]
or ecx, dword [esp]
not ecx
cmovg cx, word [esp + ecx*4 - 0x6b08600a]
mov cl, byte [ebp + ecx*2 - 0x35843002]
jno 0x81f0a9
adc ebp, 4
shld dx, ax, cl
mov ecx, 0x7b1ab73d
sar word [esp + ecx - 0x7b1ab73c], 0x66
inc cx
mov word [ecx + ebp - 0x7b1ab73e], dx
neg dword [esp + ecx - 0x7b1ab73e]
sub cx, word [esp + ecx - 0x7b1ab73d]
mov edx, ecx
lea esi, [edx + esi - 0x7b1ab816]
shl dx, 0x86
mov eax, dword [esi + edx - 0x7b1a0480]
xor eax, ebx
inc ecx
ror dword [esp + ecx - 0x7b1ab813], cl
btr edx, ecx
not eax
sal dword [esp + ecx - 0x7b1ab813], 6
btr ecx, 0x89
rol eax, 1
dec edx
not eax
sal cl, 0x62
bswap eax
xor dword [esp + edx - 0x7b12047f], ecx
and edx, edx
dec eax
xor ebx, eax
add edi, eax
movsx eax, cx
mov word [esp + ecx - 0x7b1ab84b], dx
shl edx, 0x4b
mov dword [esp + ecx - 0x7b1ab84c], edi
inc eax
xor eax, 0xc32fc416
call fcn.00784c1b