кто-либо может объяснить этот код мне?

По-видимому, этот код пытается изменить стек, чтобы при возврате функции main выполнение программы не возвращалось регулярно в библиотеку времени выполнения (которая обычно завершает программу), а вместо этого перескакивает в код сохранен в массиве шеллкода .

1) int * ret;

определяет переменную в стеке, сразу после аргументов функции main .

2) ret = (int *) & ret + 2;

позволяет переменной ret указывать на int * , который помещается в два int сек выше ret в стеке. Предположительно, это то место, где находится адрес возврата, где программа продолжит работу, когда вернется main .

2) (* ret) = (int) шелл-код;

В качестве адреса возврата устанавливается адрес содержимого массива шелл-код , так что шелл-код содержимое будет выполнено при возврате main .

шеллкод , по-видимому, содержит машинные инструкции, которые, возможно, выполняют системный вызов для запуска / bin / sh . Я мог ошибаться в этом, поскольку на самом деле я не разбирал шеллкод .

P.S .: Этот код зависит от машины и компилятора и, возможно, не будет работать на всех платформах.

Ответьте на ваш второй вопрос:

и что произойдет, если я использую ret = (int) & ret +2 и почему мы добавили 2? почему не 3 или 4 ?? ? и я думаю, что int составляет 4 байта, поэтому 2 будет 8 байтов нет?

ret объявлен как int * , поэтому присваивается int (например, (int) & ret ) было бы ошибкой. Что касается того, почему добавлено 2, а не какое-либо другое число: очевидно, потому что этот код предполагает, что адрес возврата будет находиться в этом месте в стеке. Рассмотрим следующее:

• В этом коде предполагается, что стек вызовов растет вниз, когда что-то на него нажимается (как это действительно происходит, например, с процессорами Intel). Вот почему число добавляется , а не вычитается : адрес возврата находится в более высоком адресе памяти, чем автоматические (локальные) переменные (например, ret ).

• Из того, что я помню со времен сборки Intel, функция C часто вызывается следующим образом: сначала все аргументы помещаются в стек в обратном порядке (справа налево). Затем вызывается функция. Таким образом, адрес возврата помещается в стек. Затем устанавливается новый кадр стека, который включает в себя размещение регистра ebp в стеке. Затем локальные переменные устанавливаются в стеке под всем, что было помещено в него до этого момента.

Теперь я предполагаю следующую структуру стека для вашей программы:

+-------------------------+
|  function arguments     |                       |
|  (e.g. argv, argc)      |                       |  (note: the stack
+-------------------------+   <-- ss:esp + 12     |   grows downward!)
|  return address         |                       |
+-------------------------+   <-- ss:esp + 8      V
|  saved ebp register     |                       
+-------------------------+   <-- ss:esp + 4  /  ss:ebp - 0  (see code below)
|  local variable (ret)   |                       
+-------------------------+   <-- ss:esp + 0  /  ss:ebp - 4

Внизу лежит ret (32-битное целое число). Выше находится сохраненный регистр ebp (который также имеет ширину 32 бита). Выше указан 32-битный адрес возврата.(Выше будут аргументы main - argc и argv - но здесь они не важны.) Когда функция выполняется, стек указатель указывает на ret . Адрес возврата находится на 64 бита «выше» ret , что соответствует + 2 в

ret = (int*)&ret + 2; 

. Это + 2 , потому что ret ] - это int * , а int - 32-битное, поэтому добавление 2 означает установку его в ячейку памяти 2 × 32 бита (= 64 бита) выше (int *) & ret ... который будет местоположением обратного адреса, если все предположения в предыдущем абзаце верны.

Экскурсия: Позвольте мне продемонстрировать на языке ассемблера Intel, как может быть вызвана функция C (если я правильно помню - я не гуру в этой теме, поэтому могу ошибаться):

// first, push all function arguments on the stack in reverse order:
push  argv
push  argc

// then, call the function; this will push the current execution address
// on the stack so that a return instruction can get back here:
call  main

// (afterwards: clean up stack by removing the function arguments, e.g.:)
add   esp, 8

Внутри main может произойти следующее:

// create a new stack frame and make room for local variables:
push  ebp
mov   ebp, esp
sub   esp, 4

// access return address:
mov   edi, ss:[ebp+4]

// access argument 'argc'
mov   eax, ss:[ebp+8]

// access argument 'argv'
mov   ebx, ss:[ebp+12]

// access local variable 'ret'
mov   edx, ss:[ebp-4]

...

// restore stack frame and return to caller (by popping the return address)
mov   esp, ebp
pop   ebp
retf

См. Также: Описание последовательности вызова процедуры в C для другого объяснения этой темы.