Защищенное исполнение программ на базе аппаратной и системной поддержки архитектуры "Эльбрус"

Защищенное исполнение программ на базе аппаратной и системной поддержки архитектуры «Эльбрус»

A.К. Ким, Генеральный директор ОАО «ИНЭУМим. И.С.Брука»,

B.Ю. Волконский, нач. отделения ОАО «ИНЭУМим. И.С.Брука»,

Ф.А. Груздов, нач. отдела ЗАО «МЦСТ», Ю.Х. Сахин, нач. отделения ОАО «ИНЭУМим. И.С.Брука», С.В. Семенихин, нач. отделения ОАО «ИНЭУМим. И.С.Брука»,

Разработанные в России универсальные микропроцессоры с архитектурой «Эльбрус» обеспечивают эффективные средства защищенного исполнения программ на базе аппаратных тегов и контекстной межмодульной защиты данных. На основе анализа семантики программирования C и C++, средствами которых можно нарушить их модульную и объектную защищенность, показано, что для обеспечения безопасной и при этом эффективной реализации необходима определенная поддержка со стороны аппаратуры, операционной системы и систем языкового программирования - компиляторов, редакторов связи, отладчиков. Предлагаемая реализация обеспечивает полную и эффективную модульную защиту и может служить основой для защиты от компьютерных вирусов. Перенос реальных программ в среду защищенного исполнения демонстрирует ее эффективность при обнаружении скрытых и опасных ошибок исполнения.

1. Введение

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

Существует два основных способа построения новой программной системы на базе готовых компонентов

• Использование готовых программ в качестве составных частей новой программы

• Использование готовых, а также создаваемых в процессе разработки библиотек в качестве строительных блоков новой программной системы

Различие между двумя подходами достаточно велико как с точки зрения эффективности, так и с точки зрения безопасности.

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

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

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

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

языковые границы объектов, «зависшие» ссылки на уничтоженные объекты, доступ в приватные области данных.

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

На протяжении многих лет предпринималось множество попыток добиться безопасной реализации языков C и C++ как программно -аппаратными, так и исключительно программными средствами. Но программно-аппаратные подходы, особенно в последние годы, зачастую пытались бороться с отдельными типами уязвимостей, в первую очередь с нарушением границ объектов, называемым в литературе переполнением буфера (buffer overflow). А все чисто программные подходы приводили к резкому снижению производительности программ.

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

2. Семантические основы защищенного исполнения программ

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

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

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

Реализация, рассматриваемая в этой работе, базируется на аппаратной поддержке проверок в архитектуре «Эльбрус» [1-4] и в защищенной операционной системе. Основной принцип предлагаемой реализации -не накладывать никаких ограничений на язык программирования, допуская потерю эффективности для потенциально опасных конструкций, только в том случае, если в языке имеются безопасные альтернативные средства.

2.1. Модули, интерфейсы и контекст

Модуль представляет собой отдельную единицу компиляции на языке C. Все модули размещаются и взаимодействуют в едином виртуальном пространстве.

Все переменные, а также функции и прочие точки передачи управления в модуле разделены на три группы: внутренние для модуля, импортированные из другого модуля и экспортируемые в другие модули. Для единицы компиляции на языке C эти группы будут соответственно представлены объектами с квалификатором static, объектами с ква-лификатором extern, определенными в других модулях, и объектами с квалификатором extern, определенными в данном модуле (это относится и к данным, и к функциям). Кроме адресов функций точками передачи управления являются адреса возвратов из функций, а также адреса передачи управления при межпроцедурных переходах, формируемые функцией setjump и используемые функцией longjmp.

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

Множество, которое состоит из экспортируемых объектов модуля и всех его внутренних объектов, ссылки на которые передаются в качест-

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

• адреса функций использовались только в операциях вызова функций

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

• адреса межпроцедурных переходов использовались только функцией 1опд^р и только для перехода на метку, переданную соответствующим вызовом функции Бе^итр

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

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

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

него. Такая организация как раз и позволяет разделить контексты модулей.

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

2.2. Контекстная защита

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

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

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

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

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

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

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

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

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

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

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

3. Реализация защищенного исполнения программ

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

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

3.1. Аппаратная поддержка

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

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

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

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

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

массив, область стека

Рис. 1. Использование тегированной памяти для защиты данных.

Дескриптор массива кроме адреса начала массива содержит размер массива, и смещение относительно начала массива, соответствующее текущему значению указателя (рис. 1).

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

позволяет легко отделить дескрипторы от прочих объектов (рис.1). Аппаратура не допускает сборку нового дескриптора из отдельных частей уже существующих и тем более его создание вручную, в обход аппаратуры или операционной системы.

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

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

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

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

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

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

кода функции через ее дескриптор невозможны. При создании дескриптора функции гарантируется попадание базового адреса в диапазон адресов кода модуля.

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

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

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

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

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

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

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

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

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

3.2. Поддержка в операционной системе

Выделение и освобождение памяти под объекты. Операционная система должна взять на себя реализацию части функций управления памятью, которые традиционно включались в библиотеки динамической поддержки реализации языков. В первую очередь это касается функций выделения и освобождения памяти под объекты, таких как malloc, realloc, calloc, free в языке C, а также new, delete в языке C++. При этом должны решаться сразу несколько проблем, связанных с защитой, с одной стороны, и с эффективной реализацией функций управления памятью - с другой.

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

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

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

Поддержка реализации межпроцедурных переходов. Реализация межпроцедурных переходов, таких как longjmp в языке C или throw в языке C++, связанная определением точного места, куда должно быть передано управление после раскрутки стека, также требует специальной поддержки со стороны операционной системы.

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

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

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

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

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

При реализации механизма исключений языка C++ используется другой интерфейс с операционной системой. Поскольку языковый интерфейс не требует заведения глобальных буферов, а может быть реализован через механизм параметров, это существенно облегчают поддержку безопасной межпроцедурной передачи управления. В стеке вызовов в связующей информации делается пометка функции, в которой встретился оператор try (установлена «ловушка»). Исполнение оператора приводит к вызову функции операционной системы, которая ищет по стеку помеченную функцию, в ее локальных данных находит структуру с меткой передачи управления, заносит в эту структуру ссылку на тип исключения и передает управление в функцию. Далее сама функция проверяет тип исключения и передает управление найденному оператору catch или повторно возбуждает исключение, если оператор не найден.

3.3. Поддержка в компиляторе и редакторе связей

Реализация операций с адресами. Компилятор использует специальные аппаратные команды при работе с адресами. В первую очередь это относится к адресной арифметике. Простейшие операции продвижения указателя по массиву реализуются обычными арифметическими командами. Получение дескриптора подмассива или дескриптора поля объекта или структуры требует использования специальных операций.

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

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

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

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

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

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

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

4. Результаты переноса программ в среду защищенного исполнения

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

1. Обращение к неинициализированным данным

2. Выходы за границу объектов (массивов) - ошибка переполнения буфера

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

4. Отклонения от стандарта языка, такие как использование неявных типов данных, характерное для старого стиля программирования (стиль Кернигана-Ритчи), работа со стандартными библиотеками без предварительных описаний функций, использование конкретной реализации языковых конструкций с неопределенным поведением

5. Преобразование целого в указатель

6. Запись в глобальную память ссылок, смотрящих на локальные переменные.

Эти группы проблем можно объединить в три категории:

• Реальные ошибки в программах, которые представляют собой явное нарушение защиты или могут приводить к нему. К этой категории относятся проблемы из групп 1 и 2

• Опасная работа с указателями, которая может приводить к нарушениям защиты. К этой категории относятся проблемы из групп 5 и 6

• Использование непереносимых свойств языка или его конкретной реализации, которые являются источником трудностей переноса и также могут приводить к ошибкам. К этой категории относятся проблемы из групп 3 и 4.

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

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

При защищенном исполнении программ с языков С и С++, оттранслированных с использованием описанной аппаратной и системной поддержки, фиксируются любые нарушения защиты памяти, воспринимаемые в обычных системах как «неопределенное поведение». При этом опасные и сложные ошибки, отнимающие заметное время в традиционных системах даже у опытных программистов, хорошо локализуются. Благодаря режиму защищенного исполнения, на Государственных испытаниях ВК «Эльбрус-3М1» была продемонстрирована высокая эффективность в части обнаружения ошибок (таблица 1), в том числе при переносе и исполнении задач пользователей, международного пакета SPEC95 и международного пакета SAMATE, который содержит собранные по всему миру ошибочные фрагменты широко распространенных программ. Основные типы обнаруженных ошибок - нарушение границ объектов (buffer overflow), использование неинициализированных данных, использование опасных конструкций языка или опасных отклонений от стандарта языка.

Таблица 1. Эффективность поддержки защищенной реализации

языков программирования.

категории задач всего задач задач с найденными ошибками

задачи пользователей 7 4

пакет SPECint95 8 7

Пакет негативных тес- 888 874

тов SAMATE на нарушение

защиты

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

5. Заключение

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

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

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

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

Дальнейшее направление исследований предполагает анализ более широкого класса программ на предмет их адаптации к особенностям предложенной безопасной реализации языков C/C++.

Литература

7. Бабаян Б.А. Защищенные информационные системы http://www.mcst.ru/SECURE INFORMATION SYSTEM V5 2r.pdf

8. Волконский В.Ю. Безопасная реализация языков программирования на базе аппаратной и системной поддержки // Вопросы радиоэлектроники, сер. ЭВТ. 2008, вып. 2. С. 98-141.

9. B. Babayan. Main principles of E2k architecture // Free Software Magazine, Vol. 1, No. 2, Feb. 2002.

10. Ф. Груздов, Ю. Сахин. Архитектурная поддержка типизации данных // Информационные технологии и вычислительные системы. 1999.

11. Волконский В.Ю., Тихонов В.Г., Эльцин Е.А. Реализация языков программирования, гарантирующая межмодульную защиту, //Высокопроизводительные вычислительные системы и микропроцессоры. Сборник научных трудов ИМВС РАН. Выпуск 2, 2001. С. 3-20