Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00699 010497 11036744 na godz. na dobę w sumie
Strażnik bezpieczeństwa danych - książka
Strażnik bezpieczeństwa danych - książka
Autor: , Liczba stron: 608
Wydawca: Helion Język publikacji: polski
ISBN: 83-7361-513-X Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> hacking >> bezpieczeństwo systemów
Porównaj ceny (książka, ebook, audiobook).

Poznaj swojego napastnika

Nietrudno znaleźć książkę o bezpieczeństwie komputerów -- wielu użytkowników i administratorów czuje się przytłoczonych liczbą tego rodzaju publikacji. Jednak z każdym nowym programem wykorzystującym słabości systemów komputerowych wzrasta stopień wyrafinowania ataków na nie.

Każdy administrator musi być świadomy różnego rodzaju zagrożeń związanych z jego komputerem, jak np. istnienie trojanów -- niewinnie wyglądających programów szpiegowskich wysyłających informacje o poczynaniach użytkownika, wykorzystanie reinżynierii oprogramowania czy ataków z użyciem SQL.

'Strażnik bezpieczeństwa danych' mówi o tym, co najgorszego może spotkać użytkownika komputera. Jej autorzy wyznają zasadę, że aby skutecznie się bronić, należy jak najlepiej zrozumieć napastnika. Obejmuje ona szeroki zakres tematów, począwszy od reinżynierii oprogramowania, poprzez ataki na systemy operacyjne, a skończywszy na socjotechnice -- wszystko po to, aby poznać wroga i przygotować się do walki.
'Strażnik bezpieczeństwa danych' jest najbardziej wyczerpującą i najbardziej aktualną książką opisującą sztukę wirtualnych wojen -- ataków wymierzonych w systemy komputerowe oraz obrony przed nimi.

Jeżeli znajdujesz się na linii frontu, broniąc swoich sieci przed atakami,
na pewno będziesz potrzebował tej książki.

O autorach:
Cyrus Peikari jest autorem kilku książek poświęconych bezpieczeństwu systemów komputerowych i często bierze czynny udział w konferencjach dotyczących tego zagadnienia. [więcej...\

Cyrus Peikari specjalizuje się w wykrywaniu włamań, zabezpieczaniu sieci i systemów oraz wykrywaniu ich słabych punktów. [więcej...\

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

IDZ DO IDZ DO PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ SPIS TREĎCI SPIS TREĎCI KATALOG KSI¥¯EK KATALOG KSI¥¯EK KATALOG ONLINE KATALOG ONLINE ZAMÓW DRUKOWANY KATALOG ZAMÓW DRUKOWANY KATALOG TWÓJ KOSZYK TWÓJ KOSZYK DODAJ DO KOSZYKA DODAJ DO KOSZYKA CENNIK I INFORMACJE CENNIK I INFORMACJE ZAMÓW INFORMACJE ZAMÓW INFORMACJE O NOWOĎCIACH O NOWOĎCIACH ZAMÓW CENNIK ZAMÓW CENNIK CZYTELNIA CZYTELNIA FRAGMENTY KSI¥¯EK ONLINE FRAGMENTY KSI¥¯EK ONLINE Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl Stra¿nik bezpieczeñstwa danych Autorzy: Cyrus Peikari, Anton Chuvakin T³umaczenie: Witold Zio³o (przedmowa, rozdz. 1 – 10), Marek Pêtlicki (rozdz. 11 – 17), S³awomir Dzieniszewski (rozdz. 18 – 22, dod. A) ISBN: 83-7361-513-X Tytu³ orygina³u: Security Warrior Format: B5, stron: 606 Poznaj swojego napastnika Nietrudno znaleĥæ ksi¹¿kê o bezpieczeñstwie komputerów — wielu u¿ytkowników i administratorów czuje siê przyt³oczonych liczb¹ tego rodzaju publikacji. Jednak z ka¿dym nowym programem wykorzystuj¹cym s³aboġci systemów komputerowych wzrasta stopieñ wyrafinowania ataków na nie. Ka¿dy administrator musi byæ ġwiadomy ró¿nego rodzaju zagro¿eñ zwi¹zanych z jego komputerem, jak np. istnienie trojanów — niewinnie wygl¹daj¹cych programów szpiegowskich wysy³aj¹cych informacje o poczynaniach u¿ytkownika, wykorzystanie rein¿ynierii oprogramowania czy ataków z u¿yciem SQL. „Stra¿nik bezpieczeñstwa danych” mówi o tym, co najgorszego mo¿e spotkaæ u¿ytkownika komputera. Jej autorzy wyznaj¹ zasadê, ¿e aby skutecznie siê broniæ, nale¿y jak najlepiej zrozumieæ napastnika. Obejmuje ona szeroki zakres tematów, pocz¹wszy od rein¿ynierii oprogramowania, poprzez ataki na systemy operacyjne, a skoñczywszy na socjotechnice -- wszystko po to, aby poznaæ wroga i przygotowaæ siê do walki. „Stra¿nik bezpieczeñstwa danych” jest najbardziej wyczerpuj¹c¹ i najbardziej aktualn¹ ksi¹¿k¹ opisuj¹c¹ sztukê wirtualnych wojen — ataków wymierzonych w systemy komputerowe oraz obrony przed nimi. O autorach: Doktor Cyrus Peikari jest za³o¿ycielem firmy Airscanner Corporation, producenta narzêdzi do zabezpieczania sieci bezprzewodowych. Jest autorem kilku ksi¹¿ek poġwiêconych bezpieczeñstwu systemów komputerowych i czêsto bierze czynny udzia³ w konferencjach dotycz¹cych tego zagadnienia. Zajmuje siê równie¿ zabezpieczeniami w InformIT.com. Doktor Anton Chuvakin jest starszym analitykiem do spraw zabezpieczeñ, pracuje w firmie netForensics. Specjalizuje siê w wykrywaniu w³amañ, zabezpieczaniu sieci i systemów oraz wykrywaniu ich s³abych punktów. Jest autorem wielu artyku³ów dotycz¹cych zabezpieczania sieci i komputerów. Je¿eli znajdujesz siê na linii frontu, broni¹c swoich sieci przed atakami, na pewno bêdziesz potrzebowa³ tej ksi¹¿ki. Spis treści Przedmowa .......................................................................................................................11 Część I Łamanie programów...................................................m...............17 Rozdział 1. Asembler......................................................................................................19 .............................20 Rejestry ...................................................0...................................................0................. ..................23 Rozkazy asemblera...................................................0...................................................0........ Źródła dodatkowych informacji...................................................0.......................................................24 Rozdział 2. Reinżynieria oprogramowania systemu Windows ............................25 Historia reinżynierii oprogramowania ...................................................0...........................................27 Narzędzia reinżynierii oprogramowania ...................................................0.......................................27 Przykłady reinżynierii oprogramowania...................................................0........................................39 Źródła dodatkowych informacji...................................................0.......................................................47 Rozdział 3. Reinżynieria oprogramowania systemu Linux...................................49 Podstawowe narzędzia i techniki ...................................................0....................................................50 Dobra deasemblacja...................................................0...................................................0.........................71 Trudności ...................................................0...................................................0..........................................84 Pisanie nowych narzędzi...................................................0...................................................0................89 Źródła dodatkowych informacji...................................................0.....................................................129 Rozdział 4. Reinżynieria oprogramowania systemu Windows CE ...................131 Architektura systemu Windows CE ...................................................0..............................................132 Podstawy reinżynierii oprogramowania systemu Windows CE.................................................137 Reinżynieria oprogramowania Windows CE w praktyce ...................................................0.........145 Reinżynieria programu serial.exe ...................................................0..................................................161 Źródła dodatkowych informacji...................................................0.....................................................174 6 Spis treści Rozdział 5. Ataki przepełnienia bufora....................................................................175 Przepełnienie bufora ...................................................0...................................................0..... ................175 Wyjaśnienie pojęcia bufora ...................................................0.............................................................177 Uderzenie w stos...................................................0...................................................0......... ...................179 Przepełnienie sterty ...................................................0...................................................0.......................180 Zapobieganie przepełnieniom bufora ...................................................0...........................................180 Przepełnienie bufora w praktyce ...................................................0...................................................182 Źródła dodatkowych informacji...................................................0.....................................................189 Część II Polowanie w sieci ...................................................m...............191 Rozdział 6. Protokoły TCP/IP ...................................................................................193 Krótka historia TCP/IP...................................................0...................................................0... ..............193 Enkapsulacja...................................................0...................................................0...................................194 Protokół TCP ...................................................0...................................................0............. .....................195 ........................197 Protokół IP ...................................................0...................................................0.............. ....................199 Protokół UDP ...................................................0...................................................0............. ....................199 Protokół ICMP...................................................0...................................................0............ Protokół ARP...................................................0...................................................0............. .....................200 ...................200 Protokół RARP ...................................................0...................................................0............ .................201 Protokół BOOTP ...................................................0...................................................0........... Protokół DHCP ...................................................0...................................................0............ ..................201 Uzgadnianie TCP/IP...................................................0...................................................0....... ..............201 .....................203 Ukryte kanały...................................................0...................................................0............ ......................203 Protokół IPv6 ...................................................0...................................................0............ Ethereal...................................................0...................................................0................. ...........................205 Analiza pakietów...................................................0...................................................0......... ..................206 Fragmentacja...................................................0...................................................0............. ......................208 Źródła dodatkowych informacji...................................................0.....................................................214 Rozdział 7. Socjotechnika ...........................................................................................215 Podstawy...................................................0...................................................0.........................................216 Prowadzenie ataków...................................................0...................................................0....... ..............218 Zaawansowana socjotechnika...................................................0.........................................................226 Źródła dodatkowych informacji...................................................0.....................................................228 Rozdział 8. Rekonesans ...............................................................................................229 Rekonesans online ...................................................0...................................................0.........................229 Wnioski...................................................0...................................................0.................. ..........................242 Źródła dodatkowych informacji...................................................0.....................................................242 Spis treści 7 Rozdział 9. Rozpoznawanie systemów operacyjnych ..........................................243 Ustanowienie sesji telnet ...................................................0...................................................0..............243 Rozpoznawanie stosu TCP...................................................0...................................................0...........244 Narzędzia specjalizowane ...................................................0...................................................0............247 Pasywne rozpoznawanie systemów operacyjnych ...................................................0.....................247 Nieostre rozpoznawanie systemów operacyjnych...................................................0......................251 Rozpoznawanie systemu operacyjnego na podstawie wartości czasu oczekiwania TCP/IP ....253 Źródła dodatkowych informacji...................................................0.....................................................254 Rozdział 10. Zacieranie śladów .................................................................................255 Przed kim należy się ukrywać?...................................................0......................................................255 Zacieranie śladów po ataku ...................................................0............................................................256 Ukrywanie się przed środkami dochodzeniowymi...................................................0....................262 Utrzymanie dostępu...................................................0...................................................0....... ...............268 Źródła dodatkowych informacji...................................................0.....................................................275 Część III Ataki na systemy ...................................................m...............277 Rozdział 11. Obrona systemu Unix...........................................................................279 Hasła ...................................................0...................................................0................................................280 Dostęp do plików ...................................................0...................................................0......... .................284 Dzienniki systemowe ...................................................0...................................................0....................287 Sieciowy dostęp do systemów Unix...................................................0..............................................291 Wzmacnianie Uniksa...................................................0...................................................0.....................296 Obrona sieci uniksowej...................................................0...................................................0.................313 Serwer Apache ...................................................0...................................................0...............................319 Źródła dodatkowych informacji...................................................0.....................................................328 Rozdział 12. Ataki na system Unix...........................................................................331 ......................331 Ataki lokalne ...................................................0...................................................0............ Ataki zdalne...................................................0...................................................0............. .......................340 Ataki blokady usług...................................................0...................................................0......................357 Źródła dodatkowych informacji...................................................0.....................................................365 Rozdział 13. Ataki na systemy klienckie Windows..............................................367 Ataki blokady usług...................................................0...................................................0......................367 Ataki zdalne...................................................0...................................................0............. .......................377 Zdalny pulpit i zdalna pomoc ...................................................0........................................................380 Źródła dodatkowych informacji...................................................0.....................................................385 8 Spis treści Rozdział 14. Ataki na serwery Windows.................................................................387 Historia wersji ...................................................0...................................................0.......... ......................387 Ataki na mechanizm uwierzytelniania Kerberos ...................................................0........................388 Omijanie ochrony przed przepełnieniem bufora ...................................................0........................393 Słabości mechanizmu Active Directory ...................................................0........................................394 Łamanie zabezpieczeń PKI ...................................................0...................................................0. .........396 Łamanie zabezpieczeń kart elektronicznych...................................................0................................397 Szyfrowany system plików...................................................0...................................................0. .........400 Zewnętrzne narzędzia szyfrujące...................................................0...................................................402 Źródła dodatkowych informacji...................................................0.....................................................405 Rozdział 15. Bezpieczeństwo usług WWW opartych na protokole SOAP.......407 ................408 Szyfrowanie XML ...................................................0...................................................0.......... Podpisy cyfrowe XML ...................................................0...................................................0...... ............410 Źródła dodatkowych informacji...................................................0.....................................................411 Rozdział 16. Ataki za pomocą wymuszeń kodu SQL...........................................413 Wprowadzenie do języka SQL ...................................................0.......................................................413 Ataki wymuszeń kodu SQL...................................................0...................................................0.. .......417 Obrona przed wymuszeniami kodu SQL...................................................0.....................................424 Przykłady PHP-Nuke...................................................0...................................................0....... .............428 Źródła dodatkowych informacji...................................................0.....................................................431 Rozdział 17. Bezpieczeństwo sieci bezprzewodowych .........................................433 Redukcja rozproszenia sygnału...................................................0......................................................433 Problemy z WEP ...................................................0...................................................0........... .................435 Łamanie zabezpieczeń WEP ...................................................0...................................................0. .......435 Łamanie zabezpieczeń WEP w praktyce ...................................................0......................................441 Sieci VPN.............................................0...................................................0...............................................442 TKIP ...................................................0...................................................0..................... ............................443 ..............................444 SSL...................................................0...................................................0...................... Wirusy bezprzewodowe...................................................0...................................................0..... ..........444 Źródła dodatkowych informacji...................................................0.....................................................449 Część IV Zaawansowane techniki obrony ........................................451 Rozdział 18. Analiza śladów w systemie audytowania ......................................453 Podstawy analizy dzienników...................................................0........................................................454 Przykłady dzienników...................................................0...................................................0..... .............454 Stany rejestrowane w dziennikach ...................................................0................................................464 Spis treści 9 Kiedy zaglądać do dzienników? ...................................................0....................................................465 Przepełnienie dzienników i ich agregacja...................................................0.....................................467 Wyzwania związane z analizą dzienników ...................................................0.................................468 Narzędzia do zarządzania informacjami bezpieczeństwa...................................................0.........469 Globalna agregacja dzienników ...................................................0.....................................................469 Źródła dodatkowych informacji...................................................0.....................................................470 Rozdział 19. Systemy detekcji włamań ....................................................................471 Przykłady systemów IDS ...................................................0...................................................0... ..........472 Zastosowanie analizy Bayesowskiej ...................................................0..............................................478 Sposoby oszukiwania systemów IDS ...................................................0............................................484 Przyszłość systemów IDS...................................................0...................................................0.. ...........486 Przypadek systemu IDS Snort...................................................0........................................................489 Błędy związane z rozmieszczaniem systemów IDS...................................................0......................494 Źródła dodatkowych informacji...................................................0.....................................................496 Rozdział 20. Słoiki miodu ...........................................................................................497 ........................499 Motywy ...................................................0...................................................0................... ...........499 Budowanie infrastruktury...................................................0...................................................0. Przechwytywanie ataków ...................................................0...................................................0... .........511 Źródła dodatkowych informacji...................................................0.....................................................512 Rozdział 21. Reagowanie na incydenty....................................................................513 Przykład z życia: chaos z powodu robaka ...................................................0...................................513 Definicje...................................................0...................................................0...........................................514 Podstawowy schemat reagowania na incydenty ...................................................0........................517 ..........................521 Małe sieci...................................................0...................................................0............... Sieci średnich rozmiarów ...................................................0...................................................0. ............528 Duże sieci ...................................................0...................................................0........................................530 Źródła dodatkowych informacji...................................................0.....................................................535 Rozdział 22. Zbieranie i zacieranie śladów.............................................................537 Podstawowe informacje o komputerach...................................................0.......................................538 Odpadki informacji ...................................................0...................................................0.......................540 Narzędzia do zbierania śladów...................................................0......................................................541 Narzędzia śledcze na rozruchowych dyskach CD-ROM...................................................0...........547 Evidence Eliminator ...................................................0...................................................0......................551 Przykład procedury zbierania dowodów: atak na serwer FTP...................................................0.559 Źródła dodatkowych informacji...................................................0.....................................................569 10 Spis treści Dodatki...................................................m..................................................571 Dodatek A Przydatne polecenia SoftICE i lista punktów wstrzymania..........573 ...................573 ...............577 Polecenia SoftICE...................................................0...................................................0........ Kody wstrzymania ...................................................0...................................................0......... Skorowidz .......................................................................................................................581 Ataki przepełnienia bufora Atakowanie aplikacji jest podstawową techniką, którą stosują inżynierowie badający sła- be punkty programów. W ten sposób oszczędzają firmie niepotrzebnych wydatków i nie narażają jej dobrego imienia na szwank, wykrywając zawczasu słabe punkty progra- mów. W tym rozdziale dokonamy przeglądu różnych technik atakowania aplikacji, wy- korzystując zdobyte wcześniej wiadomości z zakresu reinż ynierii oprogramowania. Przepełnienie bufora Aby dokonać ataku przepełnienia bufora, potrzebna jest bardzo dobra znajomość asemblera, C++ i atakowanego systemu operacyjnego. W tym podrozdziale opiszemy ataki przepełnie- nia bufora, prześledzimy ich ewolucję i zademonstrujemy przykład takiego ataku. Przepełnienie bufora (ang. buffer overflow) polega na podaniu programowi większej liczby da- nych, niż to przewidział twórca programu. Nadmiarowe dane przekraczają obszar pamięci, który został przeznaczony dla danych, a tym samym wkraczają w obszar pamięci, który był przeznaczony na instrukcje programu. W idealnej wersji tego ataku nadmiarowe dane są nowymi instrukcjami, które umożliwiają napastnikowi sterowanie pracą procesora. Ataki przepełnienia bufora nie są niczym nowym, już w 1988 roku robak Morris wykorzy- stywał tę technikę. Samo zagrożenie dla bezpieczeństwa systemów komputerowych, spo- wodowane przepełnieniem bufora, znane jest od lat 60. ubiegłego wieku. Przykład przepełnienia bufora Możliwość przepełniania bufora bierze się z wrodzonej słabości języka C++. Problem, który został odziedziczony z języka C i który dotyczy również innych języków progra- mowania, takich jak Fortran, polega na tym, że C++ nie kontroluje automatycznie długości 176 Rozdział 5. Ataki przepełnienia bufora podawanych programowi danych. Aby to lepiej zrozumieć, posłużmy się przykładem kodu przedstawiającego, jak funkcje C/C++ zwracają dane programowi głównemu: // lunch.cpp : Przepełnienie bufora stomach #include stdafx.h #include stdio.h #include string.h void bigmac(char *p); int main(int argc, char *argv[]) { bigmac( Could you supersize that please? ); // przepełnienie spowoduje : : wpisane 9 znaków return 0; } void bigmac(char *p) { char stomach[10]; //ograniczamy rozmiar bufora do 10 znaków strcpy(stomach, p); printf(stomach); } Aby sprawdzić działanie programu, należy skompilować go za pomocą kompilatora C++. Chociaż kompilacja przebiegnie bez przeszkód, wykonywanie uruchomionego programu załamie się, co przedstawiono na rysunku 5.1. Rysunek 5.1. Załamanie programu na skutek przepełni.enia bufora Co się stało? Po uruchomieniu programu, funkcji bigmac przekazywany jest długi łańcuch znaków „Could you supersize that please?”. Niestety funkcja strcpy() nie sprawdza długości kopiowanych łańcuchów. Jest to bardzo niebezpieczne, gdyż przekazanie funk- cji łańcucha o długości większej niż dziewięć znaków powo duje przepełnienie bufora. Funkcja strcpy(), podobnie jak kilka innych funkcji języka C++, ma istotną wadę, która powoduje, że nadmiarowe znaki są wpisywane do obszaru pamięci leżącego poza zmienną. Z reguły powoduje to załamanie się programu. W tym konkretnym przypadku załamanie programu spowodowała próba czytania poza granicą statycznego łańcucha. Wyjaśnienie pojęcia bufora 177 W najgorszym przypadku tego rodzaju przepełnienie umożliwia wykonanie w zaata- kowanym systemie dowolnego kodu, o czym powiemy w d alszej części rozdziału. Wyjaśnienie pojęcia bufora Podatność na przepełnienie bufora jest najczęściej wykorzystywaną luką w systemie bez- pieczeństwa. Aby zrozumieć, jak kraker wykorzystuje przepełnienie bufora do wniknięcia lub załamania pracy komputera, należy zrozumieć, czym jest bufor. W podrozdziale wyjaśniamy, co to jest bufor. Zaawansowani czytelnicy mogą przejść do następnego podrozdziału „Uderzenie w stos”. Program komputerowy składa się kodu, który korzysta ze zmiennych zapisanych w róż- nych miejscach pamięci. Podczas wykonywania się programu zmiennym przydzielana jest pamięć, a jej ilość zależy od rodzaju informacji, które ma przechowywać zmienna. Na przykład dane typu Short Integer zajmują niewiele miejsca w pamięci RAM, natomiast dane Long Integer zajmują go więcej. Istnieją różne rodzaje zmiennych, a każdy rodzaj może potrzebować innej ilości pamięci. Przestrzeń zarezerwowana w pamięci dla zmien- nej jest używana do przechowywania informacji niezbędnych do wykonywania się pro- gramu. Program przechowuje w tym obszarze pamięci zawartość zmiennej i w razie potrzeby pobiera ją stamtąd. Ta wirtualna przestrzeń n azywana jest buforem. Dobrą analogią bufora jest kolekcja płyt CD przechowywana w stojaku z — dajmy na to — 300 przegródkami. Pamięć komputera jest podobna do takiego stojaka, choć oczywi- ście liczba przegródek, w których komputer umieszcza informacje, jest liczona w milio- nach. Płyty z naszego zbioru należą do trzech kategorii — staroci, klasyki i popu (rysu- nek 5.2). Logicznie podzielmy stojak na trzy równe części. Dolne 100 przegródek stojaka CD będzie mieścić starocie, środkowe — klasykę, a górne — pop. Każda przegródka stojaka otrzyma własny numer. Na podstawie numeru przegródki wiadomo, gdzie zaczy- nają się i kończą płyty każdej kategorii. Rysunek 5.2. Podzielony na części stojak jest podobn.y do bufora 178 Rozdział 5. Ataki przepełnienia bufora Pamięć komputera wygląda bardzo podobnie. Gdy program jest ładowany, przydziela wszystkim zmiennym, których ma używać, fragmenty pamięci. Jedna zmienna progra- mu może zajmować kilka przegródek w pamięci. Taka sama sytuacja ma miejsce rów- nież w przypadku płyt CD — żeby umieścić w stojaku czteropłytowy album z utworami Bacha, należy użyć czterech kolejnych przegródek. Ta część pamięci nazywa się buforem. Mówiąc prosto, bufor to fragment pamięci komputera, który program zarezerwował na zawartość zmiennej, aby w razie potrzeby móc ją stamtąd pobierać. Mając już ogólne pojęcie o buforze, wyjaśnijmy, na czym polega jego przepełnienie. Wyja- śnieniu towarzyszy rysunek 5.3, na którym widać przegródki stojaka przeznaczone na starocie (1 – 100) oraz klasykę (101 – 200). Załóżmy teraz, że jest to kolekcja płyt kolegi, a ponieważ nie lubimy ani staroci, ani klasyki, ani popu, chcemy zmusić kolegę, żeby za- grał naszą płytę CD z muzyką rockową. Rysunek 5.3. Przykład przepełnienia bufora Co wiemy o organizacji płyt na stojaku CD kolegi? Wiemy, że przegródki stojaka są po- dzielone następująco: 1 – 100, 101 – 200, 201 – 300. Sekcja staroci (1 – 100) jest już prawie wypełniona i ma tylko cztery wolne przegródki (97 – 100), natomiast sekcja klasyki po- zostaje zupełnie pusta. Możemy teraz dać koledze zestaw pięciu płyt Barry’ego Manilo- wa (dla potrzeb przykładu załóżmy, że to kategoria starocie), w którym w miejscu piątej płyty przemyciliśmy płytę rockową. Jeśli kolega, wkładając płyty do stojaka, nie zwraca uwagi na numery przegródek, naszą płytę rockową umieści w przegródce 101. Teraz wystarczy poprosić kolegę, by zagrał coś z kolekcji płyt z muzyką klasyczną. Kolega sprawdzi numery przegródek, stwierdzi, że w sekcji z muzyką klasyczną znajduje się jed- na płyta, wyjmie ją i umieści w odtwarzaczu. Ku swojemu zdziwieniu zamiast muzyki Beethovena usłyszy muzykę rockową. W bardzo podobny sposób haker dokonuje ataku przepełnienia bufora w komputerze. Naj- pierw musi znaleźć działający program, który jest podatny na przepełnienie bufora. Na- wet gdy działanie hakera nie zakończy się uruchomieniem szkodliwego kodu, z pewno- ścią doprowadzi do załamania programu. Haker musi też znać dokładny rozmiar bufora, który będzie chciał przepełnić. W przypadku stojaka z płytami CD wystarczyło podaro- wać przyjacielowi pięć płyt CD, z których jedna przepełniła segment staroci. W przy- padku komputerów czasem bywa to równie proste. Uderzenie w stos 179 Dobrze napisany program nie pozwoli sobie na przepełnienie bufora — to tak, jakby użyć trzech różnych stojaków na płyty CD po sto przegródek każdy, a nie jednego stoja- ka o trzystu przegródkach. Gdyby kolega z przykładu miał trzy różne stojaki, zauwa- żyłby, że kolekcja staroci zawiera o jedną płytę za dużo, i podjąłby odpowiednie działa- nia, które prawdopodobnie doprowadziłyby do odkrycia przemyconej w zestawie płyty z muzyką rockową. Drugim etapem ataku przepełnienia bufora jest wykonanie dostarczonego kodu (ładun- ku). Ładunkiem jest zwykle polecenie umożliwiające zdalny dostęp do zaatakowanego komputera lub inne polecenie ułatwiające hakerowi przejęcie komputera. Na przykład serwer Internet Information Server firmy Microsoft miał słaby punkt umożliwiający na- pastnikowi utworzenie kopii dowolnego pliku i umieszczenie jej w części dostępnej przez WWW. Plikiem tym mogło być wszystko, co umożliwiało zdalny dostęp — począwszy od pliku haseł, a skończywszy na pliku programu. Przeprowadzenie skutecznego ataku przepełnienia bufora jest trudne. Jednak nawet wte- dy, gdy atak przepełnienia bufora nie powiedzie się do końca, najczęściej i tak spowo- duje problemy w atakowanym komputerze. Zwykle polegają one na załamaniu się działa- nia zaatakowanego programu lub nawet całego systemu. Program, do którego należała zajęta w wyniku ataku pamięć, nie sprawdza, czy jej zawartość nie zmieniła się, dlatego użyje jej, zakładając, że jest to ta sama zawartość, z której korzystał ostatnio. Gdy na przykład zechce odczytać liczbę używaną do dalszych obliczeń, a zamiast niej otrzyma wyraz „Bob”, nie będzie wiedział, co z nim począć. Uderzenie w stos W tym podrozdziale opiszemy mechanizm typowego przepełnienia bufora. Na rysunku 5.4 przedstawiono widok stosu po wywołaniu funkcji. Wskaźnik stosu wskazuje na wierz- chołek stosu znajdujący się u dołu rysunku. Rysunek 5.4. Wygląd stosu po wywołaniu funkcji 180 Rozdział 5. Ataki przepełnienia bufora C++ umieszcza na stosie następujące dane — zmienne lokalne, wskaźnik poprzedniej ramki, adres powrotu oraz argumenty funkcji. Dane te nazywane są ramką funkcji i reprezentują stan funkcji. Wskaźnik ramki lokalizuje bieżącą ramkę, a wskaźnik poprzedniej ramki przechowuje wskaźnik ramki funkcji, która wywołała da ną funkcję. Gdy napastnik przepełni bufor znajdujący się na stosie (podając więcej danych, niż może on przyjąć), bufor powiększy się w kierunku leżącego na stosie adresu powrotu. Celem hakera jest zmiana tego adresu. Gdy działanie funkcji kończy się, adres powrotu pobie- rany jest ze stosu, po czym następuje skok pod ten adres. Zmieniając adres powrotu, ha- ker może przejąć kontrolę nad procesorem. Jeżeli zmieniony adres powrotu będzie wska- zywał na szkodliwy kod umieszczony w przepełnionym buforze, kod zostanie wykonany z uprawnieniami zaatakowanego programu. Przepełnienie sterty Z powodu szerokiego nagłośnienia problemu oraz w wyniku stosowania technik prewen- cyjnych, omawianych w dalszej części rozdziału, ataki przepełnienia bufora stają się coraz rzadsze. W efekcie mamy coraz częściej do czynienia z ata kami przepełnienia sterty. Stertą (ang. heap) nazywamy obszar pamięci dynamicznie przydzielonej aplikacji w celu przechowywania w niej zmiennych. W ataku przepełnienia sterty haker usiłuje zmienić zawartość takich zmiennych, jak hasła, nazwy plików oraz identyfikatory UID znajdują- ce się na stercie. Jaka jest różnica między przepełnieniem bufora a przepełnieniem sterty? W przypadku przepełnienia bufora zmiana zawartości adresu powrotu znajdującego się na stosie oznacza próbę wykonania określonych instrukcji maszynowych. W przypadku przepeł- nienia sterty zmiana zawartości zmiennych dynamicznych oznacza próbę podniesienia poziomu uprawnień w systemie. Programy stosujące przepełnienie sterty wykorzystują błędy formatów oraz atakują funkcje malloc( ) i free( ). Badacze zaczęli wyróżniać osobną klasę przepełnień nazywaną błędami formatów (ang. format bugs). Słabym punktem języka C jest istnienie specyfikatora formatu n, który ka- że funkcji printf zapisać do podanego funkcji argumentu typu int * liczbę sformatowa- nych do tej pory bajtów. Mechanizm ten można wykorzystać, gdy program nie filtruje otrzymywanych od użytkownika danych, używanych jako pierwszy argument funkcji printf. Mechanizm varargs języka C++ umożliwia funkcjom (np. funkcji printf) używa- nie zmiennej liczby argumentów. Funkcje pobierają ze stosu tyle argumentów (i takiego typu), ile określa pierwszy argument funkcji printf. Problemowi temu można zapobiec, używając zamiast funkcji printf(buf)funkcji printf( s , buf). Zapobieganie przepełnieniom bufora Najlepszym sposobem, by uniemożliwić ataki przepełnienia bufora, jest przestrzeganie przez programistę właściwych praktyk programowania. Na leżą do nich: Zapobieganie przepełnieniom bufora 181 • sprawdzanie wielkości danych przed umieszczeniem ich w buforze, • użycie funkcji ograniczających liczbę i (lub) format wpr owadzanych znaków, • unikanie niebezpiecznych funkcji języka C, takich jak scanf( ), strcpy( ), strcat( ), getwd( ), gets( ), strcmp( ), sprintf( ). Jak w praktyce zapobiegać przepełnianiu bufora? Programiści używają funkcji strcpy( ) kopiującej łańcuch źródłowy do bufora docelowego. Niestety bufor docelowy może nie być na tyle pojemny, by pomieścić łańcuch źródłowy. Gdy użytkownik wprowadzi bardzo długi łańcuch źródłowy, spowoduje przepełnienie bufora docelowego. Aby zapobiec tego rodzaju błędom, należy przed skopiowaniem każdego łańcucha źró- dłowego sprawdzać jego długość. Prostszym sposobem może być użycie funkcji strnc- py( ). Funkcja ta działa podobnie do funkcji strcpy( ), a różni się od niej tym, że ko- piuje tylko pierwszych n bajtów łańcucha źródłowego, co umożliwia ochronę przed przepełnianiem bufora. Zautomatyzowane badanie kodu Nie urodził się jeszcze programista, który nie popełnia błędów. Dlatego teraz zajmiemy się narzędziami, których zadaniem jest badanie podatności kodu na przepełnienie bufora. Jeszcze nie tak dawno brakowało skutecznych narzędzi do automatycznego badania kodu źródłowego pod kątem podatności na przepełnienie bufora. Uwzględnienie wszystkich możliwych przyczyn tego rodzaju błędów w programach liczących tysiące wierszy kodu jest bowiem niezwykle trudne. Jednym z komercyjnych programów służących do tego celu jest PolySpace (http://www. polyspace.com), zawierający narzędzie do wykrywania w czasie kompilacji możliwości przepełnienia bufora w programach napisanych w ANSI C. I choć moduł Viewer może działać w systemie Windows, to zasadniczy moduł Verifier wymaga użycia Linuksa. Programiści, którzy piszą tylko dla systemu Windows, ale chcą posłużyć się programem PolySpace, będą musieli przemóc się i zainstalować gdzieś system Linux. Wyniki działa- nia programu można analizować już w systemie Windows. Jeżeli ktoś jeszcze nie używa Linuksa, powinien zrobić to niezwłocznie — prawdziwy specjalista ds. bezpieczeństwa powinien z łatwością poruszać się w obu środowiskach. Jednak mając na uwadze za- twardziałych linuksofobów, firma PolySpace zaczęła przenosić motor programu Verifier do systemu Windows. Dodatki do kompilatora Dla Linuksa dostępne są dodatki do kompilatora C++ oraz biblioteki, które sprawdzają w czasie wykonywania się programu wielkość wprowadzanych danych. Przykładem te- go może być StackGuard (http://immunix.org), który wykrywa ataki uderzenia w stos, chroniąc przed zmianą adres powrotu funkcji. Podczas wywołania funkcji umieszcza on 182 Rozdział 5. Ataki przepełnienia bufora obok adresu powrotu bajty „przynęty”, natomiast podczas kończenia pracy funkcji sprawdza, czy przynęta została zmieniona. Jeżeli tak się stało, umieszcza zapis w dzien- niku zdarzeń systemu i kończy działanie programu. StackGuard jest zaimplementowany w postaci niewielkiej łatki na generator kodu kom- pilatora gcc, umieszczanej w procedurach function_prolog( ) i function_epilog( ). Używa funkcji function_prolog( )do ułożenia „przynęty” na stosie, a gdy funkcja kończy działanie, za pomocą funkcji function_epilog( ) bada stan „przynęty”. W ten sposób może wykryć każdą próbę uszkodzenia adresu powrotu jeszcze przed zakończe- niem działania funkcji. Innym przydatnym programem firmy immunix.org jest FormatGuard, który zabezpiecza przed błędami formatów. Wykorzystuje on cechę języka C++ polegającą na odróżnianiu makr o identycznych nazwach, ale różniących się liczbą argumentów. FormatGuard za- wiera definicje makr funkcji printf dla od jednego do stu argumentów. Każde z tych makr wywołuje bezpieczną osłonę, która zlicza w łańcuchu formatu liczbę znaków „ ” i od- mawia wywołania, gdy liczba argumentów nie odpowiada liczbie specyfikatorów . Żeby chronić program za pomocą FormatGuard, należy skompilować go, wykorzystując nagłówki glibc pochodzące z FormatGuard. FormatGuard jest osłoną funkcji libc: sys- log( ), printf( ), fprintf( ), sprintf( ), snprintf( ). Inne sposoby ochrony Inny sposób zapobiegający przepełnieniu bufora polega na uniemożliwianiu wykonywa- nia kodu w obszarze pamięci stosu i danych. Nie jest to co prawda kompletne rozwiąza- nie i napastnik wciąż może wykonać skok w nieprzewidziane miejsce, mimo to utrudnia znacznie wykonanie kodu. Rozwiązanie to dostępne jest w postaci łatki na system Linux. Dodatkową linię obrony mogą stanowić narzędzia kontrolujące rozmiar danych. W prze- ciwieństwie do C++, Perl i Java posiadają wbudowane mechanizmy kontroli długości danych, które zwalniają programistę od tworzenia własnych mechanizmów zabezpie- czających. Wykorzystując narzędzia dostępne w różnych systemach operacyjnych, w moż- liwość taką można wyposażyć również C++. Do narzędzi tego typu należą BOWall, Bo- undschecker firmy Compuware czy Purify firmy Rational. Przepełnienie bufora w praktyce Po zapoznaniu się z zagadnieniami związanymi z przepełnieniem bufora, pora przejść do przykładu umożliwiającego sprawdzenie zdobytej wiedzy na odpowiednim progra- mie testowym. W przykładzie posłużymy się programem typu crackme o nazwie weird.exe. Pro- gram można pobrać ze strony http://www.securitywarrior.com. Przepełnienie bufora w praktyce 183 Program stworzył Analyst, a prezentowany tu przykład opublikował +Tsehp, dzięki uprzejmości którego możemy go przedstawić. Uruchomiony w wierszu poleceń, pro- gram prosi o podanie numeru seryjnego (rysunek 5.5), którego oczywiście nie znamy, ale możemy go zgadnąć. Kiedy to się uda, program wyświ etli komunikat z gratulacjami. Rysunek 5.5. Program weird.exe służący do testowania p.rzepełnienia bufora Zacznijmy od wpisania numeru seryjnego „IOWNU”. Ponieważ jest on niepoprawny, nie spowoduje żadnej reakcji programu, a ponowne wciśnięcie klawisza Enter zakończy pracę programu. Po kilku dalszych próbach dojdziemy do wniosku, że istnieje lepszy sposób odkrycia poprawnego numeru seryjnego. Można co prawda napisać program, który będzie próbował odgadnąć numer seryjny metodą „brute-force”, ale jest to rozwiązanie nie- eleganckie. Nadszedł czas, aby skorzystać z narzędzi reinżynierii oprogramowania systemu Windows. Jedyną regułą tej zabawy jest zakaz zmieniani a instrukcji badanego programu. Poprawny numer seryjny znajdziemy, wykorzystując techniki reinżynierii oprogramo- wania poznane w poprzednich rozdziałach. Potrzebne do t ego będą: • znajomość asemblera x86, • deasembler taki, jak IDA Pro lub W32DASM, • konwerter kodów szesnastkowych na znaki ASCII. Zaczynamy od uruchomienia programu IDA Pro i otwarcia pliku weird.exe. Przechodzi- my od razu do okna Strings, w którym szukamy łańcucha znaków zawierającego gratu- lacje (rysunek 5.6). Po dwukrotnym kliknięciu łańcucha na ekranie pojawia się kod, któ- remu należy się przyjrzeć (rysunek 5.7). Rysunek 5.6. Łańcuchy znaków znajdujące się w programie wei.rd.exe 184 Rozdział 5. Ataki przepełnienia bufora Rysunek 5.7. Badany fragment kodu widziany w programie. IDA Pro Nie ma żadnych żelaznych i dających szybkie wyniki reguł łamania programów. Rein- żynieria oprogramowania jest bardziej sztuką niż wiedzą i często w takim samym stop- niu, co na wiedzy i doświadczeniu, opiera się na szczęściu i intuicji. W tym przypadku rozpoczęliśmy od kodu używającego łańcucha znaków z gratulacjami, gdyż wygląda on obiecująco. Oto kod programu: CODE:00401108 push ebp CODE:00401109 mov ebp, esp CODE:0040110B add esp, 0FFFFFFB4h ; znak CODE:0040110E push offset aTheAnalystSWei ; _ _va_args CODE:00401113 call _printf ; pokaż tekst CODE:00401118 pop ecx CODE:00401119 push offset asc_40C097 ; _ _va_args CODE:0040111E call _printf ; jak wyżej CODE:00401123 pop ecx CODE:00401124 push offset aEnterYourSeria ; _ _va_args CODE:00401129 call _printf ; i tu też CODE:0040112E pop ecx CODE:0040112F lea eax, [ebp+s] ; bufor CODE:00401132 push eax ; s CODE:00401133 call _gets ; pobiera podany numer seryjny CODE:00401138 pop ecx CODE:00401139 nop CODE:0040113A lea edx, [ebp+s] CODE:0040113D push edx ; s CODE:0040113E call _strlen ; pobiera jego długość CODE:00401143 pop ecx CODE:00401144 mov edx, eax CODE:00401146 cmp edx, 19h ; czy jest krótszy niż 25? CODE:00401149 jl short loc_401182 ; tak CODE:0040114B cmp edx, 78h ; czy jest dłuższy niż 120? CODE:0040114E jg short loc_401182 ; tak CODE:00401150 mov eax, 1 ; eax = 1, inicjacja pętli CODE:00401155 cmp edx, eax ; czy to już wszystkie znaki? CODE:00401157 jl short loc_40115E ; nie, dlatego wykonuje skok CODE:00401159 CODE:00401159 loc_401159: ; CODE XREF: _main+54j CODE:00401159 inc eax ; eax = eax + 1 CODE:0040115A cmp edx, eax ; czy to już wszystkie znaki? CODE:0040115C jge short loc_401159 ; nie, kontynuowanie pętli Przepełnienie bufora w praktyce 185 CODE:0040115E CODE:0040115E loc_40115E: ; CODE XREF: _main+4Fj CODE:0040115E mov eax, 7A69h ; eax = 31337 CODE:00401163 test eax, eax CODE:00401165 jnz short loc_401182 ; wyjście CODE:00401167 cmp eax, 1388h CODE:0040116C jl short loc_401182 ; wyjście CODE:0040116E cmp eax, 3A98h CODE:00401173 jg short loc_401182 ; wyjście CODE:00401175 jmp short loc_401182 ; wyjście CODE:00401177 ; ------------------------------------------------------------------ CODE:00401177 push offset aWooCongrats ; _ _va_args ; komunikat o powodzeniu CODE:0040117C call _printf CODE:00401181 pop ecx CODE:00401182 CODE:00401182 loc_401182: ; CODE XREF: _main+41j CODE:00401182 ; _main+46j ... CODE:00401182 call _getch ; czekanie na naciśnięcie klawisza CODE:00401187 xor eax, eax CODE:00401189 mov esp, ebp CODE:0040118B pop ebp CODE:0040118C retn W kodzie odkrywamy podstęp. Wygląda na to, że w ogóle nie istnieje możliwość zoba- czenia komunikatu z gratulacjami! Po przejrzeniu kodu stwierdzamy, że nie ma w nim odwołania do tej części kodu, która odpowiada za wyświetlenie gratulacji na ekranie, a są tylko skoki prowadzące do zakończenia działania programu. To dziwne, ale pewnie dla- tego program nazywa się weird.exe1. Wydaje się, że jedynym sposobem, żeby zobaczyć komunikat z gratulacjami, jest wyko- nanie wyświetlającego go kodu przez przepełnienie bufora programu. Mówiąc inaczej, sami musimy stworzyć taki numer seryjny, który przepełniając bufor programu, zmusi go do wykonania określonego kodu. Żeby wykonać ten kod, musimy na stosie umieścić numer seryjny przygotowany w bardzo precyzyjny sposób . Zacząć należy od sprawdzenia położenia i wielkości bufo ra: CODE:0040112E pop ecx CODE:0040112F lea eax, [ebp+s] ; bufor CODE:00401132 push eax ; s CODE:00401133 call _gets ; pobiera podany numer seryjny CODE:00401138 pop ecx CODE:00401139 nop CODE:0040113A lea edx, [ebp+s] CODE:0040113D push edx ; s Widzimy, że zawartość eax trafia na stos bezpośrednio przed wywołaniem funkcji gets( ). 1 Dziwak — przyp. tłum. 186 Rozdział 5. Ataki przepełnienia bufora Działanie poprzedniego fragmentu kodu objaśnimy za pomo cą instrukcji w języku C: ----------------------------------------------------------------------------- #include stdio.h #include string.h #include conio.h #include iostream.h int main( ) { unsigned char name[50]; gets(name); } ----------------------------------------------------------------------------- Jak widać, w programie w języku C definiujemy bufor „name” o długości 50 bajtów. Następnie za pomocą funkcji gets pobieramy do bufora name dane. Zdefiniowaliśmy bu- for o długości 50 znaków; co by się stało, gdybyśmy teraz podali programowi 100 zna- ków? Bez wątpienia spowodowałoby to przepełnienie bufo ra. Sprawdźmy teraz, ile bajtów ma bufor programu weird.exe. Według programu IDA ma on długość 75 znaków. Najpierw przyjrzyjmy się parametrom stosu: CODE:00401108 s = byte ptr -4Ch CODE:00401108 argc = dword ptr 8 CODE:00401108 argv = dword ptr 0Ch CODE:00401108 envp = dword ptr 10h CODE:00401108 arg_11 = dword ptr 19h W ten sposób przekonaliśmy się, że rozmiar bufora wynosi 75 znaków. Sprawdźmy to, podając programowi 80 znaków: -- The analyst s weird crackme -- --------------------------------- enter your serial please: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA Jak się można było spodziewać, wykonywanie programu załamało się. Nie ma się cze- mu dziwić, skoro wpisaliśmy łańcuch składający się z 80 znaków, czyli o 5 znaków dłuższy niż rozmiar bufora. Zaglądając do rejestrów, odkrywamy, że EBP = 41414141h. To bardzo interesujące. Liczba 41h jest kodem ASCII litery „A”, z czego wniosek, że udało nam się zmienić zawartość rejestru EBP. Dobrze, ale naszym celem jest zmiana zawartości rejestru EIP, która umożliwi wykonanie dowo lnego kodu. Wpiszmy teraz 84 znaki i zobaczmy co się stanie: -- The analyst s weird crackme -- --------------------------------- enter your serial please: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA Przepełnienie bufora w praktyce 187 I znów nastąpiło załamanie programu, któremu tym razem towarzyszy komunikat: Instruction at the address 41414141h uses the memory addr ess at 41414141h. The memory cannot be read .2 Z tego wniosek, że program próbuje wykonać instrukcję znajdującą się pod adresem 41414141h. A gdyby tak zastąpić adres powrotu czymś innym niż 41414141h? Na przy- kład adresem kodu pokazującego komunikat z gratulacj ami? CODE:00401177 push offset aWooCongrats ; _ _va_args ; dobry chłopiec CODE:0040117C call _printf Jeżeli udałoby się umieścić w miejsce adresu powrotu adres 401177, program wykonałby kod wyświetlający komunikat z gratulacjami. Zanim to jednak zrobimy, użyjmy jeszcze takiego numeru seryjnego: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1234 Jak widać na rysunku 5.8, wykonywanie programu załamał o się pod adresem 34333231. Rysunek 5.8. Załamanie wykonywania się programu Uświadamia nam to, że musimy zmienić porządek bajtów w dostarczanym programowi ładunku. Dlaczego? Ponieważ adres, pod którym nastąpiło załamanie wykonywania się programu, jest odwróceniem porządku kodów ASCII ostatnich czterech podanych znaków. Oderwijmy się na chwilę od przykładu i wyjaśnijmy przyczynę tego stanu rzeczy. Od- wrotny porządek jest potrzebny w przypadku procesorów x86, gdyż używają one zapi- su typu little-endian. Termin „endian” wywodzi się z Podróży Guliwera Jonathana Swifta. Jest to satyryczna opowieść o mieszkańcach dwóch miast, którzy obierali ugotowane na twardo jajka, stukając je w różne końce. Mieszkańcy jednego miasta stukali jajka w ostrzej- szy koniec (ang. big end), a drugiego — w bardziej zaokrąglony (ang. little end). Ta różnica w zachowaniu mieszkańców doprowadziła z czasem do wojny . W przypadku procesorów określenia „big-endian” i „little-endian” dotyczą porządku bajtów liczb wielobajtowych. W formacie big-endian najbardziej znaczący bajt3 liczby 2 Instrukcja pod adresem 41414141h korzysta z pamięci o adresie 41414141h. Pamięć nie daje się czytać — przyp. tłum. 3 Czyli bajt, który w zapisie liczby na kartce znajduje lsię na lewym końcu liczby — przyp. tłum. 188 Rozdział 5. Ataki przepełnienia bufora zapisywany jest pod najmniejszym adresem pamięci, gdy w formacie little-endian, pod najniższym adresem zapisywany jest najmniej znaczący bajt. Operując na zawartości ad- resów, należy znać porządek, w jakim dany procesor zap isuje i odczytuje bajty z pamięci. Wróćmy do przykładu. Wiemy, że kodami szesnastkowymi znaków ASCII 1-2-3-4 są liczby 31-32-33-34. Jeżeli zmienimy porządek 1-2-3-4 na 4-3-2-1 otrzymamy liczby 34-33- 32-31, które dają adres 34333231, pod którym załamało się wykonywanie programu. Dlatego żeby skutecznie złamać program, musimy zamienić porządek bajtów podawa- nego programowi adresu. Mówiąc inaczej, aby dokonać skoku pod adres 401177, musi- my na stosie umieścić liczbę 771140. Liczbie 771140 odpowiada ciąg znaków ASCII w^Q@ (gdzie ^Q oznacza Ctrl+Q). Spróbujmy podać go teraz programowi: -- The analyst s weird crackme -- --------------------------------- enter your serial please: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAw^Q@ Po naciśnięciu klawisza Enter na ekranie wyświetlą się gratulacje (rysunek 5.9): wOO! congrats ;) Rysunek 5.9. Gratulacje Udało nam się z powodzeniem wykorzystać możliwość przepełnienia bufora do wyko- nania instrukcji umieszczonych na stosie. W tym przypadku na stosie umieściliśmy ad- res, który doprowadził do kodu, niedostępnego w żade n inny sposób. Po złamaniu programu można zapoznać się z jego kodem źród łowym: #include stdio.h #include string.h #include conio.h #include iostream.h int main( ){ int i,len,temp; unsigned char name[75]; Źródła dodatkowych informacji 189 unsigned long check=0; printf( -- The analyst s weird crackme -- ); printf( --------------------------------- ); printf( enter your serial please: ); gets(name); asm{ nop}; len=strlen(name); //cout len; if (len 25) goto theend; if (len 120 ) goto theend; for (i=1; i = len ; i++) { temp += name[i] ; } if (temp = 31337) goto theend; if (temp 5000) goto theend; if (temp 15000) goto theend; goto theend; printf( wOO! congrats ;) ); theend: getch( ); return 0; Źródła dodatkowych informacji Building Secure Software: How to Avoid Security Problebms the Right Way, John Viega • i Gary McGraw, Addison-Wesley Professional, 2001. • The Analyst s weird crackme. Publikacja +Tsehp, 2001. • Smashing the Stack for Fun and Profit, Aleph One, Phrack numer 49, 14 listopada 1996 (http://www.phrack.org). • „Endian Issues”, William Stallings, Byte.com, wrzesień 1995.
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Strażnik bezpieczeństwa danych
Autor:
,

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: