PRZYK ADOWY ROZDZIA Hack Proofing · Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel....

Wydawnictwo Helion

ul. Chopina 6

44-100 Gliwice

tel. (32)230-98-63

e-mail: [email protected]

PRZYK£ADOWY ROZDZIA£PRZYK£ADOWY ROZDZIA£

IDZ DOIDZ DO

ZAMÓW DRUKOWANY KATALOGZAMÓW DRUKOWANY KATALOG

KATALOG KSI¥¯EKKATALOG KSI¥¯EK

TWÓJ KOSZYKTWÓJ KOSZYK

CENNIK I INFORMACJECENNIK I INFORMACJE

ZAMÓW INFORMACJEO NOWO�CIACH

ZAMÓW INFORMACJEO NOWO�CIACH

ZAMÓW CENNIKZAMÓW CENNIK

CZYTELNIACZYTELNIA

FRAGMENTY KSI¥¯EK ONLINEFRAGMENTY KSI¥¯EK ONLINE

SPIS TRE�CISPIS TRE�CI

DODAJ DO KOSZYKADODAJ DO KOSZYKA

KATALOG ONLINEKATALOG ONLINE

Hack Proofing

Autor: praca zbiorowa

T³umaczenie: Bart³omiej Garbacz, Przemys³aw Szeremiota

ISBN: 83-7197-890-1

Tytu³ orygina³u: Hack Proofing Your Network,

Second Edition

Format: B5, stron: 696

Chcesz powstrzymaæ hakerów? Zostañ jednym z nich.

Aby zabezpieczyæ swoj¹ sieæ, spróbuj siê do niej w³amaæ.

Zaktualizowane i rozszerzone wydanie bestsellerowej ksi¹¿ki, napisanej przez

specjalistów od zabezpieczeñ i… w³amañ do systemów komputerowych. Jej autorzy

udowadniaj¹, ¿e nie mo¿na my�leæ o zabezpieczeniach, je�li nie pozna siê najpierw

zagro¿eñ.

• Podstawy bezpieczeñstwa sieciowego. Zapoznasz siê ze wskazówkami

dotycz¹cymi znajdowania luk w zabezpieczeniach istniej¹cych i projektowanych

systemów.

• Siedem podstawowych kategorii ataków. Odmowa obs³ugi, wyciek informacji,

dostêp do systemu plików, dezinformacja, dostêp do plików specjalnych/baz

danych, zdalne uruchomienie kodu i rozszerzenie uprawnieñ.

• Ró¿nicowanie prewencyjne. Dowiesz siê, w jaki sposób porównywaæ pliki,

biblioteki i programy oraz jakie informacje mo¿na w ten sposób uzyskaæ.

• Typowe algorytmy szyfruj¹ce. Twoje zaszyfrowane dane i twoje zaszyfrowane

has³a — czy s¹ rzeczywi�cie bezpieczne?

• S³aby punkt: ³añcuchy formatuj¹ce. Jedna z najnowszych technik w³amañ:

w³amania z u¿yciem ³añcuchów formatuj¹cych.

• Bezpieczne tunele. Naucz siê tworzyæ bezpieczne tunele s³u¿¹ce do przesy³ania

danych i rozpoznawaæ u¿ytkownika przy u¿yciu OpenSSH.

• Zabezpiecz swój sprzêt. Hardware tak¿e mo¿e stanowiæ s³aby punkt. Poznaj

techniki w³amañ sprzêtowych.

Ryan Russell chce Ci przekazaæ wa¿ne przes³anie: „To, o czym nie wiesz, stanowi dla

Ciebie zagro¿enie'. W swojej ksi¹¿ce przekazuje praktyczn¹ wiedzê o technikach

w³amañ do systemów, technikach, które mog¹ byæ wykorzystane tak¿e przeciwko

Tobie” — Kevin Mitnick.

http://helion.pl

http://helion.pl/zamow_katalog.htm

http://helion.pl/katalog.htm

http://helion.pl/zakupy/add.cgi?id=hacpro

http://helion.pl/emaile.cgi

http://helion.pl/cennik.htm

http://helion.pl/online.htm

mailto:[email protected]

http://helion.pl/ksiazki/hacpro.htm

http://www.amazon.com/exec/obidos/ASIN/1928994709

http://www.amazon.com/exec/obidos/ASIN/1928994709

Spis treści

Podziękowania.................................................................................................... 11

Współautorzy...................................................................................................... 13

Słowo wstępne, wersja 1.5 ................................................................................. 17

Słowo wstępne, wersja 1.0 ................................................................................. 21

Rozdział 1. Włamywacz — któż to taki?............................................................. 23Wprowadzenie...................................................................................................................23Co rozumiemy pod pojęciem „włamania”? ......................................................................23

Jaki jest cel włamywania?...........................................................................................24Czego należy się spodziewać po zawartości tej książki?..................................................25Klimat i uwarunkowania prawne towarzyszące działalności hakerów.............................27Podsumowanie ..................................................................................................................29Najczęściej zadawane pytania (FAQ) ...............................................................................29

Rozdział 2. Reguły bezpieczeństwa .................................................................... 31Wprowadzenie...................................................................................................................31Znaczenie znajomości zasad bezpieczeństwa ...................................................................32Zabezpieczenia po stronie klienta są nieskuteczne ...........................................................33Strony komunikacji nie mogą bezpiecznie wymieniać kluczy kryptograficznychbez dostępu do pewnej wspólnej informacji...................................................................34

Nie można całkowicie zabezpieczyć się przed szkodliwym kodem.................................37Każdy szkodliwy kod może zostać przekształcony w celu uniemożliwieniajego detekcji na podstawie sygnatury .............................................................................39

Zapory sieciowe nie stanowią pełnego zabezpieczenia przed atakami.............................41Inżynieria społeczna....................................................................................................43Ataki na serwery publiczne.........................................................................................43Bezpośredni atak na zaporę sieciową .........................................................................44Luki po stronie klienta ................................................................................................45

Każdy system wykrywania włamań (IDS) może zostać oszukany ...................................45Tajne algorytmy kryptograficzne nie są bezpieczne .........................................................47Szyfrowanie bez klucza nie jest szyfrowaniem — jest kodowaniem ...............................49Hasła przechowywane po stronie klienta nie są bezpieczne, chyba że chroni je inne hasło ....50System aspirujący do miana bezpiecznego musi być poddanyniezależnemu audytowi bezpieczeństwa ........................................................................53

Zabezpieczanie przez ukrywanie jest nieskuteczne ..........................................................55Podsumowanie ..................................................................................................................56Zagadnienia w skrócie.......................................................................................................57Najczęściej zadawane pytania (FAQ) ...............................................................................59

4 Hack Proofing Your Network. Edycja polska

Rozdział 3. Klasy ataków................................................................................... 61Wprowadzenie...................................................................................................................61Klasyfikacja ataków ..........................................................................................................61

Odmowa obsługi .........................................................................................................62Wyciek informacji ......................................................................................................70Dostęp do systemu plików..........................................................................................75Dezinformacja.............................................................................................................77Dostęp do plików specjalnych i baz danych ...............................................................81Zdalne uruchomienie kodu .........................................................................................84Rozszerzanie uprawnień .............................................................................................86

Metody testowania systemów pod kątem luk w zabezpieczeniach...................................88Dowód istnienia luki ...................................................................................................88Standardowe techniki analizy .....................................................................................92

Podsumowanie ................................................................................................................100Zagadnienia w skrócie.....................................................................................................102Najczęściej zadawane pytania (FAQ) .............................................................................103

Rozdział 4. Metodologia .................................................................................. 105Wprowadzenie.................................................................................................................105Metodologie analizy luk w zabezpieczeniach.................................................................106

Analiza kodu źródłowego .........................................................................................106Analiza kodu binarnego ............................................................................................109

Znaczenie przeglądu kodu źródłowego...........................................................................110Wyszukiwanie niebezpiecznych funkcji...................................................................110

Techniki inżynierii wstecznej..........................................................................................116Deasemblery, dekompilatory, debuggery .................................................................121

Czarne skrzynki...............................................................................................................125Układy elektroniczne ................................................................................................126


Rozdział 5. Różnicowanie ................................................................................ 131Wprowadzenie.................................................................................................................131Na czym polega różnicowanie?.......................................................................................131

Po co porównywać? ..................................................................................................134Zaglądanie w kod źródłowy......................................................................................135

Narzędzia automatyzujące porównywanie plików..........................................................140Narzędzia porównujące pliki ....................................................................................141Edytory szesnastkowe...............................................................................................143Narzędzia monitorujące system plików....................................................................146W poszukiwaniu innych narzędzi .............................................................................151

Utrudnienia......................................................................................................................152Sumy kontrolne i skróty............................................................................................153Kompresja i szyfrowanie ..........................................................................................154


Rozdział 6. Kryptografia................................................................................... 159Wprowadzenie.................................................................................................................159Podstawy kryptografii .....................................................................................................160

Historia......................................................................................................................160Rodzaje kluczy szyfrujących ....................................................................................160

Standardowe algorytmy kryptograficzne ........................................................................162Algorytmy symetryczne............................................................................................162Algorytmy asymetryczne ..........................................................................................166

Spis treści 5

Metoda pełnego przeglądu ..............................................................................................168Pełny przegląd — podstawy .....................................................................................169Wykorzystanie metody pełnego przeglądu do odgadywania haseł ..........................170

Niewłaściwe zastosowanie poprawnych algorytmów.....................................................173Niepoprawna wymiana kluczy..................................................................................174Generowanie skrótów z fragmentów informacji.......................................................175Korzystanie z krótkich haseł do generowania długich kluczy..................................176Nieprawidłowe przechowywanie kluczy tajnych i prywatnych ...............................176

Amatorskie próby kryptograficzne..................................................................................178Klasyfikacja szyfrogramu .........................................................................................178Szyfry monoalfabetyczne..........................................................................................180Inne sposoby ukrywania informacji..........................................................................181


Rozdział 7. Nieoczekiwane dane wejściowe...................................................... 191Wprowadzenie.................................................................................................................191Dlaczego nieoczekiwane dane wejściowe stanowią zagrożenie .....................................192Identyfikacja sytuacji zagrożonych nieoczekiwanymi danymi.......................................193

Aplikacje i narzędzia lokalne....................................................................................193HTTP i HTML ..........................................................................................................193Nieoczekiwane dane w zapytaniach SQL.................................................................196Uwierzytelnianie aplikacji ........................................................................................199Kamuflaż...................................................................................................................203

Techniki wyszukiwania i eliminacji luk..........................................................................205Testowanie metodą czarnej skrzynki ........................................................................205Korzystanie ze źródeł................................................................................................209Filtracja — odkażanie danych ..................................................................................210Oznaczanie znaków specjalnych nie zawsze wystarcza ...........................................210Perl ............................................................................................................................211Cold Fusion (Cold Fusion Markup Language) .........................................................212ASP ...........................................................................................................................212PHP ...........................................................................................................................213Ochrona zapytań SQL...............................................................................................213Usuwać po cichu czy informować o błędnych danych? ...........................................214Funkcja obsługi niepoprawnych danych...................................................................215Zastępowanie żetonami.............................................................................................215

Korzystanie z zabezpieczeń oferowanych przez języki programowania ........................216Perl ............................................................................................................................216PHP ...........................................................................................................................217ColdFusion (Cold Fusion Markup Language) ..........................................................218ASP ...........................................................................................................................218MySQL .....................................................................................................................219

Narzędzia związane z nieoczekiwanymi danymi wejściowymi .....................................219Web Sleuth................................................................................................................219CGIAudit...................................................................................................................219RATS ........................................................................................................................220Flawfinder .................................................................................................................220Retina ........................................................................................................................220Hailstorm...................................................................................................................220Pudding .....................................................................................................................220



Rozdział 8. Przepełnienie bufora....................................................................... 225Wprowadzenie.................................................................................................................225Działanie stosu ................................................................................................................225

Obraz stosu................................................................................................................229Osobliwości stosu .....................................................................................................229

Ramka stosu ....................................................................................................................230Wprowadzenie do ramki stosu..................................................................................230Przykładowy program: przekazywanie parametrów do funkcji ...............................231Ramki stosu i konwencje wywołania funkcji ...........................................................235

Podstawowe techniki przepełnienia bufora.....................................................................236Przykładowy program: niekontrolowane przepełnienie bufora ................................237

Pierwsze samodzielne przepełnienie bufora ...................................................................241Utworzenie programu podatnego na atak wykorzystujący przepełnienie bufora .....241Atak...........................................................................................................................244

Przepełnienie bufora — techniki zaawansowane............................................................271Filtrowanie danych wejściowych..............................................................................272Nadpisanie wskaźnika funkcji przechowywanego na stosie ....................................274Przepełnienia sterty...................................................................................................275

Konstruowanie ładunku — zagadnienia zaawansowane ................................................278Korzystać z posiadanego...........................................................................................278


Rozdział 9. Ciągi formatujące .......................................................................... 287Wprowadzenie.................................................................................................................287Istota błędów ciągów formatujących...............................................................................289

Gdzie i dlaczego występują błędy ciągów formatujących? ......................................292Jak wyeliminować te błędy? .....................................................................................294W jaki sposób ciągi formatujące są wykorzystywane przez włamywaczy?.............294Przebieg ataków z użyciem ciągów formatujących ..................................................298Co nadpisywać ..........................................................................................................301

Analiza podatnego programu ..........................................................................................302Testowanie wykorzystujące przypadkowe ciągi formatujące.........................................305Atak z użyciem ciągu formatującego ..............................................................................308Podsumowanie ................................................................................................................316Zagadnienia w skrócie.....................................................................................................317Najczęściej zadawane pytania (FAQ) .............................................................................318

Rozdział 10. Monitorowanie komunikacji (sniffing) ............................................. 321Wprowadzenie.................................................................................................................321Istota monitorowania.......................................................................................................322

Sposób działania .......................................................................................................322Przedmiot monitorowania ...............................................................................................323

Zdobywanie danych uwierzytelniających.................................................................323Przechwytywanie innych danych ruchu w sieci .......................................................328

Popularne programy służące do monitorowania .............................................................329Ethereal .....................................................................................................................329Network Associates Sniffer Pro................................................................................330NT Network Monitor ................................................................................................332WildPackets ..............................................................................................................333TCPDump .................................................................................................................334dsniff .........................................................................................................................334Ettercap .....................................................................................................................337Esniff.c ......................................................................................................................337Sniffit ........................................................................................................................337

Spis treści 7

