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

Disassembly:
test byte [0x937cd8], 1
jne 0x8a033a
mov eax, 0xdc80
mov word [0x937018], ax
add eax, 3
mov word [0x93701a], ax
or dword [0x937cd8], 1
mov edx, 0xdc8d
mov eax, edx
mov word [0x93701c], ax
add eax, 4
mov word [0x93701e], ax
lea ecx, [edx + 0xa]
mov eax, ecx
mov word [0x937020], ax
add eax, 0xfffffff4
mov word [0x937022], ax
lea eax, [edx - 9]
mov word [0x937024], ax
add eax, 5
mov word [0x937026], ax
lea eax, [edx + 0xe]
push edi
mov edi, eax
add eax, 0xffffffec
mov ecx, eax
mov word [0x937036], ax
lea eax, [edx + 0xf]
mov word [0x937038], ax
add eax, 0x2c
mov word [0x937028], di
mov word [0x93702a], di
mov dword [0x93702c], 0xdc9bdc8d
mov dword [0x937030], 0xdc9adc97
mov word [0x937034], cx
mov word [0x93703a], ax
pop edi
xor eax, eax
mov ecx, 0xdcc8
xor cx, word [eax + 0x937018]
add eax, 2
mov word [eax + 0x93774e], cx
cmp eax, 0x24
jb 0x8a033c
mov eax, 0x937750
ret

Function at 0x8a0708
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937cc0], 1
jne 0x8a075d
or dword [0x937cc0], 1
mov dword [0x9370c8], 0x8bafad9a
mov dword [0x9370cc], 0xbca9adba
mov dword [0x9370d0], 0xb1ad83ad
mov dword [0x9370d4], 0xe1e0b08d
mov dword [0x9370d8], 0xa1a9aee8
mov dword [0x9370dc], 0xf2acada4
mov word [0x9370e0], 0xc8e8
xor eax, eax
mov cl, byte [eax + 0x9370c8]
xor cl, 0xc8
mov byte [eax + 0x9377ac], cl
inc eax
cmp eax, 0x1a
jb 0x8a075f
mov eax, 0x9377ac
ret

Function at 0x8a083f
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937cbc], 1
jne 0x8a08a5
or dword [0x937cbc], 1
mov dword [0x9370e4], 0xa5bda68d
mov dword [0x9370e8], 0xbca9baad
mov dword [0x9370ec], 0xe8a6a7a1
mov dword [0x9370f0], 0xadaca6a1
mov dword [0x9370f4], 0xbda7e8b0
mov dword [0x9370f8], 0xaea7e8bc
mov dword [0x9370fc], 0xa6a9bae8
mov word [0x937100], 0xadaf
mov byte [0x937102], 0xc8
xor eax, eax
mov cl, byte [eax + 0x9370e4]
xor cl, 0xc8
mov byte [eax + 0x9377c8], cl
inc eax
cmp eax, 0x1f
jb 0x8a08a7
mov eax, 0x9377c8
ret

Function at 0x8a08c2
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937cb8], 1
jne 0x8a090e
or dword [0x937cb8], 1
mov dword [0x937104], 0x8dafad9a
mov dword [0x937108], 0x83a5bda6
mov dword [0x93710c], 0xb08db1ad
mov dword [0x937110], 0xaee8e1e0
mov dword [0x937114], 0xada4a1a9
mov dword [0x937118], 0xc8e8f2ac
xor eax, eax
mov cl, byte [eax + 0x937104]
xor cl, 0xc8
mov byte [eax + 0x9377e8], cl
inc eax
cmp eax, 0x18
jb 0x8a0910
mov eax, 0x9377e8
ret

Function at 0x8a0a73
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937cb4], 1
jne 0x8a0aa8
or dword [0x937cb4], 1
mov dword [0x93711c], 0xa4a4bd86
mov dword [0x937120], 0xa6a7abe8
mov dword [0x937124], 0xbcb0adbc
mov byte [0x937128], 0xc8
xor eax, eax
mov cl, byte [eax + 0x93711c]
xor cl, 0xc8
mov byte [eax + 0x937800], cl
inc eax
cmp eax, 0xd
jb 0x8a0aaa
mov eax, 0x937800
ret
Function at 0x8a0ac5
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937cb0], 1
jne 0x8a0b11
or dword [0x937cb0], 1
mov dword [0x93712c], 0x87afad9a
mov dword [0x937130], 0x83a6adb8
mov dword [0x937134], 0xb08db1ad
mov dword [0x937138], 0xaee8e1e0
mov dword [0x93713c], 0xada4a1a9
mov dword [0x937140], 0xc8e8f2ac
xor eax, eax
mov cl, byte [eax + 0x93712c]
xor cl, 0xc8
mov byte [eax + 0x937810], cl
inc eax
cmp eax, 0x18
jb 0x8a0b13
mov eax, 0x937810
ret

Function at 0x8a0b2e
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937cac], 1
jne 0x8a0b8a
or dword [0x937cac], 1
mov dword [0x937144], 0x99afad9a
mov dword [0x937148], 0xb1baadbd
mov dword [0x93714c], 0xa7aea681
mov dword [0x937150], 0xe0b1ad83
mov dword [0x937154], 0xa9aee8e1
mov dword [0x937158], 0xacada4a1
mov word [0x93715c], 0xe8f2
mov byte [0x93715e], 0xc8
xor eax, eax
mov cl, byte [eax + 0x937144]
xor cl, 0xc8
mov byte [eax + 0x937828], cl
inc eax
cmp eax, 0x1b
jb 0x8a0b8c
mov eax, 0x937828
ret

Function at 0x8a0c7d
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937ca8], 1
jne 0x8a0ce3
or dword [0x937ca8], 1
mov dword [0x937160], 0xa5bda68d
mov dword [0x937164], 0xbca9baad
mov dword [0x937168], 0xe8a6a7a1
mov dword [0x93716c], 0xadaca6a1
mov dword [0x937170], 0xbda7e8b0
mov dword [0x937174], 0xaea7e8bc
mov dword [0x937178], 0xa6a9bae8
mov word [0x93717c], 0xadaf
mov byte [0x93717e], 0xc8
xor eax, eax
mov cl, byte [eax + 0x937160]
xor cl, 0xc8
mov byte [eax + 0x937844], cl
inc eax
cmp eax, 0x1f
jb 0x8a0ce5
mov eax, 0x937844
ret

Function at 0x8a0d00
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937ca4], 1
jne 0x8a0d5c
or dword [0x937ca4], 1
mov dword [0x937180], 0x99afad9a
mov dword [0x937184], 0xb1baadbd
mov dword [0x937188], 0xa7aea681
mov dword [0x93718c], 0xe0b1ad83
mov dword [0x937190], 0xa9aee8e1
mov dword [0x937194], 0xacada4a1
mov word [0x937198], 0xe8f2
mov byte [0x93719a], 0xc8
xor eax, eax
mov cl, byte [eax + 0x937180]
xor cl, 0xc8
mov byte [eax + 0x937864], cl
inc eax
cmp eax, 0x1b
jb 0x8a0d5e
mov eax, 0x937864
ret

Function at 0x8a0ebe
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937ca0], 1
jne 0x8a0ef3
or dword [0x937ca0], 1
mov dword [0x93719c], 0xa4a4bd86
mov dword [0x9371a0], 0xa6a7abe8
mov dword [0x9371a4], 0xbcb0adbc
mov byte [0x9371a8], 0xc8
xor eax, eax
mov cl, byte [eax + 0x93719c]
xor cl, 0xc8
mov byte [eax + 0x937880], cl
inc eax
cmp eax, 0xd
jb 0x8a0ef5
mov eax, 0x937880
ret

Function at 0x8a0f10
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937c9c], 1
jne 0x8a0f5c
or dword [0x937c9c], 1
mov dword [0x9371ac], 0x87afad9a
mov dword [0x9371b0], 0x83a6adb8
mov dword [0x9371b4], 0xb08db1ad
mov dword [0x9371b8], 0xaee8e1e0
mov dword [0x9371bc], 0xada4a1a9
mov dword [0x9371c0], 0xc8e8f2ac
xor eax, eax
mov cl, byte [eax + 0x9371ac]
xor cl, 0xc8
mov byte [eax + 0x937890], cl
inc eax
cmp eax, 0x18
jb 0x8a0f5e
mov eax, 0x937890
ret
Function at 0x8a0f79
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937c98], 1
jne 0x8a0fd5
or dword [0x937c98], 1
mov dword [0x9371c4], 0x99afad9a
mov dword [0x9371c8], 0xb1baadbd
mov dword [0x9371cc], 0xa7aea681
mov dword [0x9371d0], 0xe0b1ad83
mov dword [0x9371d4], 0xa9aee8e1
mov dword [0x9371d8], 0xacada4a1
mov word [0x9371dc], 0xe8f2
mov byte [0x9371de], 0xc8
xor eax, eax
mov cl, byte [eax + 0x9371c4]
xor cl, 0xc8
mov byte [eax + 0x9378a8], cl
inc eax
cmp eax, 0x1b
jb 0x8a0fd7
mov eax, 0x9378a8
ret

Function at 0x8a1283
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937c94], 1
mov ecx, 0xdcc8
jne 0x8a12ef
or dword [0x937c94], 1
lea eax, [ecx + 0x18]
mov word [0x9371e0], ax
add eax, 0xffffffac
mov word [0x9371e2], ax
lea eax, [ecx - 0x1b]
mov word [0x9371e4], ax
inc eax
mov word [0x9371e6], ax
lea eax, [ecx - 0x1f]
mov word [0x9371e8], ax
add eax, 0x14
mov word [0x9371ea], ax
lea eax, [ecx - 0x24]
mov word [0x9371ec], ax
add eax, 0x18
mov word [0x9371ee], ax
lea eax, [ecx + 0x19]
mov word [0x9371f0], ax
mov eax, ecx
mov word [0x9371f2], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0x9371e0]
add eax, 2
mov word [eax + 0x9378c2], dx
cmp eax, 0x14
jb 0x8a12f1
mov eax, 0x9378c4
ret

Function at 0x8a130f
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937c90], 1
mov ecx, 0xdcc8
jne 0x8a137b
or dword [0x937c90], 1
lea eax, [ecx + 0x18]
mov word [0x9371f4], ax
add eax, 0xffffffcc
mov word [0x9371f6], ax
lea eax, [ecx - 0x1b]
mov word [0x9371f8], ax
inc eax
mov word [0x9371fa], ax
lea eax, [ecx - 0x1f]
mov word [0x9371fc], ax
add eax, 0x14
mov word [0x9371fe], ax
lea eax, [ecx - 0x24]
mov word [0x937200], ax
add eax, 0x18
mov word [0x937202], ax
lea eax, [ecx + 0x19]
mov word [0x937204], ax
mov eax, ecx
mov word [0x937206], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0x9371f4]
add eax, 2
mov word [eax + 0x9378d6], dx
cmp eax, 0x14
jb 0x8a137d
mov eax, 0x9378d8
ret

Function at 0x8a139b
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937c8c], 1
jne 0x8a13e7
or dword [0x937c8c], 1
mov dword [0x937208], 0x87afad9a
mov dword [0x93720c], 0x83a6adb8
mov dword [0x937210], 0xb08db1ad
mov dword [0x937214], 0xaee8e1e0
mov dword [0x937218], 0xada4a1a9
mov dword [0x93721c], 0xc8e8f2ac
xor eax, eax
mov cl, byte [eax + 0x937208]
xor cl, 0xc8
mov byte [eax + 0x9378ec], cl
inc eax
cmp eax, 0x18
jb 0x8a13e9
mov eax, 0x9378ec
ret

Function at 0x8a1404
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937c88], 1
jne 0x8a1460
or dword [0x937c88], 1
mov dword [0x937220], 0x99afad9a
mov dword [0x937224], 0xb1baadbd
mov dword [0x937228], 0xbda4a99e
mov dword [0x93722c], 0xe0b08dad
mov dword [0x937230], 0xa9aee8e1
mov dword [0x937234], 0xacada4a1
mov word [0x937238], 0xe8f2
mov byte [0x93723a], 0xc8
xor eax, eax
mov cl, byte [eax + 0x937220]
xor cl, 0xc8
mov byte [eax + 0x937904], cl
inc eax
cmp eax, 0x1b
jb 0x8a1462
mov eax, 0x937904
ret
Function at 0x8a147d
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937c84], 1
jne 0x8a14d9
or dword [0x937c84], 1
mov dword [0x93723c], 0x99afad9a
mov dword [0x937240], 0xb1baadbd
mov dword [0x937244], 0xbda4a99e
mov dword [0x937248], 0xe0b08dad
mov dword [0x93724c], 0xa9aee8e1
mov dword [0x937250], 0xacada4a1
mov word [0x937254], 0xe8f2
mov byte [0x937256], 0xc8
xor eax, eax
mov cl, byte [eax + 0x93723c]
xor cl, 0xc8
mov byte [eax + 0x937920], cl
inc eax
cmp eax, 0x1b
jb 0x8a14db
mov eax, 0x937920
ret

Function at 0x8a155b
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937c80], 1
jne 0x8a15a6
or dword [0x937c80], 1
mov dword [0x937258], 0xadb8b19c
mov dword [0x93725c], 0xbba9bfe8
mov dword [0x937260], 0xbca7a6e8
mov dword [0x937264], 0xbbe8a9e8
mov dword [0x937268], 0xa6a1babc
mov word [0x93726c], 0xc8af
xor eax, eax
mov cl, byte [eax + 0x937258]
xor cl, 0xc8
mov byte [eax + 0x93793c], cl
inc eax
cmp eax, 0x16
jb 0x8a15a8
mov eax, 0x93793c
ret

Function at 0x8a15c3
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937c7c], 1
jne 0x8a162c
or dword [0x937c7c], 1
mov dword [0x937270], 0xa9bea681
mov dword [0x937274], 0xe8aca1a4
mov dword [0x937278], 0xa9bca9ac
mov dword [0x93727c], 0xb2a1bbe8
mov dword [0x937280], 0xa7aee8ad
mov dword [0x937284], 0xa1bfe8ba
mov dword [0x937288], 0x9ae8adac
mov dword [0x93728c], 0x9b978f8d
mov word [0x937290], 0xc892
xor eax, eax
mov cl, byte [eax + 0x937270]
xor cl, 0xc8
mov byte [eax + 0x937954], cl
inc eax
cmp eax, 0x22
jb 0x8a162e
mov eax, 0x937954
ret

Function at 0x8a17a8
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937c78], 1
jne 0x8a17f4
or dword [0x937c78], 1
mov dword [0x937294], 0x87afad9a
mov dword [0x937298], 0x83a6adb8
mov dword [0x93729c], 0xb08db1ad
mov dword [0x9372a0], 0xaee8e1e0
mov dword [0x9372a4], 0xada4a1a9
mov dword [0x9372a8], 0xc8e8f2ac
xor eax, eax
mov cl, byte [eax + 0x937294]
xor cl, 0xc8
mov byte [eax + 0x937978], cl
inc eax
cmp eax, 0x18
jb 0x8a17f6
mov eax, 0x937978
ret

Function at 0x8a1811
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937c74], 1
jne 0x8a1877
or dword [0x937c74], 1
mov dword [0x9372ac], 0x9bafad9a
mov dword [0x9372b0], 0xa99ebcad
mov dword [0x9372b4], 0x8dadbda4
mov dword [0x9372b8], 0xbcbbe0b0
mov dword [0x9372bc], 0xafa6a1ba
mov dword [0x9372c0], 0xa9aee8e1
mov dword [0x9372c4], 0xacada4a1
mov word [0x9372c8], 0xe8f2
mov byte [0x9372ca], 0xc8
xor eax, eax
mov cl, byte [eax + 0x9372ac]
xor cl, 0xc8
mov byte [eax + 0x937990], cl
inc eax
cmp eax, 0x1f
jb 0x8a1879
mov eax, 0x937990
ret

Function at 0x8a19e3
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937c70], 1
jne 0x8a1a2f
or dword [0x937c70], 1
mov dword [0x9372cc], 0x87afad9a
mov dword [0x9372d0], 0x83a6adb8
mov dword [0x9372d4], 0xb08db1ad
mov dword [0x9372d8], 0xaee8e1e0
mov dword [0x9372dc], 0xada4a1a9
mov dword [0x9372e0], 0xc8e8f2ac
xor eax, eax
mov cl, byte [eax + 0x9372cc]
xor cl, 0xc8
mov byte [eax + 0x9379b0], cl
inc eax
cmp eax, 0x18
jb 0x8a1a31
mov eax, 0x9379b0
ret
Function at 0x8a1a4c
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937c6c], 1
jne 0x8a1aab
or dword [0x937c6c], 1
mov dword [0x9372e4], 0x9bafad9a
mov dword [0x9372e8], 0xa99ebcad
mov dword [0x9372ec], 0x8dadbda4
mov dword [0x9372f0], 0xbface0b0
mov dword [0x9372f4], 0xe1acbaa7
mov dword [0x9372f8], 0xa1a9aee8
mov dword [0x9372fc], 0xf2acada4
mov word [0x937300], 0xc8e8
xor eax, eax
mov cl, byte [eax + 0x9372e4]
xor cl, 0xc8
mov byte [eax + 0x9379c8], cl
inc eax
cmp eax, 0x1e
jb 0x8a1aad
mov eax, 0x9379c8
ret

Function at 0x8a1c18
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937c68], 1
jne 0x8a1c92
or dword [0x937c68], 1
mov dword [0x937304], 0xbcbbbd85
mov dword [0x937308], 0xadb8bbe8
mov dword [0x93730c], 0xb1aea1ab
mov dword [0x937310], 0xa6e8a9e8
mov dword [0x937314], 0xade5a6a7
mov dword [0x937318], 0xb1bcb8a5
mov dword [0x93731c], 0xaabdbbe8
mov dword [0x937320], 0xe8b1ada3
mov dword [0x937324], 0xa1babcbb
mov word [0x937328], 0xafa6
mov byte [0x93732a], 0xc8
xor eax, eax
mov cl, byte [eax + 0x937304]
xor cl, 0xc8
mov byte [eax + 0x9379e8], cl
inc eax
cmp eax, 0x27
jb 0x8a1c94
mov eax, 0x9379e8
ret

Function at 0x8a1caf
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937c64], 1
jne 0x8a1cfb
or dword [0x937c64], 1
mov dword [0x93732c], 0x87afad9a
mov dword [0x937330], 0x83a6adb8
mov dword [0x937334], 0xb08db1ad
mov dword [0x937338], 0xaee8e1e0
mov dword [0x93733c], 0xada4a1a9
mov dword [0x937340], 0xc8e8f2ac
xor eax, eax
mov cl, byte [eax + 0x93732c]
xor cl, 0xc8
mov byte [eax + 0x937a10], cl
inc eax
cmp eax, 0x18
jb 0x8a1cfd
mov eax, 0x937a10
ret

Function at 0x8a1d18
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937c60], 1
jne 0x8a1d6a
or dword [0x937c60], 1
mov dword [0x937344], 0xad8c809b
mov dword [0x937348], 0xadbcada4
mov dword [0x93734c], 0xe0b1ad83
mov dword [0x937350], 0xa9aee8e1
mov dword [0x937354], 0xacada4a1
mov word [0x937358], 0xe8f2
mov byte [0x93735a], 0xc8
xor eax, eax
mov cl, byte [eax + 0x937344]
xor cl, 0xc8
mov byte [eax + 0x937a28], cl
inc eax
cmp eax, 0x17
jb 0x8a1d6c
mov eax, 0x937a28
ret

Function at 0x8a1eb9
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937c5c], 1
jne 0x8a1f05
or dword [0x937c5c], 1
mov dword [0x93735c], 0x87afad9a
mov dword [0x937360], 0x83a6adb8
mov dword [0x937364], 0xb08db1ad
mov dword [0x937368], 0xaee8e1e0
mov dword [0x93736c], 0xada4a1a9
mov dword [0x937370], 0xc8e8f2ac
xor eax, eax
mov cl, byte [eax + 0x93735c]
xor cl, 0xc8
mov byte [eax + 0x937a40], cl
inc eax
cmp eax, 0x18
jb 0x8a1f07
mov eax, 0x937a40
ret

Function at 0x8a1f22
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937c58], 1
jne 0x8a1f75
or dword [0x937c58], 1
mov dword [0x937374], 0xad8c809b
mov dword [0x937378], 0xadbcada4
mov dword [0x93737c], 0xbda4a99e
mov dword [0x937380], 0xe8e1e0ad
mov dword [0x937384], 0xa4a1a9ae
mov dword [0x937388], 0xe8f2acad
mov byte [0x93738c], 0xc8
xor eax, eax
mov cl, byte [eax + 0x937374]
xor cl, 0xc8
mov byte [eax + 0x937a58], cl
inc eax
cmp eax, 0x19
jb 0x8a1f77
mov eax, 0x937a58
ret
Function at 0x8a1f92
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937c54], 1
jne 0x8a204d
or dword [0x937c54], 1
mov dword [0x937390], 0x8c8b8a89
mov dword [0x937394], 0x808f8e8d
mov dword [0x937398], 0x84838281
mov dword [0x93739c], 0x98878685
mov dword [0x9373a0], 0x9c9b9a99
mov dword [0x9373a4], 0x909f9e9d
mov dword [0x9373a8], 0xaaa99291
mov dword [0x9373ac], 0xaeadacab
mov dword [0x9373b0], 0xa2a1a0af
mov dword [0x9373b4], 0xa6a5a4a3
mov dword [0x9373b8], 0xbab9b8a7
mov dword [0x9373bc], 0xbebdbcbb
mov dword [0x9373c0], 0xb2b1b0bf
mov dword [0x9373c4], 0xfbfaf9f8
mov dword [0x9373c8], 0xfffefdfc
mov dword [0x9373cc], 0xe7e3f1f0
mov byte [0x9373d0], 0xc8
xor eax, eax
mov cl, byte [eax + 0x937390]
xor cl, 0xc8
mov byte [eax + 0x937a78], cl
inc eax
cmp eax, 0x41
jb 0x8a204f
mov eax, 0x937a78
ret

Function at 0x8a20fa
Capabilities:
Encode data using base64

Disassembly:
push ebp
mov ebp, esp
push ecx
mov ecx, dword [ebp + 8]
push ebx
push esi
push edi
mov edi, eax
xor edx, edx
push 3
lea eax, [ecx + 2]
pop ebx
div ebx
mov esi, dword [ebp + 0x10]
shl eax, 2
inc eax
cmp dword [esi], eax
jae 0x8a2124
mov dword [esi], eax
xor al, al
jmp 0x8a21fc
mov eax, ecx
xor edx, edx
push 3
pop ecx
div ecx
mov esi, dword [ebp + 0xc]
mov ecx, dword [0x931a7c]
xor edx, edx
imul eax, eax, 3
test eax, eax
je 0x8a21a0
dec eax
push 3
pop ebx
div ebx
inc eax
mov edx, eax
mov dword [ebp - 4], eax
imul edx, edx, 3
movzx eax, byte [edi]
shr eax, 2
mov al, byte [eax + ecx]
mov byte [esi], al
movzx eax, byte [edi + 1]
movzx ebx, byte [edi]
shr eax, 4
shl ebx, 4
add eax, ebx
and eax, 0x3f
mov al, byte [eax + ecx]
mov byte [esi + 1], al
movzx eax, byte [edi + 2]
movzx ebx, byte [edi + 1]
shr eax, 6
lea eax, [eax + ebx*4]
and eax, 0x3f
mov al, byte [eax + ecx]
mov byte [esi + 2], al
movzx eax, byte [edi + 2]
and eax, 0x3f
mov al, byte [eax + ecx]
mov byte [esi + 3], al
add esi, 4
add edi, 3
dec dword [ebp - 4]
jne 0x8a214e
cmp edx, dword [ebp + 8]
jae 0x8a21ef
movzx eax, byte [edi]
inc edx
cmp edx, dword [ebp + 8]
jae 0x8a21b4
movzx edi, byte [edi + 1]
jmp 0x8a21b6
xor edi, edi
mov ebx, eax
shr ebx, 2
and ebx, 0x3f
mov bl, byte [ebx + ecx]
mov byte [esi], bl
mov ebx, edi
shr ebx, 4
shl eax, 4
add ebx, eax
and ebx, 0x3f
mov al, byte [ebx + ecx]
mov byte [esi + 1], al
cmp edx, dword [ebp + 8]
jae 0x8a21e3
and edi, 0xf
mov cl, byte [ecx + edi*4]
jmp 0x8a21e5
mov cl, 0x3d
mov byte [esi + 2], cl
mov byte [esi + 3], 0x3d
add esi, 4
mov eax, dword [ebp + 0x10]
mov byte [esi], 0
sub esi, dword [ebp + 0xc]
mov dword [eax], esi
mov al, 1
pop edi
pop esi
pop ebx
leave
ret

Function at 0x8a2e58
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937c50], 1
jne 0x8a2ebf
or dword [0x937c50], 1
mov dword [0x937abc], 0xb194b1a6
mov dword [0x937ac0], 0xb994bba2
mov dword [0x937ac4], 0xaeafaaae
mov dword [0x937ac8], 0xa5a294b9
mov dword [0x937acc], 0xad94bfa2
mov dword [0x937ad0], 0xe3aea7a2
mov dword [0x937ad4], 0xaaadebe2
mov dword [0x937ad8], 0xafaea7a2
mov byte [0x937adc], 0xcb
xor eax, eax
mov cl, byte [eax + 0x937abc]
xor cl, 0xcb
mov byte [eax + 0x937b7c], cl
inc eax
cmp eax, 0x21
jb 0x8a2ec1
mov eax, 0x937b7c
ret
Function at 0x8a2edc
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937c4c], 1
jne 0x8a2f43
or dword [0x937c4c], 1
mov dword [0x937ae0], 0xb194b1a6
mov dword [0x937ae4], 0xb994bba2
mov dword [0x937ae8], 0xaeafaaae
mov dword [0x937aec], 0xa2ad94b9
mov dword [0x937af0], 0xb894aea7
mov dword [0x937af4], 0xe3bfaabf
mov dword [0x937af8], 0xaaadebe2
mov dword [0x937afc], 0xafaea7a2
mov byte [0x937b00], 0xcb
xor eax, eax
mov cl, byte [eax + 0x937ae0]
xor cl, 0xcb
mov byte [eax + 0x937ba0], cl
inc eax
cmp eax, 0x21
jb 0x8a2f45
mov eax, 0x937ba0
ret

Function at 0x8a2f60
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937c48], 1
jne 0x8a2fde
or dword [0x937c48], 1
mov dword [0x937b04], 0xb194b1a6
mov dword [0x937b08], 0xb994bba2
mov dword [0x937b0c], 0xaeafaaae
mov dword [0x937b10], 0xb3ae94b9
mov dword [0x937b14], 0xa8aab9bf
mov dword [0x937b18], 0xa2ad94bf
mov dword [0x937b1c], 0xbf94aea7
mov dword [0x937b20], 0xaea394a4
mov dword [0x937b24], 0xe2e3bbaa
mov dword [0x937b28], 0xa2aaadeb
mov dword [0x937b2c], 0xcbafaea7
xor eax, eax
mov cl, byte [eax + 0x937b04]
xor cl, 0xcb
mov byte [eax + 0x937bc4], cl
inc eax
cmp eax, 0x2c
jb 0x8a2fe0
mov eax, 0x937bc4
ret

Function at 0x8a2ffe
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937c44], 1
jne 0x8a3068
or dword [0x937c44], 1
mov dword [0x937b30], 0xa7a2aa8d
mov dword [0x937b34], 0xbfebafae
mov dword [0x937b38], 0xb9a8eba4
mov dword [0x937b3c], 0xaebfaaae
mov dword [0x937b40], 0xb8aeafeb
mov dword [0x937b44], 0xaaa5a2bf
mov dword [0x937b48], 0xa5a4a2bf
mov dword [0x937b4c], 0xbfaabbeb
mov dword [0x937b50], 0xcbebf1a3
xor eax, eax
mov cl, byte [eax + 0x937b30]
xor cl, 0xcb
mov byte [eax + 0x937bf0], cl
inc eax
cmp eax, 0x24
jb 0x8a306a
mov eax, 0x937bf0
ret

Function at 0x8a3085
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937c40], 1
jne 0x8a30a9
or dword [0x937c40], 1
mov dword [0x937b54], 0xbfaabbeb
mov dword [0x937b58], 0xcbebf1a3
xor eax, eax
mov cl, byte [eax + 0x937b54]
xor cl, 0xcb
mov byte [eax + 0x937c14], cl
inc eax
cmp eax, 8
jb 0x8a30ab
mov eax, 0x937c14
ret

Function at 0x8a30c6
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937c3c], 1
jne 0x8a312c
or dword [0x937c3c], 1
mov dword [0x937b5c], 0xa7a2aa8d
mov dword [0x937b60], 0xbfebafae
mov dword [0x937b64], 0xb9a8eba4
mov dword [0x937b68], 0xaebfaaae
mov dword [0x937b6c], 0xbfbea4eb
mov dword [0x937b70], 0xebbfbebb
mov dword [0x937b74], 0xaea7a2ad
mov word [0x937b78], 0xebf1
mov byte [0x937b7a], 0xcb
xor eax, eax
mov cl, byte [eax + 0x937b5c]
xor cl, 0xcb
mov byte [eax + 0x937c1c], cl
inc eax
cmp eax, 0x1f
jb 0x8a312e
mov eax, 0x937c1c
ret
Function at 0x8abbc0
Capabilities:
Encode data using xor

Disassembly:
mov cl, byte [edx]
mov eax, dword [eax + 0x1f0]
test cl, cl
je 0x8abbe2
lea esp, [esp]
imul eax, eax, 0xf4243
movzx ecx, cl
inc edx
xor eax, ecx
mov cl, byte [edx]
test cl, cl
jne 0x8abbd0
ret
Function at 0x8bb810
Capabilities:
Hash data using sha1

Disassembly:
push ebp
mov ebp, esp
mov eax, dword [ebp + 8]
xor ecx, ecx
mov dword [eax + 8], 0x67452301
mov dword [eax + 0xc], 0xefcdab89
mov dword [eax + 0x10], 0x98badcfe
mov dword [eax + 0x14], 0x10325476
mov dword [eax + 0x18], 0xc3d2e1f0
mov dword [eax + 0x1c], ecx
mov dword [eax], ecx
mov dword [eax + 4], ecx
xor eax, eax
pop ebp
ret

Function at 0x8bb900
Capabilities:
Enumerate pe sections

Disassembly:
push ebp
mov ebp, esp
push esi
mov esi, dword [ebp + 8]
mov eax, dword [esi + 0x1c]
mov edx, 0x40
cmp eax, edx
jb 0x8bb919
lea eax, [edx - 0x30]
pop esi
pop ebp
ret
lea ecx, [eax*8]
add dword [esi], ecx
push ebx
mov ebx, 0
adc dword [esi + 4], ebx
push edi
mov byte [eax + esi + 0x20], 0x80
mov edi, 1
add dword [esi + 0x1c], edi
mov eax, dword [esi + 0x1c]
mov ecx, 0x38
cmp eax, ecx
jbe 0x8bb972
cmp eax, edx
jae 0x8bb95e
lea esp, [esp]
mov byte [eax + esi + 0x20], bl
add dword [esi + 0x1c], edi
mov eax, dword [esi + 0x1c]
cmp eax, edx
jb 0x8bb950
lea edx, [esi + 0x20]
push esi
call fcn.008bb310
add esp, 4
mov dword [esi + 0x1c], ebx
mov ecx, 0x38
cmp dword [esi + 0x1c], ecx
jae 0x8bb98f
jmp 0x8bb980
mov edx, dword [esi + 0x1c]
mov byte [esi + edx + 0x20], bl
add dword [esi + 0x1c], edi
cmp dword [esi + 0x1c], ecx
jb 0x8bb980
movzx eax, byte [esi + 7]
movzx ecx, byte [esi + 6]
movzx edx, byte [esi + 5]
mov byte [esi + 0x58], al
movzx eax, byte [esi + 4]
mov byte [esi + 0x59], cl
movzx ecx, byte [esi + 3]
mov byte [esi + 0x5a], dl
movzx edx, byte [esi + 2]
mov byte [esi + 0x5b], al
movzx eax, byte [esi + 1]
mov byte [esi + 0x5c], cl
movzx ecx, byte [esi]
mov byte [esi + 0x5d], dl
lea edx, [esi + 0x20]
push esi
mov byte [esi + 0x5e], al
mov byte [esi + 0x5f], cl
call fcn.008bb310
movzx edx, byte [esi + 0xb]
mov eax, dword [ebp + 0xc]
mov byte [eax], dl
movzx ecx, byte [esi + 0xa]
mov byte [eax + 1], cl
movzx edx, byte [esi + 9]
mov byte [eax + 2], dl
movzx ecx, byte [esi + 8]
mov byte [eax + 3], cl
movzx edx, byte [esi + 0xf]
mov byte [eax + 4], dl
movzx ecx, byte [esi + 0xe]
mov byte [eax + 5], cl
movzx edx, byte [esi + 0xd]
mov byte [eax + 6], dl
movzx ecx, byte [esi + 0xc]
mov byte [eax + 7], cl
movzx edx, byte [esi + 0x13]
mov byte [eax + 8], dl
movzx ecx, byte [esi + 0x12]
mov byte [eax + 9], cl
movzx edx, byte [esi + 0x11]
mov byte [eax + 0xa], dl
movzx ecx, byte [esi + 0x10]
mov byte [eax + 0xb], cl
movzx edx, byte [esi + 0x17]
mov byte [eax + 0xc], dl
movzx ecx, byte [esi + 0x16]
mov byte [eax + 0xd], cl
movzx edx, byte [esi + 0x15]
mov byte [eax + 0xe], dl
movzx ecx, byte [esi + 0x14]
mov byte [eax + 0xf], cl
movzx edx, byte [esi + 0x1b]
mov byte [eax + 0x10], dl
movzx ecx, byte [esi + 0x1a]
mov byte [eax + 0x11], cl
movzx edx, byte [esi + 0x19]
add esp, 4
mov byte [eax + 0x12], dl
movzx ecx, byte [esi + 0x18]
pop edi
pop ebx
mov byte [eax + 0x13], cl
xor eax, eax
pop esi
pop ebp
ret
Function at 0x8bd5a0
Capabilities:
Hash data using sha256

Disassembly:
push ebp
mov ebp, esp
mov eax, dword [ebp + 8]
xor ecx, ecx
mov dword [eax + 0x28], ecx
mov dword [eax], ecx
mov dword [eax + 4], ecx
mov dword [eax + 8], 0x6a09e667
mov dword [eax + 0xc], 0xbb67ae85
mov dword [eax + 0x10], 0x3c6ef372
mov dword [eax + 0x14], 0xa54ff53a
mov dword [eax + 0x18], 0x510e527f
mov dword [eax + 0x1c], 0x9b05688c
mov dword [eax + 0x20], 0x1f83d9ab
mov dword [eax + 0x24], 0x5be0cd19
xor eax, eax
pop ebp
ret