Объект ядра ос windows может наследовать только мьютекс

Введение

Для работы с важными системными ресурсами ОС Windows создает объекты, управление которыми осуществляет менеджер объектов. Когда приложение открывает файл, создает поток или семафор, оно получает описатель ( handle ) соответствующего объекта (см.
рис.
4.1). Например, после выполнения программного оператора

hSemaphore = CreateSemaphore(NULL, 0, MaxCount, "MySemaphore");

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

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

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

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

Объекты ядра

В рамках данного курса нам придется активно использовать объекты, называемые в руководствах по Win32-программированию объектами ядра (kernel objects). Поддержка объектов ядра осуществляется собственно ядром и исполнительной системой. Помимо объектов ядра имеются также объекты, предназначенные для управления окнами (User), и объекты, предназначенные для управления графикой (GDI). Изучение этих категорий объектов, реализуемых подсистемой поддержки окон и графики и ориентированных на разработку графических интерфейсов пользователя, выходит за пределы данного курса.

К сожалению, понятие «объект ядра» имеет разный смысл у разных авторов (ср., например, это понятие в MSDN или в
[
Рихтер
]
, c одной стороны, и в
[
Руссинович
]
— с другой), поэтому для дальнейшего изложения потребуется уточнение терминологии.

Дело в том, что совокупность объектов образует слоеную структуру. Ядро поддерживает базовые объекты двух видов: объекты диспетчера (события, мьютексы, семафоры, потоки ядра, таймеры и др.) и управляющие (DPC, APC, прерывания, процессы, профили и др.) Более подробно эти внутриядерные объекты описаны в
[
Руссинович
]
.

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

Внешнее отличие объектов ядра (объектов исполнительной системы) от объектов User и GDI состоит в наличии у первых атрибутов защиты, которые являются одним из параметров, создающих объект ядра функций.
Далее эти объекты ядра (объекты исполнительной системы) будут называться просто объектами.

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

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

Структура объекта. Методы объекта

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

Счетчик ссылок на объект увеличивается на 1 при открытии объекта и уменьшается на 1 при его закрытии. Значение счетчика ссылок, равное нулю, означает, что объект больше не используется и выделенное ему адресное пространство ядра может быть освобождено. Наличие счетчика означает, что даже после завершения процесса, создавшего объект, этот объект может не быть разрушен (если его счетчик не обнулен).

Квота устанавливает ограничения на объемы ресурсов. Несмотря на то, что в ОС Windows реализован код для отслеживания квот, в настоящее время квоты не применяются и существуют достаточно мягкие ограничения. Например, по умолчанию лимит на открытые объекты для процесса — 230. Множество объектов делится на типы, а у каждого из объектов есть атрибуты, неизменные для объектов данного типа. Ссылка на тип объекта также входит в состав заголовка. Поля имя объекта и каталог будут описаны в разделе «именование объектов».

Методы объекта

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

Описатели объектов

Создание новых объектов, или открытие по имени уже существующих, приложение может осуществить при помощи Win32-функций, таких, как CreateFile, CreateSemaphore, OpenSemaphore и т.д. Это библиотечные процедуры, за которыми стоят сервисы Windows и методы объектов. В случае успешного выполнения создается 64-битный описатель в таблице описателей процесса в памяти ядра. На эту таблицу есть ссылка из блока управления процессом EPROCESS (см.
«Реализация процессов и потоков»
).

Из 64-х разрядов описателя 29 разрядов используются для ссылки на блок памяти объекта ядра, 3 — для флагов, а оставшиеся 32 — в качестве маски прав доступа. Маска прав доступа формируется на этапе создания или открытия объекта, когда выполняется проверка разрешений. Таким образом, описатель объекта — принадлежность процесса, создавшего этот объект. По умолчанию он не может быть передан другому процессу. Тем не менее, система предоставляет возможность дублирования описателя и передачи его другому процессу специальным образом (см. ниже раздел «Совместное использование объектов» и часть IV «Безопасность«).

Win32-функции, создающие объект, возвращают приложению не сам описатель, а индекс в таблице описателей, то есть малое число: типа 1,2 а не 64-разрядное (см.
рис.
4.3). Впоследствии это значение передается одной из функций, которая принимает описатель объекта в качестве аргумента. Одной из таких функций является функция CloseHandle, задача которой — закрыть объект. Во избежание утечки памяти всегда рекомендуется закрывать объект, если в нем отпала надобность. Впрочем, по окончании работы процесса система закрывает все его объекты. Таким образом, структуры объектов ядра доступны только ядру, приложение не может самостоятельно найти эти структуры в памяти и напрямую модифицировать их содержимое.

Именование объектов. Разделяемые ресурсы

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

«Увидеть» пространство имен можно только при помощи специальных инструментальных средств, например, с помощью утилиты winobj, входящей в состав MS Platform SDK. Другую версию этой утилиты можно бесплатно получить на сайте http://www.sysinternals.com.

1. Что такое объект ядра?

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

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

c)Скопировать объект использование подсчета подсчета:

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

d)Безопасность объекта ядра:

1) Все функции, используемые для создания объектов ядра, почти указывают на одинSECURITY_ATTRIBUTES Используется для защиты объекта ядра, если этот параметр передается вNULLЗатем используйте атрибут безопасности по умолчанию текущего токена безопасности процесса.SECURITY_ATTRIBUTESсерединаlpSecurityDescriptorУчаствовать в одномSecurity_descriptor Security Descriptor Structure, которая используется для установки атрибутов безопасности объекта ядра.

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

3) Методы различения объектов ядра и обычных объектов:

Почти функция создания объекта ядра имеет параметры указанной информации атрибута безопасности.

2. Таблица обработки объектов обработки

a) Каждый процесс поддерживает таблицу обработки объектов ядра. Каждый элемент в таблице представляет собой структуру данных. Члены этой структуры данных содержат реальный адрес объекта ядра и разрешения доступа.Руководство, удерживаемое кодом пользователя (эта ручка используется для всех пользовательских потоков в этом процессе, но он может реализовать объекты ядра по перекрестному борьбе через некоторый механизм), на самом деле является значением индекса таблицы объектов ядра этой ручки объекта ядра. Анкет Следовательно, когда объект ядра выключается, переменная не очищена, а таблица с помощью объекта ядра переоценивает объект ядра в этой позиции индекса.BUGСущность В других процессах доступ к объекту ядра этой ручки, на самом деле, значение индекса таблицы направления объектов ядра, соответствующая другим процессам, также будет вызватьBUG。

b)  При вызове функции для создания объекта ядра, если вызов сбой, возвращаемое значение может быть0 ЛибоINVALID_HANDLE_VALUE（-1）。следовательноВозвращающаяся стоимость единого суждения0ЛибоINVALID_HANDLE_VALUEэто не правильно.

c) Независимо от того, как создан объект ядра, вы должны позвонитьCloseHandleСистеме показано, что этот объект был завершен.CloseHandleПроверьте таблицу обработки ядра процесса внутренне, чтобы проверить, является ли грандиозное действительное. Если он действителен, адрес структуры данных данных объекта ядра индексируется и минус счетчик в структуре. Если счетчик используется0Ядро операционной системы уничтожило объект ядра.CloseHandle Перед возвращением функция также очистит соответствующие элементы записи в таблице ручки объекта процесса ядра. передачаCloseHandleПосле этого, даже если объект ядра все еще существует, этот процесс рассматривает ручку как недействительную. Следовательно, этот процесс не может быть использован.использоватьCloseHandleПосле этого ручка должна быть установлена ​​наNULL。

D) Когда процесс выходит, все объекты будут выпущены. Система гарантирует, что после окончания процесса ничего не останется. (Объект ядра определяет, следует ли перерабатывать ресурсы в соответствии с счетчиком в объекте ядра. Если счетчик равен 0Затем отпустите объект, иначе он просто уменьшит счетчик до операции）

3. Объект ядра Cross -Borderding

а) Хандикап для ручки объекта

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

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

Iii.

1. Инициализируйте одинSECURITY_ATTRIBUTES Структура, вкладывая членовbInheritHandle Назначен какTRUEЧтобы показать, что объект ядра может наследовать и передать функцию создания основного объекта. ИспользоватьSetHandleInformationУстановите логотип наследования для рукоятки объекта ядра. Есть один, соответствующий одномуGetHandleInformation, Логотип наследства для возврата ручки.

2. ПозвонитеCreateProcessСоздайте дочерний процесс и будетCreateProcessсерединаbInheritHandlesПараметр установлен наTRUEСущность Это показывает, что дочерний процесс будет наследовать направление объекта ядра, которая может быть унаследована в родительском процессе.

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

а) Передайте параметры командной строки в процесс ребенка

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

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

Iv. Логотип изменения ручки

1SetHandleInformationВы можете изменить признаки наследования направления объекта ядра

а) Первый параметр идентифицирует эффективную ручку объекта ядра

б) Второй параметрdwMaskРасскажите функции, какой или какой логотип хочет изменить

в) третий параметрdwFlagsУкажите желание установить логотип, почему.

2. черезGetHandleInformation Может получить текущий знак ручки объекта ядра

Исходный код процесса отца:

 1 #define _CRT_SECURE_NO_DEPRECATE
 2 #include <iostream>
 3 #include <windows.h>
 4 using namespace std;
 5 
 6 DWORD _stdcall Thread(LPVOID param)
 7 {
 8     while (1)
 9     {
10         cout << "loop" << endl;
11         Sleep(500);
12     }
13     return 0;
14 }
15 
16 int AnsiToUnicode (char *str_ansi, wchar_t *str_wide, unsigned int chcount)
17 {
18     return MultiByteToWideChar(CP_ACP, 0, str_ansi, -1, str_wide, chcount);
19 }
20 
21 int main(void)
22 {
23     /*
24     SECURITY_ATTRIBUTES sa;
25     sa.nLength = sizeof(sa);
26     sa.bInheritHandle = TRUE;
27     sa.lpSecurityDescriptor = NULL;*/
28 
29     HANDLE hThread = CreateThread (NULL, 0, Thread, NULL, 0, NULL);
30     //CloseHandle(hThread);        //Если ручка закрыта, дочерний процесс не сможет получить доступ к объекту ядра родительского процесса
31 
32     SetHandleInformation (hThread, HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT);
33 
34     Sleep(1000);
35 
36 
37     STARTUPINFO info = {0};
38     PROCESS_INFORMATION pi = {0};
39     char comline[256];
40     TCHAR p[256];
41 
42     sprintf(comline, "%d", hThread);
43     AnsiToUnicode(comline, p, sizeof(p));
44 
45     SetEnvironmentVariable(L"hThread", p);            //Чтобы добавить переменные окружающей среды перед созданием дочернего процесса, в противном случае детский процесс не будет наследовать переменные среды родительского процесса
46     
47     CreateProcess (L"..\debug\child.exe", p, NULL, NULL, TRUE, CREATE_NEW_CONSOLE, NULL, NULL, &info, &pi);
48     CloseHandle(pi.hProcess);
49     CloseHandle(pi.hThread);
50 
51 
52     cin.get();
53     return 0;
54 }

Исходный код:

 1 #include <iostream>
 2 #include <windows.h>
 3 using namespace std;
 4 
 5 int UnicodeToAnsi(wchar_t *str_wide, char *str_ansi, unsigned int cbsize)
 6 {
 7     return WideCharToMultiByte(CP_ACP, 0, str_wide, -1, str_ansi, cbsize, NULL, NULL);
 8 }
 9 
10 int main (int argv, char ** argc)
11 {
12 
13 
14     //  Командная строка получает ручку наследования.
15     /*
16     HANDLE hThread = (HANDLE)atol(argc[0]);  
17     cout << "get kernal handle: " << argc[0] << endl;
18     TerminateThread(hThread, 0);
19     cout << "kill my parent process thread " << endl;
20     */
21 
22     
23     HANDLE hThread;
24     TCHAR buf[256] = {0};
25     char str[256] = {0};
26     GetEnvironmentVariable(L"hThread", buf, sizeof(buf));
27     UnicodeToAnsi(buf, str, sizeof(str));
28     cout << str << endl;
29     hThread = (HANDLE) atoi(str);
30     TerminateThread(hThread, 0);
31     
32 
33     cin.get();
34     return 0;
35 }

б) Называть объект

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

ii. Все объекты ядра имеют одинаковое пространство имени, даже если их типы не одинаковы.

Iii. Когда процесс вызываетCreate*  При создании функции объекта ядра, если он уже существуетpszNameИмя объекта ядра указывает, что параметр будет игнорировать другие параметры. Если нетpszNameИмя объекта ядра указывает параметр, и другие параметры будут переданы.

Iv. За исключениемCreate* Все еще может использоватьOpen* Откройте общий объект ядра.Open*изpszName Параметры не могут быть переданы вNULL。Create*а такжеOpen*Основное различие между функцией: если объект не существует,Create*Создаст его,Open*Неудача закончится с отказом вызова.

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

vi. Терминальная служба пространство

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

2. Объект ядра именования услуг всегда должен быть расположен в глобальном пространстве именования. По умолчанию объект ядра именования приложения находится в пространстве имени текущего сеанса. Если вы хотите позволить ему присоединиться к глобальному пространству именования, вы можете добавить «Global » префикс в его имени. Поместите объект ядра именования в текущий сеанс. ». Session <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<sСессияid>«Ограничьте объекты ядра именования могут только работать. Обратите внимание, что эти префиксы различаются.

Терминал Служба Имя ПРИМЕР ПРИМЕР:

 1 #include <iostream>
 2 #include <windows.h>
 3 using namespace std;
 4 
 5 int main (void)
 6 {
 7     //  Создайте глобальный доступный Mutex
 8     HANDLE hMutex;
 9     hMutex = CreateMutex (NULL, FALSE, L"Global\Mutex");
10     if (GetLastError() == ERROR_ALREADY_EXISTS)
11     {
12         cout << "this is old mutex" << endl;
13     }
14     else if (NULL == hMutex)
15     {
16         
17         cout << "create object error" << endl;
18     }
19     else
20         cout << "this is new mutex" << endl;
21     
22     cin.get();
23     return 0;
24 }

vii. Частное пространство имени

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

2. Шаги по созданию частного пространства именования:

а) Создать граничный дескриптор CreateBoundaryDescriptor

б) создатьSID（Единственное число пользователя, групповой и компьютерной учетной записи) CreateWellSIDSID

в)SIDИсправлено с дескриптором границы.AddSIDToBoundaryDescriptor

г) Инициализировать дескриптор безопасности//Использование книгиConvertStringSecurityDescriptorToSecurityDescriptor

e) Создать частное именованное пространство CreatePrivingNamespace

3. Примечание, CreatePrivateNamespaceа также OpenPrivateNamespace возвращатьсяHANDLE Не ручка объекта ядра, его следует использоватьClosePrivateNamspaceВыходи из псевдо -ручки, которую они возвращаются.

4. Если частное пространство именования не хочет упоминаться другими процессами после закрытия процесса, вам следует позвонитьClosePrivateNamespaceИ пройти во втором параметреPRIVATE_NAMESPACE_FLAG_DESTROY。

5. Граница будет прекращена или вызвана в процессеDeleteBoundaryDescriptorЗакройте его по делу.

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

7. Имя, которое мы указали для частного названного пространства, является псевдонимом, видным только в процессе. Другие процессы(Даже тот же процесс)Может открыть одно и то же частное пространство и указать для него другие псевдонимы.

Пример индивидуального имени пространства:

 1 #include <windows.h>
 2 #include <sddl.h>
 3 #include <strsafe.h>
 4 #include <iostream>
 5 using namespace std;
 6 
 7 
 8 
 9 void CheckInstances()
10 {
11 
12     BOOL bIsNamespaceOpen = FALSE;
13 
14     //Создать дескриптор границ
15     HANDLE hBoundary = CreateBoundaryDescriptor(L"my_private_name", 0);
16 
17 
18     //Создайте SID
19     BYTE localAdminSID[SECURITY_MAX_SID_SIZE];
20     DWORD cbSID = sizeof(localAdminSID);
21     if ( !CreateWellKnownSid(WinBuiltinAdministratorsSid, NULL, localAdminSID, &cbSID) )
22     {
23         cout << "CreateWellKnownSID error : " << GetLastError() << endl;
24         return ;
25     }
26 
27     //Связывать SID с дескриптором границ
28     if ( !AddSIDToBoundaryDescriptor (&hBoundary, localAdminSID) )
29     {
30         cout << "AddSIDToBoundaryDescriptor error : " << GetLastError() << endl; 
31     }
32 
33     //Преобразовать строку дескриптора безопасности в дескриптор безопасности
34     SECURITY_ATTRIBUTES sa;
35     sa.nLength = sizeof(sa);
36     sa.bInheritHandle = FALSE;
37     if ( !ConvertStringSecurityDescriptorToSecurityDescriptor (L"D:(A;;GA;;;BA)", SDDL_REVISION_1, &sa.lpSecurityDescriptor, NULL) )
38     {
39         cout << "ConvertStringSecurityDescriptorToSecurityDescriptor error : " << GetLastError() << endl;
40         return ;
41     }
42 
43     //Создайте запатентованное пространство имени
44     TCHAR szNamespace[256] = L"my_private_name";
45     HANDLE hNamespace = CreatePrivateNamespace (&sa, hBoundary, szNamespace);
46     LocalFree (sa.lpSecurityDescriptor);
47     DWORD dwError = GetLastError();
48 
49     if (hNamespace == NULL)
50         if (dwError == ERROR_ALREADY_EXISTS)
51         {
52             //  Если это пространство для именования существует, откройте это пространство имени
53             cout << "CreatePrivateNamespace failed : " << GetLastError() << endl;
54             hNamespace = OpenPrivateNamespace (hBoundary, szNamespace);
55 
56             bIsNamespaceOpen = TRUE;
57         }
58 
59 
60     TCHAR szMutex[256];
61     StringCchPrintf (szMutex, _countof(szMutex), L"%s\%s", szNamespace, L"MyMutex");
62 
63     HANDLE hMutex = CreateMutex (NULL, FALSE, szMutex);
64     if (GetLastError () == ERROR_ALREADY_EXISTS)
65     {
66         cout << "Этот объект ядра уже существует" << endl;
67     }
68     else if (hMutex == NULL)
69     {
70         cout << "Создайте ошибку" << endl;
71     }
72     else
73     {
74         cout << "Создание объекта подражания успешно" << endl;
75     }
76 
77 
78     if (hNamespace != NULL)
79     {
80         if (bIsNamespaceOpen)
81             ClosePrivateNamespace (hNamespace, PRIVATE_NAMESPACE_FLAG_DESTROY);
82         else
83             ClosePrivateNamespace (hNamespace, PRIVATE_NAMESPACE_FLAG_DESTROY);
84     }
85     
86     DeleteBoundaryDescriptor (hBoundary);
87 
88     CloseHandle (hMutex);
89 }
90 
91 int main (void)
92 {
93 
94     CheckInstances();
95 
96     while (1);
97     return 0;
98 }

в). ИспользуйтеDuplicateHandle Вы можете скопировать ручку объекта

1. DuplicateHandleПолучите элемент записи в таблице обработки процессов, а затем создайте копию этого элемента записи в таблице ручки другого процесса.

2. DuplicateHandle серединаdwOptionsПараметры могут быть указаныDUPLICATE_SAME_ACCESSа такжеDUPLICATE_CLOSE_SOURCEЗнак. Если вы указалиDUPLICATE_SAME_ACCESSЗнак будет надеяться, что целевой дескриптор имеет тот же крышку доступа, что и исходный процесс. Если вы указалиDUPLICATE_CLOSE_SOURCEЛоготип закроет ручку исходного процесса. С помощью этого знака количество объектов ядра не будет затронуто.

3. DuplicateHandle Как и наследование, целевой процесс не знает, что теперь он может получить доступ к новому объекту ядра, поэтому исходный процесс каким -то образом уведомит целевой процесс. В отличие от наследования, исходный процесс не может использовать параметры командной строки или изменять переменные среды целевого процесса.

4. Можно использоватьDuplicateHandleИзменить разрешения на доступ к объекту ядра

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

Дублировать три примера процесса:

Среди них процесс S является исходным процессом, процесс T является целевым процессом.

S Процесс исходный код:

 1 #define _CRT_SECURE_NO_DEPRECATE
 2 #include <iostream>
 3 #include <windows.h>
 4 using namespace std;
 5 
 6 
 7 int AnsiToUnicode (char *str_ansi, wchar_t *str_wide, unsigned int chcount);
 8 DWORD _stdcall Thread(LPVOID param);
 9 
10 int main(void)
11 {
12     cout << "Я процесс s" << endl;
13 
14 
15     HANDLE hThread = CreateThread (NULL, 0, Thread, NULL, 0, NULL);
16     Sleep(1000);
17 
18     //  Добавьте значение ручки в блок среды
19     char comline[256];
20     TCHAR p[256];
21     sprintf(comline, "%d", hThread);
22     AnsiToUnicode(comline, p, sizeof(p));
23     SetEnvironmentVariable(L"hThread", p);    
24 
25 
26     //  Уточните ручку резьбы к процессу C.
27     STARTUPINFO info = {0};
28     PROCESS_INFORMATION pi = {0};
29     CreateProcess (L"..\debug\C.exe", NULL, NULL, NULL, TRUE, CREATE_NEW_CONSOLE, NULL, NULL, &info, &pi);
30 
31 
32     CloseHandle(pi.hProcess);
33     CloseHandle(pi.hThread);
34     cin.get();
35     return 0;
36 }
37 
38 
39 DWORD _stdcall Thread(LPVOID param)
40 {
41     while (1)
42     {
43         Sleep(500);
44         cout << "loop" << endl;
45     }
46     return 0;
47 }
48 
49 int AnsiToUnicode (char *str_ansi, wchar_t *str_wide, unsigned int chcount)
50 {
51     return MultiByteToWideChar(CP_ACP, 0, str_ansi, -1, str_wide, chcount);
52 }

T Процесс исходный код:

 1 #include <iostream>
 2 #include <Windows.h>
 3 using namespace std;
 4 
 5 int main (void)
 6 {
 7     cout << "Я процесс t" << endl;
 8 
 9     HANDLE hThread;
10 
11     cout << "Пожалуйста, введите значение ручки объекта ядра, я закрою потоки процесса S:" << endl;
12     while (cin >> hThread)
13         TerminateThread(hThread, 0);
14 
15     cin.get();
16     return 0;
17 }

C Процесс исходный код:

 1 #include <iostream>
 2 #include <windows.h>
 3 #include <Tlhelp32.h>
 4 using namespace std;
 5 
 6 int UnicodeToAnsi(wchar_t *str_wide, char *str_ansi, unsigned int cbsize);
 7 HANDLE GetProcessHandle (LPCTSTR szProceName);
 8 
 9 int main (void)
10 {
11     cout << "Я процесс C" << endl;
12 
13 
14     //Получить ручку объекта резьбы процесса S процесса S
15     HANDLE hThread;
16     TCHAR buf[256] = {0};
17     char str[256] = {0};
18 
19     GetEnvironmentVariable(L"hThread", buf, sizeof(buf));
20     UnicodeToAnsi(buf, str, sizeof(str));
21     hThread = (HANDLE) atoi(str);
22     cout << "Получить объект ядра потока процесса из процесса S: " << hThread << endl;
23 
24 
25     //  Ручка репликации
26     HANDLE hobj;
27     HANDLE hSProcess, hTProcess;
28     hSProcess = GetProcessHandle(L"S.exe");
29     hTProcess =  GetProcessHandle(L"T.exe");
30     if (TRUE == DuplicateHandle (hSProcess, hThread, hTProcess, &hobj, 0, TRUE, DUPLICATE_SAME_ACCESS) )
31         cout << "Справиться: " <<  hobj << "  Копия успешно может теперь управлять объектом ядра процесса S в процессе T!" << endl;
32 
33     
34     CloseHandle (hSProcess);
35     CloseHandle (hTProcess);
36 
37     cin.get();
38     return 0;
39 }
40 
41 
42 HANDLE GetProcessHandle (LPCTSTR szProceName)
43 {
44     HANDLE hSanpshot = CreateToolhelp32Snapshot (TH32CS_SNAPPROCESS, 0);
45     if (hSanpshot == INVALID_HANDLE_VALUE  || hSanpshot == NULL)
46     {
47         return NULL;
48     }
49 
50     PROCESSENTRY32 pe;
51     BOOL ok;
52     pe.dwSize = sizeof(pe);
53     ok = Process32First (hSanpshot, &pe);
54     if ( !ok )
55         return NULL;
56 
57     do{
58         if ( 0 == wcscmp( pe.szExeFile , szProceName) )
59         {
60             return OpenProcess (PROCESS_ALL_ACCESS, FALSE, pe.th32ProcessID);
61         }
62         ok = Process32Next (hSanpshot, &pe);
63     }while (ok);
64 
65     return NULL;
66 }
67 
68 int UnicodeToAnsi(wchar_t *str_wide, char *str_ansi, unsigned int cbsize)
69 {
70     return WideCharToMultiByte(CP_ACP, 0, str_wide, -1, str_ansi, cbsize, NULL, NULL);
71 }

Дублировать два примера процесса

Процесс S имеет объект ядра, а дескриптор объекта ядра в процессе S копируется в таблицу обработки T -процесса.

S Процесс исходный код:

 1 #include <iostream>
 2 #include <windows.h>
 3 #include <process.h>
 4 #include <TlHelp32.h>
 5 
 6 using namespace std;
 7 
 8 
 9 unsigned __stdcall thread (void * lpPragma);
10 HANDLE GetProcessHandle(LPCTSTR szName);
11 
12 
13 int main (void)
14 {
15 
16  
17     HANDLE hThread;
18     hThread = (HANDLE)_beginthreadex(NULL, 0, thread, NULL, 0, NULL);
19     cout << "my thread handle: " << hThread << endl;
20 
21 
22 
23     HANDLE hTarget;
24     if (DuplicateHandle (GetCurrentProcess(), hThread, GetProcessHandle(L"Target.exe"), &hTarget, 0, FALSE, DUPLICATE_SAME_ACCESS ) )
25         cout << "Ручка успешно воспроизведена, и его значение ручки составляет:" << hTarget << endl;
26          
27 
28 
29     cin.get();
30     return 0;
31 }
32 
33 
34 unsigned __stdcall thread (void * lpPragma)
35 {
36     while (1)
37     {
38         Sleep (500);
39         cout << "terminal me" << endl;
40     }
41 
42     return 0;
43 }
44 
45 HANDLE GetProcessHandle(LPCTSTR szName)
46 {
47     HANDLE hSanpshot;
48     hSanpshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
49     if ( INVALID_HANDLE_VALUE == hSanpshot )
50     {
51         return NULL;
52     }
53 
54     PROCESSENTRY32 pe;
55     BOOL bOk;
56     pe.dwSize = sizeof(pe);
57 
58     bOk = Process32First (hSanpshot, &pe);
59     if (!bOk)
60         return NULL;
61 
62     do {
63         if ( !wcscmp (pe.szExeFile, szName) )
64         {
65             return OpenProcess (PROCESS_ALL_ACCESS, FALSE, pe.th32ProcessID);
66         }
67         bOk = Process32Next (hSanpshot, &pe);
68     }while (bOk);
69 
70     return NULL;
71 }

T Процесс исходный код:

#include <iostream>
#include <windows.h>
#include <stdlib.h>
#include <process.h>
using namespace std;

unsigned __stdcall thread (void * lpPragma);

int main (void)
{
	HANDLE hRecv;


 
	HANDLE hThread;
	hThread = (HANDLE)_beginthreadex(NULL, 0, thread, NULL, 0, NULL);

	cout << "my thread handle: " << hThread << endl;
	 Cout << "Пожалуйста, введите копию копируемой ручки:" << endl;
	cin >> hRecv;


	TerminateThread(hRecv, 0);




	while (1);
	return 0;
}


unsigned __stdcall thread (void * lpPragma)
{
	while (1)
	{
	
		Sleep (1500);
		MessageBox(NULL, L"run", L"", 0);
	}

	return 0;
}

Больший интерес из всех трёх групп объектов представляет категория объект ядра.
Рассмотрим более подробно Kernel object.

Каждый объект ядра — это блок памяти, выделенный ядром ОС и доступный только ядру ОС.
Этот блок памяти представляет собой структуру данных, члены которой хранят информацию об объекте (дескриптор безопасности, счетчик использования и т.д.).
Некоторые члены этих структур одинаковы для всех типов объектов, но большинство относятся к конкретному типу объекта.
Например, объект процесса имеет идентификатор процесса, базовый приоритет и код выхода, тогда как объект файла имеет байтовое смещение, режим sharing mode и режим open mode.
Поскольку структуры данных объекта ядра доступны только ядру ОС, приложение не может найти эти структуры данных в памяти и напрямую изменить их содержимое.
Windows API предлагает набор функций, которые документированными способами взаимодействуют с этими структурами.
Когда используется функция, которая создает объект ядра, она возвращает дескриптор, который идентифицирует объект.
Передавая этот дескриптор различным функциям Windows, система точно знает с каким объектом ядра необходимо взаимодействовать.Объекты ядра принадлежат ядру ОС, а не процессу.
Процесс вызывает функцию, которая создает объект ядра. Если процесс завершается, объект ядра не обязательно уничтожается.
Если другой процесс использует данный объект ядра, ОС ​​знает, что нельзя уничтожать этот объект, пока другой процесс не перестанет его использовать.
Для этого в ОС предусмотрен счетчик использования. Когда объект ядра создается впервые, его счетчик использования устанавливается на 1.
Затем, когда другой процесс получает доступ к существующему объекту ядра, счетчик использования увеличивается на единицу.
Когда процесс завершается, ядро ОС ​​автоматически уменьшает счетчик использования для всех объектов ядра на единицу.
Если счетчик использования объекта становится равным 0, ядро ОС ​​уничтожает объект.Дескриптор безопасности (Security Descriptor).
Объекты ядра могут быть защищены дескриптором безопасности.
Почти все функции, которые создают объекты ядра, имеют указатель на структуру SECURITY_ATTRIBUTES в качестве аргумента.
Именно этим и отличается Kernel object от других категорий (ни у User object, ни у GDI object нет дескрипторов безопасности).

Более подробно что из себя представляет дескриптор безопасности рассмотрим на примере функции CreateProcess

1
2
3
4
5
6
7
8
9
10
11
12

BOOL CreateProcessW(
  [in, optional]      LPCWSTR               lpApplicationName,
  [in, out, optional] LPWSTR                lpCommandLine,
  [in, optional]      LPSECURITY_ATTRIBUTES lpProcessAttributes,
  [in, optional]      LPSECURITY_ATTRIBUTES lpThreadAttributes,
  [in]                BOOL                  bInheritHandles,
  [in]                DWORD                 dwCreationFlags,
  [in, optional]      LPVOID                lpEnvironment,
  [in, optional]      LPCWSTR               lpCurrentDirectory,
  [in]                LPSTARTUPINFOW        lpStartupInfo,
  [out]               LPPROCESS_INFORMATION lpProcessInformation
);

Большинство приложений просто передают NULL для этого аргумента, поэтому объект ядра создается с безопасностью по умолчанию.
Безопасность по умолчанию означает, что любой пользователь группы администраторов и создатель объекта ядра имеют определённый доступ к создаваемому объекту, всем остальным доступ запрещен.
Структура SECURITY_ATTRIBUTES описывается следующим образом

1
2
3
4
5

typedef struct _SECURITY_ATTRIBUTES {
  DWORD  nLength;
  LPVOID lpSecurityDescriptor;
  BOOL   bInheritHandle;
} SECURITY_ATTRIBUTES, *PSECURITY_ATTRIBUTES, *LPSECURITY_ATTRIBUTES;

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

1
2
3
4
5
6
7
8
9
10

PSECURITY_DESCRIPTOR pProcessSecurityDescriptor, pThreadSecurityDescriptor;
 
SECURITY_ATTRIBUTES ProcessAttributes{ sizeof(SECURITY_ATTRIBUTES) };
ProcessAttributes.lpSecurityDescriptor = pProcessSecurityDescriptor;
 
SECURITY_ATTRIBUTES ThreadAttributes{ sizeof(SECURITY_ATTRIBUTES) };
ThreadAttributes.lpSecurityDescriptor = pThreadSecurityDescriptor;
 
CreateProcess(ApplicationName, nullptr, &ProcessAttributes, &ThreadAttributes,
    FALSE, CREATE_SUSPENDED, nullptr, nullptr, &StartupInfo, &ProcInfo);

*PSECURITY_DESCRIPTOR в данном случае определен как LPVOID, не путайте со структурой PISECURITY_DESCRIPTOR

Существуют два способа получить инициализированный Security Descriptor:
— наследовать уже созданный дескриптор безопасности другим процессом
— сформировать специальную строку типа SDDL (Security Descriptor Definition Language) и конвертировать её в указатель с помощью функции ConvertStringSecurityDescriptorToSecurityDescripto r

1
2
3
4
5
6

BOOL ConvertStringSecurityDescriptorToSecurityDescriptorW(
  [in]  LPCWSTR              StringSecurityDescriptor,
  [in]  DWORD                StringSDRevision,
  [out] PSECURITY_DESCRIPTOR *SecurityDescriptor,
  [out] PULONG               SecurityDescriptorSize
);

Рассмотрим следующую SDDL строку

1
2

LPCWSTR StringSecurityDescriptor = TEXT("O:BAG:BAD:(A;;CCDCLCSWRP;;;SY)(A;;CCDCLCSWRP;;;BA)"
    "(A;;CCDCLCSWRP;;;IU)(A;;CCDCLCSWRP;;;LS)(A;;0xb;;;AC)S:(ML;;NX;;;LW)");

Первое на что необходимо обратить внимание — это на двоеточие, оно служит разделением для групп

O:owner_sid
G:group_sid
D:(string_ace1)(string_ace2)... (string_aceN)
S:(string_ace1)(string_ace2)... (string_aceN)

Каждый string_ace заключен в круглые скобки и имеет следующую структуру:

(ace_type;ace_flags;rights;object_guid;inherit_object_guid;account_sid)

Допустимые типы ace_type

Разрешенные ace_flags

Набор rights (общие права, права доступа к файлам и папкам, особые права реестра и сервисов)

object_guid и inherit_object_guid используются для определения безопасности объектов в Active Directory.
Они не используются при защите файловой системы или реестра. «OA» и «OD» в поле ace_type строки ACE соответствуют ACE, разрешающему и запрещающему объект, соответственно.
В этом случае object_guid содержит GUID объекта, которому разрешено, а inherit_object_guid содержит GUID объекта, от которого он наследует разрешения.

Поле account_sid в структуре ACE обозначает участника безопасности, которому предоставлены или запрещены права доступа, указанные в ACE.
Поле account_sid может содержать SID, который представляет собой длинный структурированный идентификатор, который практически не имеет смысла для человека, или сокращенное обозначение «строка SID» для обычной учетной записи

Список SID строк можно расшифровать на сайте MSDN
Список ACE строк можно расшифровать на сайте MSDN

Таким образом:
O:BA — владелец (Owner) данного дескриптора безопасности является SDDL_BUILTIN_ADMINISTRATORS (DOMAIN_ALIAS_RID_ADMINS)
G:BA — группа (Group), в которую входит дескриптор безопасности, также является SDDL_BUILTIN_ADMINISTRATORS (DOMAIN_ALIAS_RID_ADMINS)

Список управления доступом на уровне пользователя DACL (Discretionary Access Control List)
D:(A;;CCDCLCSWRP;;;SY)(A;;CCDCLCSWRP;;;BA)(A;;CCDCLCSWRP;;;IU)(A;;CCDCLCSWRP;;;LS)(A;;0xb;;;AC)

И системный список управления доступом SACL (System Access Control List)
S:(ML;;NX;;;LW)

Следовательно для первой части DACL получается следующая расшифровка (данный DACL относится к группе Directory service object):
A — SDDL_ACCESS_ALLOWED (флаг ACCESS_ALLOWED_ACE_TYPE)
CC — SDDL_CREATE_CHILD (флаг ADS_RIGHT_DS_CREATE_CHILD)
DC — SDDL_DELETE_CHILD (флаг ADS_RIGHT_DS_DELETE_CHILD)
LC — SDDL_LIST_CHILDREN (флаг ADS_RIGHT_ACTRL_DS_LIST)
SW — SDDL_SELF_WRITE (флаг ADS_RIGHT_DS_SELF)
RP — SDDL_READ_PROPERTY (флаг ADS_RIGHT_DS_READ_PROP)
SY — SDDL_LOCAL_SYSTEM (SECURITY_LOCAL_SYSTEM_RID)

и для SACL
ML — SDDL_MANDATORY_LABEL (флаг SYSTEM_MANDATORY_LABEL_ACE_TYPE)
NX — SDDL_NO_EXECUTE_UP (флаг SYSTEM_MANDATORY_LABEL_NO_EXECUTE_UP)
LW — Low Mandatory Level (SID S-1-16-4096)

Метки целостности

Моя программа KernelExplorer (её консольная версия) выводит всю возможную информацию об ACL

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

*В данный момент занят адаптацией информации о ACL для GUI версии.Таблица дескрипторов объекта ядра процесса.
В первой части я вскользь упомянул, что каждый дескриптор имеет записи во внутренней таблице, которые содержат адреса ресурсов и средства идентификации типа ресурса.
Когда процесс инициализируется, система выделяет для него таблицу дескрипторов.
Эта таблица дескрипторов используется только для объектов ядра, User object или GDI object не имеют доступа к ней.
Подробности того, как структурирована и управляется таблица дескрипторов не документированы.
Но при этом, структуру таблицы дескрипторов процесса схематично можно представить следующим образом

Index	Pointer to Kernel Object Memory Block	Access Mask	Flags
1	0x0000000000000000	                0x00000000	0x00000000
2	0x0000000000000000	                0x00000000	0x00000000
...
n	0x0000000000000000	                0x00000000	0x00000000

Каждая структура содержит указатель на объект ядра, маску доступа и набор флагов.
При первой инициализации процесса его таблица дескрипторов пуста.
Затем, когда поток в процессе вызывает функцию, которая создает объект ядра, ядро ОС выделяет блок памяти для объекта и инициализирует его.
Ядро ОС сканирует таблицу дескрипторов процесса на наличие пустой записи.
Для указателя будет установлен адрес внутренней памяти структуры данных объекта ядра.
Для маски доступа будет установлен гарантированный доступ (granted access).
Набор флагов соответственно устанавливается из переданного Security Descriptor, а в случае NULL — устанавливается безопасность по умолчанию.

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

Пулы памяти.
Выгружаемый и невыгружаемый пулы служат ресурсами памяти, которые ОС использует для хранения своих структур данных.
Невыгружаемый пул (Non-paged pool) — используется операционной системой для хранения данных.
Ядро ОС взаимодействует с невыгружаемым пулом когда выполняются подпрограммы обслуживания прерываний (ISR) и отложенные вызовы процедур (DPC), которые являются функциями, связанными с прерываниями.
Примерами могут служить такие системные прерывания, как переключение режима UserMode в KernelMode — syscall либо sysenter (в Windows XP данное прерывание обозначалось int 2e и в ntdll.dll сохранилось в качестве совместимости с более старым ПО).
Невыгружаемый пул расположен только в физической памяти, а виртуальной памяти невыгружаемого пула назначается физическая память.
Общие системные структуры данных, хранящиеся в невыгружаемом пуле, включают ядро ОС ​​и объекты ядра, которые представляют процессы, потоки, мьютексы, семафоры, события, файловые объекты, IRP и др.
Выгружаемый пул (Paged pool) — буфер памяти операционной системы, куда записываются данные файла подкачки, позволяя переориентировать физическую память.
Когда ОС обращается к памяти выгружаемого пула, которая находится в файле подкачки, происходит системное исключение Page fault, и затем диспетчер памяти считывает данные обратно в физическую память.
Из всех объектов ядра реестр (Registry) является основным программным средством, использующим выгружаемый пул.

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

Для саморазвития:
неплохая статья от Джона Р. Миченера — «Понимание прав доступа к файлам и реестру Windows»

Объекты операционной системы. Часть 3: Уровень целостности

PS: если интересно, параллельно я веду тему в разделе Windows 11 по исследованию комплекса безопасности Windows Как работает комплекс мер Безопасность Windows

Ядро ОС — часть ОС, рационально размещаемая в ОЗУ, которая работает в привилегированном режиме и выполняет следующие функции:

—           Управление и синхронизация процессов.

—           Управление памятью.

—           Диспетчеризация.

—           Управление файловой системой, прерываниями, IO и т.д.

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

—           программные

—           аппаратные

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

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

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

Объекты ядра.

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

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

Все объекты имеют описатели (Handle). Большинство объектов обладают свойством наследования.

Объекты ядра Windows:

—           Процесс, поток.

—           Файловый объект – открытый файл.

—           Проекция файла на память.

—           Событие, Семафор, Мьютекс.

—           Почтовый ящик, канал, сокет и т.д.

ОС ведет учет объектов и управляет ими. Пользователь может запросить информацию об объекте.

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

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

Пример – ОС QNX, Win-NT (HAL-аналог микроядра).