Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00478 010175 11041403 na godz. na dobę w sumie
The Shellcoders Handbook. Edycja polska - książka
The Shellcoders Handbook. Edycja polska - książka
Autor: , , , , , , Liczba stron: 560
Wydawca: Helion Język publikacji: polski
ISBN: 83-7361-597-0 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> hacking >> bezpieczeństwo systemów
Porównaj ceny (książka, ebook, audiobook).

Usuń luki w zabezpieczeniach programów i systemów operacyjnych

Niemal co tydzień dowiadujemy się o nowych 'łatach' usuwających luki w zabezpieczeniach systemów operacyjnych i programów. Niestety -- często, zanim łata zostanie rozpowszechniona i zainstalowana na komputerach, ktoś wykorzysta 'dziurę' w systemie i włamie się do niego. Cóż więc zrobić, aby zabezpieczyć swoje dane przez atakiem hakera? Jak znaleźć słabe punkty zabezpieczeń i usunąć je? W jaki sposób zaimplementować odpowiednie zabezpieczenia w tworzonym przez siebie oprogramowaniu?

Książka 'The Shellcoder's handbook. Edycja polska' zawiera odpowiedzi na wszystkie te pytania. Książka będąca efektem pracy zespołu złożonego ze specjalistów w zakresie bezpieczeństwa systemów komputerowych, analityków i hakerów przedstawia sposoby wykrywania słabych punktów oprogramowania tworzonego w języku C i sprawdzenia możliwości ich wykorzystania. Opisuje luki w istniejących systemach i programach oraz sposoby ich zabezpieczenia. Zawarte w niej wiadomości pozwolą na tworzenie własnych systemów wykrywania błędów i pomogą ustalić, czy błędy te stanowią potencjalne zagrożenie.

Nie dopuść do tego, aby Twoje programy padły ofiarą ataku hakera.

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 The Shellcoders Handbook. Edycja polska Autorzy: J. Koziol, D. Litchfield, D. Aitel, Ch. Anley, S. Eren, N. Mehta, R. Hassell T³umaczenie: Jaromir Senczyk ISBN: 83-7361-597-0 Tytu³ orygina³u: The Shellcoders Handbook Format: B5, stron: 560 Przyk³ady na ftp: 165 kB Usuñ luki w zabezpieczeniach programów i systemów operacyjnych • Poznaj przyczyny powstawania luk • Naucz siê sposobów w³amañ do systemów • Podejmij odpowiednie ġrodki zapobiegawcze Niemal co tydzieñ dowiadujemy siê o nowych „³atach” usuwaj¹cych luki w zabezpieczeniach systemów operacyjnych i programów. Niestety — czêsto, zanim ³ata zostanie rozpowszechniona i zainstalowana na komputerach, ktoġ wykorzysta „dziurê” w systemie i w³amie siê do niego. Có¿ wiêc zrobiæ, aby zabezpieczyæ swoje dane przez atakiem hakera? Jak znaleĥæ s³abe punkty zabezpieczeñ i usun¹æ je? W jaki sposób zaimplementowaæ odpowiednie zabezpieczenia w tworzonym przez siebie oprogramowaniu? Ksi¹¿ka „The Shellcoder’s handbook. Edycja polska” zawiera odpowiedzi na wszystkie te pytania. Ksi¹¿ka bêd¹ca efektem pracy zespo³u z³o¿onego ze specjalistów w zakresie bezpieczeñstwa systemów komputerowych, analityków i hakerów przedstawia sposoby wykrywania s³abych punktów oprogramowania tworzonego w jêzyku C i sprawdzenia mo¿liwoġci ich wykorzystania. Opisuje luki w istniej¹cych systemach i programach oraz sposoby ich zabezpieczenia. Zawarte w niej wiadomoġci pozwol¹ na tworzenie w³asnych systemów wykrywania b³êdów i pomog¹ ustaliæ, czy b³êdy te stanowi¹ potencjalne zagro¿enie. • Podstawowe metody w³amañ do ró¿nych systemów operacyjnych • Techniki przepe³niania stosu, wykorzystywania kodu pow³oki i b³êdów ³añcuchów formatuj¹cych • Kontrola s³abych punktów programów metodami wstrzykiwania kodu i fuzzingu • Kontrola kodu ĥród³owego programów • Klasy b³êdów • Sposoby ġledzenia s³abych punktów • Analiza kodu binarnego • Tworzenie eksploitów • Ataki na systemy zarz¹dzania bazami danych Spis treści O Autorach ...................................................h................................... 13 Część I Wprowadzenie do metod włamań: Linux na procesorach x86 ..............................................15 Rozdział 1. Wprowadzenie ...................................................h.............................. 17 Podstawowe pojęcia ...................................................p...................................................p.. 17 Zarządzanie pamięcią...................................................p............................................. 18 Asembler ...................................................p...................................................p............. 20 Rozpoznawanie przekładu kodu C++ w języku asemblera.............................................. 21 Podsumowanie ...................................................p...................................................p.......... 23 Rozdział 2. Przepełnienia stosu...................................................h....................... 25 Bufory ...................................................p...................................................p....................... 25 Stos...................................................p...................................................p............................ 27 Wywołania funkcji i stos...................................................p........................................ 28 Przepełnianie buforów na stosie...................................................p................................... 31 Wykorzystanie rejestru EIP...................................................p.................................... 32 Zdobywanie uprawnień root...................................................p......................................... 34 Problem adresu...................................................p...................................................p.... 36 Metoda rozkazów NOP ...................................................p.......................................... 39 Stos zabraniający wykonywania rozkazów ...................................................p.................. 41 Metoda powrotu do biblioteki libc ...................................................p......................... 41 Podsumowanie ...................................................p...................................................p.......... 44 Rozdział 3. Kod powłoki...................................................h.................................. 45 Wywołania systemowe...................................................p................................................. 46 Kod powłoki używający wywołania systemowego exit()................................................ 48 Wstrzykiwanie kodu powłoki...................................................p....................................... 51 Tworzenie nowej powłoki ...................................................p............................................ 53 Podsumowanie ...................................................p...................................................p.......... 61 Rozdział 4. Błędy łańcuchów formatujących ...................................................h.... 63 Warunki wstępne...................................................p...................................................p....... 63 Łańcuchy formatujące ...................................................p.................................................. 63 Błędy łańcuchów formatujących ...................................................p.................................. 65 6 The Shellcoder s Handbook. Edycja polska Włamania za pomocą łańcuchów formatujących...................................................p.......... 69 Atak na usługę...................................................p...................................................p..... 70 Ujawnianie informacji...................................................p............................................ 71 Przejęcie sterowania ...................................................p...................................................p.. 76 Jak to możliwe?...................................................p...................................................p......... 85 Przegląd technik łańcucha formatującego ...................................................p.................... 85 Podsumowanie ...................................................p...................................................p.......... 88 Rozdział 5. Wprowadzenie do metod przepełnienia sterty.................................... 89 Sterta ...................................................p...................................................p......................... 89 Zarządzanie stertą...................................................p...................................................p 91 Wyszukiwanie przepełnień sterty...................................................p................................. 91 Podstawowe metody przepełniania sterty...................................................p............... 92 Średnio zaawansowane metody przepełniania stosu ................................................. 98 Zaawansowane przepełnienia sterty ...................................................p..................... 104 Podsumowanie ...................................................p...................................................p........ 105 Część II Włamania na platformach Windows, Solaris i Tru64.......107 Rozdział 6. Wprowadzenie do systemu Windows............................................... 109 Różnice między systemami Linux i Windows...................................................p............ 109 Win32 i PE-COFF...................................................p................................................ 110 Sterty ...................................................p...................................................p....................... 112 Wątki...................................................p...................................................p................. 113 Zalety i wady DCOM i DCE-RPC ...................................................p............................. 114 Rozpoznanie...................................................p...................................................p...... 116 Włamania ...................................................p...................................................p.......... 117 Tokeny i podszywanie...................................................p.......................................... 118 Obsługa wyjątków w Win32 ...................................................p................................ 120 Śledzenie działania programów w systemie Windows .................................................. 121 Błędy w Win32 ...................................................p...................................................p. 122 Tworzenie kodu powłoki w systemie Windows...................................................p... 122 Przewodnik hakera po funkcjach Win32...................................................p.............. 123 Rodzina systemów Windows z punktu widzenia hakera......................................... 123 Podsumowanie ...................................................p...................................................p........ 124 Rozdział 7. Kody powłoki w Windows ...................................................h............ 125 Składnia i filtry...................................................p...................................................p........125 Przygotowywanie kodu powłoki ...................................................p................................ 126 Parsowanie bloków PEB ...................................................p............................................ 127 Analiza kodu heapoverflow.c...................................................p............................... 128 Przeszukiwanie z użyciem obsługi wyjątków...................................................p............. 143 Tworzenie nowej powłoki ...................................................p.......................................... 146 Dlaczego nie warto tworzyć nowej powłoki w Windows ....................................... 147 Podsumowanie ...................................................p...................................................p........ 148 Rozdział 8. Przepełnienia w systemie Windows................................................. 149 Przepełnienia buforów na stosie...................................................p................................. 149 Procedury obsługi wyjątków dla ramek wywołań funkcji....................................... 150 Wykorzystanie procedur obsługi wyjątków na platformie Windows 2003 Server.. 154 Końcowe uwagi na temat nadpisań procedur obsługi wyjątków............................. 158 Ochrona stosu i Windows 2003 Server ...................................................p...................... 159 Przepełnienia sterty ...................................................p...................................................p. 164 Sterta procesu...................................................p...................................................p.... 164 Sterty dynamiczne...................................................p................................................ 165 Spis treści 7 Korzystanie ze sterty ...................................................p............................................ 165 Jak działa sterta ...................................................p...................................................p. 165 Wykorzystanie przepełnień sterty...................................................p............................... 168 Nadpisanie wskaźnika funkcji RtlEnterCriticalSection w bloku PEB..................... 169 Nadpisanie wskaźnika pierwszej wektoryzowanej procedury obsługi wyjątków pod adresem 77FC3210 ...................................................p..................................... 171 Nadpisanie wskaźnika filtra nieobsłużonych wyjątków.......................................... 174 Nadpisanie wskaźnika procedury obsługi wyjątków w bloku TEB ........................ 179 Naprawa sterty ...................................................p...................................................p.. 180 Inne aspekty przepełnień sterty ...................................................p............................ 182 Podsumowanie przepełnień sterty ...................................................p........................ 183 Inne przepełnienia ...................................................p...................................................p... 183 Przepełnienia sekcji .data ...................................................p..................................... 183 Przepełnienia bloków TEB i PEB ...................................................p........................ 185 Przepełnienie buforów i stosy zabraniające wykonania kodu........................................ 185 Podsumowanie ...................................................p...................................................p........ 190 Rozdział 9. Filtry ...................................................h.......................................... 191 Tworzenie eksploitów i filtry alfanumeryczne ...................................................p........... 191 Tworzenie eksploitów i filtry Unicode ...................................................p....................... 195 Unicode...................................................p...................................................p............. 195 Konwersja z ASCII na Unicode ...................................................p........................... 196 Wykorzystanie słabych punktów związanych z kodem Unicode .................................. 196 Zbiór rozkazów dostępnych dla eksploitów Unicode.............................................. 197 Metoda wenecka...................................................p...................................................p...... 198 Implementacja metody weneckiej dla kodu ASCII ................................................. 199 Dekoder i dekodowanie...................................................p.............................................. 202 Kod dekodera ...................................................p...................................................p.... 203 Ustalenie adresu bufora...................................................p........................................ 204 Podsumowanie ...................................................p...................................................p........ 205 Rozdział 10. Wprowadzenie do włamań w systemie Solaris ................................. 207 Wprowadzenie do architektury SPARC ...................................................p..................... 208 Rejestry i okna rejestrów...................................................p...................................... 208 Szczelina zwłoki ...................................................p.................................................. 210 Rozkazy złożone ...................................................p.................................................. 211 Kody powłoki na platformie Solaris/SPARC ...................................................p............. 211 Kod powłoki i określanie własnego położenia ...................................................p..... 212 Prosty kod powłoki dla platformy SPARC...................................................p........... 212 Przydatne wywołania systemu Solaris ...................................................p................. 213 Rozkaz NOP i rozkazy wypełniające ...................................................p................... 214 Ramki na stosie platformy Solaris/SPARC ...................................................p................ 214 Techniki przepełnień stosu...................................................p......................................... 215 Przepełnienia o dowolnym rozmiarze ...................................................p.................. 215 Okna rejestrów komplikują przepełnienia stosu...................................................p... 216 Inne czynniki utrudniające przepełnienia stosu...................................................p.... 216 Możliwe rozwiązania ...................................................p........................................... 217 Przepełnienia jednym bajtem ...................................................p............................... 217 Położenie kodu powłoki...................................................p....................................... 218 Przykłady przepełnień stosu...................................................p....................................... 219 Atakowany program...................................................p............................................. 219 Eksploit ...................................................p...................................................p............. 221 Przepełnienia sterty na platformie Solaris/SPARC...................................................p..... 224 Wprowadzenie do sterty systemu Solaris...................................................p............. 224 Struktura drzewa sterty...................................................p......................................... 225 8 The Shellcoder s Handbook. Edycja polska Metoda podstawowa (t_delete)...................................................p................................... 243 Ograniczenia standardowych przepełnień sterty ...................................................p.. 246 Cele nadpisań ...................................................p...................................................p.... 247 Inne słabe punkty sterty...................................................p.............................................. 249 Przepełnienia jednym bajtem ...................................................p............................... 250 Podwójne zwolnienie ...................................................p........................................... 250 Inne błędy funkcji free()...................................................p....................................... 250 Przykład przepełnienia sterty...................................................p...................................... 251 Atakowany program...................................................p............................................. 251 Inne techniki włamań w systemie Solaris...................................................p................... 255 Przepełnienia danych statycznych...................................................p........................ 255 Obejście zabezpieczenia stosu...................................................p.............................. 255 Podsumowanie ...................................................p...................................................p........ 256 Rozdział 11. Zaawansowane metody włamań w systemie Solaris........................ 257 Śledzenie modułu dynamicznej konsolidacji krok po kroku ......................................... 258 Sztuczki przepełnień sterty Solaris/SPARC ...................................................p............... 271 Zaawansowany kod powłoki na platformie Solaris/SPARC ......................................... 273 Podsumowanie ...................................................p...................................................p........ 284 Rozdział 12. Włamania w systemie HP Tru64 Unix ............................................. 285 Architektura procesorów Alpha...................................................p.................................. 286 Rejestry procesorów Alpha ...................................................p.................................. 286 Zbiór rozkazów ...................................................p...................................................p. 287 Konwencje wywołań...................................................p............................................ 287 Pobieranie licznika rozkazów (GetPC)...................................................p....................... 289 Wywołania systemowe...................................................p............................................... 291 Dekoder XOR dla kodu powłoki ...................................................p................................ 291 Kod powłoki setuid + execve ...................................................p..................................... 293 Wywołania systemowe setuid(0) i execve( /bin/sh , ...) ......................................... 293 Kompilacja kodu w asemblerze i wyodrębnienie kodu powłoki ............................. 294 Kodowanie uzyskanych kodów powłoki funkcją XOR........................................... 295 Dołączenie zakodowanego kodu do dekodera XOR ............................................... 296 Kompilacja i wyodrębnienie ostatecznej postaci kodu powłoki.............................. 297 Kod powłoki zestawiający połączenie zwrotne ...................................................p.......... 299 Kod powłoki wyszukujący gniazdo sieciowe ...................................................p............. 300 Kod powłoki dowiązujący gniazdo sieciowe...................................................p.............. 301 Przepełnienia stosu...................................................p...................................................p.. 303 Obejście ochrony stosu ...................................................p........................................ 303 Włamanie do usługi rpc.ttdbserver...................................................p............................. 304 Podsumowanie ...................................................p...................................................p........ 311 Część III Wykrywanie słabych punktów .......................................313 Rozdział 13. Tworzenie środowiska pracy...................................................h........ 315 Źródła informacji...................................................p...................................................p..... 316 Narzędzia do tworzenia kodu ...................................................p..................................... 316 gcc...................................................p...................................................p..................... 316 gdb ...................................................p...................................................p.................... 317 NASM...................................................p...................................................p............... 317 WinDbg...................................................p...................................................p............. 317 OllyDbg...................................................p...................................................p............. 317 SoftICE ...................................................p...................................................p............. 318 Visual C++...................................................p...................................................p........ 318 Python ...................................................p...................................................p............... 318 Spis treści 9 Narzędzia śledzenia kodu...................................................p........................................... 318 Własne skrypty...................................................p...................................................p.. 318 Wszystkie platformy ...................................................p............................................ 320 Unix ...................................................p...................................................p.................. 320 Windows ...................................................p...................................................p........... 321 Artykuły, które powinieneś przeczytać ...................................................p...................... 322 Archiwa artykułów...................................................p............................................... 324 Optymalizacja procesu tworzenia kodu powłoki...................................................p........ 325 Plan eksploitu...................................................p...................................................p.... 325 Tworzenie kodu powłoki za pomocą asemblera wbudowanego w kompilator........ 325 Biblioteka kodów powłoki ...................................................p................................... 327 Kontynuacja działania atakowanego procesu...................................................p....... 327 Zwiększanie stabilności eksploitu ...................................................p........................ 328 Wykorzystanie istniejącego połączenia...................................................p................ 329 Podsumowanie ...................................................p...................................................p........ 330 Rozdział 14. Wstrzykiwanie błędów...................................................h................. 331 Ogólny projekt systemu...................................................p.............................................. 332 Generowanie danych wejściowych ...................................................p...................... 332 Wstrzykiwanie błędów...................................................p......................................... 335 Moduł modyfikacji...................................................p............................................... 335 Dostarczanie błędów do aplikacji...................................................p......................... 339 Algorytm Nagla...................................................p...................................................p. 340 Zależności czasowe...................................................p.............................................. 340 Heurystyki...................................................p...................................................p......... 340 Protokoły ze stanem i bez...................................................p..................................... 341 Monitorowanie błędów...................................................p............................................... 341 Wykorzystanie programu uruchomieniowego...................................................p...... 341 FaultMon...................................................p...................................................p........... 342 Kompletna aplikacja testująca ...................................................p.................................... 342 Podsumowanie ...................................................p...................................................p........ 343 Rozdział 15. Fuzzing...................................................h....................................... 345 Ogólna teoria fuzzingu ...................................................p............................................... 345 Analiza statyczna kontra fuzzing...................................................p.......................... 349 Fuzzing jest skalowalny ...................................................p....................................... 349 Wady fuzzerów ...................................................p...................................................p....... 351 Modelowanie dowolnych protokołów sieciowych ...................................................p..... 352 Inne technologie fuzzerów ...................................................p......................................... 352 Migotanie bitów ...................................................p...................................................p 353 Modyfikacja programów open source ...................................................p.................. 353 Fuzzing i analiza dynamiczna ...................................................p.............................. 353 SPIKE...................................................p...................................................p...................... 354 Jak działa SPIKE?...................................................p................................................ 354 Zalety stosowania struktur programu SPIKE do modelowania protokołów sieciowych...................................................p........... 355 Inne fuzzery...................................................p...................................................p.............362 Podsumowanie ...................................................p...................................................p........ 362 Rozdział 16. Kontrola kodu źródłowego ...................................................h........... 363 Narzędzia...................................................p...................................................p................. 364 Cscope...................................................p...................................................p............... 364 Ctags ...................................................p...................................................p................. 365 Edytory...................................................p...................................................p.............. 365 Cbrowser ...................................................p...................................................p........... 365 10 The Shellcoder s Handbook. Edycja polska Zautomatyzowane narzędzia kontroli kodu źródłowego ............................................... 366 Metodologia ...................................................p...................................................p............ 367 Metoda zstępująca...................................................p................................................ 367 Metoda wstępująca...................................................p............................................... 367 Metoda selektywna...................................................p............................................... 367 Klasy błędów...................................................p...................................................p........... 368 Ogólne błędy logiki...................................................p.............................................. 368 (Prawie) wymarłe klasy błędów ...................................................p........................... 368 Błędy łańcuchów formatujących ...................................................p.......................... 369 Ogólne błędy określenia zakresu...................................................p.......................... 370 Pętle ...................................................p...................................................p.................. 371 Przepełnienia jednym bajtem ...................................................p............................... 372 Błędy braku zakończenia łańcucha ...................................................p...................... 373 Błędy przeskoczenia bajtu zerowego ...................................................p................... 374 Błędy porównania wartości ze znakiem ...................................................p............... 375 Błędy związane z wartościami całkowitymi...................................................p......... 376 Konwersje wartości całkowitych o różnej reprezentacji ......................................... 378 Błędy podwójnego zwolnienia ...................................................p............................. 379 Użycie obszarów pamięci poza okresem ich ważności ........................................... 380 Użycie niezainicjowanych zmiennych ...................................................p................. 380 Błędy użycia po zwolnieniu ...................................................p................................. 381 Wielowątkowość i kod wielobieżny...................................................p..................... 382 Słabe punkty i zwykłe błędy...................................................p....................................... 382 Podsumowanie ...................................................p...................................................p........ 383 Rozdział 17. Ręczne wykrywanie błędów ...................................................h......... 385 Filozofia ...................................................p...................................................p.................. 385 Przepełnienie extproc systemu Oracle...................................................p........................ 386 Typowe błędy architektury...................................................p......................................... 390 Problemy pojawiają się na granicach ...................................................p................... 390 Problemy pojawiają się podczas przekładu danych................................................. 391 Problemy występują w obszarach asymetrii...................................................p......... 393 Problemy uwierzytelniania i autoryzacji ...................................................p.............. 393 Problemy występują w najbardziej oczywistych miejscach .................................... 394 Obejście kontroli danych wejściowych i wykrywanie ataku ......................................... 394 Filtrowanie niedozwolonych danych...................................................p.................... 395 Zastosowanie alternatywnego kodowania ...................................................p............ 395 Dostęp do plików ...................................................p................................................. 396 Unikanie sygnatur ataków...................................................p.................................... 398 Pokonywanie ograniczeń długości ...................................................p....................... 398 Atak typu DOS na implementację SNMP w Windows 2000 ........................................ 400 Wykrywanie ataków typu DOS...................................................p.................................. 401 SQL-UDP...................................................p...................................................p................ 402 Podsumowanie ...................................................p...................................................p........ 403 Rozdział 18. Śledzenie słabych punktów ...................................................h......... 405 Wprowadzenie...................................................p...................................................p......... 406 Przykładowy program zawierający słaby punkt...................................................p... 406 Projekt komponentów ...................................................p.......................................... 409 Budujemy VulnTrace ...................................................p........................................... 416 Posługiwanie się biblioteką VulnTrace ...................................................p................ 421 Techniki zaawansowane...................................................p....................................... 424 Podsumowanie ...................................................p...................................................p........ 425 Spis treści 11 Rozdział 19. Audyt kodu binarnego ...................................................h................. 427 Audyt kodu binarnego i kontrola kodu źródłowego — podobieństwa i różnice............ 427 IDA Pro ...................................................p...................................................p................... 428 Krótki kurs obsługi...................................................p............................................... 429 Symbole uruchomieniowe...................................................p.................................... 430 Wprowadzenie do audytu kodu binarnego ...................................................p................. 430 Ramki stosu...................................................p...................................................p....... 430 Konwencje wywołań...................................................p............................................ 432 Kod generowany przez kompilator ...................................................p...................... 433 Konstrukcje typu memcpy ...................................................p................................... 436 Konstrukcje typu strlen ...................................................p........................................ 437 Konstrukcje języka C++...................................................p....................................... 438 Wskaźnik this...................................................p...................................................p.... 438 Odtwarzanie definicji klas...................................................p.......................................... 438 Tablice funkcji wirtualnych ...................................................p................................. 439 Proste, ale przydatne wskazówki...................................................p.......................... 440 Ręczna analiza kodu binarnego ...................................................p.................................. 440 Szybka weryfikacja wywołań bibliotecznych ...................................................p...... 440 Podejrzane pętle i rozkazy zapisu ...................................................p........................ 440 Błędy logiki...................................................p...................................................p....... 441 Graficzna analiza kodu binarnego...................................................p........................ 442 Ręczna dekompilacja ...................................................p........................................... 442 Przykłady analizy kodu binarnego ...................................................p............................. 443 Błędy serwera Microsoft SQL...................................................p.............................. 443 Błąd RPC-DCOM wykryty przez grupę LSD ...................................................p...... 444 Błąd IIS WebDAV ...................................................p............................................... 444 Podsumowanie ...................................................p...................................................p........ 446 Część IV Techniki zaawansowane ...............................................447 Rozdział 20. Alternatywne strategie eksploitów ................................................. 449 Modyfikacja programu ...................................................p............................................... 450 Modyfikacja 3 bajtów kodu systemu SQL Server ...................................................p...... 450 MySQL i modyfikacja 1 bitu...................................................p...................................... 454 Modyfikacja uwierzytelniania RSA w OpenSSH...................................................p....... 456 Inne koncepcje modyfikacji działającego kodu...................................................p.......... 457 Modyfikacja generatora losowego w GPG 1.2.2...................................................p.. 458 Serwer progletów ...................................................p...................................................p.... 459 Proxy wywołań systemowych ...................................................p.................................... 459 Problemy związane z proxy wywołań systemowych...................................................p.. 461 Podsumowanie ...................................................p...................................................p........ 470 Rozdział 21. Eksploity działające w rzeczywistym środowisku ............................. 471 Czynniki wpływające na niezawodność ...................................................p..................... 471 Magiczne adresy...................................................p...................................................p 471 Problem wersji ...................................................p...................................................p.. 472 Problemy kodu powłoki ...................................................p....................................... 473 Środki zaradcze ...................................................p...................................................p....... 475 Przygotowanie...................................................p...................................................p... 476 Metoda pełnego przeglądu ...................................................p................................... 476 Lokalny eksploit...................................................p...................................................p 477 Sygnatury systemów i aplikacji...................................................p............................ 477 Wycieki informacji...................................................p............................................... 479 Podsumowanie ...................................................p...................................................p........ 479 12 The Shellcoder s Handbook. Edycja polska Rozdział 22. Ataki na systemy baz danych ...................................................h...... 481 Ataki w warstwie sieciowej...................................................p........................................ 482 Ataki w warstwie aplikacji ...................................................p......................................... 491 Wykonywanie poleceń systemu operacyjnego ...................................................p........... 491 Microsoft SQL Server ...................................................p.......................................... 492 Oracle...................................................p...................................................p................ 492 IBM DB2 ...................................................p...................................................p.......... 493 Wykorzystanie przepełnień na poziomie języka SQL ...................................................p 495 Funkcje języka SQL...................................................p............................................. 496 Podsumowanie ...................................................p...................................................p........ 497 Rozdział 23. Przepełnienia jądra..................................................h....................... 499 Typy słabych punktów jądra ...................................................p...................................... 499 Słabe punkty jądra...................................................p...................................................p... 507 Przepełnienie stosu przez wywołanie exec_ibcs2_coff_prep_zmagic() w systemie OpenBSD ...................................................p........................................ 507 Słaby punkt ...................................................p...................................................p....... 508 Funkcja vfs_getvfssw() i możliwość przeglądania modułów jądra w systemie Solaris .. 512 Wywołanie systemowe sysfs() ...................................................p............................. 514 Wywołanie systemowe mount()...................................................p........................... 514 Podsumowanie ...................................................p...................................................p........ 515 Rozdział 24. Wykorzystanie słabych punktów jądra ............................................ 517 Słaby punkt funkcji exec_ibcs2_coff_prep_zmagic()...................................................p. 517 Wyznaczenie przesunięć i adresów pułapek ...................................................p........ 522 Nadpisanie adresu powrotu i przejęcie sterowania.................................................. 523 Wyszukiwanie deskryptora procesu (lub struktury proc) ........................................ 524 Kod eksploitu wykonywany w trybie jądra...................................................p.......... 526 Powrót kodu wykonywanego na poziomie jądra...................................................p.. 528 Uzyskanie uprawnień root (uid=0)...................................................p....................... 533 Eksploit słabego punktu funkcji vfs_getvfssw() systemu Solaris.................................. 538 Eksploit ...................................................p...................................................p............. 539 Moduł jądra...................................................p...................................................p....... 540 Uzyskanie uprawnień root (uid=0)...................................................p....................... 543 Podsumowanie ...................................................p...................................................p........ 544 Dodatki ...................................................r....................................545 Skorowidz ...................................................h.................................. 547 Rozdział 8. Przepełnienia w systemie Windows Zakładamy, że Czytelnik przystępujący do lektury tego rozdziału posiada przynajmniej podstawową znajomość systemu Windows NT lub jego późniejszych wersji, a także zna sposoby wykorzystywania przepełnień buforów na tej platformie. W rozdziale omó- wimy bardziej zaawansowane aspekty przepełnień w systemie Windows, na przykład związane z obchodzeniem zabezpieczeń stosu zastosowanych w systemie Windows 2003 Server czy przepełnieniami sterty. Zrozumienie tych zagadnień wymagać będzie znajomości kluczowych rozwiązań zastosowanych na platformie Windows, takich jak bloki TEB (Thread Environment Block) i PEB (Process Environment Block), a także struktury pamięci procesów, plików wykonywalnych oraz nagłówków PE. Jeśli któreś z tych pojęć są obce Czytelnikowi, to przed przystąpieniem do lektury tego rozdziału powinien uzupełnić wiadomości w tym zakresie. W rozdziale będziemy korzystać z narzędzi wchodzących w skład pakietu Visual Studio 6 firmy Microsoft, w szczególności z programu uruchomieniowego MSDEV, kompilatora języka C wywoływanego z wiersza poleceń (cl) oraz programu dumpbin. Program dumpbin jest doskonałym narzędziem uruchamianym z wiersza poleceń — wyświetla wszelkie informacje o plikach binarnych, tabelach importu i eksportu, sekcjach pli- ków oraz kodzie w asemblerze. Czytelnikom, którzy wolą posługiwać się narzędziem wyposażonym w graficzny interfejs użytkownika, proponujemy doskonały deasembler firmy Datarescue o nazwie IDA Pro. Tworząc kod eksploitów na platformie Windows, możemy korzystać ze składni asemblera zgodnej z przyjętą przez firmę Intel bądź za- proponowanej przez AT T. Wybór zależy od indywidualnych upodobań i preferencji. Przepełnienia buforów na stosie Metoda przepełniania buforów znana jest już od wielu lat i z pewnością będzie wykorzy- stywana również w przyszłości. I nadal za każdym razem, gdy jest wykrywana w nowo- czesnym oprogramowaniu, nie wiadomo, czy śmiać się, czy płakać. Tak czy owak, błędy 150 Część II ♦ Włamania na platformach Windows, Solaris i Tru64 te stanowią doskonałą pożywkę dla początkujących hakerów. W sieci Internet dostęp- nych jest wiele dokumentów szczegółowo opisujących sposoby wykorzystywania prze- pełnień buforów. Omówiliśmy je również w pierwszych rozdziałach tej książki, dlate- go teraz nie będziemy już powtarzać tych informacji. Typowy eksploit bazujący na przepełnieniu stosu doprowadza do nadpisania adresu po- wrotu zapisanego na stosie adresem, który wskazuje rozkaz lub blok kodu przekazujący sterowanie do kodu umieszczonego w buforze użytkownika. Zanim zajmiemy się po- głębieniem tego zagadnienia, krótko omówimy procedury obsługi wyjątków bazujących na ramkach stosu. Następnie przyjrzymy się sposobom nadpisywania struktur rejestracji wyjątków na stosie i pokażemy, w jaki sposób technika taka może prowadzić do obej- ścia zabezpieczeń stosu wbudowanych w system Windows 2003 Server. Procedury obsługi wyjątków dla ramek wywołań funkcji Procedura obsługi wyjątków jest fragmentem kodu, który zostaje wywołany na skutek pojawienia się problemu podczas wykonania procesu, na przykład naruszenia uprawnień dostępu bądź wykonania dzielenia przez zero. Procedury obsługi wyjątków mogą być powiązane z konkretnymi funkcjami. Wywołanie każdej funkcji prowadzi do utworzenia na stosie odpowiadającej jej ramki wywołania. Informacja o procedurze obsługi wyjątków może zostać umieszczona w ramce wywołania w strukturze : 26+10A 4 )+564#6+10. Struktura taka składa się z dwóch elementów: wskaźnika następnej struktury : 26+10A4 )+564#6+10 oraz wskaźnika właściwej procedury obsługi wy- jątków. W ten sposób procedury obsługi wyjątków mogą tworzyć listę przedstawioną na rysunku 8.1. Rysunek 8.1. Procedury obsługi wyjątków dla ramek wywołań funkcji Rozdział 8. ♦ Przepełnienia w systemie Windows 151 Każdy wątek procesu Win32 posiada przynajmniej jedną procedurę obsługi wyjątków. Procedura ta tworzona jest podczas uruchamiania wątku. Adres pierwszej struktury : 26+10A4 )+564#6+10 znajduje się w każdym bloku TEB pod adresem HU=?. W mo- mencie wystąpienia wyjątków lista procedur obsługi przeglądana jest do momentu zna- lezienia właściwej procedury obsługi wyjątku (czyli takiej, która zajmie się obsługą wyjątku). Obsługa wyjątków w oparciu o ramki na stosie odbywa się na poziomie ję- zyka C za pomocą słów kluczowych VT[ i GZEGRV. Przypominamy, że większość kodów przedstawionych w tej książce dostępna jest pod adresem ftp://ftp.helion.pl/przyklady/ hell.zip KPENWFGUVFKQJ KPENWFGYKPFQYUJ FYQTF/[ ZEGRVKQP*CPFNGT XQKF ] RTKPVH +PGZEGRVKQPJCPFNGT   ZKV2TQEGUU   TGVWTP _ KPVOCKP ] VT[ ] AACUO ] RQYQFWLGY[LæVGM ZQTGCZGCZ ECNNGCZ _ _ AAGZEGRV /[ ZEGRVKQP*CPFNGT ] RTKPVH QQRU  _ TGVWTP _ Jeśli w bloku umieszczonym wewnątrz VT[ wystąpi wyjątek, to wywołana zostanie funkcja /[ ZEGRVKQP*CPFNGT. W przykładzie tym celowo wywołujemy wyjątek, zeru- jąc zawartość rejestru #:, a następnie wykonując rozkaz ECNNGCZ. Podczas przepełniania bufora na stosie i nadpisywania adresu powrotu mogą również ulec nadpisaniu inne zmienne, co może być przyczyną komplikacji podczas włama- nia. Załóżmy na przykład, że funkcja odwołuje się do pewnej struktury za pomocą rejestru #:, który wskazuje początek tej struktury. Niech zmienna lokalna tej funkcji reprezentuje przesunięcie wewnątrz wspomnianej struktury. Jeśli zmienna ta zostanie nadpisana przy okazji nadpisywania adresu powrotu, a następnie załadowana do reje- stru 5+ i wykonany będzie na przykład rozkaz OQXFYQTFRVT=GCZ GUK?GFZ to musimy zapewnić, że wartość, którą nadpisaliśmy tą zmienną, w połączeniu z za- wartością rejestru #: reprezentuje adres, pod którym dozwolony jest zapis danych. 152 Część II ♦ Włamania na platformach Windows, Solaris i Tru64 W przeciwnym bowiem razie nastąpi naruszenie ochrony pamięci, wywołane zostaną odpowiednie procedury obsługi wyjątków, a działanie procesu zostanie najprawdopo- dobniej zakończone i stracimy szansę wykonania naszego kodu. Nawet jeśli skory- gujemy odpowiednio adres reprezentowany przez #:  5+, to musimy liczyć się z wy- stąpieniem wielu innych podobnych problemów, którym należy zaradzić, zanim funkcja zwróci sterowanie. W niektórych przypadkach może to nawet być niemożliwe. Najprostsza metoda rozwiązania tego problemu polega na nadpisaniu struktury : 26+10A4 )+564#6+10 w taki sposób, aby zapewnić sobie kontrolę nad wskaźni- kiem procedury obsługi wyjątku. Dzięki temu w momencie wystąpienia wyjątku mo- żemy przejąć kontrolę nad procesem — na przykład przez zastąpienie wskaźnika proce- dury obsługi wyjątków adresem kodu, który przekaże sterowanie z powrotem do naszego bufora. Zastanówmy się teraz, w jaki sposób nadpisać wskaźnik procedury obsługi wyjątku, abyśmy mogli wykonać dowolny kod umieszczony w buforze. Rozwiązanie zależy od konkretnej wersji systemu i zainstalowanych pakietów serwisowych. W systemach Windows 2000 i Windows XP bez zainstalowanych pakietów serwisowych rejestr $: wskazuje bieżącą strukturę : 26+10A4 )+564#6+10, czyli właśnie tą, którą nadpi- sujemy. Możemy wtedy nadpisać wskaźnik procedury obsługi wyjątków za pomocą adresu, pod którym znajduje się rozkaz LORGDZ lub ECNNGDZ. W ten sposób na skutek wystąpienia wyjątków powrócimy zawsze do nadpisanej struktury : 26+10A4 )+ 564#6+10. Wtedy nadpiszemy wskaźnik następnej struktury : 26+10A4 )+564#6+10 adresem kodu, który wykona krótki skok ponad adresem rozkazu LOR GDZ. Sposób nadpisania struktury : 26+10A4 )+564#6+10 ilustruje rysunek 8.2. Rysunek 8.2. Nadpisywanie struktury EXCEPTION_ REGISTRATION W systemach Windows 2003 Server oraz Windows XP Service Pack 1 sytuacja wy- gląda jednak inaczej. Rejestr $: nie wskazuje już struktury : 26+10A4 )+564#6+10. Wszystkie rejestry, które dotąd wskazywały przydatne informacje, teraz zostają wyze- rowane przed wywołaniem procedury obsługi wyjątków. Zmiany tej firma Microsoft dokonała prawdopodobnie w odpowiedzi na sposób działania robaka Code Worm, który używał tego mechanizmu do przejęcia kontroli nad serwerami IIS. Poniżej przedsta- wiamy kod odpowiedzialny za wspomnianą modyfikację (dla systemu Windows XP Professional SP1). Rozdział 8. ♦ Przepełnienia w systemie Windows 153 ($ZQTGCZGCZ ($ZQTGDZGDZ ($$ZQTGUKGUK ($ ZQTGFKGFK ($(RWUJFYQTFRVT=GUR J? ($RWUJFYQTFRVT=GUR J? ($RWUJFYQTFRVT=GUR J? ($$RWUJFYQTFRVT=GUR J? ($(RWUJFYQTFRVT=GUR J? ($ECNN($ ($RQRGFK ($RQRGUK ($#RQRGDZ ($$TGVJ ($ RWUJGDR ($(OQXGDRGUR ($RWUJFYQTFRVT=GDR  J? ($RWUJGFZ ($RWUJFYQTFRVTHU=? ($ OQXFYQTFRVTHU=?GUR ($RWUJFYQTFRVT=GDR J? ($RWUJFYQTFRVT=GDR J? ($RWUJFYQTFRVT=GDR  J? ($ RWUJFYQTFRVT=GDR ? ($(OQXGEZFYQTFRVT=GDR J? ($#ECNNGEZ Począwszy od adresu Z($, rejestry #:, $:, 5+ i + są kolejno zerowane za pomocą rozkazu :14. Następnie pod adresem Z($ wykonywany jest rozkaz ECNN, który powoduje przejście do adresu Z($ . Rozkaz znajdujący się pod adresem Z($( umieszcza w rejestrze : wskaźnik procedury obsługi wyjątku, którą wywołuje następny rozkaz. Nawet mimo tej modyfikacji haker może przejąć kontrolę nad działaniem systemu. Jed- nak nie dysponując wartościami rejestrów, które wskazywałyby ważne dane procesu użytkownika, musi odnaleźć je na własną rękę. A to zmniejsza szansę powodzenia ataku. Ale czy rzeczywiście? Zaraz po wywołaniu procedury obsługi wyjątku zawartość stosu będzie wyglądać następująco: 52CFTGURQYTQVW Z($# 52 YUMCļPKMV[RWY[LæVMW Z  52 CFTGUUVTWMVWT[ : 26+10A4 )+564#6+10 Zamiast nadpisywać wskaźnik procedury obsługi wyjątków adresem rozkazu LOR GDZ lub ECNNGDZ, wystarczy nadpisać go adresem kodu zawierającego następujące rozkazy: RQRTGI RQRTGI TGV Wykonanie każdego rozkazu 212 zwiększa wartość rejestru 52 o 4, wobec czego w mo- mencie wykonania rozkazu 4 6 rejestr 52 wskazuje dane procesu użytkownika. Przypo- mnijmy, że rozkaz 4 6 pobiera adres znajdujący się na wierzchołku stosu (wskazywany przez 52) i powoduje przekazanie sterowania na ten adres. Dzięki temu haker nie potrzebuje już rejestru wskazującego bufor ani nie musi domyślać się jego położenia. 154 Część II ♦ Włamania na platformach Windows, Solaris i Tru64 Gdzie znajdziemy blok potrzebnych do tego rozkazów? Praktycznie na końcu kodu każdej funkcji. Paradoksalnie najlepszym miejscem okazuje się blok rozkazów w kodzie, który zeruje rejestry przed wywołaniem procedury obsługi wyjątku. Blok ten znajduje się pod adresem Z($. ($RQRGUK ($#RQRGDZ ($$TGVJ To, że zamiast rozkazu TGV znajduje się tam rozkaz TGV, nie ma większego znaczenia. Zwiększy on zawartość rejestru 52 o Z zamiast o Z. Wykonanie tych rozkazów przeniesie nas z powrotem do struktury : 26+10A4 )+564#6+10 na stosie. Konieczne będzie też zastąpienie wskaźnika następnej struktury : 26+10A4 )+564#6+10 kodem rozkazu krótkiego skoku oraz dwóch rozkazów 012EQRQYQNKPCOQOKPæèCFTGUYUMC WLæE[DNQMTQMCÎYRQRRQRKTGV. Każdy proces Win32 i każdy wątek takiego procesu posiada przynajmniej jedną pro- cedurę obsługi wyjątków bazującą na ramce na stosie. Procedurę tę otrzymuje w mo- mencie jego uruchamiania. Jeśli stosujemy metodę przepełnień buforów na platformie Windows 2003 Server, to wykorzystanie takich procedur obsługi wyjątków umożliwi nam obejście zabezpieczeń stosu zastosowanych na tej platformie. Wykorzystanie procedur obsługi wyjątków na platformie Windows 2003 Server Wykorzystanie procedur obsługi wyjątków umożliwia obejście zabezpieczeń stosu zastosowanych na platformie Windows 2003 Server. (Omówienie tego zagadnienia zawiera punkt „Ochrona stosu i Windows 2003 Server”). W momencie wystąpienia wy- jątku na platformie Windows 2003 Server sprawdzana jest poprawność pierwszej pro- cedury obsługi skonfigurowanej dla tego wyjątku. W ten sposób Microsoft chce za- bezpieczyć się przed atakami na zasadzie przepełnienia stosu, które powodują nadpisanie adresu procedury obsługi wyjątków. W jaki sposób sprawdzana jest poprawność procedury obsługi wyjątków? Za kontrolę tę odpowiedzialny jest kod funkcji -K7UGT ZEGRVKQP KURCVEJGT znajdującej się w bi- bliotece 06 .. ... Najpierw sprawdza ona, czy wskaźnik procedury obsługi wyjątku nie wskazuje adresu na stosie. W tym celu używane są wartości w bloku TEB określające zakres adresów stosu i znajdujące się pod adresami (5=? i (5=?. Jeśli adres proce- dury obsługi wyjątku wypada w tym zakresie, to nie zostanie ona wywołana. Jeśli adres procedury obsługi wyjątku nie jest adresem stosu, to następnie adres ten porównywany jest z listą załadowanych modułów (zarówno wykonywalnych, jak i DLL). Co ciekawe, jeśli adres procedury obsługi wyjątków nie przypada w przestrzeni adresowej żadnego z tych modułów, to uważany jest za bezpieczny i procedura zostaje wywołana. W prze- ciwnym razie adres procedury obsługi wyjątków porównywany jest jeszcze z listą za- rejestrowanych procedur obsługi wyjątków. Następnie pobierany jest wskaźnik nagłówka PE za pomocą wywołania funkcji 4V N+OCIG0V*GCFGT. Jeśli bajt przesunięty Z( względem początku nagłówka (jest to naj- starszy bajt pola charakterystyki DLL w nagłówku PE) jest równy Z, to moduł ten Rozdział 8. ♦ Przepełnienia w systemie Windows 155 jest niedozwolony. Jeśli adres procedury obsługi wyjątku należy do zakresu adresów tego modułu, to procedura nie zostanie wywołana. Wskaźnik nagłówka PE zostaje przekazany jako parametr funkcji 4VN+OCIG KTGEVQT[ PVT[6Q CVC. W tym przypadku wywołanie tej funkcji dotyczy katalogu Load Configuration Directory i zwraca adres oraz rozmiar tego katalogu. Jeśli moduł nie dysponuje tym katalogiem, to funkcja zwraca wartość 0 i na tym kończy się kontrola poprawności procedury obsługi wyjątków, która zostaje wywołana. Jeśli moduł posiada taki katalog, to sprawdzany jest jego rozmiar. Gdy należy on do zakresu od  do Z, to procedura obsługi wyjątku zostaje wywołana. W odległości Z bajtów od początku katalogu znajduje się wskaźnik tabeli adresów RVA (Relative Virtual Address) zarejestrowanych procedur obsługi wyjątków. Jeśli wskaźnik ten jest równy NULL, to procedura obsługi wyjątku zostaje wywołana. Przesunięta o Z bajtów względem początku katalogu jest liczba elementów tabeli adresów RVA. Jeśli równa się ona 0, to procedura obsługi wyjątku zostaje wywołana. Jeśli wszystkie dotychczasowe kontrole powiodły się, adres bazowy modułu zostaje odjęty od adresu procedury obsługi wyjątków i w wyniku tej operacji otrzymujemy adres RVA tej procedury. Adres RVA jest następnie porównywany z adresami RVA w tabeli zarejestrowanych procedur obsługi wyjątków. Jeśli zostanie tam odnaleziony, to procedura zostanie wywołana. W przeciwnym razie procedura zostanie odrzucona. Stosując przepełnienia buforów na stosie w systemie Windows 2003 Server i nadpi- sując wskaźnik procedury obsługi wyjątków, mamy do wyboru następujące możliwości: 1. Wykorzystać istniejącą procedurę obsługi wyjątku w taki sposób, by przekazała sterowanie do naszego bufora. 2. Znaleźć blok kodu spoza zakresu adresów danego modułu, który przekaże sterowanie do naszego bufora. 3. Znaleźć blok kodu należący do zakresu adresów danego modułu, który nie posiada katalogu Load Configuration Directory. Przyjrzymy się im na przykładzie wykorzystania przepełnienia bufora przez funkcję DCOM o nazwie +4GOQVG#EVKXCVKQP. Wykorzystanie istniejącej procedury obsługi wyjątkónw Adres Z(# wskazuje zarejestrowaną procedurę obsługi wyjątków w 06 .. ... Jeśli przeanalizujemy działanie tej procedury, to dojdziemy do wniosku, że można ją wykorzystać do wykonania własnego kodu. Wskaźnik naszej struktury : 26+10A 4 )+564#6+10 znajduje się pod adresem $2  J. (#(OQXGDZFYQTFRVT=GDR  J?  (#OQXGUKFYQTFRVT=GDZ  J? (#OQXGFKFYQTFRVT=GDZ ?  (#NGCGEZ=GUK GUK ? (#OQXGCZFYQTFRVT=GFK GEZ  ?  (#(ECNNGCZ Wskaźnik naszej struktury : 26+10A4 )+564#6+10 został umieszczony w rejestrze $:. Następnie wartość typu FYQTF znajdująca się Z bajtów za adresem umieszczonym w rejestrze $: zostaje załadowana do rejestru 5+. Ponieważ wcześniej przepełniliśmy 156 Część II ♦ Włamania na platformach Windows, Solaris i Tru64 strukturę : 26+10A4 )+564#6+10, to posiadamy kontrolę nad tą wartością, a w konse- kwencji nad zawartością rejestru 5+. W podobny sposób kontrolowana przez nas wartość typu dword o przesunięciu 0x08 względem adresu znajdującego się w rejestrze $: zostaje umieszczona w rejestrze +. Następnie do rejestru : zostaje załadowany adres efektywny 5+  5+  (czyli 5+ ). Ponieważ kontrolujemy zawartość reje- stru 5+, to również możemy zagwarantować odpowiednią wartość tego adresu. Kolejny rozkaz umieszcza w rejestrze #: wartość FYQTF znajdującą się pod adresem stanowiącym sumę zawartości kontrolowanego przez nas rejestru + oraz : 
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

The Shellcoders Handbook. Edycja polska
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ą: