Программирование процессоров Intel x86 в защищённом режиме
Защита: передача управления

Автор: sergh
The RSDN Group

Версия текста: 1.0

На границе тучи ходят хмуро,
Край суровый тишиной объят. 
У высоких берегов Амура 
Часовые Родины стоят 

Борис Ласкин

Время перейти эту реку вброд,
Самое время перейти эту реку вброд

Борис Гребенщиков

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

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

Не огорчайтесь, если вам придётся прочитать эту главу пару раз. Представьте себе, сколько времени я её писал и сколько раз за это время перечитывал соответствующие места [Intel 2004] :)

[Первая сторона] Что мы знаем о защищённой ОС

Немного подумав над главой «Теоретическое введение в защиту», а заодно и над всеми предыдущими, можно построить упрощённую модель гипотетической защищённой ОС.

Структура

Приблизительная структура ОС изображёна на Рисунке 1 (красным обозначены дескрипторы GDT и IDT, к которым приложение не имеет доступа). Правда, пока неясно, зачем нужен Синий Сегмент Состояния Задачи, но интуиция уже подсказывает, что без него тут не обойтись…

Рисунок 1. Структура защищённой ОС.

Более-менее то же самое, с небольшими поясняющими комментариями, описывает Таблица 1.

Схема работы

Схема работы такой ОС достаточно очевидна (многозадачности нет):

• Инициализация
• Запуск приложения
• Завершение

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

Рисунок 2. Схема работы защищённой ОС

Поправки к модели

Существенные упрощения, внесённые в модель сознательно:

• Ровно один сегмент состояния задачи, не используется никаких дополнительных «задачных» дескрипторов. Это тема главы «Многозадачность».
• Даже имея только одну задачу, можно реализовать «самодельную» многозадачность. Хранить список процессов, по таймеру вручную переключать контексты… В этом случае возникает не только вопрос защиты ОС от приложения, но и вопрос защиты различных приложений друг от друга. Вариант решения предложен в главе «Страничная адресация», а пока будем считать, что у нас одно приложение, пусть и большое.
• Обращение к портам ввода-вывода запрещёно для всех, кроме ядра ОС (нужен нулевой уровень привилегий). Будет исправлено в главе «Защита: ввод-вывод».

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

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

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

Что нужно такой ОС от механизма передачи управления

Наконец, добрались до того, ради чего эта модель строилась. Глядя на схему работы, по пунктам:

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

Теперь подумаем о программистах, писавших ядро и приложение:

• Внутри себя приложение может передавать управление без ограничений.
• Внутри себя ядро может передавать управление без ограничений.

И, наконец, вспомним о безопасности:

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

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

[Вторая сторона] Классификация способов передачи управления

Вас просто так послать, или по факсу?

Владимир Вишневский

По инструкциям/событиям:

• jmp, jxx (условные переходы: je, jc и т.п.)
• call
• int
• ret, retf
• iret, iretd
• Генерация исключения (любая инструкция, вызывающая генерацию исключения: деление на 0, неизвестный код команды, что угодно ещё).
• Внешнее прерывание

По целевому сегменту кода:

• Ближняя передача управления, происходит внутри сегмента кода, целевой сегмент явно не указан (jxx, ret, ближние call и jmp).
• DPL целевого сегмента кода совпадает с CPL.
• DPL целевого сегмента кода отличается от CPL.

По участвующим дескрипторам:

• Ни одного. Ближняя передача управления.
• Напрямую, участвует дескриптор целевого сегмента кода. Стандартные jmp или call с адресом вида <селектор сегмента кода>:<смещение>, инструкции retf, iret, iretd.
• Через шлюз ловушки/прерывания/вызова, участвует дескриптор шлюза и дескриптор целевого сегмента кода. Исключение, внешнее прерывание, инструкции int, call, jmp.

Объединяем

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

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

Требование (4)

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

Таким образом, всегда разрешены:

• Ближняя передача управления, происходит внутри сегмента кода. jxx, ret, ближние call и jmp.
• Прямая передача управления между сегментами кода, если DPL целевого сегмента кода совпадает с CPL. Стандартные jmp или call с адресом вида <селектор сегмента кода>:<смещение>, инструкции retf, iret, iretd.

Требование (2)

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

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

Из главы «Теоретическое введение в защиту» уже известно, что:

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

Именно через шлюзы налаживается связь между пользовательским кодом и кодом ОС.

Требование (3)

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