Carnivore...................................................................................................................339Dodatkowe zasoby ....................................................................................................341

Zaawansowane techniki monitorowania .........................................................................341Ataki typu man-in-the-middle (MITM) ....................................................................341Łamanie.....................................................................................................................342Sztuczki związane z przełącznikami.........................................................................342Zmiany wyboru tras ..................................................................................................343

Interfejsy API systemów operacyjnych...........................................................................344Linux .........................................................................................................................344BSD...........................................................................................................................346libpcap.......................................................................................................................346Windows ...................................................................................................................348

Ochronne środki zaradcze ...............................................................................................349Zapewnianie szyfrowania .........................................................................................349Secure Sockets Layers (SSL)....................................................................................350PGP and S/MIME .....................................................................................................351Przełączanie ..............................................................................................................351

Stosowanie technik wykrywania.....................................................................................351Wykrywanie lokalne .................................................................................................351Wykrywanie sieciowe...............................................................................................352


Rozdział 11. Przejmowanie sesji ........................................................................ 359Wprowadzenie.................................................................................................................359Istota przejmowania sesji ................................................................................................359

Przejmowanie sesji TCP ...........................................................................................361Przejmowanie sesji TCP z blokowaniem pakietów ..................................................362Przejmowanie datagramów UDP..............................................................................365

Przegląd dostępnych narzędzi .........................................................................................366Juggernaut .................................................................................................................367Hunt...........................................................................................................................370Ettercap .....................................................................................................................373SMBRelay.................................................................................................................378Programy nadzoru zakłóceń......................................................................................378

Ataki typu MITM w przypadku komunikacji szyfrowanej.............................................381Ataki typu man-in-the-middle...................................................................................382Dsniff ........................................................................................................................383Inne formy przejmowania .........................................................................................383

Podsumowanie ................................................................................................................385Zagadnienia w skrócie.....................................................................................................385Najczęściej zadawane pytania.........................................................................................387

Rozdział 12. Podrabianie (spoofing): ataki na wiarygodną tożsamość.................. 389Wprowadzenie.................................................................................................................389Istota podrabiania ............................................................................................................389

Podrabianie jako fałszowanie tożsamości.................................................................390Podrabianie jako atak aktywny .................................................................................390Możliwość podrabiania na poziomie wszystkich warstw komunikacji ....................390Podrabianie jako atak zawsze zamierzony................................................................391Różnice pomiędzy podrabianiem a zdradą ...............................................................393Podrabianie jako nie zawsze szkodliwe działanie ....................................................393Podrabianie jako nienowa idea .................................................................................394

Rys teoretyczny ...............................................................................................................394Znaczenie tożsamości ...............................................................................................395


Ewolucja zaufania ...........................................................................................................396Asymetryczne podpisy wśród ludzi ..........................................................................396

Określanie tożsamości w sieciach komputerowych ........................................................398Powrót do nadawcy...................................................................................................399Na początku była… transmisja .................................................................................400

Wezwania do przedstawienia uprawnień ........................................................................400Metodologie konfiguracji: tworzenie indeksu zaufanych uprawnień.......................413

Podrabianie w przypadku maszyn stacjonarnych............................................................415Plaga aplikacji wykonujących automatyczne aktualizacje .......................................415

Wpływ ataków podrabiania.............................................................................................417Wyrafinowane metody podrabiania i sabotaż ekonomiczny ....................................418

„Brudna robota” — planowanie systemów podrabiania .................................................428Tworzenie routera szkieletowego w obszarze użytkowników..................................428Fałszowanie łączności poprzez asymetryczne zapory sieciowe ...............................447


Rozdział 13. Tunelowanie .................................................................................. 463Wprowadzenie.................................................................................................................463Strategiczne ograniczenia projektów tuneli ....................................................................465

Poufność: dokąd zmierzają moje dane?....................................................................467Możliwość routowania: którędy mogą przejść dane?...............................................467Możliwość wdrożenia: jak trudno wszystko zbudować i uruchomić?......................468Elastyczność: w jakim celu można system wykorzystać? ........................................469Jakość: jak kłopotliwe będzie utrzymywanie systemu w ruchu?..............................471

Projektowanie całościowych systemów tunelowania .....................................................472„Drążenie” tuneli za pomocą SSH............................................................................473

Uwierzytelnianie .............................................................................................................477Dostęp podstawowy: uwierzytelnianie przez hasło ..................................................477Dostęp przezroczysty: uwierzytelnianie za pomocą klucza prywatnego..................478

Przekazywanie poleceń: bezpośrednie wykonywanie skryptów i używanie potoków.......483Przekazywanie portów: dostęp do zasobów odległych sieci...........................................488

Lokalne przekazywanie portów ................................................................................488Dynamiczne przekazywanie portów .........................................................................490Zdalne przekazywanie portów ..................................................................................498

Przechodzenie przez oporną sieć.....................................................................................500Dostęp do serwerów pośredniczących przez ProxyCommands................................500Zamienianie swojego ruchu ......................................................................................503Ograniczone uwierzytelnianie wobec ufortyfikowanej stacji bazowej ....................504Eksportowanie dostępu SSHD..................................................................................506Wzajemne łączenie maszyn umieszczonych za zaporami sieciowymi.....................508

Dalsze działania...............................................................................................................510Standardowy transfer plików przez SSH ..................................................................510Przyrostowy transfer plików przez SSH...................................................................512Wypalanie płyt CD przez SSH .................................................................................514Przesyłanie danych audio przez TCP i SSH .............................................................516


Rozdział 14. Włamania sprzętowe...................................................................... 529Wprowadzenie.................................................................................................................529Istota włamań sprzętowych .............................................................................................530Otwieranie urządzenia: ataki na obudowę i mechaniczne ..............................................530

Rodzaje mechanizmów zabezpieczających ..............................................................532Interfejsy zewnętrzne ................................................................................................537

Spis treści 9

Analiza protokołów...................................................................................................538Zakłócenia elektromagnetyczne i wyładowania elektrostatyczne ............................540

Analiza wewnętrznej budowy produktu: ataki na obwody elektryczne..........................541Inżynieria wsteczna urządzenia ................................................................................541Podstawowe techniki: typowe formy ataku ..............................................................542Techniki zaawansowane: usuwanie warstwy żywicy epoksydowejoraz rozmywanie obudowy układu scalonego........................................................546

Kryptoanaliza i metody zaciemniania.......................................................................548Potrzebne narzędzia.........................................................................................................550

Zestaw początkowy...................................................................................................550Zestaw zaawansowany..............................................................................................551

Przykład: włamanie do nośnika danych uwierzytelniających iButton............................553Eksperymentowanie z urządzeniem..........................................................................553Inżynieria wsteczna odpowiedzi „losowej” ..............................................................554

Przykład: włamanie do akceleratora E-commerce NetStructure 7110 Accelerator ........556Otwarcie urządzenia..................................................................................................557Pobranie systemu plików ..........................................................................................557Inżynieria wsteczna generatora haseł........................................................................560


Rozdział 15. Wirusy, robaki i konie trojańskie .................................................... 567Wprowadzenie.................................................................................................................567Różnice pomiędzy wirusami, robakami oraz końmi trojańskimi....................................567

Wirusy.......................................................................................................................568Robaki .......................................................................................................................569Makrowirusy .............................................................................................................569Konie trojańskie ........................................................................................................570Żarty..........................................................................................................................571

Anatomia wirusa .............................................................................................................571Propagacja.................................................................................................................572Treść zasadnicza .......................................................................................................573Inne wybiegi..............................................................................................................574

Kwestie wieloplatformowości.........................................................................................575Java ...........................................................................................................................575Makrowirusy .............................................................................................................576Rekompilacja ............................................................................................................576Shockwave Flash ......................................................................................................576

Fakty, którymi należy się martwić ..................................................................................576Robak Morris ............................................................................................................577ADMw0rm................................................................................................................577Melissa oraz I Love You...........................................................................................577Robak Sadmind.........................................................................................................582Robaki Code Red ......................................................................................................583Robak Nimda ............................................................................................................584

Tworzenie własnego złośliwego kodu ............................................................................586Nowe metody dostarczania .......................................................................................586Metody szybszej propagacji......................................................................................587Inne przemyślenia na temat tworzenia nowych odmian złośliwego kodu................588

Sposoby zabezpieczeń przed złośliwym oprogramowaniem..........................................589Oprogramowanie antywirusowe ...............................................................................589Uaktualnienia i programy korygujące.......................................................................590Bezpieczeństwo przeglądarki internetowej...............................................................591Badania antywirusowe ..............................................................................................591



Rozdział 16. Pokonywanie systemów wykrywania włamań .................................. 595Wprowadzenie.................................................................................................................595Istota działania systemów wykrywania włamań opartych na sygnaturach .....................595

Określanie wyników fałszywie pozytywnych i negatywnych ..................................598Przeciążanie alarmami ..............................................................................................598

Wykorzystanie metod pokonywania na poziomie pakietów...........................................599Opcje nagłówka IP....................................................................................................601Fragmentacja pakietu IP ...........................................................................................601Nagłówek TCP..........................................................................................................603Synchronizacja TCP..................................................................................................604Wykorzystanie pakietów Fragrouter oraz Congestant ..............................................606Środki zaradcze.........................................................................................................608

Wykorzystanie metod pokonywania w protokołach warstwy aplikacji..........................609Bezpieczeństwo jako refleksja ..................................................................................609Unikanie dopasowania ..............................................................................................610Techniki ataku z poziomu sieci WWW ....................................................................611Środki zaradcze.........................................................................................................612

Wykorzystanie metod pokonywania poprzez morfingu kodu.........................................612Podsumowanie ................................................................................................................615Zagadnienia w skrócie.....................................................................................................616Najczęściej zadawane pytania (FAQ) .............................................................................617

Rozdział 17. Zautomatyzowane badanie systemów zabezpieczeńoraz narzędzia ataku ...................................................................... 619Wprowadzenie.................................................................................................................619Podstawowe wiadomości na temat narzędzi zautomatyzowanych .................................620

Narzędzia komercyjne ..............................................................................................623Narzędzia darmowe ..................................................................................................628

Wykorzystanie narzędzi zautomatyzowanych do celów testowania penetracyjnego .....631Testowanie za pomocą narzędzi komercyjnych .......................................................632Testowanie za pomocą narzędzi darmowych ...........................................................635

Kiedy narzędzia nie wystarczą........................................................................................638Nowe oblicze testowania luk systemów zabezpieczeń.............................................639


Rozdział 18. Raportowanie o problemach związanych z bezpieczeństwem............ 643Wprowadzenie.................................................................................................................643Zasadność raportowania o problemach związanych z bezpieczeństwem .......................644

Ujawnienie zupełne...................................................................................................645Określanie terminu przesłania oraz adresata raportu o problemie ..................................648

Określanie adresata raportów o problemach.............................................................648Określanie szczegółowości przekazywanych informacji ................................................651

Publikowanie kodu wykorzystującego lukę..............................................................652Problemy ...................................................................................................................653


Skorowidz......................................................................................................... 661

Rozdział 9.

Ciągi formatujące

Wprowadzenie

Na początku lata 2000 roku świat bezpieczeństwa komputerowego został brutalniepowiadomiony o istnieniu nowego typu luk w oprogramowaniu. Ta podklasa luk, znanajako błędy ciągów formatujących, została przedstawiona szerokiej publiczności 23 czerw-ca 2000 roku, wraz z przesłaniem na listę dystrybucyjną Bugtraq exploita demona usłu-gi FTP o nazwie WU-FTPD (Washington University FTP Daemon). Atak wykorzystu-jący opublikowany exploit umożliwiał zdalnemu włamywaczowi uzyskanie dostępu dosystemu w trybie administracyjnym na węzłach obsługujących demona WU-FTPD i toz pominięciem jakiegokolwiek uwierzytelniania, o ile konfiguracja serwera dopuszczałaanonimowe transmisje FTP (co jest w przypadku większości systemów opcją domyśl-ną). Atak był groźny, ponieważ serwery WU-FTPD były powszechnie stosowanymiserwerami FTP w Internecie.

Ale główną przyczyną szoku świata komputerowego nie była bynajmniej świadomość,że w Internecie działały dziesiątki tysięcy węzłów podatnych na ataki umożliwiająceuzyskanie dostępu zdalnego i przejęcie całkowitej kontroli nad systemem. Prawdziwympowodem była natura samej luki i jej powszechność w oprogramowaniu komputero-wym dowolnego przeznaczenia. Świat ujrzał więc zupełnie nową metodę wykorzysty-wania błędów programistycznych uważanych wcześniej za mało znaczące. Zademon-strowano, że możliwe są ataki wykorzystujące błędy ciągów formatujących.

Luka związana z ciągiem formatującym pojawia się wówczas, gdy programista prze-kazuje dane pobrane z zewnątrz do funkcji �� jako parametr definiujący postaćciągu formatującego funkcji (lub jego fragmentu). W przypadku WU-FTPD parametr po-lecenia SITE EXEC protokołu FTP był przekazywany bezpośrednio do funkcji ��.

Trudno było o lepszy zarys koncepcji ataku: atakujący mógł natychmiast i automatycz-nie pozyskać uprawnienia administracyjne na podatnych węzłach.


Wieści z podziemia…

Błędy ciągów formatujących kontra błędy przepełnienia bufora

Z pozoru oba rodzaje błędów są bardzo podobne. Nietrudno więc zaklasyfikować jedo tej samej kategorii luk w zabezpieczeniach. Choć w obu przypadkach efektem ata-ku może być nadpisanie wskaźnika funkcji i zmiana przepływu sterowania programu,problem ciągów formatujących różni się od problemu przepełnienia bufora w sposóbzasadniczy.

W przypadku luki wynikającej z błędu przepełnienia bufora błąd w oprogramowaniupolega na tym, że wrażliwa funkcja, taka jak kopiowanie bloków pamięci, przyjmujerozmiar zewnętrznego, niekontrolowanego przez aplikację źródła danych jako ograni-czenie operacji kopiowania. Przykładowo, większość błędów przepełnienia buforawynika z zastosowania funkcji bibliotecznej języka C kopiującej ciągi znakowe. W ję-zyku C ciągi znakowe reprezentowane są przez zmiennej długości tablice bajtów za-kończone bajtem zerowym. Funkcja �� (od ang. string copy) wchodząca w składbiblioteki standardowej języka C kopiuje kolejne bajty ciągu źródłowego do wskazane-go bufora docelowego; operacja kopiowania zatrzymywana jest w momencie napo-tkania w ciągu źródłowym bajtu zerowego. Jeżeli ciąg ten jest podawany z zewnątrzi ma długość większą od rozmiaru bufora docelowego, funkcja �� nadpiszerównież obszar pamięci sąsiadujący z buforem docelowym — aż do skopiowaniaostatniego bajtu ciągu źródłowego. Atak wykorzystujący przepełnienie bufora opierasię na możliwości nadpisania przez atakującego danych krytycznych dla dalszegodziałania programu (przechowywanych w sąsiedztwie bufora docelowego) własnymidanymi, przekazanymi do operacji kopiowania.

