0 POZYCJI
KOSZYK PUSTY
Pobierz fragment
Wybierz format pliku:
Pobierz

Praktyczna inżynieria wsteczna

(eBook)

Metody, techniki i narzędzia

0.00  (0 ocen)
 Dodaj recenzję
Rozwiń szczegóły
  • Druk: Warszawa, 2016

  • Wydanie/Copyright: wyd. 1

  • Autor: Gynvael Coldwind, Mateusz Jurczyk

  • Wydawca: Wydawnictwo Naukowe PWN

  • Formaty:
    ePub mobi (Watermark)
    Watermark
    Znak wodny czyli Watermark to zaszyfrowana informacja o użytkowniku, który zakupił produkt. Dzięki temu łatwo jest zidentyfikować użytkownika, który rozpowszechnił produkt w sposób niezgodny z prawem. Ten rodzaj zabezpieczenia jest zdecydowanie najbardziej przyjazny dla użytkownika, ponieważ aby otworzyć książkę zabezpieczoną Watermarkiem nie jest potrzebne konto Adobe ID oraz autoryzacja urządzenia.

Zwiń szczegóły
Cena katalogowa: 84,00 zł
Najniższa cena z 30 dni: 58,80 zł
Cena produktu

Cena katalogowa – rynkowa cena produktu, często jest drukowana przez wydawcę na książce.

Najniższa cena z 30 dni – najniższa cena sprzedaży produktu w księgarni z ostatnich 30 dni, obowiązująca przed zmianą ceny.

Wszystkie ceny, łącznie z ceną sprzedaży, zawierają podatek VAT.

58,80 zł
Dostępność:
online po opłaceniu
Dodaj do schowka

Praktyczna inżynieria wsteczna

Praktyczna Inżynieria Wsteczna. Metody, techniki i narzędzia
Inżynieria wsteczna oprogramowania jest procesem dogłębnej analizy bibliotek, aplikacji i systemów, których kod źródłowy nie jest dostępny dla badacza. Umożliwia ona zarówno odtworzenie i pełne zrozumienie logiki konkretnego programu, jak i poszerzenie wiedzy na temat sposobu działania współczesnych procesorów, kompilatorów, czy całych systemów operacyjnych. Umiejętność ta może zostać użyta do odkrywania i eksploitacji luk bezpieczeństwa, analizy złośliwego oprogramowania, a nawet podejmowania bardziej świadomych decyzji programistycznych i łatwiejszego radzenia sobie z błędami we własnym kodzie.
Książka jest kompilacją publikacji dwunastu polskich autorów z wieloletnim doświadczeniem, którzy na co dzień posługują się przedstawionymi technikami w pracy jako eksperci od bezpieczeństwa i analitycy. Wśród nich znajdziemy wielu specjalistów zatrudnionych w największych firmach informatycznych, laureatów nagrody Pwnie Award, rozpoznawalnych prelegentów uznanych konferencji i członków czołowych zespołów startujących w konkursach security Capture The Flag. Materiały zostały wybrane i zredagowane przez Gynvaela Coldwinda i Mateusza Jurczyka.
Niektóre z poruszanych zagadnień to:
Podstawowe struktury znane z języków C i C++ widziane z perspektywy inżynierii wstecznej. Pliki wykonywalne w formatach ELF oraz PE, w tym zaawansowane triki z nimi związane. Wewnętrzna budowa zabezpieczeń przed wykorzystaniem luk bezpieczeństwa. Inżynieria wsteczna oprogramowania na platformy .NET oraz Python. Metody wstrzykiwania kodu w inne procesy. Projektowanie i analiza zabezpieczeń programów. Metody śledzenia wykonania – programowe i korzystające ze wsparcia oferowanego przez współczesne procesory. Inżynieria wsteczna w analizie bezpieczeństwa oprogramowania. Różnorodność tematów poruszanych przez autorów sprawia, że pozycja ta może zainteresować zarówno osoby początkujące, jak i pasjonatów pragnących poszerzyć swoją wiedzę lub zwiększyć repertuar używanych narzędzi i technik.

  • Kategorie:
    1. Ebooki i Audiobooki »
    2. Informatyka
    1. Ebooki i Audiobooki »
    2. Technika
  • Język wydania: polski
  • ISBN: 978-83-01-19046-0
  • ISBN druku: 978-83-01-18951-8
  • Liczba stron: 526
  • Sposób dostarczenia produktu elektronicznego
    Produkty elektroniczne takie jak Ebooki czy Audiobooki są udostępniane online po uprzednim opłaceniu (PayU, BLIK) na stronie Twoje konto > Biblioteka.
    Pliki można pobrać zazwyczaj w ciągu kilku-kilkunastu minut po uzyskaniu poprawnej autoryzacji płatności, choć w przypadku niektórych publikacji elektronicznych czas oczekiwania może być nieco dłuższy.
    Sprzedaż terytorialna towarów elektronicznych jest regulowana wyłącznie ograniczeniami terytorialnymi licencji konkretnych produktów.
  • Ważne informacje techniczne
  • Minimalne wymagania sprzętowe:
    • procesor: architektura x86 1GHz lub odpowiedniki w pozostałych architekturach
    • Pamięć operacyjna: 512MB
    • Monitor i karta graficzna: zgodny ze standardem XGA, minimalna rozdzielczość 1024x768 16bit
    • Dysk twardy: dowolny obsługujący system operacyjny z minimalnie 100MB wolnego miejsca
    • Mysz lub inny manipulator + klawiatura
    • Karta sieciowa/modem: umożliwiająca dostęp do sieci Internet z prędkością 512kb/s
  • Minimalne wymagania oprogramowania:
    • System Operacyjny: System MS Windows 95 i wyżej, Linux z X.ORG, MacOS 9 lub wyżej, najnowsze systemy mobilne: Android, iPhone, SymbianOS, Windows Mobile
    • Przeglądarka internetowa: Internet Explorer 7 lub wyżej, Opera 9 i wyżej, FireFox 2 i wyżej, Chrome 1.0 i wyżej, Safari 5
    • Przeglądarka z obsługą ciasteczek i włączoną obsługą JavaScript
    • Zalecany plugin Flash Player w wersji 10.0 lub wyżej.
  • Informacja o formatach plików:
    • PDF - format polecany do czytania na laptopach oraz komputerach stacjonarnych.
    • EPUB - format pliku, który umożliwia czytanie książek elektronicznych na urządzeniach z mniejszymi ekranami (np. e-czytnik lub smartfon), dając możliwość dopasowania tekstu do wielkości urządzenia i preferencji użytkownika.
    • MOBI - format zapisu firmy Mobipocket, który można pobrać na dowolne urządzenie elektroniczne (np.e-czytnik Kindle) z zainstalowanym programem (np. MobiPocket Reader) pozwalającym czytać pliki MOBI.
    • Audiobooki w formacie MP3 - format pliku, przeznaczony do odsłuchu nagrań audio.
  • Rodzaje zabezpieczeń plików:
    • Watermark - (znak wodny) to zaszyfrowana informacja o użytkowniku, który zakupił produkt. Dzięki temu łatwo jest zidentyfikować użytkownika, który rozpowszechnił produkt w sposób niezgodny z prawem.
    • Brak zabezpieczenia - część oferowanych w naszym sklepie plików nie posiada zabezpieczeń. Zazwyczaj tego typu pliki można pobierać ograniczoną ilość razy, określaną przez dostawcę publikacji elektronicznych. W przypadku zbyt dużej ilości pobrań plików na stronie WWW pojawia się stosowny komunikat.
    Więcej informacji o publikacjach elektronicznych
Wstęp                                                                                                                                    15
1. Funkcje, struktury, klasy i obiekty na niskim poziomie                                            19
	1.1. Wywoływanie funkcji w językach (bardzo) niskiego poziomu                       21
		1.1.1. CALL, RET i konwencje wywołań                                                       21
		1.1.2. Konwencje wywołań x86                                                                      24
		1.1.3. Konwencje wywołań x86-64                                                                   27
	1.2. Struktury                                                                                                            28
		1.2.1. „Zgadywanie” wielkości i ułożenia elementów struktury w pamięci      30
		1.2.2. Rozpoznawanie budowy struktur lokalnych i globalnych                   30
		1.2.3. Rozpoznawanie budowy struktur dynamicznie alokowanych          32
	1.3. Klasy, obiekty, dziedziczenie i tablice wirtualne                                            34
		1.3.1. Prosta klasa a struktura                                                                        34
		1.3.2. Obiekty = struktury + funkcje + thiscall                                          38
		1.3.3. Wszystko zostaje w rodzinie, czyli dziedziczenie                                 38
	1.4. Podsumowanie                                                                                                  41

2. Środowisko uruchomieniowe na systemach GNU/Linux                                        43
	2.1. Wstęp                                                                                                                45
	2.2. Pliki wykonywalne ELF                                                                                     45
		2.2.1. Identyfikacja systemu i architektury docelowej                                   46
		2.2.2. Segmenty                                                                                                 49
		2.2.3. Segment PT_LOAD                                                                            51
		2.2.4. Segment PT_DYNAMIC                                                                    53
		2.2.5. Sekcja  dynamic                                                                                    53
			2.2.5.1. Deklaracja bibliotek zależnych                                            57
			2.2.5.2. Wczesna inicjalizacja programu                                          59
	2.3. Środowisko uruchomieniowe                                                                          62
		2.3.1. Kod PIC                                                                                                62
		2.3.2. Tablice GOT i PLT                                                                                 65
		2.3.3. Program ładujący ld.so                                                                           73
			2.3.3.1. Zmienne środowiskowe                                                         73
			2.3.3.2. LD_LIBRARY_PATH                                                           74
			2.3.3.3. LD_PRELOAD                                                                    75
			2.3.3.4. LD_AUDIT                                                                          77
		2.3.4. Zrzucanie pamięci procesów                                                                 81
			2.3.4.1. System plików /proc                                                              81
			2.3.4.2. Pliki specjalne w /proc/pid                                                     82
			2.3.4.3. Pliki specjalne maps i mem                                                  83
			2.3.4.4. VDSO                                                                                    85
			2.3.4.5. Wektory inicjalizacyjne                                                        86
		2.3.5. Wstrzykiwanie kodu                                                                               88
			2.3.5.1. Wersja ptrace(2)                                                                     95
		2.3.6. Samomodyfikujący się kod                                                                  96
	2.4. Podsumowanie                                                                                                  98
	Bibliografia                                                                                                                  99

3. Mechanizmy ochrony aplikacji                                                                                  101
	3.1. Wstęp                                                                                                              103
	3.2. Przepełnienie bufora na stosie                                                                      104
	3.3. Procedury obsługi wyjątków                                                                          108
	3.4. Zapobieganie wykonaniu danych                                                                  112
	3.5. Losowość układu przestrzeni adresowej                                                      114
	3.6. Dodatkowe materiały                                                                                    116
	3.7. Podsumowanie                                                                                                116
	Bibliografia                                                                                                                116

4. Metody przeciwdziałania odbudowie kodu aplikacji z pamięci procesu              119
	4.1. Wstęp                                                                                                                 121
		4.1.1. Zawartość rozdziału                                                                             121
	4.2. Packery, szyfratory i protektory plików PE                                                   122
	4.3. Emulowanie zabezpieczeń                                                                         	   126
	4.4. Ochrona przed odbudową kodu programu zapisanego z pamięci procesu                                                                                                            128
	4.5. Nanomity                                                                                                        130
	4.6. Skradziony punkt rozpoczęcia programu                                                    135
	4.7. Przekierowanie i obfuskacja importowanych funkcji                                  142
	4.9. Podsumowanie                                                                                                147
	Bibliografia                                                                                                                148

5. NET internals – format & RE                                                                                    151
	5.1. Wstęp                                                                                                              153
	5.2. Format pliku  NET                                                                                        153
		5.2.1. JIT, czyli drugi stopień kompilacji programu                                  153
		5.2.2. Język pośredni CIL                                                                            154
			5.2.2.1. Przykład 1: add()                                                                155
			5.2.2.2. Przykład 2: stringWriteTest()                                               155
			5.2.2.3. Przykład 3: programFlowTest()                                           157
		5.2.3. Dedykowane kontenery metadanych                                                161
		5.2.4. Wysokopoziomowa struktura programu zachowana w pliku wykonywalnym                                                                                    161
		5.2.5. Token                                                                                                     164
		5.2.6. Funkcje natywne                                                                                   165
		5.2.7. AOT                                                                                                    165
	5.3. Inżynieria wsteczna                                                                                        166
		5.3.1. Analiza statyczna                                                                                166
		5.3.2. Dekompilacja                                                                                      166
		5.3.3. Rekompilacja i odtwarzanie działania programu                            170
		5.3.4. Modyfikacja istniejących metod                                                        170
		5.3.5. Debug                                                                                                  174
			5.3.5.1. dnSpy                                                                                     174
			5.3.5.2. Wtyczki do WinDbg                                                             176
	5.4. Metody protekcji plików  NET                                                                      176
		5.4.1. Nadpisywanie nazw nadanych przez użytkownika                          176
		5.4.2. Szyfrowanie stałych tekstowych                                                        176
		5.4.3. Utrudnianie dekompilacji                                                                  178
		5.4.4. Ukrywanie kodu programu                                                                178
		5.4.5. Deobfuskacja                                                                                      179
	5.5. Podsumowanie                                                                                                180
	Bibliografia                                                                                                                180

6. Python – obfuskacja i inżynieria wsteczna                                                              181
	6.1. Wstęp                                                                                                                 183
	6.2. Obfuskacja a model wykonania                                                                       183
	6.3. Obfuskacja źródeł                                                                                             185
	6.4. Pliki  pyc i  pyo                                                                                                188
	6.5. Bundlery i kompilator                                                                                    190
		6.5.1. Py2exe                                                                                                  190
		6.5.2. cx_Freeze                                                                                            193
		6.5.3. PyInstaller                                                                                             194
		6.5.4. Nuitka                                                                                                  198
		6.5.5. Inne bundlery i kompilatory                                                              205
	6.6. Obiekty code i function                                                                                  205
	6.7. Kod bajtowy i gdzie go szukać                                                                         213
	6.8. Prosta obfuskacja kodu bajtowego                                                                216
	6.9. Samomodyfikujący się kod bajtowy                                                              222
	6.10. Podsumowanie                                                                                                224
	Bibliografia                                                                                                                224

7. Malware w owczej skórze, czyli o wstrzykiwaniu kodu w inne procesy            225
	7.1. Wstęp                                                                                                              227
	7.2. Przegląd technik wstrzykiwania                                                                    228
		7.2.1. Schemat działania                                                                              228
		7.2.2. Przygotowania przed implementacją                                                228
		7.2.3. Wybieranie celu                                                                                  229
			7.2.3.1. Wstrzykiwanie kodu do istniejącego procesu                  229
			7.2.3.2. Wstrzykiwanie kodu do nowo uruchomionego procesu      230
		7.2.4. Wpisywanie kodu do zdalnego procesu                                            231
		7.2.5. Metody przekierowania do wstrzykniętego kodu                            233
			7.2.5.1. Uruchomienie dodanego kodu w nowym wątku              233
			7.2.5.2. Dodawanie do istniejącego wątku (przy użyciu NtQueueApcThread)                                                        234
			7.2.5.3. Nadpisywanie punktu wejścia procesu                              235
			7.2.5.4. Nadpisywanie kontekstu procesu                                      238
			7.2.5.5. Dodawanie do okienka Tray                                              239
			7.2.5.6. PowerLoader                                                                      241
	7.3. Tworzenie wstrzykiwalnego kodu                                                                  242
		7.3.1. Podstawy shellcodu                                                                            242
		7.3.2. Warunki wstrzykiwania plików PE                                                    244
			7.3.2.1. Wstępne przygotowanie pliku PE                                       245
		7.3.3. Samodzielne ładowanie pliku PE                                                      246
			7.3.3.1. Konwersja surowego obrazu na wirtualny                        246
			7.3.3.2. Pobieranie adresów tabel                                                     248
			7.3.3.3. Rozwiązywanie relokacji                                                    250
			7.3.3.4. Rozwiązywanie importów                                                  253
			7.3.3.5. Przekierowanie wykonania do dodanego pliku PE           261
			7.3.3.6. Plik PE o cechach shellcodu                                              261
		7.3.4. Debugowanie wstrzykniętego kodu                                                  262
	7.4. Metody wstrzykiwania plików PE                                                                   264
		7.4.1. Klasyczny DLL Injection                                                                     265
			7.4.1.1. Demonstracja                                                                      265
			7.4.1.2. Implementacja                                                                    266
		7.4.2. RunPE (Process Hollowing)                                                              267
			7.4.2.1. Demonstracja                                                                      267
			7.4.2.2. Implementacja                                                                    269
		7.4.3. ChimeraPE                                                                                          273
			7.4.3.1. Demonstracja                                                                      274
			7.4.3.2. Implementacja                                                                    275
		7.4.4. Reflective DLL injection                                                                     277
			7.4.4.1. Demonstracja                                                                      277
			7.4.4.2. Implementacja                                                                    278
		7.4.5. Wstrzyknięcia DLL na poziomie systemu operacyjnego                282
			7.4.5.1. AppInit_DLLs                                                                    283
			7.4.5.2. Shim + InjectDll Tag                                                          283
	7.5. Podsumowanie                                                                                                285
	Bibliografia                                                                                                                286

8. ELFie brudne sztuczki                                                                                                287
	8.1. Wstęp                                                                                                                 289
	8.2. ELFie struktury                                                                                               289
	8.3. Rozdwojenie jaźni                                                                                          292
		8.3.1. Niewidzialny kod                                                                                292
	8.4. Misja: przechwycić resolver                                                                             299
	8.5. Klasyka wiecznie żywa                                                                                    302
	8.7. DYNAMICzne zmiany                                                                                  307
		8.7.1. Co dwie tablice to nie jedna                                                              307
		8.7.2. Jeden bajt by nimi rządzić                                                                  309
	8.8. Podsumowanie                                                                                                311
	Bibliografia                                                                                                                311

9. Łamanie zaawansowanych technik przekierowania API                                        313
	9.1. Wstęp                                                                                                              315
	9.2. Format PE – podstawy                                                                                     315
	9.3. Tabela importów                                                                                               319
	9.4. Tabela eksportów                                                                                            321
	9.5. Proste metody obfuskacji IAT                                                                      322
	9.6. Przekierowania API z przepisywaniem kodu                                              323
	9.7. Zróbmy to lepiej!                                                                                            325
	9.8. Weryfikacja hipotezy pod debuggerem                                                        326
	9.9. Automatyczne przepisywanie plików DLL                                                  326
	9.10. Pierwsza próba i pierwsze problemy                                                            331
	9.11. Modyfikacja NTDLL                                                                                       333
	9.12. Ostatnie poprawki                                                                                          335
	9.13. Efekt końcowy                                                                                                336
	9.14. Podsumowanie                                                                                                337
	Bibliografia                                                                                                                337

10. Śledzenie ścieżki wykonania procesu w systemie Linux                                    339
	10.1. Wstęp                                                                                                                 341
	10.2. Metody programowe                                                                                      342
		10.2.1. Instrumentacja kodu źródłowego                                                      342
		10.2.2. Instrumentacja programu w ramach kompilacji                              344
		10.2.3. Instrumentacja kodu binarnego                                                        347
		10.2.4. Śledzenie wywołań systemowych                                                      349
		10.2.5. Śledzenie wywołań funkcji bibliotecznych                                        350
		10.2.6. Emulacja instrukcji                                                                            351
		10.2.7. Nagrywanie i odtwarzanie przebiegu ścieżki wykonania                353
	10.3. Metody programowo-sprzętowe                                                                     355
		10.3.1. Próbkowanie instrukcji                                                                      356
		10.3.2. Rejestry debuggera                                                                            357
		10.3.3. Wykonanie krokowe                                                                          360
		10.3.4. BTF (Branch Trap Flag)                                                                    362
		10.3.5. LBR (Intel Last Branch Record)                                                      363
		10.3.6. BTS (Intel Branch Trace Store)                                                        365
		10.3.7. IPT (Intel Processor Trace)                                                                 367
	10.4. Metody sprzętowe                                                                                          370
	10.5. Porównanie wydajności                                                                                  371
	10.6. Podsumowanie                                                                                                372

11. Ciasteczko zagłady – studium przypadku eksploitacji routera                             373
	11.1. Wstęp                                                                                                                 375
	11.2. Konsola                                                                                                            375
	11.3. Architektura MIPS                                                                                        379
	11.4. Ciasteczko i ból brzucha                                                                                381
	11.5. Co w trawie piszczy                                                                                        383
		11.5.1. Funkcja sub_80244E88                                                                      386
		11.5.2. Funkcja sub_802CF6E8                                                                       389
		11.5.3. Funkcja sub_802457D0                                                                      394
		11.5.4. Argumenty dla funkcji sub_8024281C                                              396
		11.5.5. Funkcja sub_8024281C                                                                      398
	11.6. Wykorzystanie podatności                                                                               400
		11.6.1. Adres docelowy                                                                                  401
	11.7. Podsumowanie                                                                                                404
	Bibliografia                                                                                                                406

12. W pogoni za flagą – eksploitacja na systemach Windows i Linux                    407
	12.1. Wstęp                                                                                                              409
	12.2. Lokalne testowanie rozwiązań                                                                      410
	12.3. Multipurpose Calculation Machine (średnio trudne)                                411
	12.4. Memory (łatwe)                                                                                              424
	12.5. Crypto Machine (średnio trudne)                                                                433
	12.6. Quarantine (bardzo trudne)                                                                          444
	12.7. Night Sky (bardzo trudne)                                                                            461
	12.8. Bubblegum (bardzo trudne)                                                                          480
	12.9. Antipasto (łatwe)                                                                                            501
	12.10. Entree (średnio trudne)                                                                                511
	12.11. Podsumowanie                                                                                                518
	Bibliografia                                                                                                                518

Indeks                                                                                                                                  521

Inni Klienci oglądali również

264,60 zł 294,00 zł
Do koszyka

Spółka akcyjna. Praktyczny poradnik z wzorami dokumentów (e-book z suplementem elektronicznym)

Kompendium wiedzy o spółce akcyjnej Praktyczny poradnik prezentujący najważniejsze aspekty prowadzenia działalności w formie spółki akcyjnej – począwszy od jej założenia, po jej rozwiązanie czy likwidację. W ...
22,47 zł 24,97 zł
Do koszyka

Szybka nauka - praktyczne ćwiczenia

93 specjalne ćwiczenia, dzięki którym nauka nie będzie sprawiać Ci problemów. Jak często zastanawiasz się, o ile efektywniej możesz się uczyć? Jak często myślisz, by wykorzystując nowoczesne techniki szybkiej nauki spędzać mniej cz...
14,40 zł 16,00 zł
Do koszyka

INŻYNIERIA MATERIAŁOWA W ELEKTROTECHNICE. LABORATORIUM

Skrypt jest prze­znaczony dla studentów Wydziału Elektrotechniki, Automatyki, Informatyki i Inżynierii Biomedycznej Akademii Górniczo-Hutniczej. Zawiera materiały pomocnicze do dwudziestu ćwiczeń laborato­ryjnych w ramach przedmio...
89,10 zł 99,00 zł
Do koszyka

Dotacje i finansowanie Twojej firmy. Praktyczny poradnik krok po kroku dla zaczynających swój biznes

Jestem praktykiem biznesu i od 20 lat pracuję w bankowości i finansach. Jako ekspert z wieloletnim doświadczeniem pozyskałam ponad 500 dotacji na założenie firmy oraz napisałam ponad 100 biznesplanów będących załącznikami do aplikacji o środki u...
8,99 zł 9,99 zł
Do koszyka

Nawyki. Jak kształtować dobre i pozbywać się złych. Praktyczny poradnik dla osób, które chcą zmienić swoje życie

"Nawyki. Jak kształtować dobre i pozbywać się złych. Praktyczny poradnik dla osób, które chcą zmienić swoje życie".Chcesz schudnąć, zacząć ćwiczyć, nauczyć się nowego języka, być bardziej efektywnym w działaniu, popr...
48,30 zł 69,00 zł
Do koszyka

JAVA. Programowanie praktyczne od podstaw

Książka omawia konstrukcje oraz wybrane narzędzia języka Java przydatne we wszystkich rodzajach praktycznego programowania. Przeznaczona jest zarówno dla całkowicie początkujących programistów, jak i tych, którzy pragną rozwijać sw...

Recenzje

Dodaj recenzję
Nikt nie dodał jeszcze recenzji. Bądź pierwszy!