Это, кстати, и есть способ, который был нужен в Требовании (1).

Требование (5)

Соображения безопасности запрещают прямую передачу из менее привилегированного сегмента в более привилегированный – только через шлюз. Помимо прочего, запрещена прямая передача управления инструкциями iret, iretd и retf. То есть, если вызвать менее привилегированный код через шлюз (например, если поместить в менее привилегированный сегмент кода обработчик прерывания), обработчик не сможет стандартным способом вернуть управление.

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

Требование (6)

Изменение уровня привилегий в сторону уменьшения привилегий – возврат из обработчика исключения/прерывания инструкцией iretd и из системной функции инструкцией retf. При этом система проверяет регистры DS, ES, FS, GS, те из них, которые содержат селекторы слишком привилегированных сегментов (то есть сегментов, DPL которых меньше нового CPL), сбрасываются.

Итого

И спросила кроха: «Что такое хорошо, и что такое плохо?»

Самуил Яковлевич Маршак

Введём обозначения:

• С – текущий уровень привилегий (current, текущий). Это не совсем CPL, читайте дальше :)
• T – уровень привилегий сегмента, куда происходит передаче (target, целевой)
• G – уровень привилегий шлюза, через который происходит передача (gate)
• Соотношения вида «C > T» или «С > G» сравнивают не значения DPL, а именно уровни привилегий. То есть, к примеру, условие «C > T» выполняется, если текущий уровень привилегий выше, чем уровень привилегий целевого сегмента.
• DPL(x) – значение поля DPL в дескрипторе сегмента кода или шлюза
• CPL – текущий уровень привилегий в числовой форме. Если C > T, то CPL < DPL(T).

С этими обозначениями, получаем следующую табличку «можно/нельзя»:

Что не попало в таблицу:

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

Несмотря на несколько «умозрительный» способ построения таблицы, она удивительным образом совпала с правильным вариантом :) Единственное, в ней не упомянуты RPL, которые иногда всё-таки оказываются важны.

На этом завершим слегка затянувшееся введение, и начнём уже двигаться вперёд.

[Первая сторона] Передача управления через шлюз

- Каждому шлюзу – 10-и битную защиту!
- Ура!!!

Митинг продолжается :)

Для начала рассмотрим шлюз вызова. С точки зрения защиты, в процессе участвуют следующие параметры:

1. Текущий уровень привилегий (CPL)
2. RPL селектора в инструкции call
3. DPL шлюза
4. RPL селектора из дескриптора шлюза
5. DPL целевого сегмента кода

Все они обозначены и пронумерованы на Рисунке 3.

Рисунок 3. Параметры защиты, участвующие в передаче управления через шлюз вызова

Условия успешной передачи управления (все условия должны выполняться одновременно):

• CPL <= DPL шлюза
• RPL <= DPL шлюза
• CPL >= DPL целевого сегмента

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

А как же параметр (4) – RPL селектора из дескриптора шлюза? А он просто игнорируется :)

Со шлюзами ловушки/прерывания всё точно так же, только проще, так как параметров меньше.

1. Текущий уровень привилегий (CPL)
2. DPL шлюза
3. RPL селектора целевого сегмента из дескриптора шлюза (он опять не понадобится)
4. DPL целевого сегмента кода

Смотрите рисунок 4.

Рисунок 4. Параметры защиты, участвующие в передаче управления через шлюз ловушки/прерывания

Ну и условия успешной передачи управления (все условия должны выполняться одновременно):

• CPL <= DPL шлюза
• CPL >= DPL целевого сегмента

То есть, то же самое, что у шлюза вызова, но без RPL.

[Вторая сторона] Переключение стека

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

• Проверки допустимости передачи управления.
• Обнаруживается, что нужно изменить уровень привилегий.
• Откуда-то получается селектор сегмента стека и смещение стека для нового уровня привилегий. Эти значения устанавливаются регистрам SS и ESP.
• Если новый стек должен что-то содержать (адрес возврата, параметры), он заполняется.
• Собственно передача управления, изменение уровня привилегий.

Основной вопрос, конечно, где же то «откуда-то», которое содержит данные о подходящем стеке. Тут есть два варианта.

Туда (call, int, исключение, внешнее прерывание)

При передаче управления с повышением уровня привилегий, источником данных о стеке служит сегмент состояния задачи (TSS). В главе «Введение в многозадачность: одна задача» он был описан несколько неподробно, в таблице 4 и на рисунке 5 приведено более детальное описание.

Рисунок 5. Структура сегмента состояния задачи, второе приближение

Описание соответствующей структуры на ассемблере:

; Сегмент состояния задачи
task_state_segment struct
                dd      0
    esp0        dd      0
    ss0         dw      0
                dw      0 
    esp1        dd      0
    ss1         dw      0
                dw      0
    esp2        dd      0
    ss2         dw      0
                db      78 dup (0)
task_state_segment ends

Что ещё нужно сказать:

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

Наконец, более-менее точный сценарий:

• Проверки допустимости передачи управления.
• Обнаруживается, что нужно изменить уровень привилегий.
• Процессор считывает из регистра TR селектор TSS. В TSS находит нужный селектор сегмента стека и смещение, проверяет на корректность. Текущие значения SS и ESP на время сохраняются во внутренних регистрах, регистрам SS и ESP присваиваются значения из TSS. В случае каких-либо ошибок на этом этапе, генерируется исключение #TS (Invalid TSS).
• [call] В новый стек последовательно копируются: старый SS, старый ESP, параметры из старого стека, CS, EIP. Количество копируемых параметров берётся из дескриптора шлюза вызова. На каждый регистр и на каждый параметр уходит по 4 байта.
• [int, исключение, внешнее прерывание] В новый стек последовательно копируются: старый SS, старый ESP, EFLAGS, CS, EIP. На каждый регистр уходит по 4 байта.
• Собственно передача управления, изменение уровня привилегий.

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

Рисунок 6. Два стека (на картинке младшие адреса сверху, т.е. стеки растут вверх).

Стек обработчика исключения/прерывания выглядит точно так же, только вместо параметров он будет содержать EFLAGS.

Обратно (retf, iret, iretd)

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

Сценарий:

• Проверки допустимости передачи управления.
• Обнаруживается, что нужно изменить уровень привилегий (DPL сегмента, селектором которого является CS из стека, не совпадает с CPL).
• Из этого делается вывод, что в стеке должны содержаться дополнительные данные – SS и ESP старого стека.
• [retf] Эти данные расположены в стеке глубже параметров. Поэтому при вызове через шлюз стек должен всегда освобождаться вызываемой функцией.
• Данные считываются, выполняются различные проверки их корректности.
• Собственно передача управления, изменение уровня привилегий, переключение стеков, сбрасывание значений сегментных регистров, содержащих селекторы слишком привилегированных сегментов.
• [retf] При переключении, параметры автоматически удаляются и из старого стека тоже.

А подготовка стека вручную выглядит, например, так:

        ; подготовка стека для "возврата" в пользовательский режим
        mov  eax, ss3_sel          ; селектор стека 
        push eax
        mov  eax, stack3_size      ; смещение
        push eax
        mov  eax, cs3_sel          ; селектор сегмента кода
        push eax
        mov  eax, offset user_code ; адрес начала пользовательского кода
        push eax

        ; 32-х разрядный retf. Подробнее о разрядностях – в приложении
        db 66h
        retf

All together now

Наконец, объединим вместе всё, что нам известно про передачу управления, защиту и стеки.

Туда-и-обратно

Roads go ever ever on
Under cloud and under star,
Yet feet that wandering have gone
Turn at last to home afar.

J.R.R.Tolkien

Рассмотрим законченный сценарий, пусть это будет программное прерывание.

1. Пользовательский код вызывает int 21h
2. Проверка попадания номер прерывания в IDT, проверка корректности дескриптора, проверка допустимости вызова с точки зрения безопасности – DPL дескриптора шлюза не меньше CPL. В случае каких-то проблем – исключение #GP.
3. Из дескриптора извлекается селектор и смещение. Проверяется, что селектор попадает в GDT, что это селектор сегмента кода, что смещение в него попадает. Проверка допустимости вызова с точки зрения безопасности – DPL дескриптора сегмента кода не больше CPL. В случае каких-то проблем – исключение #GP.
4. Пусть DPL целевого сегмента кода не равен CPL
5. Процессор считывает из регистра TR селектор TSS. В TSS находит нужный селектор сегмента стека и смещение, проверяет на корректность. Текущие значения SS и ESP на время сохраняются во внутренних регистрах, регистрам SS и ESP присваиваются значения из TSS. В случае каких-либо ошибок на этом этапе, генерируется исключение #TS (Invalid TSS).
6. В новый стек последовательно копируются: старый SS, старый ESP, EFLAGS, CS, EIP. На каждый регистр уходит по 4 байта.
7. CS и EIP загружаются новыми значениями, изменяется CPL.
8. Начинается выполнение обработчика …
9. Завершается. Обработчик возвращает управление инструкцией iretd.
10. Проверка корректности CS и EIP из стека: попадает в GDT, соответствует сегменту кода, RPL селектора из стека равен DPL сегмента. В случае каких-то проблем – исключение #GP.
11. Пусть DPL сохранённого CS по прежнему не равен CPL (при желании, обработчик мог всё там поменять).
12. Из стека считывается значение ESP и SS, проверяются на корректность (попадание в GDT, соответствие доступному для записи сегменту данных) и на правильность уровней привилегий (должен совпадать с RPL и с DPL сегмента кода). В случае каких-то проблем – исключение #GP.
13. В регистры CS, EIP, EFLAGS, SS, ESP записываются новые значения, проверяются регистры DS, ES, FS, GS, те из них, которые содержат селекторы сегментов, недоступные на новом уровне привилегий, сбрасываются.

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

Рисунок 7. Переключение стеков при обработке программного прерывания

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

• В случае исключения и внешнего прерывания не происходит проверки CPL <= DPL шлюза. Все остальные проверки происходят!
• В случае call и шлюза вызова, добавляется проверка RPL, копирование параметров между стеками в начале и очистка стеков в конце.

Переключение режимов: инициализация TSS

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

1. Запретить маскируемые и немаскируемые прерывания.
2. Инициализировать GDT и загрузить её адрес в GDTR.
3. Инициализировать IDT и загрузить её адрес в IDTR.
4. Установить флаг PE (младший бит регистра CR0).
5. Выполнить дальний переход (jmp или call) для перезагрузки регистра CS.
6. Перезагрузить все сегментные регистры.
7. Установить значение регистру задачи. TSS, на который ссылается это регистр должен содержать данные о стеках для используемых уровней привилегий.
8. Разрешить прерывания.

Обратное переключение:

1. Сделать текущим сегментом кода какой-либо доступный для чтения сегмент с пределом FFFFh байт.
2. Загрузить во все сегментные регистры селекторы дескрипторов доступных для записи сегментов данных с пределом FFFFh.
3. Сбросить флаг PE
4. Выполнить дальний переход (jmp или call).
5. Перезагрузить сегментные регистры.
6. Восстановить в IDTR значение для реального режима.
7. Разрешить прерывания.

В общем, если не считать всяких необязательных деталей (страничная адресация и LDT, но они действительно необязательны – если не используются, их можно не инициализировать), это полные, правильные алгоритмы, соответствующие написанному в [Intel 2004]. Не прошло и девяти глав :)

Использование RPL

- Какая от него польза, Мастер?
- Никакой, насколько я знаю. - ... 
(и далее по тексту до конца абзаца)

Урсула Ле Гуин, «Волшебник Земноморья»

В главе «Теоретическое введение в защиту» был рассмотрен единственный разумный способ использования RPL – сознательное понижение уровня привилегий системной функцией при обращении по переданному пользователем указателю. Там же было обещано, что в недалёком будущем будет описан способ, как это проделать технически. Будущее наступило :)

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

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

Уровень привилегий вызывающего кода можно получить из сохранённого в стеке адреса возврата (конкретно – из RPL регистра CS). А для модификации RPL селектора по приведённым выше правилам предназначена инструкция arpl (аббревиатура для Adjust RPL, то есть «подгонка» или «настройка» RPL):

     arpl   dest, source

Здесь source это селектор с «образцовым» RPL, а dest – селектор, RPL которого будет модифицирован. Если в результате исполнения arpl операнд dest был изменён, устанавливается флаг ZF, если нет – сбрасывается. dest может быть 16-и разрядным регистром или областью памяти, source – всегда 16-и разрядный регистр.

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

• lar (Load Address Rights)
• verr (Verify Right Read)
• verw (Verify Right Write)
• lsl (Load Segment Limit)

Они подробно описаны в [Intel 2004].

Пример

Изменение уровня привилегий

Что делает программа:

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

Схема работы изображена на рисунке 8.

Рисунок 8. Схема работы примера.

Как она это делает:

• В GDT находятся следующие дескрипторы: шлюза вызова (та самая системная функция), сегмента состояния задачи, сегмента кода с нулевым уровнем привилегий, сегмента стека для него, сегмента кода с третьим уровнем привилегий, сегмента стека для него, сегмента данных, сегмента видеопамяти, сегмента стека для переключения в реальный режим (см. про него ниже).
• При старте всё это инициализируется.
• После чего переключается режим.
• Текущее значение SS и ESP сохраняется до момента переключения обратно в реальный режим, в качестве новых значений прописываются селектор стека для нулевого уровня привилегий и размер выделенной под него памяти.
• Стек «подготавливается» для инструкции retf, в качестве адреса возврата указывается начало «пользовательского» кода.
• Исполняется инструкция retf, управление передаётся пользовательскому коду. При этом происходит изменение уровня привилегий с нулевого на третий, со всеми сопутствующими эффектами: переключением стеков и сбросом значений сегментных регистров.
• Пользовательский код кладёт в стек параметр и вызывает системную функцию инструкцией call.
• При этом происходит изменение уровня привилегий с третьего на нулевой и, естественно, переключение стеков.
• Системная функция имеет четыре варианта поведения и выбирает один из них, в зависимости от значения параметра. В двух случаях она что-то (не важно, что) делает с экраном, в «остальных» случаях сразу возвращает управление, а в последнем, самом интересном случае, переключает процессор в реальный режим и завершает работу программы.
• Последний случай реализован так – функция ничего не делает сама, а просто передаёт управление коду деинициализации защищённого режима.
• За исключением одной особенности, код деинициализации полностью стандартен. Особенность связана с сегментами стека и описана ниже.

На что ещё стоит обратить внимание (при написании примера мне было сложнее всего найти ошибки именно в этих деталях):

• На RPL селекторов.
• На сегментный регистр ES, значение которого каждый раз заново устанавливается в системной функции, вместо того, чтобы один раз установить при инициализации. DPL сегмента видеопамяти – 0, поэтому при изменении уровня привилегий значение ES сбрасывается.
• Код деинициализации начинается с установки сегмента стека, корректного с точки зрения реального режима – размером 64 Кб. Это связано с той же особенностью x86, которая позволяет организовать Unreal mode – процессор сохраняет значения флагов и предела сегмента при переключении режимов. В данном случае это могло привести к тому, что в реальном режиме размер сегмента стека оказался бы 128 байт, после чего DOS отказался бы работать. Давным-давно, в главе «Управление памятью: сегменты и дескрипторы» было замечание на эту тему, с упором именно на сегменты стека, но, скорее всего, вы про него уже забыли.

Надеюсь, после таких пояснений, проблем с пониманием примера не возникнет.

; change_level.asm
; Программа переключается в пользовательский режим
; и вызывает из него системную функцию. 

        .model tiny
        .code
        .386p
        org     100h

;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; Структуры
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;

; Сегментный дескриптор
segment_descriptor struct
    limit_low   dw      0    ; Младшие два байта поля Segment limit
    base_low    dw      0    ; Младшие два байта поля Base Address
    base_high0  db      0    ; Второй байт поля Base Address
    type_and_permit db  0    ; Флаги
    flags       db      0    ; Ещё одни флаги
    base_high1  db      0    ; Старший байт поля Base Address
segment_descriptor ends

; Дескриптор шлюза
gate_descriptor struct
    offset_low  dw      0    ; Два младших байта поля Offset
    selector    dw      0    ; Поле Segment Selector
    params      db      0    ; Количество параметров в стеке
    type_and_permit db  0    ; Флаги
    offset_high dw      0    ; Старшие байты поля Offset
gate_descriptor ends

; Регистр, описывающий таблицу дескриптров
table_register struct
    limit       dw      0    ; Table Limit
    base        dd      0    ; Linear Base Address
table_register ends

; Сегмент состояния задачи
task_state_segment struct
                dd      0
    esp0        dd      0
    ss0         dw      0
                dw      0
    esp1        dd      0
    ss1         dw      0
                dw      0
    esp2        dd      0
    ss2         dw      0
                db      78 dup (0)
task_state_segment ends

;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; Код инициализации и завершения работы 
;
;;;;;;;;;;;;;;;;;;;;;;;;;;

start:
        ; Подготавливаем DS
        push    cs
        pop     ds

        ; Устанавливаем правильный сегмент в long-jmp-to-RM
        mov     ax, cs
        mov     cs:rm_cs, ax

        ; Инициализация сегмента TSS
        mov     eax, offset tss_dsc
        mov     ebx, offset tss_seg
        call    init_descriptor_base

        ; Сегменты кода-данных
        mov     eax, offset cs0_dsc  ; системный код
        mov     ebx, 0
        call    init_descriptor_base
        mov     eax, offset cs3_dsc  ; пользовательский код
        call    init_descriptor_base
        mov     eax, offset ds3_dsc  ; пользовательские данные
        call    init_descriptor_base

        ; Сегмент стека для cs0
        mov     eax, offset ss0_dsc
        mov     ebx, offset stack0_seg
        call    init_descriptor_base

        ; Сегмент стека для cs3
        mov     eax, offset ss3_dsc
        mov     ebx, offset stack3_seg
        call    init_descriptor_base

        ; Сегмент стека для переключения в реальный режим
        mov     eax, offset rmss_dsc
        mov     ebx, 0
        call    init_descriptor_base

        ; Сохраняем старый стек
        mov  old_ss, ss
        mov  old_esp, esp

        ; Запрещаем прерывания
        call disable_interrupts
        ; Инициализируем GDT
        call initialize_gdt
        ; Переключаем режим
        call set_PE

        ; 16-разрядный дальний переход. Перключает содержимое cs из нормального
        ; для реального режима (адрес) в нормальное для защищённого (селектор).
        ; Базовый адрес целевого сегмента совпадает с cs,
        ; поэтому смещение можно прописать сразу
        db      0EAh    ; код команды дальнего перехода
        dw      $ + 4   ; смещение
        dw      cs0_sel ; селектор

        ; загрузить селектор дескриптора TSS в TR
        mov  ax, tss_sel
        ltr  ax

        ; Устанавливаем новый стек
        mov  dx, ss0_sel
        mov  ss, dx
        mov  esp, stack0_size

        ; загружаем селектор сегмента с DPL == 3 в DS. Если этого не сделать,
        ; при смене уровня привилегий значение DS будет сброшено.
        mov ax, ds3_sel
        mov ds, ax

        ; подготовка стека для "возврата" в пользовательский режим
        mov  eax, ss3_sel          ; селектор стека
        push eax
        mov  eax, stack3_size      ; смещение
        push eax
        mov  eax, cs3_sel          ; селектор сегмента кода
        push eax
        mov  eax, offset user_code ; адрес начала пользовательского кода
        push eax

        ; 32-х разрядный retf. Подробнее о разрядностях – в приложении
        db 66h
        retf

back_to_rm:
        ; перед переключением в реальный режим установим 
        ; правильный сегмент стека (размером 64 Кб)
        mov  dx, rmss_sel
        mov  ss, dx
        mov  esp, old_esp

        call clear_PE

        ; Мы в реальном режиме, осталось окончательно разобраться со
        ; стеком, значением регистра cs и остальными сегментными регистрами

        ; 16-разрядный дальний переход. Перключает содержимое cs из нормального
        ; для защищённог режима (селектор) в нормальное для реальног (адрес).
        ; Адрес сегмента вычисляется и прописывается во время выполнения.
        db      0EAh   ; код команды дальнего перехода
        dw      $ + 4  ; смещение
rm_cs   dw      0      ; сегмент

        ; Восстанавливаем стек
        mov  dx, old_ss
        mov  ss, dx
        mov  esp, old_esp

        ; устанавливаем разумные значения сегментным регистрам
        mov  ax, cs
        mov  ds, ax
        mov  es, ax

        call enable_interrupts
        ret

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; Пользовательский код
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

user_code:

        ; Параметр в стек
        mov eax, 1
        push eax

        ; вызов
        db 9Ah
        dw 0
        dw call_sel

        ; параметр в стек
        mov eax, 123
        push eax

        ; вызов
        db 9Ah
        dw 0
        dw call_sel

        ; бесконечный цикл. По идее, здесь мы оказаться не должны
        jmp $

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; Системная функция
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; Приниммает один четырёхбайтный параметр. В зависимости от его значения:
;   - 123 – завершает работу программы, выходит в RM
;   - 1   - проходит по экрану, инкрементирует атрибуты всех символов
;   - 2   - проходит по экрану, инкрементирует значения всех символов
;   - иначе – не делает ничего
call_handler:

        ; Состояние стека в данный момент:
        ; [esp]      – eip
        ; [esp + 4]  – cs
        ; [esp + 8]  – параметр
        ; (если была смена привилегий) [esp + 12] – старый esp
        ; (если была смена привилегий) [esp + 16] - старый ss

        ; Помещаем параметр в ebx
        mov ebx, [esp + 8]

        ; Подготовка к работе с экраном
        push   eax
        push   ecx
        push   es

        mov    ax, video_sel  ; Сегмент видеопамяти
        mov    es, ax
        mov    eax, 0         ; Текущий символ
        mov    ecx, 80 * 25   ; Колическтво символов на экране

        ; Выбор ветки функции, которая будет выполняться
        cmp  ebx, 123
        je   value123    ; 123
        cmp  ebx, 1
        je   value1      ; 1
        cmp  ebx, 2
        je   value2      ; 2

        ; непонятное значение параметра – просто выходим из функции
        jmp  exit_handler

value123:
        ; Выходим в RM, завершаем работу
        jmp  back_to_rm

value1:
        ; проходит по экрану, инкрементирует атрибуты всех символов
screen_loop1:

        inc    eax
        inc    byte ptr es:[eax]          ; Меняем атрибут
        inc    eax
        loop   screen_loop1

        jmp    exit_handler


value2:
        ; проходит по экрану, инкрементирует значения всех символов
screen_loop2:
        inc    byte ptr es:[eax]          ; Меняем символ
        inc    eax
        inc    eax
        loop   screen_loop2

exit_handler:

        pop    es
        pop    ecx
        pop    eax

        ; 32-х разрядный выход с очисткой стека
        db 66h
        retf 4

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; Данные
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; Глобальная таблица дескрипторов
GDT          label   byte
             ; Нулевой дескриптор
             segment_descriptor <>
             ; Дескриптор шлюза вызова
             gate_descriptor <call_handler, cs0_sel, 1, 11101100b, 0>
             ; Дескриптор TSS, 104 байта, базовый адрес 0
tss_dsc      segment_descriptor <103, 0, 0, 10001001b, 0,  0>
             ; Дескриптор сегмента кода с системными привелегиями
cs0_dsc      segment_descriptor <0ffffh, 0, 0, 10011010b, 0, 0>
             ; Дескриптор сегмента стека для него
ss0_dsc      segment_descriptor <stack0_size - 1, 0, 0, 10010010b, 0, 0>
             ; Дескриптор сегмента кода с пользовательскими привелегиями
cs3_dsc      segment_descriptor <0ffffh, 0, 0, 11111010b, 0, 0>
             ; Дескриптор сегмента стека для него
ss3_dsc      segment_descriptor <stack3_size - 1, 0, 0, 11110010b, 0, 0>
             ; Дескриптор сегмента данных с пользовательскими привилегиями
ds3_dsc      segment_descriptor <0ffffh, 0, 0, 11110010b, 0, 0>
             ; Дескриптор сегмента видеопамяти, доступен только системе
video_dsc    segment_descriptor <0ffffh, 08000h, 0bh, 10010010b, 0, 0>
             ; Дескриптор сегмента стека
rmss_dsc     segment_descriptor <0ffffh, 0, 0, 10010010b, 0, 0>


; Данные для загрузки в GDTR
gdtr      table_register <$ - GDT - 1, 0>

; Селекторы
call_sel     equ 00001000b    ; селектор шлюза вызова
tss_sel      equ 00010000b    ; селектор TSS
cs0_sel      equ 00011000b    ; сегмент системного кода
ss0_sel      equ 00100000b    ; системный стек
cs3_sel      equ 00101011b    ; сегмент пользовательского кода
ss3_sel      equ 00110011b    ; пользовательский стек
ds3_sel      equ 00111011b    ; пользовательские данные
video_sel    equ 01000000b    ; видеопамять
rmss_sel     equ 01001000b    ; стек для реального режима

; Сегменты стека
stack0_seg    db 128 dup (0)
stack0_size   equ $ - stack0_seg
stack3_seg    db 128 dup (0)
stack3_size   equ $ - stack3_seg

; Сегмент TSS
tss_seg   task_state_segment <0, stack0_size, ss0_sel>

; Место для хранения данных о стеке реального режима
old_ss    dw 0
old_esp   dd 0

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; Служебные функции
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; Устанавливает базу дескриптора сегмента
;    в eax передаётся адрес структуры segment_descriptor
;    в ebx передаётся смещение базы относительно cs
init_descriptor_base:
        push   ecx

        ; Получаем базу
        mov     ecx, 0
        mov     cx, cs
        shl     ecx, 4
        add     ecx, ebx

        ; Прописываем её в дескриптор
        mov     (segment_descriptor ptr [eax]).base_low, cx
        shr     ecx, 16
        mov     (segment_descriptor ptr [eax]).base_high0, cl

        pop     ecx
        ret

; Инициализирует GDT
initialize_gdt:
        ; Вычисляем линейный адрес начала массива дескрипторов
        call    cs_to_eax
        add     eax, offset GDT
        ; Записываем его в структуру
        mov     dword ptr gdtr.base, eax

        ; Загружаем GDTR
        lgdt    fword ptr gdtr
        ret

; Запрещает маскируемые и немаскируемые прерывания
disable_interrupts:
        cli              ; запретить прерывания
        in      al, 70h  ; индексный порт CMOS
        or      al, 80h  ; установка бита 7 в нем запрещает NMI
        out     70h, al
        ret

; Разрешает маскируемые и немаскируемые прерывания
enable_interrupts:
        in      al, 70h  ; индексный порт CMOS
        and     al, 7Fh  ; сброс бита 7 отменяет блокирование NMI
        out     70h, al
        sti              ; разрешить прерывания
        ret

; Устанавливает флаг PE
set_PE:
        mov     eax, cr0 ; прочитать регистр CR0
        or      al, 1    ; установить бит PE,
        mov     cr0, eax ; с этого момента мы в защищенном режиме
        ret

; Сбрасывает флаг PE
clear_PE:
        mov     eax, cr0 ; прочитать CR0
        and     al, 0FEh ; сбросить бит PE
        mov     cr0, eax ; с этого момента мы в реальном режиме
        ret

; Вычисляет линейный адрес начала сегмента кода
cs_to_eax:
        mov     eax, 0
        mov     ax, cs
        shl     eax, 4
        ret

        end     start

Задания

Разные способы нарушения работы программы:

• Поменяйте DPL стека нулевого уровня
• Поменяйте DPL шлюза вызова.
• При переходе к пользовательскому коду, не кладите в стек информацию о стеке с третьим уровнем привилегий. Таким образом вы убедитесь, что она нужна. Верните всё обратно, но поменяйте RPL селекторов.
• Не вызывайте инструкцию ltr.
• Поменяйте RPL селектора стека нулевого уровня в TSS
• Загружайте регистр ES селектором сегмента видеопамяти в начале программы, уберите повторную инициализацию из call_handler, убедитесь, что значение регистра сбрасывается. Исправьте программу так, чтобы этот вариант работал (смену уровней привилегий в программе сохраните!).
• Уберите инициализацию DS после переключения в защищённый режим. Убедитесь, что программа падает. Измените программу так, чтобы не падала (опять же, смену привилегий сохраните).
• Попробуйте завершать выполнение пользовательского кода не вызовом системной функции, а передачей управления в точку back_to_rm.
• Попробуйте возвращать управление из call_handler обычной инструкцией retf 4 (без префикса), инструкцией retf (32-х разрядной и 16-и разрядной).

Просто эксперименты:

• Поменяйте DPL в дескрипторе TSS. Убедитесь, что он никому не интересен.
• Поменяйте RPL селектора сегмента кода в дескрипторе шлюза вызова. Убедитесь, что он тоже никому не интересен.
• Выведите из пользовательского кода значения регистров CS и SS (для этого проще всего разрешить пользователям доступ к видеопамяти).
• Выведите из call_handler дамп стека и значения регистров CS и SS.
• Разбейте call_handler на две функции: draw_handler (с одним параметром) и exit_handler (без параметров), причём draw_handler должна работать не на нулевом, а на первом уровне привилегий. Поменяйте процесс инициализации и права доступа, чтобы всё это работало.
• Переделайте первоначальную передачу управления пользовательскому коду так, чтобы вместо retf использовалась инструкция iretd. Перед выполнением iretd сбросьте 14-й бит (нумеруем от 0) в регистре флагов, об этом флаге читайте в главе «Многозадачность».
• Перепишите программу так, чтобы вместо шлюза вызова и инструкции call использовался шлюз ловушки и int 21h. Параметр передавайте в регистре.
• А теперь – не прерывание, а исключение. Не забудьте изменять адрес возврата в стеке, заодно убедитесь, что это всё ещё возможно. Убедитесь, что при обработке исключения DPL шлюза не играет роли.
• Попытайтесь через шлюз передать управление с понижением уровня привилегий. Попробуйте разные варианты – вызов, программное прерывание, исключение, внешнее прерывание.