Praktyczna inżynieria wsteczna. Metody, techniki i narzędzia Gynvael Coldwind, Mateusz Jurczyk

Spis treści książki

• Okładka
• Strona tytułowa
• Strona redakcyjna
• Spis treści
• Wstęp
• 1. Funkcje, struktury, klasy i obiekty na niskim poziomie
  • 1.1. Wywoływanie funkcji w językach (bardzo) niskiego poziomu
    • 1.1.1. CALL, RET i konwencje wywołań
    • 1.1.2. Konwencje wywołań x86
    • 1.1.3. Konwencje wywołań x86-64
  • 1.2. Struktury
    • 1.2.1. Zgadywanie wielkości i ułożenia elementów struktury w pamięci
    • 1.2.2. Rozpoznawanie budowy struktur lokalnych i globalnych
    • 1.2.3. Rozpoznawanie budowy struktur dynamicznie alokowanych
  • 1.3. Klasy, obiekty, dziedziczenie i tablice wirtualne
    • 1.3.1. Prosta klasa a struktura
    • 1.3.2. Obiekty = struktury + funkcje + thiscall
    • 1.3.3. Wszystko zostaje w rodzinie, czyli dziedziczenie
  • 1.4. Podsumowanie
• 2. Środowisko uruchomieniowe na systemach GNU/Linux
  • 2.1. Wstęp
  • 2.2. Pliki wykonywalne ELF
    • 2.2.1. Identyfikacja systemu i architektury docelowej
    • 2.2.2. Segmenty
    • 2.2.3. Segment PT_LOAD
    • 2.2.4. Segment PT_DYNAMIC
    • 2.2.5. Sekcja .dynamic
      • 2.2.5.1. Deklaracja bibliotek zależnych
      • 2.2.5.2. Wczesna inicjalizacja programu
  • 2.3. Środowisko uruchomieniowe
    • 2.3.1. Kod PIC
    • 2.3.2. Tablice GOT i PLT
    • 2.3.3. Program ładujący ld.so
      • 2.3.3.1. Zmienne środowiskowe
      • 2.3.3.2. LD_LIBRARY_PATH
      • 2.3.3.3. LD_PRELOAD
      • 2.3.3.4. LD_AUDIT
    • 2.3.4. Zrzucanie pamięci procesów
      • 2.3.4.1. System plików /proc
      • 2.3.4.2. Pliki specjalne w /proc/pid
      • 2.3.4.3. Pliki specjalne maps i mem
      • 2.3.4.4. VDSO
      • 2.3.4.5. Wektory inicjalizacyjne
    • 2.3.5. Wstrzykiwanie kodu
      • 2.3.5.1. Wersja ptrace(2)
    • 2.3.6. Samomodyfikujący się kod
  • 2.4. Podsumowanie
  • Bibliografia
• 3. Mechanizmy ochrony aplikacji
  • 3.1. Wstęp
  • 3.2. Przepełnienie bufora na stosie
  • 3.3. Procedury obsługi wyjątków
  • 3.4. Zapobieganie wykonaniu danych
  • 3.5. Losowość układu przestrzeni adresowej
  • 3.6. Dodatkowe materiały
  • 3.7. Podsumowanie
  • Bibliografia
• 4. Metody przeciwdziałania odbudowie kodu aplikacji z pamięci procesu
  • 4.1. Wstęp
    • 4.1.1. Zawartość rozdziału
  • 4.2. Packery, szyfratory i protektory plików PE
  • 4.3. Emulowanie zabezpieczeń
  • 4.4. Ochrona przed odbudową kodu programu zapisanego z pamięci procesu
  • 4.5. Nanomity
  • 4.6. Skradziony punkt rozpoczęcia programu
  • 4.7. Przekierowanie i obfuskacja importowanych funkcji
  • 4.9. Podsumowanie
  • Bibliografia
• 5. .NET internals format and RE
  • 5.1. Wstęp
  • 5.2. Format pliku .NET
    • 5.2.1. JIT, czyli drugi stopień kompilacji programu
    • 5.2.2. Język pośredni CIL
      • 5.2.2.1. Przykład 1: add()
      • 5.2.2.2. Przykład 2: stringWriteTest()
      • 5.2.2.3. Przykład 3: programFlowTest()
    • 5.2.3. Dedykowane kontenery metadanych
    • 5.2.4. Wysokopoziomowa struktura programu zachowana w pliku wykonywalnym
    • 5.2.5. Token
    • 5.2.6. Funkcje natywne
    • 5.2.7. AOT
  • 5.3. Inżynieria wsteczna
    • 5.3.1. Analiza statyczna
    • 5.3.2. Dekompilacja
    • 5.3.3. Rekompilacja i odtwarzanie działania programu
    • 5.3.4. Modyfikacja istniejących metod
    • 5.3.5. Debug
      • 5.3.5.1. dnSpy
      • 5.3.5.2. Wtyczki do WinDbg
  • 5.4. Metody protekcji plików .NET
    • 5.4.1. Nadpisywanie nazw nadanych przez użytkownika
    • 5.4.2. Szyfrowanie stałych tekstowych
    • 5.4.3. Utrudnianie dekompilacji
    • 5.4.4. Ukrywanie kodu programu
    • 5.4.5. Deobfuskacja
  • 5.5. Podsumowanie
  • Bibliografia
• 6. Python obfuskacja i inżynieria wsteczna
  • 6.1. Wstęp
  • 6.2. Obfuskacja a model wykonania
  • 6.3. Obfuskacja źródeł
  • 6.4. Pliki .pyc i .pyo
  • 6.5. Bundlery i kompilator
    • 6.5.1. Py2exe
    • 6.5.2. cx_Freeze
    • 6.5.3. PyInstaller
    • 6.5.4. Nuitka
    • 6.5.5. Inne bundlery i kompilatory
  • 6.6. Obiekty code i function
  • 6.7. Kod bajtowy i gdzie go szukać
  • 6.8. Prosta obfuskacja kodu bajtowego
  • 6.9. Samomodyfikujący się kod bajtowy
  • 6.10. Podsumowanie
  • Bibliografia
• 7. Malware w owczej skórze, czyli o wstrzykiwaniu kodu w inne procesy
  • 7.1. Wstęp
  • 7.2. Przegląd technik wstrzykiwania
    • 7.2.1. Schemat działania
    • 7.2.2. Przygotowania przed implementacją
    • 7.2.3. Wybieranie celu
      • 7.2.3.1. Wstrzykiwanie kodu do istniejącego procesu
      • 7.2.3.2. Wstrzykiwanie kodu do nowo uruchomionego procesu
    • 7.2.4. Wpisywanie kodu do zdalnego procesu
    • 7.2.5. Metody przekierowania do wstrzykniętego kodu
      • 7.2.5.1. Uruchomienie dodanego kodu w nowym wątku
      • 7.2.5.2. Dodawanie do istniejącego wątku (przy użyciu NtQueueApcThread)
      • 7.2.5.3. Nadpisywanie punktu wejścia procesu
      • 7.2.5.4. Nadpisywanie kontekstu procesu
      • 7.2.5.5. Dodawanie do okienka Tray
      • 7.2.5.6. PowerLoader
  • 7.3. Tworzenie wstrzykiwalnego kodu
    • 7.3.1. Podstawy shellcodu
    • 7.3.2. Warunki wstrzykiwania plików PE
      • 7.3.2.1. Wstępne przygotowanie pliku PE
    • 7.3.3. Samodzielne ładowanie pliku PE
      • 7.3.3.1. Konwersja surowego obrazu na wirtualny
      • 7.3.3.2. Pobieranie adresów tabel
      • 7.3.3.3. Rozwiązywanie relokacji
      • 7.3.3.4. Rozwiązywanie importów
      • 7.3.3.5. Przekierowanie wykonania do dodanego pliku PE
      • 7.3.3.6. Plik PE o cechach shellcodu
    • 7.3.4. Debugowanie wstrzykniętego kodu
  • 7.4. Metody wstrzykiwania plików PE
    • 7.4.1. Klasyczny DLL Injection
      • 7.4.1.1. Demonstracja
      • 7.4.1.2. Implementacja
    • 7.4.2. RunPE (Process Hollowing)
      • 7.4.2.1. Demonstracja
      • 7.4.2.2. Implementacja
    • 7.4.3. ChimeraPE
      • 7.4.3.1. Demonstracja
      • 7.4.3.2. Implementacja
    • 7.4.4. Reflective DLL injection
      • 7.4.4.1. Demonstracja
      • 7.4.4.2. Implementacja
    • 7.4.5. Wstrzyknięcia DLL na poziomie systemu operacyjnego
      • 7.4.5.1. AppInit_DLLs
      • 7.4.5.2. Shim + InjectDll Tag
  • 7.5. Podsumowanie
  • Bibliografia
• 8. ELFie brudne sztuczki
  • 8.1. Wstęp
  • 8.2. ELFie struktury
  • 8.3. Rozdwojenie jaźni
    • 8.3.1. Niewidzialny kod
  • 8.4. Misja: przechwycić resolver
  • 8.5. Klasyka wiecznie żywa
  • 8.7. DYNAMICzne zmiany
    • 8.7.1. Co dwie tablice to nie jedna
    • 8.7.2. Jeden bajt by nimi rządzić
  • 8.8. Podsumowanie
  • Bibliografia
• 9. Łamanie zaawansowanych technik przekierowania API
  • 9.1. Wstęp
  • 9.2. Format PE podstawy
  • 9.3. Tabela importów
  • 9.4. Tabela eksportów
  • 9.5. Proste metody obfuskacji IAT
  • 9.6. Przekierowania API z przepisywaniem kodu
  • 9.7. Zróbmy to lepiej!
  • 9.8. Weryfikacja hipotezy pod debuggerem
  • 9.9. Automatyczne przepisywanie plików DLL
  • 9.10. Pierwsza próba i pierwsze problemy
  • 9.11. Modyfikacja NTDLL
  • 9.12. Ostatnie poprawki
  • 9.13. Efekt końcowy
  • 9.14. Podsumowanie
  • Bibliografia
• 10. Śledzenie ścieżki wykonania procesu w systemie Linux
  • 10.1. Wstęp
  • 10.2. Metody programowe
    • 10.2.1. Instrumentacja kodu źródłowego
    • 10.2.2. Instrumentacja programu w ramach kompilacji
    • 10.2.3. Instrumentacja kodu binarnego
    • 10.2.4. Śledzenie wywołań systemowych
    • 10.2.5. Śledzenie wywołań funkcji bibliotecznych
    • 10.2.6. Emulacja instrukcji
    • 10.2.7. Nagrywanie i odtwarzanie przebiegu ścieżki wykonania
  • 10.3. Metody programowo-sprzętowe
    • 10.3.1. Próbkowanie instrukcji
    • 10.3.2. Rejestry debuggera
    • 10.3.3. Wykonanie krokowe
    • 10.3.4. BTF (Branch Trap Flag)
    • 10.3.5. LBR (Intel Last Branch Record)
    • 10.3.6. BTS (Intel Branch Trace Store)
    • 10.3.7. IPT (Intel Processor Trace)
  • 10.4. Metody sprzętowe
  • 10.5. Porównanie wydajności
  • 10.6. Podsumowanie
• 11. Ciasteczko zagłady studium przypadku eksploitacji routera
  • 11.1. Wstęp
  • 11.2. Konsola
  • 11.3. Architektura MIPS
  • 11.4. Ciasteczko i ból brzucha
  • 11.5. Co w trawie piszczy
    • 11.5.1. Funkcja sub_80244E88
    • 11.5.2. Funkcja sub_802CF6E8
    • 11.5.3. Funkcja sub_802457D0
    • 11.5.4. Argumenty dla funkcji sub_8024281C
    • 11.5.5. Funkcja sub_8024281C
  • 11.6. Wykorzystanie podatności
    • 11.6.1. Adres docelowy
  • 11.7. Podsumowanie
  • Bibliografia
• 12. W pogoni za flagą eksploitacja na systemach Windows i Linux
  • 12.1. Wstęp
  • 12.2. Lokalne testowanie rozwiązań
  • 12.3. Multipurpose Calculation Machine (średnio trudne)
  • 12.4. Memory (łatwe)
  • 12.5. Crypto Machine (średnio trudne)
  • 12.6. Quarantine (bardzo trudne)
  • 12.7. Night Sky (bardzo trudne)
  • 12.8. Bubblegum (bardzo trudne)
  • 12.9. Antipasto (łatwe)
  • 12.10. Entree (średnio trudne)
  • 12.11. Podsumowanie
  • Bibliografia
• Przypisy

pokaż cały spis treści

ukryj recenzje