W przypadku błędów ciągów formatujących problem polega na tym, że pobierane z ze-wnątrz dane włączane są do parametru definiującego ciąg formatujący funkcji. Należyto traktować jako błąd walidacji danych wejściowych, nie mający nic wspólnego z błę-dami polegającymi na przekroczeniu rozmiaru bufora docelowego operacji kopiowania.Hakerzy wykorzystują błędy ciągów formatujących w celu zapisania określonych war-tości w konkretnych obszarach pamięci. W przypadku ataków przepełniających buforatakujący nie może dowolnie wybrać obszaru docelowego dla danych wejściowych.

Innym źródłem nieporozumień jest to, że błędy ciągów formatujących i błędy przepeł-nienia bufora mogą występować równocześnie, kiedy w programie wykorzystywana jestfunkcja ��. Aby zrozumieć różnicę pomiędzy tymi błędami, ważne jest uświa-domienie sobie sposobu działania funkcji ��. Funkcja ta umożliwia programi-ście utworzenie sformatowanego (na podobieństwo formatu ciągów funkcji ��)ciągu znakowego i umieszczenie go w buforze. Błąd przepełnienia bufora występujewówczas, gdy utworzony ciąg jest dłuższy od docelowego bufora. Jest to zwykle rezul-tatem zastosowania w ciągu specyfikatora ��, który powoduje umieszczenie w danymmiejscu konstruowanego ciągu innego ciągu znakowego, zakończonego bajtem zero-wym. Jeżeli zmienna wprowadzana w miejsce specyfikatora �� jest pobierana z zewnątrzi nie jest obcinana do pewnego rozmiaru, może spowodować rozciągnięcie tworzonegociągu tak, że nie będzie się on mieścił w buforze docelowym. Luki spowodowaneniewłaściwym zastosowaniem funkcji �� wynikają z czego innego — z inter-pretowania danych pobieranych spoza aplikacji jako fragmentu ciągu formatującego.

Zanim exploit ujrzał światło dzienne, błędy związane z ciągami formatującymi uważanebyły za co najwyżej złą aczkolwiek nieszkodliwą praktykę programistyczną — nie-eleganckie uproszczenie wynikające z pośpiechu — słowem nic, co mogłoby zagrażaćbezpieczeństwu. Do tej pory błąd tego rodzaju mógł w najgorszym razie spowodować

Rozdział 9. ♦ Ciągi formatujące 289

załamanie demona usługi, równoznaczne z atakiem odmowy obsługi. Światek ludzi zwią-zanych z zabezpieczeniami dostał nauczkę. Błędy te przyczyniły się do zaatakowania nie-zliczonej liczby serwerów sieciowych.

Jak już wspomniano, luki związane z ciągami formatującymi zostały ujawnione po razpierwszy w czerwcu 2000 roku. Exploit WU-FTPD został napisany przez osobnika zna-nego pod pseudonimem tf8 i był datowany 15 października 1999. Przy założeniu, że dzię-ki temu exploitowi niektórzy hakerzy uświadomili sobie rolę niepoprawnego wykorzysta-nia ciągów formatujących, mieli oni ponad 8 miesięcy na opracowanie i napisanie koduexploitów wymierzonych w inne oprogramowanie, niekoniecznie w serwery WU-FTPD.To zresztą tylko ostrożne szacunki, oparte na założeniu, że opublikowany exploit de-mona WU-FTPD był pierwszym tego rodzaju atakiem. Nie ma jednak na to żadnychdowodów; komentarze, którymi opatrzony był exploit nie wskazywały bynajmniej, abyautor odkrył nową metodę ataków.

Krótko po ujawnieniu słabości wynikających z błędnego stosowania ciągów forma-tujących pojawiło się kilka exploitów atakujących innego typu aplikacje. W czasie pisa-nia tej książki opublikowano już dziesiątki scenariuszy ataków wykorzystujących cią-gi formatujące. Należy do tej liczby dodać nieznaną liczbę ataków nieujawnionych.

Według oficjalnej klasyfikacji błędy ciągów formatujących nie zasługują na wydzieleniedla nich osobnej kategorii i plasowane są wśród pozostałych błędów programistycznych,takich jak błędy przepełnienia bufora czy hazard wykonania. Błędy ciągów formatują-cych można zakwalifikować jako błędy walidacji danych wejściowych; zasadniczo sąone skutkiem nadmiernej wiary programistów w poprawność danych pochodzących spozaaplikacji i przekazywania tych danych jako parametrów definiujących ciąg formatują-cy funkcji operującej na ciągach znakowych.

W tym rozdziale Czytelnik zostanie wprowadzony w problematykę błędów ciągówformatujących, zapozna się z ich przyczynami i pozna sposoby ich wykorzystaniaprzez włamywaczy. W rozdziale zaprezentowane zostaną konkretne luki tego rodzajuwystępujące w rzeczywistych systemach; Czytelnik zapozna się też z procesem przy-gotowywania i przeprowadzania ataku — wykorzystującego ciąg formatujący — nawęzeł zdalny.

Istota błędów ciągów formatujących

Zrozumienie istoty błędów związanych z ciągami formatującymi wiąże się z funkcją�� i sposobem jej działania.

Programiści systemów komputerowych bardzo często stają w obliczu koniecznościdynamicznego tworzenia ciągów znakowych. Ciągi te mogą zawierać znakową repre-zentację zmiennych różnego typu; liczba i typ wszystkich zmiennych reprezentowa-nych ciągiem znakowym niekoniecznie muszą być znane programiście na etapietworzenia kodu źródłowego. Powszechna konieczność dynamicznej i elastycznej kon-strukcji ciągów znakowych i konieczność stosowania procedur formatujących w naturalny


sposób zaowocowała opracowaniem rodziny funkcji ��. Funkcje typu ��konstruują i umieszczają na wyjściu ciągi znakowe formatowane dynamicznie, w faziewykonania programu. Funkcje te wchodzą w skład biblioteki standardowej języka C.Podobne funkcje implementowane są również w innych językach (np. w języku Perl).

Funkcje z rodziny �� pozwalają programiście na tworzenie ciągów znakowychna podstawie ciągu formatującego i zmiennej liczby parametrów. Ciąg formatujący tojakby szkielet przyszłego ciągu, definiujący jego podstawową strukturę oraz rozmiesz-czenie elementów leksykalnych; na podstawie tego ciągu i wartości parametrów funkcja�� konstruuje ciąg wynikowy. Elementy leksykalne ciągu formatującego okre-ślane są również mianem specyfikatorów formatujących. Oba pojęcia będą stosowanew dalszej części rozdziału.

Narzędzia i pułapki…

Funkcje rodziny printf()

Oto lista standardowego zestawu funkcji z rodziny �� zdefiniowanego w ramachbiblioteki standardowej języka C. Każda z tych funkcji (niewłaściwie stosowana) możestać się ofiarą ataku wykorzystującego błąd ciągu formatującego.

� �� funkcja ta umożliwia konstrukcję sformatowanego ciągu znakowegoi jego zapis do standardowego strumienia wyjściowego programu.

� �� funkcja ta umożliwia konstrukcję sformatowanego ciągu znakowegoi jego zapis do wskazanego strumienia plikowego (strumienia FILE w rozumieniubiblioteki libc).

� �� funkcja ta umożliwia konstrukcję sformatowanego ciągu znakowegoi jego zapis do bufora utworzonego w pamięci programu. Niepoprawne stosowanietej funkcji prowadzi często do błędów przepełnienia bufora.

� �� funkcja ta umożliwia konstrukcję sformatowanego ciągu znakowegoi zapis określonej jego części do bufora utworzonego w pamięci programu.W kontekście błędów przepełnienia bufora funkcję tę można traktować jakozabezpieczony odpowiednik funkcji ��.

Biblioteka standardowa C zawiera ponadto funkcje ��, ��, ��oraz ��. Funkcje te spełniają te same zadania co ich wyżej wymienione od-powiedniki, różniące się od nich tym, że przyjmują na wejście wskaźnik do listy pa-rametrów (nie są one przekazywane przez stos).

Zasada działania funkcji �� może zostać zilustrowana prostym przykładem:

��

W powyższym przykładowym kodzie programista wywołuje funkcję �� z dwomaparametrami: ciągiem formatującym i zmienną, której znakowa reprezentacja ma zo-stać wstawiona do ciągu wynikowego konstruowanego przez ��.

��


Powyższy ciąg formatujący składa się ze statycznej porcji tekstu i symbolu elementuleksykalnego (�), oznaczającego miejsce wstawienia wartości zmiennej. W prezento-wanym przykładzie w wyniku wywołania funkcji do wyświetlanego na ekranie ciąguwynikowego w miejsce specyfikatora � wstawiona zostanie wartość zmiennej ��w formacie Base10.

Najlepszą ilustracją będzie wydruk prezentujący efekt wykonania przykładowego pro-gramu (pamiętamy, że zmienna �� ma wartość 10):

!"��# �� $%��

Ponieważ funkcja „nie wie” ile parametrów otrzyma, są one odczytywane ze stosu pro-cesu w miarę postępu przetwarzania ciągu formatującego (czyli po napotkaniu kolej-nego specyfikatora formatu), przy czym rozmiar pobieranej ze stosu wartości uzależ-niony jest od określanego specyfikatorem typu danych. W poprzednim przykładziew ciągu formatującym osadzony został pojedynczy element symbolizujący zmienną ty-pu całkowitego. Funkcja „spodziewa się”, że drugim przekazanym do funkcji para-metrem będzie zmienna korespondująca z elementem �. W komputerach opartych naarchitekturze Intel 0x86 (ale nie tylko) parametry wywołania funkcji wstawiane są nastos podczas tworzenia ramki stosu dla wywoływanej funkcji. Kiedy funkcja odwołujesię do parametrów wywołania, odwołuje się do danych umieszczonych na stosie po-niżej ramki stosu.

W poprzednim akapicie pojawił się termin poniżej; ma on opisywać lokalizację da-nych, które zostały umieszczone na stosie przed umieszczeniem na nim danych,o których powiedzielibyśmy, że znajdują się powyżej. W procesorach Intel 0x86stos rośnie w dół. Dlatego w tej i podobnych architekturach adres szczytu stosuzmniejsza się w miarę jego rozbudowy. W takich architekturach dane lokalizowanejako umieszczone poniżej innych danych będą miały wyższe od nich adresy.

Fakt, że numerycznie wyższe adresy pamięci mogą znajdować się w niższych par-tiach stosu powoduje częste nieporozumienia. Należy zapamiętać, że pozycja nastosie opisywana jako wyższa od innej pozycji oznacza, że dane, o których mowaznajdują się bliżej szczytu stosu, co nie przeszkadza im mieć niższych adresów.

W prezentowanym przykładzie do funkcji �� przekazany został parametr kore-spondujący z określonym w ciągu formatującym elementem � — parametr będącyliczbą całkowitą. Znakowa dziesiętna reprezentacja tej liczby (10) została w ciągu wy-nikowym wstawiona w miejsce tego elementu.

Konstruując ciąg wynikowy funkcja �� pobierze z odpowiedniego obszaru stosuwartość typu całkowitego i potraktuje ją jako zmienną korespondującą z elementemzdefiniowanym w ciągu formatującym. Następnie funkcja �� dokona konwersjibinarnej wartości do postaci ciągu znakowego, którego format określany jest postaciąspecyfikatora formatu; efekt konwersji zostanie wstawiony do sformatowanego ciąguwyjściowego. Jak za chwilę się okaże, powyższe kroki podejmowane są niezależnie odtego, czy programista rzeczywiście przekazał do funkcji drugi parametr wywołania. Jeżeliwywołanie nie zawierało parametrów odpowiadających elementom ciągu formatujące-go, jako parametry potraktowane zostaną dane funkcji wywołującej funkcję ��,ponieważ znajdują się one w odpowiednich obszarach stosu.


Wróćmy do naszego przykładu: załóżmy, że w procesie rozwoju aplikacji podjęto de-cyzję, że na ekranie wyświetlany będzie jedynie statyczny ciąg znakowy, ale zapomnia-no usunąć z ciągu formatującego symbol specyfikatora formatu. Takie wywołanie funk-cji �� wyglądałoby następująco:

��&'��(��)�*��"�+,��'&

Kiedy program zainicjuje wywołanie tej funkcji, nie będzie ona „wiedzieć”, że listaparametrów wywołania nie zawierała zmiennej odpowiadającej elementowi �. Podczaskonstrukcji ciągu funkcja �� odczyta liczbę całkowitą z obszaru stosu, w którymznajdowałaby się odpowiednia zmienna (gdyby programista ją przekazał) — pobierze4 bajty leżące poniżej ramki stosu. Przy założeniu, że menedżer pamięci wirtualnej do-puści wykonanie takiego odwołania, funkcja zostanie wykonana poprawnie, a przypad-kowe 4 bajty znajdujące się w odpowiednim obszarze pamięci zostaną zinterpretowa-ne i wyświetlone jako liczba całkowita.

Efekt ten jest pokazany na poniższym wydruku:

!"��# �� $%�� -��./.01231

Pamiętamy, że żadna zmienna typu całkowitego nie została przekazana do wywołaniafunkcji ��; niemniej jednak w ciągu wynikowym znalazła się wartość całkowita.Funkcja po prostu odczytała ze stosu 4 bajty tak, jakby zostały one umieszczone nastosie w ramach wywołania funkcji. W prezentowanym przykładzie zdarzyło się, że te4 bajty w pamięci reprezentowały liczbę -1073742952, co jest dziesiętną reprezenta-cją liczby typu całkowitego ze znakiem.

Gdyby użytkownik miał możliwość wstawienia własnych danych do ciągu formatują-cego, mógłby wymusić zmianę przebiegu wykonania funkcji �� i zmusić ją dotraktowania dowolnych informacji znajdujących się w obszarze pamięci stosu jako po-prawnych zmiennych powiązanych ze specyfikatorami określonymi przez użytkownika.

Jak widać, zdolność użytkownika zewnętrznego do kontrolowania przebiegu działaniafunkcji �� może prowadzić do zaistnienia pewnych potencjalnie groźnych lukw zabezpieczeniach. Jeżeli istnieje program, który zawiera taki błąd i zwróci sforma-towany (skonstruowany) ciąg użytkownikowi, atakujący mogą odczytać potencjalniewrażliwe informacje przechowywane w pamięci programu. Możliwe jest też wykorzy-stanie szkodliwego ciągu formatującego do zapisania obszarów pamięci programu, a toza sprawą specyfikatora �. Specyfikator � ma umożliwiać programistom pobranie liczbyznaków skonstruowanego dotychczas ciągu. Sposób, w jaki włamywacze mogą wyko-rzystywać do swoich celów ciągi formatujące zostanie szczegółowo omówiony przyokazji samodzielnej implementacji ataku wykorzystującego błąd ciągu formatującego.

Gdzie i dlaczego występują błędyciągów formatujących?

Luki związane z ciągami formatującymi to wynik błędów programistów, którzy umoż-liwiają przekazywanie jako parametrów formatujących danych nie poddanych wcze-śniejszej weryfikacji. Poniżej wymienione zostaną niektóre spośród najpowszechniejszych


błędów programistycznych owocujących potencjalną luką związaną z nadużyciem ciąguformatującego.

Pierwszym błędem jest wywołanie funkcji �� bez przekazania do niej ciągu for-matującego; podatne wywołanie zawiera wyłącznie ciąg do wyświetlenia:

�� !�$��

W powyższym przykładzie zamiast ciągu formatującego do funkcji �� przeka-zywany jest od razu „drugi” parametr (często jest to parametr przekazany w wierszupoleceń). Gdy teraz użytkownik jako parametr wywołania programu poda ciąg odpo-wiadający specyfikatorowi formatu, zostanie on jako taki potraktowany przez funkcję��:

!"��# �� $%�� -��./.01231

Błędy tego rodzaju są często popełniane przez programistów niedoświadczonych lubnieobytych z funkcjami bibliotecznymi języka C. Czasem konstrukcje takie stosowa-ne są z lenistwa — nie wszystkim programistom chce się przekazywać ciąg formatu-jący zawierający wyłącznie specyfikator �. Powody tego rodzaju są zresztą przyczy-ną znacznej części wszystkich luk w zabezpieczeniach oprogramowania.

Powszechne jest też definiowanie funkcji wykorzystujących wewnętrznie wywołaniafunkcji �� (na przykład w funkcjach rejestrujących i informujących o błędach).W procesie programowania aplikacji programista może zapomnieć, że funkcja wyświe-tlająca komunikat o błędzie wywołuje funkcję �� (lub inną funkcję z tej rodziny)przekazując do niej otrzymane parametry w niezmienionej postaci. Takie przeoczeniemoże wyrobić nawyk wywoływania funkcji raportującej tak, jakby wyświetlała onapojedynczy ciąg znakowy:

��4(��

Celem ataku symulowanego w dalszej części rozdziału będą właśnie takie błędy.

Jedną z najważniejszych przyczyn powszechności błędów ciągów formatujących w sys-temach Unix jest niewłaściwe korzystanie z funkcji � ��. Funkcja � �� jestinterfejsem programistycznym systemowego demona rejestrującego zdarzenia. Progra-miści mogą używać funkcji � �� do zapisywania w systemowych plikach dziennikakomunikatów o różnego rodzaju błędach. Funkcja � �� przyjmuje jako parametryciąg formatujący i zestaw parametrów korespondujących z określonymi w tym ciąguspecyfikatorami formatu (pierwszym parametrem wywołania funkcji � �� jestpriorytet wpisu). Wielu programistów korzystających z tej funkcji zapomina lub niewie o tym, że powinni przekazywać osobno ciąg formatujący i osobno dane umieszcza-ne we wpisie pliku dziennika. Wiele luk związanych z ciągami formatującymi wynikaz następującej konstrukcji kodu:

��5�64789:��

Jeżeli zmienna �� zawiera dane pobierane z zewnątrz (np. identyfikator użytkowni-ka, który spowodował nieudaną próbę logowania do systemu), powyższa sytuacja możezostać w prosty sposób zamieniona w poważną lukę.


Jak wyeliminować te błędy?

Podobnie jak w przypadku większości innych luk wynikających z niewłaściwego ko-dowania, najlepszym sposobem eliminacji luk ciągów formatujących jest zapobiega-nie im. Programiści muszą uświadomić sobie, że tego rodzaju błędy są zagrożeniemdla systemu, ochoczo urzeczywistnianym przez hakerów. Niestety, globalna pobudkai powszechna troska o kwestie bezpieczeństwa wydają się być sprawą dość odległejprzyszłości.

Administratorzy i użytkownicy zatroskani o zabezpieczenie swoich systemów powin-ni osiągnąć rozsądny poziom bezpieczeństwa w wyniku wdrożenia poprawnej po-lityki korzystania z systemu. Powinni na początek zadbać o usunięcie bitów setuidz wszystkich zbędnych programów systemowych i zablokowanie wszystkich niepotrzeb-nych usług.

Mike Frantzen opublikował rozwiązanie problemu ciągów formatujących, adresowanedo administratorów i programistów i blokujące możliwość wykorzystania błędów cią-gów formatujących. Rozwiązanie to polega na przeliczaniu liczby parametrów przekazy-wanych do funkcji �� i porównywaniu jej z liczbą specyfikatorów formatu umiesz-czonych w ciągu formatującym. Zostało ono zaimplementowane pod nazwą FormatGuardw projekcie Immunix, dystrybucji systemu Linux, której główną cechą ma być bezpie-czeństwo aplikacji.

Artykuł Mike’a Frantzena został zarchiwizowany na liście dystrybucyjnej Bugtraqpod adresem www.securityfocus.com/archive/1/72118. FormatGuard dostępny jest zaśpod adresem www.immunix.org/formatguard.html.

W jaki sposób ciągi formatującesą wykorzystywane przez włamywaczy?

Istnieją trzy podstawowe cele, które włamywacz może osiągnąć za pomocą błędu cią-gu formatującego. Po pierwsze, atakujący może spowodować błąd działania procesuw wyniku odwołania do niepoprawnego adresu. Może to zaowocować odmową obsługi.Po drugie, atakujący, jeżeli udostępni się mu sformatowany ciąg wynikowy, może od-czytać zawartość pamięci procesu. Po trzecie, może sprowokować zapis do pamięci pro-gramu, czego efektem może być wykonanie pewnego kodu.

Niszczenie i ochrona…

Przepełnianie bufora za pomocą ciągu formatującego

Pobierane od użytkowników ciągi formatujące mogą być wykorzystane do uprawdopo-dobnienia sytuacji przepełnienia bufora. W niektórych sytuacjach funkcja ��może skonstruować zbyt długi ciąg (przepełniający bufor), o ile przed przekazaniemciągu źródłowego montowanego w ciągu docelowym nie jest kontrolowana jego dłu-gość. Niekiedy taka kontrola długości powoduje niemożność przekazania przez ata-kującego nadmiarowego ciągu formatującego lub ciągu wstawianego zamiast specy-fikatora ��.


Jeżeli dane pobierane przez użytkownika są osadzane w ciągu przekazywanym póź-niej jako ciąg formatujący funkcji ��, rozmiar ciągu wynikowego może zostaćzmieniony przez zastosowanie specyfikatorów wypełniających. Przykładowo, jeżeliwłamywacz ma możliwość włączenia do ciągu formatującego dla funkcji ��specyfikatora ��, ciąg wynikowy skonstruowany przez tę funkcję będzie o około100 bajtów dłuższy od zakładanego przez programistę. Za pomocą wypełniających spe-cyfikatorów formatu można konstruować ciągi na tyle długie, że ich skopiowanie dobufora spowoduje jego przepełnienie. Można w ten sposób ominąć ograniczenia dłu-gości danych wejściowych nakładane przez programistę i sprowokować wykonaniew imieniu procesu-ofiary dowolnego kodu (patrz rozdział 8.).

Ten sposób wykorzystania ciągów formatujących nie będzie omawiany w niniejszymrozdziale. Choć angażuje on specyfikatory formatu do nadpisania pewnych obszarówpamięci, specyfikatory te powodują jedynie wydłużenie ciągu, którego kopiowanie dobufora docelowego daje zwykłe przepełnienie bufora. Ten rozdział jest natomiast po-święcony atakom przy użyciu wyłącznie specyfikatorów formatu, bez odwoływania siępóźniej do innych technik włamaniowych wykorzystujących błędy programistyczne,takich jak ataki przepełnienia bufora. Opisana powyżej sytuacja może natomiast zostaćwykorzystana do przeprowadzenia „czystego” ataku ciągu formatującego, którego re-zultatem będzie zapis do wybranego obszaru pamięci.

Odmowa obsługi

Najprostszym atakiem wykorzystującym ciąg formatujący jest atak polegający na unie-ruchomieniu atakowanego procesu przez sprowokowanie błędnego odwołania do pamię-ci, czyli typowy atak odmowy obsługi. Spowodowanie błędu wykonania programu zapośrednictwem ciągu formatującego jest rzeczą stosunkowo nieskomplikowaną.

Otóż niektóre specyfikatory formatu wymagają przekazania do funkcji jako wartościzmiennych korespondujących poprawnych adresów pamięci. Jednym z takich specyfi-katorów jest �, który zostanie przedyskutowany i wykorzystany w dalszej części roz-działu. Innym tego rodzaju specyfikatorem jest specyfikator �, wymagający przeka-zania wskaźnika do ciągu bajtowego zakończonego bajtem zerowym. Jeżeli włamywaczpodstawi złośliwie ciąg formatujący zawierający jeden z tych specyfikatorów a do funkcjinie zostaną przekazane istniejące adresy pamięci, proces zostanie zatrzymany w wynikupróby odwołania się do pamięci wskazywanej przez przypadkowe wartości znajdują-ce się na stosie. Może to spowodować odmowę obsługi, przy czym atak tego rodzajunie wymaga angażowania żadnych zaawansowanych środków.

W samej rzeczy, już wcześniej — jeszcze zanim ogół zdał sobie sprawę z powagi za-grożenia — wiadomo było o problemach powodowanych podawaniem specyficznychciągów formatujących. Było na przykład powszechnie wiadomo, że przekazanie ciągu�� jako parametru jednego z poleceń klienta IRC BitchX powoduje załamanie te-go programu. Jednak, według informacji, które posiadam, aż do opublikowania exploitademona WU-FTPD nikt nie zdawał sobie sprawy, że taki błąd można ukierunkowaći wykorzystać do własnych celów.

Niewiele więcej można napisać o załamywaniu procesów za pośrednictwem spreparo-wanych ciągów formatujących. Istnieją za to dużo ciekawsze i bardziej przydatne meto-dy wykorzystania tych ciągów do włamywania się do systemów komputerowych.


Odczyt zawartości pamięci

Jeżeli ciąg wynikowy skonstruowany w funkcji �� jest udostępniany na zewnątrz,atakujący może wykorzystać odpowiednio spreparowany ciąg formatujący do odczyta-nia zawartości pewnego obszaru pamięci. Jest to poważny problem, mogący prowadzićdo wycieków wrażliwych informacji. Przykładowo, jeżeli program przyjmuje od klien-tów informacje uwierzytelniające i nie zeruje tych obszarów pamięci, w których byłyone przechowywane bezpośrednio po ich wykorzystaniu, błąd ciągu formatującegomoże przyczynić się do ich odczytania przez włamywacza. Najprostszym sposobem,jakim dysponuje w tej sytuacji włamywacz, jest zmuszenie funkcji (za pośrednictwemciągu formatującego) do skonstruowania ciągu z nieistniejących parametrów. Funkcja od-czytuje wartości wprowadzane do konstruowanego ciągu bezpośrednio ze stosu. Przy-kładowo, każde wystąpienie specyfikatora � w ciągu formatującym będzie zastępowa-ne w ciągu wynikowym 4 bajtami pamięci stosu. Taki odczyt pamięci jest ograniczonywyłącznie do danych przechowywanych w obszarze pamięci stosu.

Możliwe jest jednak również odczytanie zawartości dowolnego obszaru pamięci, a to zasprawą specyfikatora �. Jak już wiemy, specyfikator ten zastępowany jest ciągiem bajtówzakończonym bajtem zerowym. Ciąg ten jest przekazywany do funkcji �� w po-staci adresu pierwszego bajtu ciągu. Atakujący może więc odczytać dowolny obszar pa-mięci, gdy przekaże do funkcji �� specyfikator � (w ciągu formatującym) orazadres interesującego go obszaru. Adres, od którego atakujący chciałby rozpocząć odczytpowinien zostać umieszczony na stosie; byłoby to konieczne również w przypadku ad-resu korespondującego ze specyfikatorem �. Obecność w ciągu formatującym specy-fikatora � wymusi na funkcji konstruującej ciąg wynikowy odczyt kolejnych bajtówpamięci, od bajtu znajdującego się pod adresem podsuniętym przez włamywacza aż dopierwszego bajtu zerowego.

Możliwość odczytu dowolnego obszaru pamięci jest dla hakerów bardzo atrakcyjna.Atak tego rodzaju może być łączony z innymi technikami włamaniowymi; zostanieszczegółowo omówiony w dalszej części rozdziału oraz zastosowany w konkretnymprzykładzie demonstrowanym pod koniec rozdziału.

Zapis do pamięci

W treści rozdziału już kilkakrotnie pojawiła się wzmianka o specyfikatorze �. Zada-niem tego specyfikatora jest oznaczanie długości konstruowanego ciągu w czasie dzia-łania programu. Zmienną korespondującą z tym specyfikatorem jest adres. Kiedy funkcjamontująca ciąg napotyka w ciągu formatującym specyfikator �, pod adresem przeka-zanym jako parametr korespondujący z tym specyfikatorem zapisywana jest liczba zna-ków składających się na dotychczasową postać ciągu wynikowego.

Obecność takiego specyfikatora ma poważny wpływ na bezpieczeństwo, umożliwia onbowiem modyfikacje pamięci programu. Ta cecha specyfikatora � jest kluczowa dlapowodzenia ataków wykorzystujących ciągi formatujące i umożliwia wykonanie na kom-puterze-ofierze dowolnego kodu.


Metoda pojedynczego zapisu

Pierwszą z omawianych tu metod wykorzystania ciągów formatujących będzie metodazwiększenia uprawnień atakującego za pośrednictwem pojedynczego zapisu pamięciz użyciem specyfikatora �.

W niektórych programach wartości krytyczne dla działania aplikacji, takie jak identyfi-kator użytkownika i identyfikator grupy procesu przechowywane są w pamięci proce-su, co ma zwykle na celu obniżenie uprawnień programu w czasie działania. Za pomocąodpowiednio spreparowanych ciągów formatujących włamywacz może zmodyfikować tewartości.

Przykładem programu obarczonego taką słabością jest narzędzie o nazwie Screen. Screento popularny program uniksowy, umożliwiający współużytkowanie pojedynczego pseu-doterminala przez kilka procesów. Jeżeli program zostanie zainstalowany jako tzw.setuid root, uprawnienia użytkownika wywołującego program przechowywane są w jed-nej ze zmiennych programu. Kiedy tworzone jest okno, proces macierzysty programuScreen obniża przywileje wykonawcze do poziomu wartości przechowywanych w zmien-nych procesów potomnych (procesu powłoki użytkownika i tym podobnych).

Wersje programu Screen poprzedzające wersję 3.9.5 zawierały potencjalny błąd ciąguformatującego, ujawniający się podczas wyświetlania na ekranie ciągu definiowanej przezużytkownika zmiennej określającej wizualny sygnał dzwonka (ang. visual bell). Ciąg ten,definiowany w pliku konfiguracyjnym .screenrc użytkownika jest wyświetlany na ter-minalu użytkownika jako interpretacja jednego z niedrukowalnych symboli zestawuASCII. Kiedy symbol ten ma pojawić się na ekranie, określony przez użytkownikaw pliku konfiguracyjnym ciąg jest przekazywany do funkcji �� jako część cią-gu formatującego.

Ze względu na strukturę programu Screen luka ta mogła zostać wykorzystana przyużyciu ciągu zawierającego pojedynczy specyfikator �. Bez wstrzykiwania do progra-mu własnego kodu i obliczania adresów skoków. Cały atak polega na nadpisaniu prze-chowywanego przez program identyfikatora �� wybraną przez atakującego wartością,np. zerem (zero to identyfikator użytkownika ��).

Aby tego dokonać, atakujący musiał umieścić adres identyfikatora UID w pamięci tak,aby został on potraktowany jako parametr wywołania funkcji ��. Następnie wła-mywacz musiał utworzyć ciąg wprowadzający specyfikator � na odpowiednią pozycjęstosu. Mógł przesunąć docelowy adres o 2 bajty i w ten sposób wyzerować identyfi-kator użytkownika dwoma najstarszymi bajtami wartości �. Przy następnym utwo-rzeniu okna przez włamywacza, proces macierzysty Screen ustawiał uprawnienia pro-cesu potomnego zgodnie z nadpisaną wartością UID.

Lokalny włamywacz wykorzystujący błąd ciągu formatującego mógł więc rozszerzyćswoje uprawnienia w systemie do poziomu uprawnień użytkownika administracyjnego.Luka w programie Screen jest znakomitym przykładem ilustrującym jak łatwo udajesię niekiedy przeprowadzić zadziwiająco skuteczne ataki wykorzystujące ciąg formatują-cy. Opisana metoda ma jeszcze tę zaletę, że jest w dużej mierze niezależna od platformy.


Metoda wielokrotnego zapisu

Zajmiemy się teraz wielokrotnymi zapisami w pamięci atakowanego procesu. Jest totechnika nieco bardziej skomplikowana, dająca za to ciekawsze rezultaty. Odpowiedniewykorzystanie ciągu formatującego może bowiem doprowadzić do modyfikacji dowol-nego obszaru pamięci. Aby przybliżyć tę metodę Czytelnikowi, najpierw dokładnie omó-wię działanie specyfikatora � i modyfikacje, jakie można za jego pośrednictwem wpro-wadzić do pamięci procesu.

Powtórzmy więc: zadaniem specyfikatora formatu � jest wyświetlenie liczby znakówwstawionych do tej pory do ciągu wynikowego. Atakującemu najczęściej jednak trudnoumieścić tam liczbę na tyle dużą, aby mogła być potraktowana jako poprawny adrespamięci (na przykład wskaźnik wstrzykniętego kodu). Dlatego nie jest możliwe utwo-rzenie takiej wartości przy użyciu pojedynczego elementu �. Rozwiązaniem jest za-stosowanie kilku elementów i zapisanie za ich pośrednictwem w pamięci żądanegoadresu. Za pomocą tej techniki haker może zapisać niemal dowolną wartość w postacikolejnych bajtów. W ten sposób może sprowokować wykonanie przez atakowany pro-ces dowolnego kodu.

Przebieg ataków z użyciem ciągów formatujących

W tym punkcie omówiony zostanie sposób, w jaki można przeprowadzić atak wyko-rzystujący ciąg formatujący do nadpisania w pamięci procesu takich wartości jak ad-res pamięci. Sposób ten pozwala włamywaczowi wykonać w przestrzeni procesu-ofiarydowolny kod.

Czytelnik już wie, że kiedy funkcja konstruująca sformatowany ciąg wynikowy napotkaw ciągu formatującym specyfikator �, zapisuje do pamięci pewną liczbę całkowitą.Adres, pod którym dokonywany jest zapis powinien znajdować się na stosie funkcji��, gdzie „spodziewa się” ona parametru odpowiadającego temu specyfikatorowi.Atakujący musi w jakiś sposób umieścić pożądany adres na stosie i umieścić w od-powiednim miejscu ciągu formatującego element �. Czasem może tego dokonać zapośrednictwem zmiennych lokalnych funkcji, kiedy dane pobierane od użytkownikaumieszczane są na stosie funkcji.

Zwykle istnieje jednak mniej skomplikowany sposób określenia adresu docelowegowpisu. W większości podatnych programów pobrany od użytkownika ciąg formatują-cy przekazywany do funkcji �� umieszczany jest w zmiennej lokalnej utworzonejna stosie. Zakładając, że funkcja nie alokuje zbyt dużej liczby zmiennych lokalnych,możemy się spodziewać, że pobrany od użytkownika ciąg formatujący przechowywa-ny jest niedaleko ramki stosu utworzonej do wywołania funkcji ��. Atakującymoże wymusić na funkcji wykorzystanie adresu zgodnego z własnymi planami przezumieszczenie specyfikatora � w odpowiednim miejscu ciągu formatującego.

Włamywacz ma wpływ na lokalizację, spod której funkcja �� odczytuje zmiennąwskaźnikową korespondującą z elementem �. Może mianowicie umieszczać w ciąguformatującym specyfikatory � lub �, co powoduje swego rodzaju „zjadanie” kolejnychobszarów stosu przez funkcję �� aż do momentu osiągnięcia adresu osadzonego


na stosie przez atakującego. Zakładając, że dane pobierane od użytkownika przekazy-wane dalej jako ciąg formatujący nie są obcinane, atakujący może sprowokować odczytprzez funkcję �� znacznych obszarów stosu, aż dotrze ona do wartości zgodnychz jego zamierzeniami lub przez niego tam umieszczonych. Wtedy w ciągu umieszczanyjest element �, powodujący zapis pewnej liczby pod podsuniętym adresem.

Adresy osadzane w samym ciągu formatującym nie mogą zawierać bajtów zerowych,są one bowiem zwykłymi ciągami znakowymi i pierwszy bajt zerowy sygnalizuje ko-niec takiego ciągu. Nie oznacza to, że w atakach tego rodzaju nie mogą być w ogólestosowane adresy zawierające zerowe bajty — muszą być one jedynie umieszczo-ne na stosie poza ciągiem formatującym, w innych zmiennych lokalnych. Tylko w tensposób atakujący ma możliwość wykorzystania w ataku z użyciem ciągu formatu-jącego adresów z bajtami zerowymi.

Przykład: włamywacz planujący wykorzystanie jako adresu docelowego specyfikatora� wartości składowanej 32 bajty od adresu, spod którego funkcja �� odczytujepierwszy parametr wywołania, może umieścić w ciągu formatującym 8 specyfikato-rów �. Elementy � powodują umieszczenie w ciągu wynikowym szesnastkowej re-prezentacji wartości czterobajtowego słowa (w przypadku 32-bitowych procesorówIntela). Każde wystąpienie elementu � w ciągu formatującym powoduje więc odczyta-nie przez funkcję �� wartości leżącej na stosie niżej o 4 bajty od poprzedniej.Atakujący może oczywiście również wykorzystać inne specyfikatory i zmusić funkcjękonstruującą ciąg do zagłębiania się w dół stosu w poszukiwaniu zmiennej korespon-dującej z elementem �.

Konstruowanie wartości

Atakujący może też manipulować wartością, która ma być zapisana pod docelowym ad-resem pamięci. Aby zwiększyć liczbę znaków, z których składa się wynikowy ciąg kon-struowany przez ��, można stosować specyfikatory wypełniające:

��&&��;��)��<��

W powyższym przykładzie element �� wstawiony do ciągu formatującego to specyfi-kator formatu z określeniem wypełnienia. Wypełnienie to sygnalizuje funkcji ��,że reprezentacja liczby całkowitej w ciągu wynikowym ma zajmować 10 znaków.

!"��# �� $%��)��

Dziesiętna reprezentacja liczby 10 nie wymaga oczywiście aż dziesięciu znaków, dlate-go reszta wypełnienia to znaki spacji. Ta właściwość funkcji �� może zostaćwykorzystana przez atakującego do regulowania wartości zapisywanej przez specyfi-kator � bez potrzeby konstruowania bardzo długich ciągów formatujących. Wartościzapisywane w pamięci procesu są zwykle niewielkie i mogą być z powodzeniem regu-lowane właśnie specyfikatorami z wypełnieniem.


Stosując wielokrotne zapisy za pośrednictwem elementów � atakujący mogą wykorzy-stać młodszy bajt zapisywanej wartości i z kilku takich bajtów skonstruować większesłowo. W taki sposób możliwa jest konstrukcja wartości całego słowa maszynowego,takiego jak adres, przy użyciu stosunkowo niewielkich liczb zapisywanych w wynikiprzetwarzania specyfikatora �. Atakujący musi wtedy podsunąć adres każdego zapi-su przesunięty względem poprzedniego o jeden bajt.

Wykorzystując cztery elementy � i podsuwając 4 adresy, atakujący konstruuje docelo-wą wartość z najmłodszych bitów zapisywanych wartości (patrz rysunek 9.1).

Rysunek 9.1.

Adres skonstruowany

przy użyciu czterech

osobnych zapisów

Na niektórych platformach sprzętowych (np. w pewnych systemach RISC) zapisy dopamięci pod adresami nie wyrównane do dwóch bajtów są niemożliwe. Utrudnienie tomożna niejednokrotnie wyeliminować przez zastosowanie specyfikatorów powodują-cych zapis krótkiej liczby całkowitej (ang. short integer), takich jak ��.

Konstruowanie dowolnych wartości przy użyciu kolejnych zapisów jest najtrudniej-szą metodą ataku, dającą jednak atakującemu możliwość przejęcia pełnej kontroli nadprzebiegiem procesu. Umożliwia bowiem nadpisanie wskaźników do instrukcji wskaź-nikami do podsuniętego przez atakującego kodu. Jeżeli atakujący wykorzysta w tensposób ciąg formatujący, przepływ sterowania programu może zostać zmieniony tak,aby wykonaniu uległ podsunięty kod.


Co nadpisywać

Dysponując możliwością konstruowania dowolnej wartości w niemal dowolnym miej-scu pamięci, musimy zadać sobie pytanie „co (jaki adres) powinno zostać nadpisane”?Mając do dyspozycji niemal każdy adres, haker dysponuje wieloma możliwościami.Może on na przykład nadpisać adres powrotny funkcji składowany na stosie — wtedytaki atak ma efekt podobny do ataku przepełniającego bufor. Nadpisanie adresu po-wrotnego funkcji może bowiem doprowadzić do wykonania odsuniętego przez wła-mywacza kodu. Jednak w przeciwieństwie do ataków przepełniających bufor, możliwościwłamywacza korzystającego z ciągów formatujących nie ograniczają się do nadpisywaniaadresów powrotnych.

Nadpisanie adresu powrotnego

Większość ataków przepełniających bufor i opierających się na charakterystyce dzia-łania stosu wymaga od atakującego zastąpienia adresu powrotnego funkcji przecho-wywanego w określonym obszarze stosu innym wskaźnikiem instrukcji. Kiedy funkcja,w ten sposób zniekształcona, kończy swoje działanie i podejmuje próbę przekazaniasterowania z powrotem do kodu, z którego została wywołana, wykonywany jest skokpod zamieniony adres. W atakach przepełniających bufor atakujący nadpisuje adres po-wrotny funkcji dlatego, że z racji budowy stosu nie ma innych możliwości. Atakującynie może dowolnie wybrać obszaru, który zostanie nadpisany, ponieważ ma wpływjedynie na dane znajdujące się w bezpośrednim sąsiedztwie przepełnionego bufora. Atakiwykorzystujące ciągi formatujące tym się różnią od ataków przepełnienia bufora, żeumożliwiają wykonanie zapisu pod teoretycznie dowolnym adresem, określonym war-tością obszaru pamięci korespondującego ze specyfikatorem �. Atakujący może więcnadpisać adres powrotny funkcji przez jawne podanie jego lokalizacji. Kiedy funkcjapowraca, procesor rozpocznie wykonywanie kodu od instrukcji znajdujących się podwskazanym przez włamywacza adresem.

Haker nadpisujący adres powrotny funkcji może stanąć w obliczu dwóch problemów.Pierwszym z nich jest sytuacja, w której funkcja po prostu nie wraca. W przypadku lukzwiązanych z ciągami formatującymi jest to przypadek dość częsty, ponieważ wystę-pują one powszechnie w funkcjach informujących o błędach. Funkcja taka może naprzykład wypisać na wyjściu komunikat (nawet skonstruowany na podstawie otrzy-manego od użytkownika ciągu formatującego) i zakończyć działanie procesu za po-średnictwem funkcji ��. W takim przypadku nadpisanie adresu powrotnego jakiej-kolwiek funkcji poza funkcją �� nie da żadnego rezultatu. Drugim problemem jestto, że nadpisanie adresu powrotnego może zostać wykryte przez mechanizm ochronypamięci stosu, taki jak StackGuard.

Nadpisanie wpisów globalnej tablicy przesunięći innych wskaźników funkcji

Globalna tablica przesunięć (GOT, od ang. global offset table) to fragment pliku binar-nego w formacie ELF zawierający wskaźniki do funkcji bibliotecznych importowa-nych przez program. Atakujący może nadpisać wpisy tablicy GOT własnymi wskaźni-kami, wskazującymi na instrukcje podsuniętego kodu, który zostanie wykonany w wynikuwywołania odpowiedniej funkcji bibliotecznej.


Nie wszystkie pliki binarne podlegające atakom zapisywane są w formacie ELF. Wła-mywaczom zostają wtedy zwyczajne wskaźniki funkcji, będące zresztą łatwym celem.Wskaźniki funkcji są zmiennymi tworzonymi przez programistę; ich obecność w pro-gramie warunkuje powodzenie ataku. Funkcja musi zostać wywołana za pośrednictwemwskaźnika — tylko wtedy może zostać wykonany podsunięty przez atakującego kod.

Analiza podatnego programu

Czas na podjęcie decyzji co do programu, który w dalszej części rozdziału będzie służyłza przykład wykorzystania luki ciągu formatującego. Luka ta powinna dawać możliwośćzdalnego jej wykorzystania. Scenariusz, w którym penetracji systemu komputerowe-go dopuszcza się haker nie mający żadnego upoważnienia i teoretycznie od niego od-cięty jest najlepszą ilustracją zagrożeń wynikających z istnienia tego rodzaju luk. Da-lej, luka powinna znajdować się w rzeczywistym programie, najlepiej takim, któregoautorem jest znany i poważany programista; uświadomi to Czytelnikom, że tego rodzajubłędy mogą znajdować się również w oprogramowaniu pozornie pewnym i poprawnym.Przykład powinien ponadto posiadać kilka cech dających sposobność do omówieniarozmaitych aspektów błędów związanych z ciągami formatującymi, takich jak np.problem wyświetlania sformatowanego ciągu.

Zdecydowałem się zaprezentować lukę na przykładzie programu Rwhoisd. Rwhoisd czyteż demon RWHOIS jest implementacją usługi RWHOIS. Projektem serwera usługiRWHOIS zajmuje się obecnie dział badawczy i rozwojowy Network Solutions; serwerten został udostępniony szerokiej publiczności na podstawie Powszechnej LicencjiPublicznej GNU.

Klasyczny błąd umożliwiający przeprowadzenie ataku wykorzystującego ciąg formatu-jący został wykryty w rwhoisd w wersji 1.5.7.1 i wcześniejszych. Błąd ten umożliwianieautoryzowanym klientom usługi, którzy nawiązali połączenie z usługą wykonaniedowolnego kodu. Pierwszy opis tej luki ujrzał światło dzienne jako wiadomość prze-słana na listę dystrybucyjną Bugtraq (wiadomość ta została zarchiwizowana pod adre-sem www.securityfocus.com/archive/1/222756).

Aby zrozumieć istotę luki występującej w demonie rwhoisd należy zapoznać się z jegokodem źródłowym. Analizie poddany zostanie kod źródłowy wersji 1.5.7.1. W czasie pi-sania tej książki kod ten był dostępny w sieci WWW pod adresem www.rwhois.net/ftp.

Błąd ujawnia się, kiedy program w odpowiedzi na przekazanie przez użytkownikaniepoprawnego parametru polecenia �� ma wypisać na wyjściu komunikat o błędzie.

Komunikaty o błędach są przez serwer konstruowane i wypisywane za pomocą funk-cji o nazwie ��. Funkcja ta jest wykorzystywana w całym kodzie źródło-wym do obsługi sytuacji awaryjnych i do informowania o nich aplikacji klienta i same-go użytkownika. Funkcja przyjmuje kilka parametrów: liczbę całkowitą określającąnumer błędu, ciąg formatujący oraz zmienną liczbę parametrów odpowiadających spe-cyfikatorom formatującym określonym w ciągu.


Wieści z podziemia…

Najgroźniejsze błędy związane z ciągami formatującymi

Poza błędną obsługą polecenia SITE EXEC serwera WU-FTPD wykryto kilka innychzasługujących na wzmiankę luk. Niektóre z nich wykorzystane zostały w robakach in-ternetowych i narzędziach masowego włamywania i dały efekt w postaci skutecznychwłamań do tysięcy węzłów internetowych.

IRIX Telnetd — odpowiednio spreparowane dane pobrane od klienta przekazy-wane jako ciąg formatujący do funkcji �� umożliwiały hakerom zdalne wy-konanie dowolnego kodu bez konieczności przechodzenia jakichkolwiek proceduruwierzytelniających. Luka została wykryta przez grupę Last Stage of Delirium(patrz www.securityfocus.com/bid/1572).

Linux rpc.statd — wykryta w tym programie luka również związana była z nie-prawidłowym zastosowaniem funkcji �� i także umożliwiała zdalne uzyska-nie uprawnień administracyjnych. Lukę wykrył Daniel Jacobowitz i opublikował ją16 czerwca 2000 roku jako wiadomość przesłaną na listę Bugtraq (patrzwww.securityfocus.com/bid/1480).

Cfingerd — kolejna luka wynikająca z nieprawidłowego zastosowania wywołania��, odkryta przez Megyera Laszlo. Jej wykorzystanie mogło doprowadzić doprzejęcia przez zdalnego włamywacza kontroli nad atakowanym węzłem (patrzwww.securityfocus.com/bid/2576).

Implementacja modułu locale w bibliotece Libc — Jouko Pynnönen oraz zespółCore SDI niezależnie od siebie ogłosili wykrycie luki związanej z ciągiem formatu-jącym w implementacji biblioteki C wchodzącej w skład kilku systemów unikso-wych. Luka umożliwiała atakującemu lokalne przejęcie rozszerzonych uprawnieńprzez ataki na programy setuid (patrz www.securityfocus.com/bid/1634).

Implementacje rpc.ttdbserverd w systemach CDE — ISS X-Force poinformowało wykryciu luki związanej z niewłaściwym zastosowaniem funkcji �� w wersjachserwera bazy danych o nazwie ToolTalk wchodzącego w skład kilku systemów ope-racyjnych wyposażonych w CDE. Luka ta umożliwiała zdalnym, nieuwierzytelnionymhakerom wykonanie dowolnego kodu na zaatakowanym komputerze (patrz www.securityfocus.com/bid/3382).

Kod źródłowy tej funkcji zdefiniowany jest w pliku źródłowym common/client_msgs.c(podana ścieżka to ścieżka względna wobec katalogu głównego kodu, czyli katalogu,do którego rozpakowano kod źródłowy wersji 1.5.7.1 programu).

&'��"��=��;�>��)��???��@��(=��???��(��A0��'& �"��4�� 4�� 4"�� 4��4��=��'��"4��4�� 4��4�� 4��


��B�C4DEEF��GG��!$;��4��;��!$;��*�� 4��=��'��'��)�� 4�"��<��"4��4��9E8D�

Wytłuszczony wiersz sygnalizuje ten fragment kodu, w którym parametry przekazanedo funkcji �� przekazywane są do funkcji ��. Luka tkwi nie w tejkonkretnej funkcji, ale w jej nieprawidłowym wykorzystaniu w innych fragmentachkodu źródłowego. Programista tej funkcji zakłada, że funkcja ją wywołująca przekażepoprawny ciąg formatujący i wszystkie potrzebne do konstrukcji ciągu parametry.

Pełny kod tej funkcji zamieszczono w tym miejscu, ponieważ jest ona świetnym przy-kładem prowokowania sytuacji, które mogą zaowocować atakiem wykorzystującymciąg formatujący. Wiele programów wyposażanych jest w bardzo podobne funkcje.Służą one jako otoczki (ang. wrapper) wyświetlające komunikaty o błędach i wzorowa-ne są na funkcji � ��; przyjmują jako parametry numer błędu i parametry służącedo konstrukcji komunikatu. Problem (zgodnie z tym, co napisano na początku roz-działu) polega na tym, że programiści często zapominają o przekazaniu do takiej funkcjiciągu formatującego.

Należałoby teraz przeanalizować zdarzenia towarzyszące nawiązaniu połączenia z usłu-gą przez klienta i próbie przekazania za pośrednictwem funkcji �� ciąguformatującego do funkcji ��.

Dla Czytelników dysponujących kodem programu — odpowiedni fragment kodu znaj-duje się w pliku źródłowym server/soa.c. Funkcja, w której zdefiniowano interesującynas kod nosi nazwę ��. Reszta kodu została z wydruku usunięta — dlawygody i zwięzłości przykładu. Podatne na ataki wywołanie znajduje się w 53. wierszupliku źródłowego (na wydruku jest on wytłuszczony):

;;;��=4��"4��=4��4*�4�� !$��H��=4�� !"��#�$�%��

��4��4�� "�4��4"��4��C855�� ;;;


W powyższym wywołaniu funkcji �� jako ciąg formatujący przekazywa-ny jest parametr ��. Ostatecznie ciąg reprezentowany przez ten parametr zostajeprzekazany do funkcji �� (na poprzednim wydruku). Dla kontrolera kodu źró-dłowego taka konstrukcja powinna kojarzyć się z potencjalną luką. Prawidłowe wy-wołanie funkcji �� powinno mieć następującą postać:

��4��ICJ75IK4789:47ED7�� !$��

Tutaj zmienna �� przekazywana jest do funkcji �� jako parametr kore-spondujący ze specyfikatorem � ciągu formatującego. Taka postać wywołania eliminujemożliwość złośliwego podstawienia w parametrze �� ciągu interpretowanegow funkcji �� jako ciąg formatujący. Parametr �� jest jednym z parametrówdyrektywy �� przekazanym do serwera przez klienta.

Podsumowując, kiedy klient nawiązuje połączenie z serwerem rwhoisd i wykonuje po-lecenie ��, w przypadku niepoprawnych wartości parametrów polecenia wywoływanajest funkcja ��, wypisująca na standardowym wyjściu programu komuni-kat o błędzie. Procedura ta przebiega następująco:

1. Serwer rozpoznaje parametr �� i wywołuje funkcję �� do obsługipolecenia.

2. Funkcja �� przekazuje polecenie klienta do funkcji��, interpretującej i kontrolującej poprawność parametrówpolecenia.

3. Funkcja �� wykrywa błąd i przekazuje komunikat o błędzieoraz ciąg polecenia do funkcji ��. Ciąg polecenia przekazywanyjest jako ciąg formatujący.

4. Funkcja �� przekazuje otrzymany od klienta ciąg formatującydo funkcji �� (patrz wydruk).

Widać wyraźnie, że zdalny klient może złośliwie spreparować dane, które zostaną prze-kazane jako ciąg formatujący do funkcji ��. Ciąg zawierający te dane przeka-zywany jest do serwera jako parametr dyrektywy ��. Nawiązując połączenie z usługąi przesyłając szkodliwy ciąg formatujący, atakujący może przeforsować zapis własnychdanych do pamięci procesu.

Testowanie wykorzystująceprzypadkowe ciągi formatujące

Po zlokalizowaniu w kodzie źródłowym potencjalnych luk związanych z ciągami for-matującymi należałoby podjąć próbę ich wykorzystania i pokazać, że jest ono możli-we w wyniku podawania spreparowanych ciągów formatujących i obserwację reakcjiserwera.


Jeżeli program zawiera potencjalne błędy ciągów formatujących, można wykryć ichobecność poprzez sprowokowanie pewnych zachowań programu, które będą wskazy-wać na obecność takich luk. Jeżeli podatny program wyświetla postać wynikową kon-struowanych ciągów, ich istnienie jest oczywiste. Jeżeli natomiast podatny program nieudostępnia sformatowanego ciągu, jego obecność może być sygnalizowana reakcjamiprogramu na niektóre specyfikatory formatujące.

Jeżeli po przekazaniu na wejście programu ciągu �� proces załamuje się, jest praw-dopodobne, że załamanie spowodowane zostało próbą zapisu wartości liczbowej podnieprawidłowym adresem odczytanym ze stosu. Na tej podstawie można identyfikowaćpodatne programy nawet jeżeli nie wyświetlają efektów konstrukcji ciągu — wystar-czy przekazywać do nich pewne specyfikatory formatu. Jeżeli proces załamuje się, albojeżeli nie wypisuje niczego i sprawia wrażenie zawieszonego, można zaryzykować twier-dzenie, że jest podatny na ataki wykorzystujące ciąg formatujący.

Wróćmy do przykładu: serwer zwraca klientowi sformatowany, wynikowy ciąg jakojeden z elementów odpowiedzi. Znacznie upraszcza to pracę włamywacza szukającegosposobu na przeniknięcie do serwera. Poniższy wydruk zawiera przykładowy komunikatserwera rwhoisd, którego treść wskazuje na istnienie w nim błędu ciągu formatującego:

!"��# �� $%��=��0/1��(=��J-�;3)��/��)�� *��C��(��F��I��J-�;3;.;��&��'��(��)��/0��I ��"�7��=��7��)�+��4-��./.0/3A/4��"��

W powyższym przykładzie nawiązanie połączenia z usługą i przesłanie do niej specy-fikatora formatu wewnątrz parametru podejrzanego o występowanie w roli ciągu for-matującego spowodowało dołączenie do odpowiedzi serwera ciągu –1073743563w miejscu, gdzie w przekazanym ciągu znajdował się specyfikator �. Wyświetlonaliczba ujemna jest po prostu dziesiętną interpretacją 4 bajtów pamięci stosu znajdują-cych się przypadkiem tam, gdzie funkcja �� „spodziewała się” obecności pa-rametru korespondującego ze specyfikatorem �. Jest to jawne potwierdzenie obecno-ści w kodzie serwera błędu ciągu formatującego.

Po zidentyfikowaniu luki na podstawie zarówno analizy kodu źródłowego, jak i odpo-wiedzi serwera, trzeba się zastanowić nad możliwością jej wykorzystania. Ta konkretnaluka nadaje się do wykorzystania przez zdalnego klienta za pośrednictwem sieci. Ataknie wymaga przy tym przejścia procedury uwierzytelniającej i prawdopodobnie możedoprowadzić do przejęcia przez użytkownika zdalnego kontroli nad komputerem ob-sługującym serwer.

W przypadkach takich jak ten (w których program wyświetla sformatowany ciąg wy-nikowy) atakujący ma możliwość odczytania zawartości pamięci stosu i zdobycia w tensposób dodatkowych informacji przydatnych w końcowym ataku. W prezentowany po-niżej sposób atakujący może odczytywać całe słowa pamięci:

!"��# �� $%��=��0/1��(=��J-�;3)��/��)�� *��C��(��F��I��J-�;3;.;��&��*+*��/0��I ��"�7��=��7��)��@*��2/3&��*+*��*+*�


Narzędzia i pułapki…

Więcej stosu, mniej ciągu formatującego

Może się zdarzyć, że ciąg formatujący przechowywany na stosie leży poza zasięgiemfunkcji ��. Przyczyn takiego stanu rzeczy może być kilka, jedną z nich jest obcięcieciągu wejściowego (formatującego) do określonej długości. Jeżeli wejściowy ciąg for-matujący zostanie na pewnym etapie wykonywania programu (przed przekazaniem godo funkcji ��) obcięty do pewnego maksymalnego rozmiaru, liczba specyfikato-rów formatów, które zostaną wzięte pod uwagę będzie ograniczona. Istnieje kilka sposo-bów na obejście takiego utrudnienia podczas konstruowania programu atakującego.

Cały problem polega wtedy na takim operowaniu specyfikatorami funkcji ��,aby odczytała ona jak największy blok pamięci przy zastosowania jak najkrótszegociągu formatującego. Można w tym celu posłużyć się jedną z poniższych technik:

� Skorzystać z większych typów danych — pierwszym i najbardziej oczywistymrozwiązaniem jest zastosowanie specyfikatorów formatujących kojarzonychz „szerszymi” typami danych; jednym z takich specyfikatorów jest ��,interpretowany ze zmienną typu ��. W 32-bitowych architekturachIntel funkcja �� wstawi w miejsce każdego takiego specyfikatora 8 bajtówobszaru stosu. Możliwe jest również wstawienie do ciągu wynikowego zmiennejtypu �� lub "��*��, choć dane przechowywane na stosie mogąnie nadawać się do interpretacji zmiennoprzecinkowej, co może spowodowaćzałamanie procesu.

� Skorzystać z kwalifikatorów długości ciągu wyjściowego — niektóre wersjebiblioteki libc obsługują znak wielokrotności (') w specyfikatorach ciągu. Znakten informuje funkcję �� o tym, że długość (liczba znaków), do której mazostać wyrównana wartość zmiennej odpowiadającej specyfikatorowi definiowanajest parametrem wywołania (funkcja odczytuje długość wypełnienia ze stosu).Parametr ten musi być liczbą całkowitą. Każda gwiazdka powoduje więc „połknięcie”4 kolejnych bajtów stosu. Ostateczna długość interpretowanej wartości może byćjednak zastąpiona przez liczbę określoną bezpośrednio przed właściwymspecyfikatorem. Przykładowo, specyfikator �''''''''�� spowoduje wyświetlenieprzez funkcję wartości zmiennej całkowitej, reprezentowanej za pomocą dziesięciuznakach. Jednakże wartość tej zmiennej zostanie odczytana spod adresuprzesuniętego o 32 bajty. Pierwsze zastosowanie tej techniki przypisuje sięniejakiemu lorianowi.

� Odwoływać się bezpośrednio do parametrów — możliwe jest zmuszenie funkcji�� do odwoływania się wyłącznie do określonych parametrów. Służądo tego specyfikatory formatujące postaci �@%, gdzie @ jest numerem parametru(licząc od 1). Technikę tę można stosować jedynie na platformach wyposażonychw bibliotekę C obsługującą ciągi formatujące z bezpośrednim dostępemdo parametrów.

Jeżeli nawet za pomocą omówionych wyżej trików nie uda się „dosięgnąć” adresu „za-szytego” w ciągu formatującym, atakujący powinien przeanalizować kod procesu w ce-lu określenia, czy gdziekolwiek w pamięci znajduje się obszar stosu, w którym możnaby umieścić adres. Należy bowiem pamiętać, że adres niekoniecznie musi być osadzonyw ciągu formatującym, choć jest to wygodne, gdy ciąg ten alokowany jest w odpowied-nim obszarze stosu. Atakujący może przecież przekazać na wejście programu nie tylkociąg formatujący. W przypadku wspomnianego programu Screen atakujący miał na przy-kład dostęp do zmiennej konstruowanej na podstawie zmiennej środowiskowej :�LD.Ciąg ten był przechowywany na stosie w łatwiej dostępnym miejscu.


��/0��I ��"�7��=��7��)��@*��2/3�@�M�.��M�&��*+*��*+*��*+*��/0��I ��"�7��=��7��)��@*��2/3�@�M�.��M��@��&��*+*��*+*��*+*��*+*��/0��I ��"�7��=��7��)��@*��2/3�@�M�.��M��@��@�M�M��"M

W tym przykładzie klient odczytał jedno, dwa, trzy a następnie cztery słowa pamięcistosu. Wydruk wynikowy został sformatowany tak, że nadaje się do automatycznej anali-zy przez program atakujący. Prawidłowo skonstruowany program atakujący może wy-korzystać odpowiedzi serwera do rekonstrukcji pełnej zawartości stosu procesu serwera.Program taki mógłby odczytywać zawartość pamięci stosu aż do momentu napotkaniana stosie samego ciągu formatującego i na tej podstawie obliczyć pożądaną lokaliza-cję specyfikatora � w ciągu formatującym.

�(=��J-�;3)��/��)�� *��C��(��F��I��J-�;3;.;��&��*+*��*+*��*+*��*+*��*+*��*+*��*+*��*+*��*+*��*+*��*+*��*+*��*+*��*+*��*+*��*+*��*+*��*+*��*+*��*+*��*+*��*+*��*+*��*+*��*+*��,�,�,�,�,��/0��I ��"�7��=��7��)��@*��2/3�@�M�.��M��@��@�M�.��/��@*��M�0�@�M�0�1��@*��2/3�@*��2/3�@*��2��@�M�0�A�/�@*��2/3��@*��2/��@*��*A0�@*��21��@�M�0��@*��2/��@*��2/��@��0�@*��*/��@�M�0��0��@*��2/��@��3�@A�A�./1"�@/�/�13��*+*��

W tym przykładzie klient zmusił funkcję �� do przeszukania dużego obszaru sto-su tak, aby atakujący mógł określić położenie na stosie ciągu formatującego. Wytłusz-czone znaki �� to pierwsze znaki przekazanego do serwera ciągu formatującego,zawierającego przetworzone przez funkcję �� specyfikatory formatu. Jeżeli ata-kujący osadzi na początku ciągu formatującego adres, może, wstawiając w miejsce spe-cyfikatorów � element �, wymusić zapis pod adresem pamięci przekazanym w ciąguformatującym.

Atak z użyciem ciągu formatującego

Jesteśmy już gotowi do przeprowadzenia ataku wykorzystującego ciąg formatujący.W przypadku takiego programu jak rwhoisd celem włamywacza jest wymuszenie wy-konania przez zdalny komputer podsuniętego przez siebie kodu. Kod ten powinien daćatakującemu dostęp do atakowanego komputera.

Prezentowany tu exploit zostanie napisany dla demona rwhoisd 1.5.7.1 kompilowanegona platformie Linux i386. Program ten badany był w poprzednich punktach. Jak jużwspomniano, aby wykonać podstawiony kod, exploit musi nadpisać wartość, do którejatakowany proces odwołuje się później jako do adresu kolejnej instrukcji do wykonania.W prezentowanym exploicie adres powrotny funkcji nadpisywany będzie adresem „prze-myconego” kodu. Kod ten będzie realizował wywołanie �� !�� , co spowodujeudostępnienie klientowi powłoki w atakowanym systemie.

Najpierw program atakujący powinien nawiązać połączenie z usługą i spróbowaćokreślić lokalizację ciągu formatującego na stosie. Program atakujący zrealizuje topoprzez nawiązanie wielokrotnie połączenia z usługą i przekazanie do niej ciągu for-matującego zwracającego kolejne słowa stosu procesu zdalnego. Funkcja realizująca


ten fragment programu nosić będzie nazwę !�"��. Funkcja ta będzie wysyłaćdo serwera ciągi formatujące powodujące zwracanie przez serwer coraz większychobszarów pamięci stosu. Następnie każde pozyskane słowo stosu będzie porównywa-ne z wartością 0x62626262, która będzie umieszczana na początku ciągu formatują-cego. Istnieje ryzyko, że ze względu na różne rozmiary typów danych przechowywa-nych na stosie nie uda się „trafić” w pełne słowo 0x62626262 — program atakującynie obsługuje jednak takiej ewentualności.

��'��N�N��OO��'��G��N@N��!��$��N<�N��=��C855��A��

��,-,.��//�0��1"�

��'*��')��"��?�)��(��"��+;<��"��"�� G��

Przekazywany przez serwer obraz stosu łatwo poddaje się analizie, ponieważ jest for-matowany zgodnie ze specyfikatorem formatującym ��. Specyfikator �� forma-tuje każde słowo maszynowe jako 8-znakowy ciąg szesnastkowej reprezentacji tegosłowa poprzedzony ciągiem ��. Każda taka reprezentacja jednego słowa pamięci stosumoże być przekazana do jednej ze standardowych funkcji języka C, takich jak ��"��,zwracającej odpowiadającą temu ciągowi zmienną typu całkowitego.

Podstawowym celem ataku jest wykonanie własnego kodu. Aby to osiągnąć, włamywaczmusi nadpisać te obszary pamięci, których zawartość będzie później wykorzystywanajako adres kolejnych instrukcji programu. Jednym z takich obszarów jest adres powrot-ny funkcji. Czytelnik już wie, że adres ten jest głównym celem ataków przepełniającychbufor — przepełnienie bufora alokowanego na stosie może spowodować modyfikacjęprzechowywanej również na stosie wartości adresu powrotnego funkcji. W prezentowa-nym ataku nadpisany zostanie także właśnie adres powrotny funkcji — to najwygod-niejsze rozwiązanie.

Atak ma więc spowodować nadpisanie adresu powrotnego umieszczanego na stosiew momencie wywoływania funkcji ��. W binarnej wersji aplikacji rwhoisdwykorzystywanej do konstrukcji tego przykładu adres powrotny tej funkcji znajduje sięw czasie jej wykonywania pod adresem 0xbffff8c8. Adres ten będzie naszym celem.

Kiedy program atakujący zdoła już zlokalizować na stosie ciąg formatujący, powinienskonstruować nowy ciąg formatujący, zawierający w odpowiednich miejscach specyfi-katory �, tak aby sprowokować zapis do odpowiednich komórek pamięci. Można w tymcelu wykorzystać specyfikatory takie jak �, które będą pochłaniać wybrane obszary sto-su. Program atakujący konstruuje ciąg automatycznie, opierając się na efektach dzia-łania funkcji !�"��.


��B��GG��@��1��

Zmienna �"� wykorzystywana w powyższym kodzie została ustawiona w funkcji !�"�� i wskazuje lokalizację ciągu formatującego na stosie atakowanego procesu.Teraz program atakujący, znając adres, pod którym ma zostać wykonany zapis, powi-nien określić adres docelowy skoku.

Adres powrotny musi zostać nadpisany w czterech kolejnych zapisach metodą �. Abyskonstruować 4-bajtowy adres docelowy, każda kolejna operacja zapisu musi operowaćna obszarze pamięci przesuniętym o jeden bajt w stosunku do poprzedniej operacji.Cztery adresy określające to przesunięcie również muszą zostać umieszczone w ciąguformatującym:

'��'��G�M'��97E6D9�'��'��G��A'��97E6D9�G��'��'��G�10'��97E6D9�G�1�'��'��G�/1'��97E6D9�G�/��!/A$��N<�N�

Kolejnym krokiem jest zapisanie odpowiednich wartości pod każdym ze zdefiniowanychprzesunięć. Utworzą one w efekcie adres podsuniętego kodu, który zostanie umieszczo-ny na stosie. W przykładzie adresem tym jest 0xbffff9d.

Aby skonstruować taką wartość, trzeba zapisać pod adresami umieszczonymi w ciąguformatującym następujące wartości:

97E6D9��-��2"97E6D9�G��-��97E6D9�G�1��-��97E6D9�G�/��-��*�

Można to wykonać przy użyciu omawianych wcześniej specyfikatorów określającychwypełnienie.

Przykładowo, aby zapisać pod adresem #$%&'# wartość 0x0000019d, należy umieścićw odpowiednim miejscu ciągu formatującego specyfikator �()�. Interesująca nas war-tość 9d zostanie dzięki temu zapisana w ostatnim bajcie odpowiedniego obszaru. Zapomocą specyfikatorów z określeniem wypełnienia i specyfikatorów zapisu do pamięcimożna skonstruować pełną postać adresu docelowego:

