Исправление ошибки переполнения стекового буфера

Техническое описание [ править ]

Переполнение буфера происходит, когда данные, записанные в буфер, также искажают значения данных в адресах памяти, смежных с целевым буфером, из-за недостаточной проверки границ . Это может происходить при копировании данных из одного буфера в другой без предварительной проверки того, что данные помещаются в целевой буфер.

Пример править

В следующем примере, выраженном на языке C , программа имеет две соседние в памяти переменные: 8-байтовый строковый буфер A и двухбайтовое целое число с прямым порядком байтов B.

char  A 8  =  "" ; беззнаковый  короткий  B  =  1979 ;

Изначально A содержит только нулевые байты, а B содержит число 1979.

имя переменной	А	B
ценить		1979 г.
шестнадцатеричное значение	00	00	00	00	00	00	00	00	07	BB

Теперь программа пытается сохранить строку с завершающим нулем в кодировке ASCII в буфере A.

strcpy ( A ,  «чрезмерно» );

имеет длину 9 символов и кодируется до 10 байтов, включая нулевой терминатор, но A может занимать только 8 байтов. Не проверяя длину строки, он также перезаписывает значение B:

имя переменной	А	B
ценить	'e'	'x'	'c'	'e'	's'	's'	'i'	'v'	25856
шестнадцатеричный	65	78	63	65	73	73	69	76	65	00

Значение B теперь непреднамеренно заменено числом, состоящим из части строки символов. В этом примере «e», за которым следует нулевой байт, станет 25856.

Операционная система иногда может обнаружить запись данных за пределами выделенной памяти и вызвать ошибку сегментации, которая завершает процесс.

Чтобы предотвратить переполнение буфера в этом примере, вызов strcpyможет быть заменен на strlcpy, который принимает максимальную емкость A (включая символ завершения нуля) в качестве дополнительного параметра и гарантирует, что будет записано не более этого количества данных к A:

strlcpy ( A ,  «чрезмерно» ,  sizeof ( A ));

Когда она доступна, strlcpyпредпочтительнее использовать библиотечную функцию, strncpyкоторая не завершает буфер назначения нулем, если длина исходной строки больше или равна размеру буфера (третий аргумент, переданный функции), поэтому Aне может быть нулевым. завершается и не может рассматриваться как допустимая строка в стиле C.

Краткое техническое изложение[править | править код]

Описаниеправить | править код

Рассмотрим более подробно случай переполнения буфера, расположенного в области стека. Это удобнее всего сделать с помощью примера программы на языке Си или C++. Пример ориентирован на архитектуру x86, но работает и на многих других.

Когда динамический буфер, представляющий собой автоматический массив, выделяется в функции, он создаётся на стеке во время вызова этой функции. В архитектуре x86 стек растёт от бо́льших адресов к меньшим (или справа налево, в приведённых ниже диаграммах), то есть новые данные помещаются перед теми, которые уже находятся в стеке. Здесь, представляет существующий стек, и — это некоторое новое значение, которое ЦП поместил в стек:

(NEWDATA)(DATA)(DATA)(…)

Записывая данные в буфер, можно осуществить запись за его границами и изменить находящиеся там данные. Когда программа вызывает подпрограмму, она помещает адрес возврата в стек, так что подпрограмма знает, куда возвращать управление после того, как она завершится:

(ADDR)(DATA)(DATA)(…)

Когда выделятся динамический буфер, стек растёт влево на размер буфера. Так, если функция начинается с объявления , результатом будет:

(.a………)(ADDR)(DATA)(DATA)(…)

В конце подпрограммы память, занятая буфером, освобождается, и вызывается операция . Она извлекает адрес возврата из стека и выполняет переход по этому адресу, возвращая управление туда, откуда была вызвана подпрограмма.

Предположим, что 10-байтный буфер предназначен для того, чтобы содержать данные, предоставляемые пользователем (например — пароль). Если программа не проверяет количество символов, которые были введены пользователем, и записывает 14 байт в буфер, эти лишние данные «лягут» поверх адреса возврата, перезаписывая его новыми данными. Таким образом, это изменит место, в которое будет передано управление, когда завершится подпрограмма, и с которого программа продолжит исполнение после этого.

Если пользователь не злонамерен и вводит более, чем 10 символов, добавочные данные будут скорее всего случайными. В таком случае вполне возможно, что адрес возврата будет указывать на область памяти, которая неподконтрольна текущей исполняемой программе. Это вызовет ошибку сегментации в UNIX-системах или аналогичную ошибку в других операционных системах.

Однако пользователь может подставить в качестве адреса возврата и некий правильный адрес. Это вызовет переход управления в любую точку программы по его выбору. В результате потенциально может быть выполнен любой произвольный код, который этот пользователь поместил в данную область памяти, с теми привилегиями, с которыми выполняется текущая программа.

Примерправить | править код

Рассмотрим следующую программу на языке Си. Скомпилировав эту программу, мы сможем использовать её для генерации ошибок переполнения буфера. Первый аргумент командной строки программа принимает как текст, которым заполняется буфер.

 /* overflow.c - демонстрирует процесс переполнения буфера */

 #include <stdio.h>
 #include <string.h>
 
 int main(int argc, char *argv[])
 {
   char buffer10];
   if (argc < 2)
   {
     fprintf(stderr, "ИСПОЛЬЗОВАНИЕ: %s строка\n", argv]);
     return 1;
   }
   strcpy(buffer, argv1]);
   return ;
 }

Программу можно опробовать с несколькими разными строками. Строки размером в 9 или меньше символов не будут вызывать переполнение буфера. Строки в 10 и более символов будут вызывать переполнение, хотя это может и не приводить к ошибке сегментации.

Эта программа может быть переписана следующим образом, с использованием функции для предотвращения переполнения. Однако, следует учитывать, что простое отбрасывание лишних данных, как в этом примере, также может приводить к нежелательным последствиям, в том числе, при определённых условиях, к повышению привилегий. Как правило, требуется более тщательная обработка таких ситуаций.

 /* better.c - демонстрирует, как исправить ошибку */
 
 #include <stdio.h>
 #include <string.h>
 #define BUFFER_SIZE 10
 
 int main(int argc, char *argv[])
 {
   char bufferBUFFER_SIZE];
   if (argc < 2)
   {
     fprintf(stderr, "ИСПОЛЬЗОВАНИЕ: %s строка\n", argv]);
     return 1;
   }
   strncpy(buffer, argv1], BUFFER_SIZE - 1);
   bufferBUFFER_SIZE - 1 = '\0';
   return ;
 }

Атака: переполнение буфера стека

Прежде чем углубляться в технические подробности о том, что такое переполнение стекового буфера и как оно работает, давайте рассмотрим простую для понимания аналогию:

Переполнение буфера стека, как и атака Боба, перезаписывает данные, которые разработчик не собирался перезаписывать, обеспечивая полный контроль над программой и её выходными данными.

Конференция Heisenbug 2020 Moscow

4–7 ноября, Онлайн, От 14 500 до 64 000 ₽

tproger.ru

События и курсы на tproger.ru

Итак, теперь давайте посмотрим на это в реальном мире. Взгляните на следующий фрагмент кода:

В приведённой выше функции мы видим, что массив символьного типа с именем создаётся с размером 64. Затем мы видим, что переменная равна 0, и функция вызывается с переменной в качестве аргумента. Наконец, мы видим оператор , который проверяет, не равно ли значение нулю. Очевидно, что нет, где в этом приложении переменная имеет значение, отличное от 0. Так как мы собираемся её изменить?

Что ж, давайте сначала посмотрим на документацию функции :

Определение функции gets ()

Описание багов в функции gets ()

Как видите, функция просто принимает пользовательский ввод. Однако функция не проверяет, действительно ли пользовательский ввод вписывается в структуру данных, в которой мы его храним (в данном случае это ), и, таким образом, мы можем переполнить структуру данных и повлиять на другие переменные и данные стека. Кроме того, поскольку мы знаем, что все переменные хранятся в стеке, и мы знаем, что представляет собой переменная (0), всё, что нам нужно сделать, — это ввести достаточно данных, чтобы перезаписать переменную . Давайте посмотрим на диаграмму:

ASCII-диаграмма переполнения буфера стека

Как видите, если злоумышленник просто вводит слишком много текста, он может перезаписать переменную и всё остальное в стеке, включая указатели возврата. Это означает, что если злоумышленник сможет взять под контроль стек программы, он сможет эффективно контролировать всю программу и заставить её делать то, что он хочет. Например, можно просто перезаписать указатель возврата функции в стеке на пользовательский, указывающий на вредоносную функцию.

Использование переполнения буфера стека

Канонический метод использования переполнения буфера на основе стека — перезапись адреса возврата функции указателем на данные, контролируемые злоумышленником (обычно в самом стеке). Это проиллюстрировано в следующем примере:

#включают <string.h>пустота фу(char *бар){   char c12];   strcpy(c, бар);  // без проверки границ}int главный(int argc, char **argv){   фу(argv1]);   возвращаться ;}

Этот код берет аргумент из командной строки и копирует его в локальную переменную стека. . Это отлично работает для аргументов командной строки меньше 12 символов (как вы можете видеть на рисунке B ниже). Любые аргументы длиной более 11 символов приведут к повреждению стека. (Максимальное количество безопасных символов на единицу меньше размера буфера здесь, потому что в языке программирования C строки заканчиваются нулевым байтовым символом. Таким образом, для ввода из двенадцати символов требуется тринадцать байтов для хранения, за вводом следует нулевым байтом сигнального устройства. Нулевой байт затем завершает перезапись области памяти, которая на один байт выходит за пределы буфера.)

Стек программ в с различными входами:

A. — Перед копированием данных.

Б. — «привет» — это первый аргумент командной строки.

C. — «A A A A A A A A A A A A A A A A A A A A A x08 x35 xC0 x80 «- это первый аргумент командной строки.

Обратите внимание на рисунок C выше, когда в командной строке указан аргумент размером более 11 байт

перезаписывает данные локального стека, сохраненный указатель кадра и, что наиболее важно, адрес возврата. Когда возвращает он выталкивает адрес возврата из стека и переходит на этот адрес (т.е

начинает выполнение инструкций с этого адреса). Таким образом, злоумышленник перезаписал адрес возврата указателем на буфер стека. , который теперь содержит данные, предоставленные злоумышленником. При фактическом использовании переполнения буфера стека строка «A» вместо этого будет шеллкод подходит для платформы и желаемой функции. Если у этой программы были особые привилегии (например, SUID бит установлен для работы как суперпользователь), то злоумышленник может использовать эту уязвимость для получения привилегий суперпользователя на уязвимой машине

Когда возвращает он выталкивает адрес возврата из стека и переходит на этот адрес (т.е. начинает выполнение инструкций с этого адреса). Таким образом, злоумышленник перезаписал адрес возврата указателем на буфер стека. , который теперь содержит данные, предоставленные злоумышленником. При фактическом использовании переполнения буфера стека строка «A» вместо этого будет шеллкод подходит для платформы и желаемой функции. Если у этой программы были особые привилегии (например, SUID бит установлен для работы как суперпользователь), то злоумышленник может использовать эту уязвимость для получения привилегий суперпользователя на уязвимой машине.

Злоумышленник также может изменить значения внутренних переменных, чтобы воспользоваться некоторыми ошибками, например:

#включают <string.h>#включают <stdio.h>пустота фу(char *бар){   плавать My_Float = 10.5; // Адрес = 0x0023FF4C   char  c28];           // Адрес = 0x0023FF30   // Напечатаем 10.500000   printf("Мое значение с плавающей запятой =% f", My_Float);    /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~       Карта памяти:       @: c выделенная память       #: My_Float выделенная память           * c * My_Float       0x0023FF30 0x0023FF4C           |                           |           @@@@@@@@@@@@@@@@@@@@@@@@@@@@#####      foo ("моя строка слишком длинная !!!!! XXXXX");   memcpy поместит 0x1010C042 (little endian) в значение My_Float.   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/   memcpy(c, бар, Strlen(бар));  // без проверки границ ...   // Напечатаем 96.031372   printf("Мое значение с плавающей запятой =% f", My_Float);}int главный(int argc, char **argv){   фу("моя строка слишком длинная !!!!! x10x10xc0x42");   возвращаться ;}

Excel 2013: «не удалось освободить место в буфере обмена. Другая программа может использовать его прямо сейчас»

Excel 2013 часто жалуется, что » мы не смогли освободить место в буфере обмена. Другая программа может использовать его прямо сейчас», когда я пытаюсь скопировать ячейки.

некоторые сказать это может быть вызвано сигнализацией зоны или Bing Desktop. У меня нет ни одного из них. Я использую Windows 7, поэтому у меня нет clipbrd.exe. Как узнать, на что жалуется другая программа Excel?

Я тоже видел эту очень неприятную ошибку. С момента внесения ниже изменения, хотя кажется, что проблема решена.

обратите внимание, что я не работает какой-либо из программ (Bing рабочего стола и т. д.), которые обычно приписываются этой проблеме, даже самим Microsoft

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

Откройте Параметры буфера обмена, нажав стрелку расширения на ленте в разделе Главная (это Excel, но другие приложения Office должны быть идентичны или очень похожи).

откройте диалоговое окно Параметры в левом нижнем углу открывшейся панели. Выберите’Собирать, Не Показывая Офис Буфер Обмена‘ и закрыть панель.

надеюсь, проблема теперь решена, и вы можете копировать и вставлять без ошибок или фокус ячейки теряется.

редактировать: оказывается, занимательно, по крайней мере, что это может быть связано с запуском 32-разрядной версии Office на 64-битных ОС. Это, конечно, то, что я делаю, и многие другие, кажется, в той же ситуации. Будет интересно посмотреть, так ли это.

надеюсь, это поможет кому-то еще. У меня есть пользователь рабочей станции HP Z820 с Windows 7 Professional sp1, 32 ГБ оперативной памяти, 1 ТБ диск с

712 ГБ свободного пространства, Office 2013 sp1. Да, это рабочая станция, но этот пользователь запускает множество программ одновременно, включая большие электронные таблицы excel с сводными таблицами. Недавно они начали иметь эту ошибку при попытке перетащить данные в ячейку excel в другую ячейку. Они выяснили, что если Outlook не работает, то ошибка не приходит. Но это не выполнимо по мере того как потребность для потребителя иметь внешний вид, Слово, и Эксел, котор нужно раскрыть в тоже время. Я полагал, что некоторые другие приложения вмешивался в буфер обмена, так как эта ошибка не происходит с первого дня, когда я установил офис. Я начал закрывать программы по одной и после каждого испытания. Последняя программа, которую я закрыл, что позволило outlook, чтобы быть открытым и не получить сообщение об ошибке в excel был skitch. Потребитель установил skitch для того чтобы позволить им захватить экраны и принести его в Evernote из других приложений. И, по-видимому, сочетание Outlook и Skitch вызывает Excel жаловаться при попытке перетащить содержимое ячейки в другую ячейку. Я могу воспроизвести это каждый раз. Так что если у вас есть office 2013 sp1 и у вас есть outlook и excel работает с skitch работает в фоновом режиме, и вы получите ошибку при перетаскивании ячеек в excel, просто перейдите в область системного трея и убить skitch.

Это также происходит, если любая другая программа следит за буфером обмена. Например, у меня был бесплатный менеджер загрузок, и он отслеживал буфер обмена. Когда я выключил эту опцию, проблема исчезла в Excel 2013.

и у меня нет bing desktop и у меня нет зоны тревоги.

Что делать, если обнаружена уязвимость в данном приложении

Первое, что нужно сделать в том случае, когда ошибка проявилась в конкретной программе, это попробовать её переустановить, загрузив инсталлятор из проверенного источника, лучше официального. Перед инсталляцией софта следует убедиться в его безопасности, просканировав антивирусом, особенно внимательно нужно устанавливать ПО при пакетной установке, когда в довесок к скачиваемому продукту идут и дополнительные элементы, часто вредоносные или просто ненужные. Переустановка софта и перезагрузка компьютера избавляют от ошибки, если она была случайной.

Рассмотрим, несколько способов, как исправить ошибку, если произошло переполнение стекового буфера Windows 10.

Использование антивирусного ПО

В тексте ошибки переполнения буфера говорится о потенциальной угрозе безопасности, и, несмотря на достаточно преклонный возраст и известность бага, он всё ещё актуален и нередко становится средством взлома систем. Причём сбою поддаются программы различных типов, а спровоцировать его можно специально задействованным вредоносным софтом.

Рекомендуется просканировать систему на вирусы, можно в безопасном режиме, если ОС не загружается, и выполнить проверку и устранение угроз посредством встроенного Защитника Windows.

Как очистить компьютер от вирусов при появлении ошибки «Стековый буфер переполнен»:

• Открываем Защитник Windows через поисковую строку меню «Пуск» или в области уведомлений на панели задач;
• Выбираем «Защита от вирусов и угроз» и переходим к параметрам сканирования;
• Отмечаем флажком «Автономное сканирование Защитника Windows» и жмём соответствующую кнопку для начала проверки.

Чистая загрузка ОС Windows

Если переустановка софта и перезагрузка не помогли, и ошибка переполнения стекового буфера не исчезла, стоит попробовать выполнить чистую загрузку системы. Возможно, причины проблемы не относятся к данному приложению, ведь кроме работающих программ в Windows запущен ряд прочих процессов, которые и могут провоцировать баг. Для выполнения загрузки ОС в чистом виде нужно войти под учётной записью администратора компьютера, некоторые функции и приложения при этом будут недоступны, поскольку в данном режиме запускаются только необходимые системе файлы.

Для чистой загрузки Windows выполняем следующие действия:

1. Открываем консоль «Выполнить» (Win+R), вводим в поле команду msconfig, жмём «Ок» или клавишу Enter.
2. В окне «Конфигурация системы» на вкладке «Общие» снимаем отметку с пункта «Загружать элементы автозагрузки». Затем на вкладке «Службы» отмечаем пункт «Не отображать службы Майкрософт» и жмём кнопку «Отключить все».
3. Идём на вкладку «Автозагрузка» и жмём ссылку «Открыть диспетчер задач» (для Windows 10), в открывшемся окне Диспетчера задач поочерёдно отключаем каждую программу в списке.
4. Возвращаемся к окну конфигурации и жмём «Ок», после чего перезагружаемся и проверяем, исчезла ли ошибка.

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

Специализированный софт

В сети есть немало лечащих утилит (Dr.Web CureIt, Kaspersky и др.), способных избавить компьютер от вирусов. Портативные программы не будут конфликтовать с уже установленным антивирусом и эффективно выполнят задачу сканирования и удаления вредоносного ПО. Есть также антивирусный софт, способный решать проблему на низком уровне, если вирусы не дают системе запуститься. Используя утилиты с обновлённой вирусной базой, можно исправить, в том числе ошибку переполнения стекового буфера.

Восстановление Windows

Ещё одна мера, позволяющая избавится от системной ошибки, предполагает выполнение восстановления системы. Для использования функции потребуется наличие заранее созданного накопителя восстановления Windows, в качестве которого можно использовать диск или флешку. Выполняем следующие действия:

• отключаем от компьютера лишние устройства, не требуемые для работы;
• вставляем загрузочный накопитель и загружаемся с него, предварительно выставив приоритет загрузки в BIOS;
• выбираем «Восстановление системы» – «Диагностика» – «Дополнительные параметры» – «Восстановление при загрузке», далее выбираем ОС, которую требуется восстановить, и ждём окончания процесса, перезагружаемся.

Крайней мерой, когда более простые и гуманные способы решения не помогли исправить ошибку, является переустановка Windows.

Уязвимости компиляции

В случае если небезопасная функция оставляет открытую возможность переполнение буфера C, то не все потеряно. При запуске программы компиляторы часто создают случайные значения, известные как канарейки (canary), и помещают их в стек, поэтому представляют опасность. Проверка значения канарейки по отношению к ее первоначальному значению может определить, произошло ли переполнение буфера Windows. Если значение было изменено, программа будет закрыта или перейдет в состояние ошибки, а не к потенциально измененному адресу возврата.

Перед тем как исправить переполнение буфера, распаковывают на ПК ASLR. Он был разработан для защиты от ориентированного на возврат программирования как обходной путь к неисполнимым стекам, где существующие фрагменты кода объединены в цепочку на основе смещения их адресов.

Он работает путем рандомизации областей памяти структур, так что их смещения сложнее определить. Если бы эта защита существовала в конце 1980-х годов, червя Морриса можно было бы не допустить. Это связано с тем, что он функционировал частично, заполняя буфер в протоколе UNIX finger кодом эксплойта, а затем переполнял его, чтобы изменить адрес возврата и указывал на заполненный буфер.

ASLR и DEP усложняют точное определение адреса, который нужно указать, выполняя эту область памяти полностью нерабочей. Иногда уязвимость проскальзывает сквозь трещины, открытые для атаки переполнения буфера, несмотря на наличие элементов управления на уровне разработки, компилятора или операционной системы.

Причины ошибки

Что же может привести к такой неприятной ситуации? Исходя из описанного выше механизма, один из вариантов — слишком большое число вложенных вызовов функций. Особенно вероятен такой вариант развития событий при использовании рекурсии. Бесконечная рекурсия (при отсутствии механизма «ленивых» вычислений) прерывается именно таким образом, в отличие от бесконечного цикла, который иногда имеет полезное применение. Впрочем, при небольшом объеме памяти, отведенной под стек (что, например, характерно для микроконтроллеров), достаточно может быть и простой последовательности вызовов.

Другой вариант — локальные переменные, требующие большого количества памяти. Заводить локальный массив из миллиона элементов, или миллион локальных переменных (мало ли что бывает) — не самая лучшая идея. Даже один вызов такой «жадной» функции легко может вызвать переполнение стека. Для получения больших объемов данных лучше воспользоваться механизмами динамической памяти, которая позволит обработать ошибку её нехватки.

Однако динамическая память является довольно медленной в плане выделения и освобождения (поскольку этим занимается операционная система), кроме того, при прямом доступе приходится вручную выделять её и освобождать. Память же в стеке выделяется очень быстро (по сути, надо лишь изменить значение одного регистра), кроме того, у объектов, выделенных в стеке, автоматически вызываются деструкторы при возврате управления функцией и очистке стека. Разумеется, тут же возникает желание получить память из стека. Поэтому третий путь к переполнению — самостоятельное выделение в стеке памяти программистом. Специально для этой цели библиотека языка Си предоставляет функцию alloca. Интересно заметить, что если у функции для выделения динамической памяти malloc есть свой «близнец» для её освобождения free, то у функции alloca его нет — память освобождается автоматически после возврата управления функцией. Возможно, это только осложняет ситуацию — ведь до выхода из функции освободить память не получится. Даже несмотря на то, что согласно man-странице «функция alloca зависит от машины и компилятора; во многих системах ее реализация проблематична и содержит много ошибок; ее использование очень несерьезно и не одобряется» — она все равно используется.

Атака временной области хранения

Буфер представляет собой временную область для хранения данных. Когда программа или системный процесс размещает больше данных чем было изначально выделено для хранения, дополнительные переполняются. Это приводит к тому, что некоторые из них просачиваются в другие buffer, повреждают или перезаписывают данные.

При атаке с переполнением дополнительные данные содержат специальные инструкции для действий, предназначенных хакером или злонамеренным пользователем, например, они вызывают ответ, который повреждает файлы, изменяет данные или раскрывает личную информацию.

Злоумышленник использует эксплойт с переполнением, чтобы воспользоваться программой, ожидающей ввода пользователя. Существует два типа переполнения buffer: на основе стека и кучи. Основанные на куче трудны для выполнения и наименее распространенные, при этом атакуют приложение, заполняя пространство, зарезервированное для программы.

Современные компиляторы обычно предоставляют возможность проверки переполнения во время компиляции/компоновки, но во время выполнения довольно сложно проверить эту проблему без какого-либо дополнительного механизма защиты обработки исключений.

Варианты работы программы:

Уязвимость существует из-за переполнения, если пользовательский ввод argv превышает 8 байтов. Для 32-битной системы (4 байта) заполняют память двойным словом (32 бита). Размер символа составляет 1 байт, поэтому если запросить буфер с 5 байтами, система выделит 2 двойных слова (8 байтов). Вот почему при вводе более 8 байтов Buffer будет переполнен.

Подобные стандартные функции, которые технически менее уязвимы, существуют. Например, strncpy (), strncat () и memcpy (). Проблема с этими функциями заключается в том, что ответственность за определение размера буфера лежит на программисте, а не на компиляторе.

Каждый программист C/C++ должен знать проблему прежде чем начинать кодирование. Многие генерируемые проблемы в большинстве случаев могут быть защищены от переполнения.

Soft Perfect RAMDisk

Это программа менее гибкая, однако более простая. Использовать ее бесплатно можно 30 дней, далее придется заплатить.

Процесс создания диска RAM также прост:

1. Создайте образ будущего диска. Для этого кликните на вкладку «Образ», выберите «Создать образ».
2. Нажмите на кнопку с изображением папки в поле для пути к образу. В открывшемся окне выберите папку, куда хотите сохранить образ и введите его название.
3. Выберите тип образа «Жесткий диск» и укажите его объем.
4. Нажмите ОК.
5. Теперь необходимо смонтировать RAM-диск. Для этого нажмите на зеленый плюс в главном меню.
6. Снова нажмите на папку и выберите ранее созданный образ диска.
7. Ниже обязательно поставьте галочку напротив «Сохранять содержимое», чтобы данные из RAM сохранялись в образ на HDD. Также установите галочку напротив «Эмуляция жесткого диска» и нажмите «Ок».

После этого диск будет создан. Программа автоматически инициализирует образ в оперативную память при запуске ПК.

Как и в предыдущей программе, вы можете указать время автоматического сохранения файлов. Для этого кликните правой кнопкой мыши по созданному диску и выберите «Свойства». После этого нажмите на кнопку «Дополнительно», поставьте галочку в соответствующем поле и укажите промежуток времени.

Напутственные речи

Была рассмотрена атака на переполнение стека в одной конкретной программе собственного производства. Но точно также осуществляются атаки на переполнение буфера и в других уязвимых программах. И таких программ немало! Основная причина уязвимости — использование некоторых функций языка Си, работающих со строками и не проверяющих размеры своих аргументов (например strcpy, strcat, gets или sprintf). Поэтому подавляющее большинство (если не все) уязвимых программ написаны на Си. Возможно представить уязвимую программу и на другом императивном языке (вот несколько искусственный пример: цикл while, копирующий массив и в условии окончания полагающийся на корректность данных). Наконец совсем невозможно создать уязвимую программу на языке очень высокого уровня с очень строгой проверкой соответствия типов (сюда относятся в частности функциональные и логические языки программирования).

Особую опасность переполнение стека представляет в многопользовательских системах вроде Windows NT и Unix, где оно может дать возможность простому пользователю выполнить код в правах администратора (если уязвимой окажется какая-либо системная — типа setuid-root — программа). Также опасны уязвимости в программах, работающих через сеть (браузеры, чаты, мессенжеры и проч.). Они могут дать удалённому пользователю доступ к компьютеру.

Для защиты от возможности написания уязвимых программ существуют различные методы — использование специальных «безопасных» аналогов опасных функций (strncpy, strncat, …), запрет на исполнение кода в области стека, проверка границ переменных при каждом доступе к ним и др. Но всё же самый надёжный (хоть и непростой) способ — качественное программирование, чего вам и желаю.