Как пропустить строку при переполнении буфера в C

Вы, должно быть, читаете статью Разрушение стека ради удовольствия и прибыли. Я читал ту же статью и обнаружил ту же проблему, что не пропускал эту инструкцию. После нескольких часов отладки в IDA я изменил код, как показано ниже, и он печатает x = 0 и b = 5.

#include <stdio.h>

void function(int a, int b) {
     int c=0;
     int* pointer;

     pointer =&c+2;
     (*pointer)+=8;
}

void main() {
  int x =0;
  function(1,2);
  x = 3;
  int b =5;
  printf("x=%d\n, b=%d\n",x,b);
  getch();
}

Чтобы изменить обратный адрес в function() и пропустить x = 1 в main(), вам нужны две части информации.

1. Расположение адреса возврата в кадре стека.

Я использовал gdb для определения этого значения. Я устанавливаю точку останова на function() (break function), выполняю код до точки останова (run), получаю местоположение в памяти текущего кадра стека (p $rbp или info reg), а затем получить местоположение в памяти buffer (p &buffer). Используя извлеченные значения, можно определить местоположение обратного адреса.

(скомпилировано с флагом GCC -g для включения символов отладки и выполнено в 64-битной среде)

(gdb) break function
...
(gdb) run
...
(gdb) p $rbp
$1 = (void *) 0x7fffffffe270
(gdb) p &buffer
$2 = (char (*)[5]) 0x7fffffffe260
(gdb) quit

^{(адрес указателя кадра + размер слова) - адрес буфера = количество байтов от локальной переменной буфера до адреса возврата}
(0x7fffffffe270 + 8) - 0x7fffffffe260 = 24

Если у вас возникли трудности с пониманием того, как работает стек вызовов, прочтите стек вызовов и пролог функции могут помочь статьи Википедии. Это показывает сложность создания примеров "переполнения буфера" в C. Смещение 24 от buffer предполагает определенный стиль заполнения и параметры компиляции. GCC с радостью вставит стековые канарейки в настоящее время, если вы не скажете ему не делать этого.

2. Количество байтов, которое нужно добавить к адресу возврата, чтобы пропустить x = 1.

В вашем случае указатель сохраненной инструкции будет указывать на 0x00000000004002f4 (<main+35>), первую инструкцию после возврата функции. Чтобы пропустить задание, нужно сделать так, чтобы указатель сохраненной инструкции указывал на 0x00000000004002fb (<main+42>).

Ваш расчет, что это 7 байт, верен (0x4002fb - 0x4002fb = 7).

Я использовал gdb для дизассемблирования приложения (disas main) и также проверил вычисления для своего случая. Это значение лучше всего решить вручную, проверив разборку.

Обратите внимание, что я использовал 64-битную среду Ubuntu 10.10 для тестирования следующего кода.

#include <stdio.h>

void function(int a, int b, int c)  
{
    char buffer[5];
    int *ret;

    ret = (int *)(buffer + 24);
    (*ret) += 7; 
}

int main()
{
     int x = 0; 
     function(1, 2, 3);
     x = 1;
     printf("x = %i \n", x);  
     return 0;  
}

вывод

x = 0

На самом деле это просто изменение адреса возврата function(), а не фактическое переполнение буфера. При фактическом переполнении буфера вы бы переполнили buffer[5], чтобы перезаписать адрес возврата. Однако в большинстве современных реализаций для защиты от этого используются такие методы, как стековые канарейки.

То, что вы здесь делаете, похоже, не имеет ничего общего с классической атакой переполнения буфера. Вся идея атаки переполнения буфера состоит в том, чтобы изменить обратный адрес «функции». Дизассемблирование вашей программы покажет вам, откуда инструкция ret (при условии x86) берет свой адрес. Это то, что вам нужно изменить, чтобы указать на main+42.

Я предполагаю, что вы хотите явно спровоцировать здесь переполнение буфера, обычно вам нужно спровоцировать его, манипулируя входными данными «функции».

Просто объявив buffer[5], вы перемещаете указатель стека в неправильном направлении (убедитесь в этом, посмотрев на сгенерированную сборку), адрес возврата находится где-то глубже внутри стека (он был помещен туда инструкцией вызова). В x86 стеки растут вниз, то есть в сторону младших адресов.

Я бы подошел к этому, объявив int* и переместив его вверх, пока я не окажусь по указанному адресу, где адрес возврата был нажат, затем изменю это значение, чтобы оно указывало на main+42, и пусть функция ret.

Вы не можете сделать это таким образом. Вот классический пример кода переполнения буфера. Посмотрите, что произойдет, если вы наберете 5, а затем 6 символов с клавиатуры. Если вы выберете больше (должно быть 16 символов), вы перезапишете базовый указатель, затем функция вернет адрес, и вы получите ошибку сегментации. Что вы хотите сделать, так это выяснить, какие 4 символа перезаписывают адрес возврата. и заставить программу выполнить ваш код. Погуглите вокруг стека linux, структуры памяти.

 void ff(){
     int a=0; char b[5];
     scanf("%s",b);
     printf("b:%x a:%x\n" ,b ,&a);
     printf("b:'%s' a:%d\n" ,b ,a);
 }

 int main() {
     ff();
     return 0;
 }