Перерасход буфера


  Share  
|


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

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

Влияние буфера чем это что угодно, начиная с катастрофы на злоумышленник получает полный контроль за применением, и в случае работает как на высоком уровне пользователя (суперпользователя администратора или локальной системы), то контроль над всей операционной системы и любых других пользователей, которые в настоящее время входа в систему, или возьмем на, в руках злоумышленника. Если заявка на вопрос - это услуга сети, в связи с недостатком может быть червем. Первые известные Интернет червь используют буфера перерасход пальцем сервер, и был известен как Роберт Т. Моррис (или просто Моррис) пальцем червем. Хотя она, похоже, как если бы мы научились избегать перерасхода буфера, поскольку одна почти сбит Интернет в 1988, мы продолжаем наблюдать частые доклады буферной перерасход многих видов программного обеспечения.

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

Пострадавшие Языки

C является самым распространенным языком для создания буферной перерасход, внимательно следит за C + +. Можно легко создать буферную перерасход при редактировании в ассемблера ему не имеет гарантий на всех. Хотя C + + по сути же опасен, как С, поскольку она является надстройкой C, с использованием стандартной библиотеки шаблонов (STL) с осторожностью может существенно снизить потенциал mishandle строки. Увеличение строгости С + + компилятор поможет программисту избежать некоторых ошибок. Наш совет состоит в том, что даже если вы пишете на чистом C код, с помощью С + + компилятор позволит чистого кода.

Недавно изобрел языки высокого уровня абстрактного прямой доступ к памяти от программиста, в целом на значительную эффективность затрат. Языки таких, как Java, C # и Visual Basic имеют родной комбинация типов границ проверила батарей, и в целом запрещает прямой доступ к памяти. Хотя некоторые утверждают, что это делает невозможным буферной перерасход, это точнее сказать, что перерасход буферной гораздо менее вероятным. В реальности, большинство из этих языков осуществляется в C / C + +, и осуществление недостатки могут привести к буферной перерасход. Другой потенциальный источник буферной перерасход в высшие код существует потому, что код должен в конечном итоге взаимодействие с операционной системой, и эта операционная система почти наверняка написаны на C / C + +. C # позволяет выполнять без чистой, объявив небезопасных участках; Однако, в то время как он предоставляет легче совместимости с операционной системой и библиотеки написаны на C / C + +, можно сделать те же ошибки можно в C / C + + . Если программа в основном языки высокого уровня, основные действия пункта для вас продолжать подтвердить данные передаются внешние библиотеки, или вы можете выступать в качестве средства для их недостатки.

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

Грех пояснил

Классическим воплощением буфера перерасход известен как "битье стека." В обобщенной программы, стек используется для проведения контроля информацию, такую как аргументы, когда заявка должна вернуться к некогда это сделали с функцией и потому из небольшого числа регистров есть на x86 процессоры, зачастую получают регистры хранятся временно стека. К сожалению, переменные, которые на местах выделены также хранятся на стек. Эти переменные стека иногда неточно называются статически выделенные, а не динамически выделяемых кучи памяти. Если вы узнали кого-то говорим о статической буферной перерасход, то, что они реально означают собой стопку буферной перерасход. В корень проблемы заключается в том, что если применение пишет за границы массива, выделяемых на трубу, злоумышленник получает контроль уточнить информацию. И это имеет решающее значение для успеха; Нападающий хочет изменять данные для контроля значения его торгов.

Кто-то может спросить, почему мы продолжаем использовать такой системы, безусловно, опасный. Мы имели возможность избежать проблем, по крайней мере частично, с миграцией на Intel в 64 - битный Itanium чипом, где возвращение адреса хранятся в реестре. Проблема в том, что мы должны терпеть значительные потери обратной совместимости, а также написания этого выясняется, что x64 чип, вероятно, в конечном итоге наиболее популярных фишек.

Вы также можете, почему мы просто не всех перейти на код, который выполняет строгие проверки и массив запрещает прямой доступ к памяти. Проблема в том, что для многих видов применения, эксплуатационных характеристик языки высокого уровня не достаточно. Один золотой середины "- использовать языки высокого уровня для верхнего уровня интерфейса, которые взаимодействуют с опасных вещей (как пользователей!) , И ниже уровня языков для основного кода. Другим решением может в полной мере использовать возможности C + + и использовать строку библиотеки и коллекции классов. Например, Internet Information Server (IIS) 6,0 веб-сервер полностью перешел на C + + строка класс для обработки материалов, и один мужественный разработчик заявил, что он бы ампутировать его мало пальцем если буферной перерасхода были обнаружены в его код. На момент написания этой документации разработчика до сих пор его и пальцем не выпуски были выпущены против веб-серверов на протяжении почти двух лет с момента его освобождения. Современные компиляторы и решения с templatized классов, и можно написать очень высокопроизводительных C + + код.

Хватит теории - давайте Рассмотрим пример:

# включить <stdio.h>

недействительным DontDoThis (символьного ввода *)
(
символ buf [16];

strcpy (buf, материалы);

printf ( "% ы \ н", buf);
)

int основных (int argc, символ * argv [])
(
/ / поэтому мы не проверяет аргументы
/ / А что вы ожидать от приложений, использует strcpy?
DontDoThis (argv [1]);
возвращение 0;
)

Теперь давайте собирать заявки и посмотрите, что произойдет. Для этой демонстрации, автор использовал освобождение строить с символами отладки включен и стек проверки отключена. Хороший компилятор также хотим встроенная функция размером DontDoThis, особенно если речь идет лишь призыв один раз, поэтому он также инвалидов оптимизации. Вот что стек выглядит на его системе непосредственно перед призывом strcpy:

0 x0012FEC0 c8 fe 12 00 Èþ .. <- адрес в buf аргумент
0 x0012FEC4 c4 18 32 00 Ä.2. <- адрес входного аргумента
0 x0012FEC8 d0 fe 12 00 Ðþ .. <- начала buf
0 x0012FECC 04 80 40 00. <<Unicode: 80>> @.
0 x0012FED0 e7 02 3f 4f ç. ? O
0 x0012FED4 66 00 00 00 f. .. <- конец buf
0 x0012FED8 e4 fe 12 00 äþ .. <- содержимое EBP регистр
0 x0012FEDC 3f 10 40 00? . @. <- вернуться адрес
0 x0012FEE0 c4 18 32 00 Ä.2. <- адрес аргумента DontDoThis
0 x0012FEE4 c0 далее 12 00 Àÿ ..
0 x0012FEE8 10 13 40 00 .. @. <- адрес главной () вернется

Не забывайте, что все значения на стек являются назад. Этот пример, с Intel системы, которая "практически endian." Это означает, наименее значительный байт значения раньше, так что если вы видите обратного адреса в памяти как "3f104000", это действительно адрес 0x0040103f.

Теперь давайте посмотрим что происходит, когда buf является перезаписан. Первая информация о контроле стека является содержание расширенного Базы Pointer (EBP) регистра. EBP содержит рамки указатель, и если со смещением на один переполнение происходит, EBP будет усечено. Если злоумышленник может контролировать память на 0x0012fe00 (вне на нулей - один из последних байта), программа прыжков в этом месте и выполняет нападающий - поставляется код.

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

После обратного адреса был перезаписан, то злоумышленник получает играть с аргументами эксплуатационных функций. Если программа пишет на любой из этих аргументов, а затем вернулись, она представляет собой дополнительные возможности для хаоса. Этот момент становится важным при рассмотрении эффективности контрмер стека фальсификации таких, как Криспин Коуэн в Stackguard, IBM's ProPolice, и в Microsoft / ОО компилятор флаг.

Как видите, мы только что атакующий по меньшей мере три способа взять под контроль нашей заявки, и это только в очень простую функцию. Если C + + класса с виртуальными функциями, объявленным в стек, то виртуальные функции указатель таблицы будут доступны, и это может легко привести к подвиги. Если один из аргументов к функции происходит в качестве указателя на функцию, которая является довольно распространенным в любой оконной системы (например, X Window System или Microsoft Windows), затем переписав указателя на функцию до использования является очевидным способом отвлечь контроля по заявлению.

Многие, многие более умные пути захватить контроль в заявке имеются, чем наши слабые мозги могут думать о. Существует дисбаланс между нашими способностями, как разработчики и способностей и ресурсов злоумышленника. Вы не допускается неограниченное количество времени написать заявление, но нападающие не могут иметь что-либо еще делать с их обширной свободное время, чем понять, как сделать свой код делать то, чего они хотят. Код может защитить активы, ценных чтобы оправдать месяцев усилий, чтобы подорвать вашу заявку. Злоумышленники тратить много времени узнать о последних событиях в нанесении увечий, и ресурсов, как www.metasploit.com где они могут мышкой свой путь обстреливать код, что делает почти то, что они хотят, хотя в операционной ограничивается набором символов.

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

Суть этого состоит в том, что обличительная речь умная вещь - это просто исправить ошибки! Там были несколько раз, что "качество кода усовершенствования", оказались безопасности устанавливает в ретроспективе. Это просто автор провел более трех часов заявив в команде разработчиков о том, они должны исправить эту ошибку. Электронной почты резьба в общей сложности восемь человек, и мы легко провел 20 часов (половина лица - в неделю) обсуждается ли решить проблему или не потому, что в команде разработчиков хотят доказательство того, что код был эксплуатации. После безопасности эксперты доказали ошибкой было действительно проблемы, решения оценивается в один час времени и разработчик нескольких часов испытаний времени. Это невероятно трата времени.

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

Это общее заблуждение, что перерасход в кучи буферы меньше, чем эксплуатационные стека перерасход, но это оказалось не так. Большая куча реализаций страдают от той же основной недостаток, как стек - пользователя данных и контроля данные смешиваются. В зависимости от реализации распределитель памяти, часто можно получить кучу менеджер поставить четыре байта из атакующего выбор в место, указанное в злоумышленник. Подробная информация о том, как нападение на кучи несколько arcane. А недавно и четкие письменные представления по этому вопросу, "Надежные Windows Хип заслуги" на Мэтью "shok" Коновер и Oded Хоровиц, можно найти на http://cansecwest.com/ csw04/csw04-Oded + Connover.ppt. Даже если менеджер кучи не может быть сорвано сделать злоумышленник в торгах, данные в соседнем ассигнований может содержать функции указатели или указатели, которые будут использоваться для записи информации. В свое время, используя переполнение кучи был рассмотрен экзотических и труднодоступных переполнения кучи в настоящее время некоторые из самых частых типов эксплуатируемых ошибок.

Грешное C / C + +

Есть много способов захватить буфера в C / C + +. Вот чем вызваны червем Морриса пальцем:

символ buf [20];

получает (buf);

Существует абсолютно никоим образом не использовать запускается следующим образом вклад stdin без риска переполнения буфера в использовании fgets вместо. Возможно, второй самый популярный способ переполнения буферов состоит в использовании strcpy (см. предыдущий пример). Это еще один способ вызвать проблемы:

символ buf [20];
символ префикса [] = "http://";

strcpy (buf, префикс);
strncat (buf, пути, sizeof (buf));
Что было сделано неправильно? Проблема здесь заключается в том, что strncat имеет слабо разработан интерфейс. Функция хочет символов имеющихся буфера, или пространства слева, а не общий размер буфера назначения. Вот еще любимый способ вызвать переполнение:

символ buf [MAX_PATH];

sprintf (buf, "% ы -% г \ н", пути, errno);

Это практически невозможно, за исключением в некоторых случаях угол, использовать sprintf безопасно. Одним из важнейших бюллетене безопасности для Microsoft Windows была выпущена из-за sprintf используется в функции отладки лесозаготовок. См. бюллетень MS04 - 011 для получения дополнительной информации (см. ссылку в "Другие ресурсы" раздела).

Вот еще любимое:

символ buf [32];
strncpy (buf, данные, strlen (данные));
Так что же случилось с этим? Последний аргумент - длина входящего буфера, а не размер буфера назначения!

Другой способ вызвать проблемы является mistaking характера приходится рассчитывать байта. Если вы занимающихся символы, это то же самое, но если вы занимающихся Unicode есть два байтов на один символ. Вот пример:

_ snwprintf (wbuf, sizeof (wbuf), "% ы \ н", материалы);
Следующие перерасход это чуть более интересно:

bool CopyStructs (InputFile * pInFile, неподписанные долго рассчитывать)
(
неподписанные долго я;

m_pStructs = новый Structs [подсчета];

в (я = 0; я <подсчета; я + +)
(
если (! ReadFromFile (pInFile, и (m_pStructs [я])))
перерыв;
)
)
Как неэффективности этих мер? Рассмотрим, что когда вы позвоните в C + + [] новый оператор, он похож на следующий код:

ptr = malloc (sizeof (тип) * рассчитывать);
Если пользователь поставляет рассчитывать, это не сложно определить стоимость, что происходит умножения операции внутри. Затем выделить буфера намного меньше, чем нужно, и злоумышленник может написать на своей буфера. Предстоящая C + + компилятор в Microsoft Visual Studio 2005 содержит внутренние проверки для предотвращения этой проблемы. Аналогичная проблема может произойти внутри во многих реализациях calloc, которая выполняет ту же операцию. В этом суть многих ошибок целочисленного переполнения: Это не целочисленного переполнения, которое вызывает проблема безопасности; Его буферной перерасход, что следующим быстро, что приводит к головной боли. Но об этом в Син 3.

Вот еще один способ буфера перерасход может получить создан:

# определить MAX_BUF 256
недействительным BadCode (символьного ввода *)
(
Короче вр;
символ buf [MAX_BUF];

вр = strlen (входные);

/ / конечно, мы можем использовать strcpy безопасно
если (вр <MAX_BUF)
strcpy (buf, материалы);
)
Это выглядит, как будто она должна работать, правда? Код фактически сопряжено с проблемами. Мы начнем в этом более подробно, когда мы обсуждаем целочисленное переполнение в Син 3, но прежде считают, что целых всегда типа подписали int. Ввода более 32K будет щелкнуть вр на отрицательное число; Он получит взброс на int и поддержания знака; И теперь всегда меньше, чем MAX_BUF, вызвав переполнение. Второй способ вам сталкиваться проблем, если строка больше, чем 64K. Теперь у Вас появилась усечение ошибка: вр будет небольшим положительным числом. Основные проблемы заключается помнить, что size_t определяется в язык как правильный тип использовать для переменных, которые представляют размеры в спецификации языка. Еще одна проблема, которая заключается в том, что скрытую вклада не может быть ничтожным - прекращено. Вот что код лучше выглядит:

постоян size_t MAX_BUF = 256;
недействительным LessBadCode (символьного ввода *)
(
size_t вр;
символ buf [MAX_BUF];

вр = strlen (входные);

/ / конечно, мы можем использовать strcpy безопасно
если (вр <MAX_BUF)
strcpy (buf, материалы);
)

Похожие Sins

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

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

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

Пятнистость грех План

Вот компоненты для поиска:

  • Input, будь то чтение из сети, в файл, или из командной строки

  • Передача данных говорит материалы для внутренней структуры

  • Использование небезопасных комбинация обработки требует

  • Использование арифметического расчета распределения размера или оставшихся размер буфера

Пятнистость грех ходе код обзор

Пятнистость этот грех в ходе рассмотрения код варьируется от очень легко чрезвычайно сложно. Простой вещи искать являются использование небезопасных функций обработки строки. Один из вопросов, которые могут возникнуть, что можно найти много примеров безопасного использования, но это был наш опыт, есть проблемы скрываются среди правильный призыв. Преобразование кода использовать только безопасные призывает имеет очень низкий коэффициент регрессии (в любом из 1/10th к 1/100th от обычной - исправить ошибку регрессии ставка), и его подвиги будут удалены из вашего кода.

Один из эффективных способов сделать это - позволить компилятору найти опасные функции требует вас. Если вы неопределенная strcpy, strcat, sprintf, а аналогичные функции, компилятор найдет все они для вас. А проблемы, которые могут возникнуть, что некоторые приложениям вновь выполнены все или часть С перспективе времени внутри библиотеки.

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

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

Тестирование Методы Найдите Син

Фузз испытания, какие вопросы ваша заявка на полузасушливых случайных материалов, является одним из методов тестирования лучше использовать. Попробуйте увеличить объем ввода символов при соблюдении поведение приложение. Что-то нужно посмотреть, что иногда несоответствия между материалы проверки приведут в относительно небольших окон уязвимых код. Например, кто-то может поставить проверку в одном месте, что вклад не должен превышать 260 символов, а затем выделить 256 байта буфера. Если вы проведете очень много материалов, это будут просто отвергнуты, но если вы попали в переполнение точно, можно найти эксплуатировать. Длина, которые кратны двух кратным два плюс или минус один часто найти проблем.

Другие уловки, чтобы попытаться ищем в любом месте входного где продолжительность что-то указанного пользователя. Изменение длины, чтобы она не совпадает с длиной строки, и особенно искать возможность целочисленного переполнения - условиях, когда длина + 1 = 0 зачастую опасно.

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

Один изменения можно внести в свой код, что если утверждать, является проверка вводимого пользователем, изменения, вытекающие из

утверждают (вр <MAX_PATH);

в

если (вр> = MAX_PATH)
(
утверждают (ложных);
вернуться ложным;
)

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

Пример Sins

Следующие элементы, которые поступают непосредственно из общей уязвимости и воздействия списка, или CVE (http://cve.mitre.org), примеры буферной перерасход. Интересный фрагмент trivia заключается в том, что, как я пишу эти строки, 1.734 CVE записей, которые соответствуют "буферной перерасход" существует. Поиск в CERT информации, в которых отражаются только более широко распространенных и серьезных уязвимости, урожайность 107 обращений о "буферной перерасход."

CVE - 1999 - 0042

С CVE описание: "Переполнение буфера в Университете Вашингтона в реализации протокола IMAP и серверов."

Это CVE вступления подробно описаны в консультативных CERT CA - 1997 - 09, и участвует буфера перерасход в подлинности последовательность из Университета Вашингтона Почтовое отделение протокола (СОЗ) и в Интернете сообщение Access Protocol (IMAP) серверов. В связи с этим уязвимости заключалась в том, что электронная почта сервера не выполнил мере привилегия, и использовать предоставлен доступ к нападающим. В переполнение приводит к широкой эксплуатации уязвимых системах.

Сети уязвимости проверок для поиска уязвимых версий этого сервера найдены аналогичные недостатки в Сиэтле Labs SLMail 2,5, как сообщалось на www.winnetmag.com/Article/ArticleID/9223/9223.html.

CVE - 2000 - 0389 - CVE - 2000 - 0392

С CVE - 2000 - 0389: "Переполнение буфера в krb_rd_req функционировать в Kerberos 4 и 5 позволяет удаленному атакующему получить привилегиями суперпользователя."

С CVE - 2000 - 0390: "Переполнение буфера в krb425_conv_principal функционировать в Kerberos 5 позволяет удаленному атакующему получить привилегиями суперпользователя."

С CVE - 2000 - 0391: "Переполнение буфера в krshd в Kerberos 5 позволяет удаленному атакующему получить привилегиями суперпользователя."

С CVE - 2000 - 0392: "Переполнение буфера в ksu в Kerberos 5 позволяет локальным пользователям получить привилегиями суперпользователя."

Этот комплекс проблем в МТИ реализации Kerberos документально, как консультативного CERT CA - 2000 - 06, обнаружен в www.cert.org/advisories/CA-2000-06.html. Хотя исходный код были доступны для общественности в несколько лет, и проблемы связаны с использованием опасных функций обработки строки (strcat), только сообщалось в 2000.

CVE - 2002 - 0842, CVE - 2003 - 0095, МОГУТ - 2003 - 0096

С CVE - 2002 - 0842:

Формат уязвимость строки в некоторых сторонних изменений в mod_dav для лесозаготовки недопустимый шлюз сообщений (например, Oracle9i Application Server 9.0.2) позволяет удаленному атакующему выполнить произвольный код с помощью назначения URI, что силами "502 Bad Шлюз "ответ, который приводит к спецификаторы форматирования строки должны быть возвращены из dav_lookup_uri () в mod_dav.c, который затем используется в призыв к ap_log_rerror ().

С CVE - 2003 - 0095:

Переполнение буфера в ORACLE.EXE для баз данных Oracle Server 9i, 8i, 8.1.7 и 8.0.6 позволяет удаленному атакующему выполнить произвольный код с помощью длительного имя пользователя, что обеспечивается во время входа в эксплуатации за счет клиента приложений, которые выполняют свои собственной подлинности, о чем свидетельствует использование LOADPSP.

С МОГУТ - 2003 - 0096:

Множественные переполнения буфера в Oracle 9i данных Выпуск 2, Выпуск 1, 8i, 8.1.7 и 8.0.6 позволяют удаленному атакующему выполнить произвольный код с помощью (1) длительного перехода строку аргумент для TO_TIMESTAMP_TZ функции, (2) долгое время зоны аргумент для TZ_OFFSET функции, или (3) долгое СПРАВОЧНИК параметр к BFILENAME функции.

Эти уязвимости описаны в консультативных CERT CA - 2003 - 05, расположенной в www.cert.org/advisories/CA-2003-05.html. Проблемы один набор несколько найдены Дэвид Литчфилд и его команда на следующего поколения Security Software ООО качестве стороне, это свидетельствует о том, что рекламу своей заявки, как "неразрывная" не может быть лучшим, что нужно сделать, хотя Г-н Литчфилд расследует приложений.

МОЖНО - 2003 - 0352

С CVE описание:

Переполнение буфера в определенный интерфейс для DCOM RPC в Microsoft Windows NT 4,0, 2000, XP и Server 2003 позволяет удаленному атакующему выполнять произвольный код через неправильный сигнал, как эксплуатируются в Blaster / MSblast / LovSAN и Nachi / Велчиа черви .

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

Более подробную информацию по этой проблеме можно найти на www.cert.org/advisories/ CA - 2003 - 23.html и www.microsoft.com/technet/security/bulletin/MS03-039.asp

Выкуп Шаги

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

Заменить опасных функций обработки строки

Вы должны, как минимум, заменить небезопасные функции, как strcpy, strcat, и sprintf с засчитывается версии каждой из этих функций. Вы несколько вариантов того, чтобы заменить их. Имейте в виду, что подсчет старых функций интерфейса проблем, и прошу вас сделать арифметических во многих случаях для определения параметров. Компьютеры не так хорошо математику, как вы, возможно, надежду. Позже библиотек как strsafe, безопасных CRT (C перспективе времени библиотека), которые будут отправлены в Microsoft Visual Studio (и по ускоренной принять участие в ANSI C / C + + стандарт) и strlcat / strlcpy для * nix. Вы должны также позаботиться о том, как с каждой из этих функций обработки прекращения и усечение строк. Некоторые функции гарантии недействительными прекращения, но большая часть пожилых подсчет функций нет. В Microsoft Управление группой опыт замены небезопасных функций обработки строки для Управления 2003 версии о том, что коэффициент регрессии (новые ошибки исправить причиненный процентов) была крайне низкой, поэтому не позволяйте страх регрессии остановить вас.

Ревизия ассигнований

Другим источником буферной перерасход происходит от арифметических ошибок.

Проверка петли и массив обращений

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

Заменить C буферов строк с C + + Строки

Это более эффективный, чем просто замена обычной С звонков, но может вызвать огромное количество изменений в существующий код, особенно если код еще не составлен, как C + +. Вы должны также знать и понимать эксплуатационных характеристик в STL контейнер классов. Очень возможно, чтобы написать высокопроизводительных STL код, но как и многие другие аспекты программирования, несоблюдением Читайте В изящных руководство (RTFM) часто приводит к менее оптимальных результатов. Наиболее распространенными замене использовать STL std:: строка или std: wstring шаблонов классов.

Заменить статические массивы с STL контейнеры

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

Использование инструментов для анализа

Есть несколько хороших инструментов, грядущих на рынке, что анализировать C / C + + код безопасности дефекты; Примеры включают Coverity, PREfast и Klocwork. Visual Studio. NET 2005 будет включать PREfast и другой инструментарий, названный Исходный код языка аннотация (SAL), чтобы выследить безопасности дефектов таких, как буферные перерасход. Лучший способ описать SAL является путем кода.

В (глупый), например, что следует, вы знаете, отношения между данными и рассчитывать аргументы: данные подсчета байтов долго. Но компилятор не знает; Он видит только символ * и size_t.

аннулируются * DoStuff (символ * данные, size_t рассчитывать) (
статических характеристик buf [32];
вернуться memcpy (buf, данных, подсчет);
)

Этот код выглядит OK (игнорируя тот факт, мы хотят вернуться статические буферы, но юмор нам). Однако, если рассчитывать больше, что 32, то у вас перерасход буфера. А SAL аннотированный вариант это поймать ошибка:

аннулируются * DoStuff (__in_ecount (рассчитывать) * символ данных, size_t рассчитывать) (
статических характеристик buf [32];
вернуться memcpy (buf, данных, подсчет);
)
Это объясняется тем, что компилятор и / или PREfast теперь знает, что данные и рассчитывать тесно взаимосвязаны.

Дополнительные защитные меры

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

Stack Protection

Stack protection was pioneered by Crispin Cowan in his Stackguard product, and was independently implemented by Microsoft as the /GS compiler switch. At its most basic, stack protection places a value known as a canary on the stack between the local variables and the return address. Newer implementations may also re-order variables for increased effectiveness. The advantage of this approach is that it is cheap, has minimal performance overhead, and has the additional benefit of making debugging stack corruption bugs easier. Another example is ProPolice, a Gnu Compiler Collection (GCC) extension created by IBM. Any current product should utilize stack protection.

You should be aware that stack protection can be overcome by a variety of techniques. If a virtual function pointer table is overwritten and the function is called prior to return from the function—virtual destructors are good candidates—then the exploit will occur before stack protection can come into play.

Non-executable Stack and Heap

This countermeasure offers considerable protection against an attacker, but it can have a significant application compatibility impact. Some applications legitimately compile and execute code on the fly, such as many applications written in Java and C#. It’s also important to note that if the attacker can cause your application to fall prey to a return into libc attack, where a legitimate function call is made to accomplish nefarious ends, then the execute protection on the memory page may be removed.

Unfortunately, most of the hardware currently available is unable to support this option, and support varies with CPU-type, operating system, and operating system version as well. As a result, you cannot count on this protection being present in the field, but you must test with it enabled to ensure that your application is compatible with a non-executable stack and heap, by running your application on hardware that supports hardware protection, and the target operating system set to use the protection. For example, if you are targeting Windows XP, then make sure you run all your tests on a Windows XP SP2 computer using an AMD Athlon 64 FX processor. On Windows, this technology is called Data Execution Protection (DEP); it was once known as No eXecute (NX).

Windows Server 2003 SP1 also supports this capability. PaX for Linux and OpenBSD also support non-executable memory

Other Resources
this is an article added by Hendra Fang

Share  

© 2005-2010 E-articles.info All Rights Reserved - Terms and conditions