��11.@��3��&&�(��P��1��&&��21@��0��&&�(��P��1��&&��1A1@��3��&&�(��P��1��&&��21@��3��&&�(��P��1��&&��


Warto odnotować fakt, że wartości podawane w specyfikatorach wypełniających sąsilnie uzależnione od łącznej liczby znaków włączonych do wynikowego, sformatowa-nego ciągu. Jeżeli sformatowany ciąg jest prezentowany na zewnątrz, możliwe jest au-tomatyczne określenie liczby znaków wypełnienia.

Po nadpisaniu adresu powrotnego funkcji, funkcja �� zakończy swoje działanienormalnie, ale po powrocie z funkcji �� procesor rozpocznie wykonywaniekodu podstawionego przez atakującego. Rysunek 9.2 demonstruje efekt udanego ata-ku wykorzystującego ciąg formatujący.

Rysunek 9.2.Penetracja komputeraw wynikuprzeprowadzeniaataku ciąguformatującegona usługę rwhoisd

Oto kompletny kod programu atakującego:

&&��+��+�(P��&&��"��(=��"��;3;.;��(��5�@&/MA&&&&��"��+��"��(��+"�+,��Q��"��"��@*��M�M&&��"��"��Q��"�&&��"��+��@��(��NR�(S�(��N&&�=��)&&(((;��;��&��= �&�&111.3A

?��"��B��"�;=T?��"��B��";=T?��"��B��;=T?��"��B��&��;=T?��"��B��&��;=T?��"��B��&��;=T?��"��B��@&;=T

�@��

?"��>ICKLD��@A1A1A1A1�&&��*��"��U��(��VU��?"��97E6D9��@*��M�M�&&��"��W��*Q"��"��(��

�"��4��=��'��"��"��*��4��=��'��=��'��"4�""��=��'�� "��

��=��'�� !$��


��"4��"��

��""�4��""�4��

��(=��

��=��!3��$��&&�*��"*��=��!��$��&&�*��"�(��

��!�$��N-N��&&��"��"��(��!�$��N�N��!1$��N�N��!/$��N�N��!0$��N�N��&&�(��P��!3$��N�N��&&�(��P��!A$��N�N��&&�(��P��!.$��N�N��&&�(��P��

��'��'��G�M��>ICKLD��&&�(��VU��

��!�1$��N<�N�

��*��O��""�4��*��O��""�4��

��7>4ICD9��F�RX4F9ED7L��B��)�� *"��O��""�4��B��*")��

��;�4�""�;�4�""��4�""��1.;�;�;��;�4��=��0/1��;�4��7>4ICD9�

��O��""�4��B��)��

��(=��*��4��&&��4��(=��97E6D9��&&��+��,��+,��(��&&��(��P��,��"��(��

��(=��"��!�$��N<N��*��


��(��"�<��0��"��10��!��$��N�N�

��!�$��N�N��OO��!�$��NN��OO��!1$��N"N��'*��')��<�� *��(�"��Y<��

��@��

��"��*��4��=��'��=��'��&&��+��+��QU��-��&&��(��(��,��+,��

��"��

��"��3��&&��"��PW(��(��V��!��$��N<�N�

��(=��H��"��3��

��(��G��(��<��

��"��10��"��;<��@��-�� !��$��N<�N�

��

��(=��!��-��$�H��N<N��G��"��G��10��"��;<��@��-��


�� !��$��N<�N��"��"4�""��

��"4�""��=��'��&&��+��+��"��"��(�"��(��&&��(��+��(��=��P�(��&&��(��+,��,��+,��

��=��'��=��!��$��"��=��"��

��G�A�

��(=��'��H��N<�N��OO��'��H��N<N��'��N�N��OO��'��G��N@N��!��$��N<�N��=��C855��A��

��=��>ICKLD��'*��')��"��?�)��(��"��+;<��"��"�� G�� '��N�N��OO��'��G��N�N��G��&&��@�� GG�� "��

�"��4��=��'��&&��+��+��,��+,��&&��(��+,��"��"��(��&&��+,��(��P��)��&&��"�P�"��

��=��'�=��"��

��<@2�<@/�<@"*<@M2<@�/<@0/<@M2<@�*<@0�<@*�<@/�<@�"<@M�<@�*<@13<@3��<@M2<@�/<@M/<@�/<@��<@M2<@./<@1M<@/�<@��<@MM<@0/<@1.<@M2<@0/<@1��


��<@M/<@�M<@�3<@M"<@0*<@1M<@M"<@3/<@1�<@M2<@�/<@�"<@M�<@/�<@"*��<@/�<@��<@0�<@�"<@M�<@�M<@"A<@��<@��<@��&*&�=��

��G�M��@0��221��&&��+��+��*��

��'��'��G�M'��97E6D9��&&��"��W(�(�*��'��'��G��A'��97E6D9�G��'��'��G�10'��97E6D9�G�1��'��'��G�/1'��97E6D9�G�/��'��'��G�/A'��97E6D9�G�0��!/A$��N<�N�

��B��-��GG��@��1��&&��P��Z�"��"��"��(��

��&&��Z��+��+��Z��"�(��+�*��+�"��

��11.@��3��&&�(��P��1��&&��21@��0��&&�(��P��1��&&��1A1@��3��&&�(��P��1��&&��21@��3��&&�(��P��1��&&��

��=��"��=��"��&&�(��(��"��"��*��

��<��&&��[��,��(�+��

�"��&&��+��,"��+��&&��(P��=��-��

��"4��"��=��*��!��10$�

��>K4\DE��O�"��

��(=��>K4FD9��O�"��>K4FD9��O�"��G��O�"��C855��C855��C855��>K4IFFD9��O�"��*��*��*��*��*��-�1��"��(��*��*��


��>K4IFFD9��O�"��*��*��*��"��*��10��;<��@��

��*��!$��N<�N��*��

Podsumowanie

Błędy ciągów formatujących są jednymi z nowszych narzędzi hakerskiego warsztatu.

Techniki włamaniowe polegające na wykorzystywaniu błędów programistycznych stałysię w ciągu ostatnich kilku lat bardzo wyrafinowane. Jednym z powodów takiego stanurzeczy jest to, że po prostu większa liczba hakerów, a więc więcej par oczu analizujei wyszukuje słabości w kodach źródłowych wszelkich programów. Dzięki temu łatwiejdziś zdobyć informacje dotyczące istoty wszelkiego rodzaju luk oraz sposobu działaniaspecyficznych funkcji systemowych.

Generalnie włamywacze stosunkowo niedawno spostrzegli możliwości tkwiące w pro-stych i powszechnych błędach programistycznych. Funkcje z rodziny �� orazzwiązane z ich niepoprawnym stosowaniem błędy istniały od lat — ale do niedawnanikt nie zorientował się, że mogą one zostać wykorzystane nawet do uruchomienia nazdalnej maszynie dowolnego kodu. Wraz z atakami ciągów formatujących pojawiły sięinne nowe techniki, takie jak nadpisywanie struktur funkcji �� (nadpisywaniewskaźników przy wywołaniu ��) czy błędu indeksowania zmiennych całkowitychze znakiem.

Dzisiejsi włamywacze dokładnie wiedzą czego szukają i mają świadomość sposobu,w jaki nieistotne z pozoru błędy i przeoczenia programistów wpływają na podatnośćsystemu na ataki. Hakerzy zaglądają więc do każdego programu, obserwują jego re-akcje na wszelkie możliwe dane wejściowe. Dziś programiści muszą być bardziej niżkiedykolwiek wcześniej świadomi faktu, że praktycznie nie istnieją dopuszczalne błędy— nawet niewielki błąd, jeżeli nie zostanie w porę wyeliminowany, może być przy-czyną katastrofy. Administratorzy systemowi i użytkownicy muszą być zaś świadomitego, że w wykorzystywanym przez nich oprogramowaniu mogą czaić się błędy dziśnieznane, ale w przyszłości być może wystawiające system na zmasowane ataki.


Zagadnienia w skrócie

Istota błędów ciągów formatujących

� Błędy ciągów formatujących wynikają z nieświadomości programistów,dopuszczających przekazywanie danych wejściowych jako ciągów formatującychdo funkcji ��.

� Dzięki błędom ciągów formatujących atakujący może odczytywać i zapisywaćwybrane obszary pamięci procesu.

� Wykorzystanie luk związanych z ciągami formatującymi może doprowadzićdo wykonania dowolnego kodu w wyniku nadpisania adresów powrotnych,wpisów tablicy GOT, wskaźników funkcji i tak dalej.

Analiza podatnego programu

� Podatne programy wykorzystują zwykle funkcję �� i przekazują do niejjako ciąg formatujący dane pobrane z zewnętrznego źródła.

� Stosowanie „otoczki” dla funkcji �� powoduje często, że programiścizapominają o konieczności jawnego przekazania do takiej otoczki ciąguformatującego.

� Nieprawidłowe korzystanie z funkcji � �� to przyczyna dużej liczby znanychataków wykorzystujących ciągi formatujące, w tym ataków bardzo groźnychdla integralności węzłów internetowych.

Testowanie wykorzystujące przypadkowe ciągi formatujące

� Programy można testować pod kątem podatności na ataki ciągów formatującychza pomocą obserwacji ich reakcji na różnego rodzaju ciągi formatujące podawanena ich wejście.

� Umieściwszy w ciągu formatującym specyfikatory �, � czy �, możemyokreślić podatność programu na ataki ciągów formatujących, o ile ciąg wynikowykonstruowany przez funkcję �� prezentowany jest na zewnątrz. Niecotrudniej określić podatność programu, jeżeli ciągi wynikowe nie są zwracaneużytkownikowi.

� Obserwując dziwne zachowania procesu (załamanie, zawieszenie) w reakcjina specyfikatory � lub � podane na wejście programu, możemy z dużymprawdopodobieństwem zdiagnozować podatność programu na atakiwykorzystujące ciągi formatujące.

Atak z użyciem ciągu formatującego

� Możliwe jest konstruowanie takich ciągów formatujących, których podanie nawejście programu spowoduje odczyt lub zapis konkretnych obszarów pamięciatakowanego procesu. Luki związane z ciągami formatującymi nie są ściślezależne od platformy. Niektóre programy, takie jak Screen, można z powodzeniematakować niezależnie od platformy systemowo-sprzętowej, na której zostałyuruchomione.


� W przypadku programów, które prezentują na zewnątrz efekt konstrukcjiciągu sformatowanego atakujący może dokonywać odczytów sporych obszarówpamięci procesu i wykorzystywać zdobyte w ten sposób informacje w dalszychfazach ataków. Dzięki tej technice atakujący może wręcz zrekonstruowaćzawartość stosu procesu i określić konieczne do nadpisania adresu powrotnegofunkcji pozycje specyfikatorów �.

� Atakujący może dzięki ciągom formatującym przeforsować wielokrotne zapisyi w ten sposób umieścić w pamięci procesu dowolne wartości. Technika taumożliwia zapis dowolnej wartości w niemal dowolnym obszarze pamięciprocesu.

� Na platformach blokujących niewyrównane operacje zapisu (w procesorach RISCoperacja zapisu musi być wyrównana do dwóch bajtów) można zastosowaćspecyfikator ��, pozwalający na zapis w pamięci dwubajtowej zmiennej typu��*��.

Najczęściej zadawane pytania (FAQ)

Zamieszczone poniżej najczęściej zadawane pytania (FAQ), na które odpowiedzi udzieliliautorzy niniejszej książki, mają na celu zarówno sprawdzenie zrozumienia przez Czy-telnika przedstawionych w rozdziale zagadnień, jak i pomoc w przypadku praktycznegoich wykorzystania.

P: Czy systemy z niewykonywalną pamięcią stosu lub zabezpieczenia integralnościobszaru stosu takie jak StackGuard mogą zapobiec atakom wykorzystującymciągi formatujące?

O: Niestety nie. Błędy wynikające z niewłaściwego stosowania ciągów formatującychumożliwiają atakującemu przeforsowanie zapisów do niemal dowolnych obszarówpamięci. Mechanizm StackGuard zabezpiecza integralność danychprzechowywanych w ramce stosu, systemy blokujące wykonywanie koduna obszarze stosu udaremniają zaś próby uruchomienia kodu podsuniętego przezwłamywacza, o ile został on umieszczony na stosie. Błędy ciągów formatującychpozwalają hakerom na ominięcie obu tych zabezpieczeń. Dzięki możliwościzapisu wybranego obszaru pamięci haker niekoniecznie musi nadpisywać adrespowrotny funkcji — może nadpisać inne wskaźniki funkcji przechowywanepoza obszarem stosu (unika w ten sposób naruszenia jego integralności, którazostałaby wykryta przez StackGuarda) i umieścić kod ładunku na przykład nastercie. Zabezpieczenia takie jak StackGuard i niewykonywalny obszar stosumogą uniemożliwić przeprowadzanie powszechnie znanych, publikowanychataków, jednakże nie mogą powstrzymać utalentowanego i odpowiedniozdeterminowanego włamywacza.


P: Czy błędy tego rodzaju są charakterystyczne dla systemu Unix?

O: Nie. Powszechność błędów ciągów formatujących w systemach uniksowychwynika z częstego stosowania w oprogramowaniu dla tych systemów funkcji��. Również błędy powodowane nieprawidłowym stosowaniem funkcji� �� są charakterystyczne dla Uniksa. Zasadniczo jednak możliwośćprzeprowadzenia ataku wykorzystującego ciąg formatujący uzależniona jestod tego, czy implementacja standardowych bibliotek C dla danej platformyobsługuje specyfikatory � funkcji ��. Jeżeli dana implementacjaobsługuje ten specyfikator, każdy program konsolidowany z biblioteką libcobarczony błędem ciągu formatującego może zostać wykorzystany doprzeprowadzenia ataku skutkującego wykonaniem dowolnego kodu.

P: Jak mogę odnaleźć luki związane z ciągami formatującymi?

O: Znaczna część tego rodzaju słabości może być w prosty sposób wychwyconapodczas analizy kodu źródłowego. Analizę taką można zautomatyzować: polegaona bowiem na kontrolowaniu listy parametrów przekazywanych do wszelkichwywołań funkcji ��. Każda z funkcji z rodziny �� wywoływanaz jednym parametrem jest potencjalnym obiektem ataku (o ile przekazywanedo niej dane pochodzą bezpośrednio od użytkownika).

P: Jak mogę wyeliminować albo chociaż ograniczyć ryzyko występowaniaw stosowanym przeze mnie oprogramowaniu niewykrytych luk związanychz ciągami formatującymi?

O: Na początek warto opracować i wdrożyć odpowiednią politykę bezpieczeństwa.Bazując na modelu minimalnych uprawnień musisz upewnić się, że wszelkieniezbędne narzędzia systemowe zainstalowane z bitem setuid są dostępnewyłącznie dla ograniczonej i zaufanej grupy użytkowników. Należy też zablokowaćdostęp do zbędnych usług systemowych lub je wyłączyć.

P: Czy istnieją jakieś symptomy, na podstawie których mogę określić, czy ktośpróbuje włamać się do mojego systemu z użyciem ciągów formatujących?

O: To bardzo istotne pytanie, ponieważ wiele błędów ciągów formatujących opierasię na niepoprawnym wykorzystaniu funkcji � ��. Kiedy podejmowane sąpróby wykorzystania takich błędów, ciągi konstruowane na podstawie ciągówformatujących zapisywane są w systemowych plikach dziennika. Administratormoże na podstawie analizy zawartości tych plików zidentyfikować próby atakówwykorzystujących ciąg formatujący — pojawiają się one w dzienniku jako dziwniewyglądające, często bezsensowne (zawierające litery i cyfry) komunikaty. Innymi,nieco mniej wyraźnymi wskazówkami mogą być częste załamania, zawieszenialub inne niepoprawne zachowania demonów usług wynikające z naruszeniamechanizmów ochrony pamięci.

P: Gdzie mogę znaleźć więcej informacji na temat ataków ciągów formatujących?

O: Tematyce tej poświęcono szereg świetnych publikacji. Autorem jednej z nichjest Tim Newsham — jego artykuł opublikowany na łamach Guardent dostępnyjest pod adresem www.securityfocus.com/arcive/1/81565. Autorzy polecają równieżlekturę artykułów publikowanych przez TESO (www.team-teso.net/articles/formatstring) oraz HERT (www.hert.org/papers/format.html).

PRZYK ADOWY ROZDZIA Hack Proofing · Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel....

Documents

Transcript of PRZYK ADOWY ROZDZIA Hack Proofing · Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel....