Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00222 006694 13592631 na godz. na dobę w sumie
Bezpieczne programowanie. Aplikacje hakeroodporne - książka
Bezpieczne programowanie. Aplikacje hakeroodporne - książka
Autor: Liczba stron: 312
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-2405-8 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> hacking >> bezpieczeństwo systemów
Porównaj ceny (książka, ebook, audiobook).

Wyjdź zwycięsko z pojedynku z krakerami!

Wyobraź sobie sytuację, w której poświęcasz mnóstwo czasu na stworzenie nowego, ciekawego rozwiązania w świecie informatyki. Kosztuje Cię to wiele dni i nocy ogromnego wysiłku. Dokładnie w momencie opuszczenia Twojego bezpiecznego komputera, udostępniony światu, Twój pomysł zostaje wystawiony na ciężką próbę - w sieci działają krakerzy, którzy za wszelką cenę będę próbowali złamać Twoje zabezpieczenia lub wykorzystać luki w Twojej aplikacji. Jak tego uniknąć? Jak tworzyć oprogramowanie odporne na ich ataki?

Proste i przejrzyste odpowiedzi na podobnie skomplikowane pytania znajdziesz właśnie w tej książce! Podczas lektury poznasz zagrożenia, na jakie narażony jest programista, oraz proste sposoby utrudniania krakerom zadania. Dodatkowo zdobędziesz wiedzę na temat metod szyfrowania danych i wyznaczania sygnatur. Jednak, co najważniejsze, zobaczysz, jak wykorzystać tę wiedzę w praktyce! W publikacji 'Bezpieczne programowanie. Aplikacje hakeroodporne ' znajdziesz również sporo ciekawych informacji na temat zabezpieczania aplikacji sieciowych oraz zaawansowane metody, gwarantujące podniesienie bezpieczeństwa Twojego produktu do wysokiego poziomu. To jeszcze nie wszystko! W kolejnych rozdziałach autor prezentuje sposoby ochrony przed debugerami, patenty na bezpieczne tworzenie kodu na platformie .NET oraz psychologiczne aspekty tworzenia hakeroodpornych aplikacji!

Dowiedz się, jak tworzyć aplikacje odporne na ataki!

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

Darmowy fragment publikacji:

Bezpieczne programowanie. Aplikacje hakeroodporne Autor: Jacek Ross ISBN: 978-83-246-2405-8 Format: 158×235, stron: 312 WyobraŸ sobie sytuacjê, w której poœwiêcasz mnóstwo czasu na stworzenie nowego, ciekawego rozwi¹zania w œwiecie informatyki. Kosztuje Ciê to wiele dni i nocy ogromnego wysi³ku. Dok³adnie w momencie opuszczenia Twojego bezpiecznego komputera, udostêpniony œwiatu, Twój pomys³ zostaje wystawiony na ciê¿k¹ próbê – w sieci dzia³aj¹ krakerzy, którzy za wszelk¹ cenê bêdê próbowali z³amaæ Twoje zabezpieczenia lub wykorzystaæ luki w Twojej aplikacji. Jak tego unikn¹æ? Jak tworzyæ oprogramowanie odporne na ich ataki? Proste i przejrzyste odpowiedzi na podobnie skomplikowane pytania znajdziesz w³aœnie w tej ksi¹¿ce! Podczas lektury poznasz zagro¿enia, na jakie nara¿ony jest programista, oraz proste sposoby utrudniania krakerom zadania. Dodatkowo zdobêdziesz wiedzê na temat metod szyfrowania danych i wyznaczania sygnatur. Jednak, co najwa¿niejsze, zobaczysz, jak wykorzystaæ tê wiedzê w praktyce! W publikacji „Bezpieczne programowanie. Aplikacje hakeroodporne” znajdziesz równie¿ sporo ciekawych informacji na temat zabezpieczania aplikacji sieciowych oraz zaawansowane metody, gwarantuj¹ce podniesienie bezpieczeñstwa Twojego produktu do wysokiego poziomu. To jeszcze nie wszystko! W kolejnych rozdzia³ach autor prezentuje sposoby ochrony przed debugerami, patenty na bezpieczne tworzenie kodu na platformie .NET oraz psychologiczne aspekty tworzenia hakeroodpornych aplikacji! (cid:129) Przegl¹d zagro¿eñ, rodzaje oszustw i naruszeñ bezpieczeñstwa (cid:129) Zabezpieczenie programu przy u¿yciu numeru seryjnego (cid:129) Dostêpne na rynku systemy zabezpieczania aplikacji (cid:129) Algorytmy szyfruj¹ce (cid:129) Tworzenie skrótów wiadomoœci (cid:129) Wykorzystanie szyfrowania przy zabezpieczaniu oprogramowania (cid:129) Zabezpieczenia aplikacji wykorzystuj¹cych PHP i .NET (cid:129) Ochrona przed atakami typu: wstrzykiwanie SQL, XSS, DOS i DDOS (cid:129) U¿ywanie zaawansowanych metod ochrony oprogramowania (cid:129) Sposoby zaciemniania programu (cid:129) Ochrona kodu przed debugerami (cid:129) Zastosowanie kluczy sprzêtowych i technik biometrycznych (cid:129) Psychologiczne aspekty ochrony oprogramowania Dowiedz siê, jak tworzyæ aplikacje odporne na ataki! Spis treĈci Wstöp .............................................................................................. 9 Rozdziaä 1. ZagroĔenia czyhajñce na programistów ........................................... 11 1.1. Dawno, dawno temu w Ğwiecie gier ........................................................................... 11 1.2. Moje przygody z grą Metal Knights ........................................................................ 14 1.3. Niebezpieczny edytor map, czyli sáabe punkty ........................................................ 16 1.4. A jak to robią w Diablo... czyli coĞ o bezpieczeĔstwie aplikacji sieciowych .......... 19 1.5. Rodzaje oszustw i naruszeĔ bezpieczeĔstwa ........................................................... 21 1.5.1. Nieuprawnione uĪycie bądĨ kopiowanie programu ........................................ 21 1.5.2. Nielegalna podmiana autorstwa kodu ............................................................. 23 1.5.3. Nieuprawniona modyfikacja kodu .................................................................. 23 1.6. Pirat, Robin Hood, kraker? ...................................................................................... 24 1.7. Czy ja takĪe mam myĞleü o zabezpieczeniach? ....................................................... 25 1.8. Czym siĊ róĪni kraker od záodzieja samochodów? .................................................. 27 Zadania do samodzielnego wykonania ........................................................................... 30 Pytania kontrolne ............................................................................................................ 31 Rozdziaä 2. Proste metody zabezpieczenia programów ......................................... 33 2.1. WstĊp ....................................................................................................................... 33 2.2. Numer seryjny ......................................................................................................... 33 2.3. CrackMe — przykáady sáaboĞci prostych zabezpieczeĔ przed nieuprawnionym uĪytkowaniem programu ................................................. 35 2.3.1. CrackMe1 ....................................................................................................... 35 2.3.2. CrackMe2 ....................................................................................................... 42 2.4. Gotowe systemy zabezpieczania aplikacji przed nieuprawnionym uĪyciem ........... 44 Przegląd systemów zabezpieczających dostĊpnych na rynku ................................... 47 2.5. ZakoĔczenie ............................................................................................................. 50 Zadania do samodzielnego wykonania ........................................................................... 51 Pytania kontrolne ............................................................................................................ 51 Rozdziaä 3. Teoria szyfrowania. Algorytmy szyfrujñce w praktyce ....................... 53 3.1. WstĊp ....................................................................................................................... 53 3.2. Szyfrowanie i kodowanie informacji ....................................................................... 53 3.3. Historyczne algorytmy szyfrowania i kodowania .................................................... 54 3.3.1. Początki .......................................................................................................... 54 3.3.2. Szyfry przestawieniowe i podstawieniowe, szyfr Cezara ............................... 55 3.3.3. Szyfry polialfabetyczne .................................................................................. 55 3.3.4. Zasada Kerckhoffsa ........................................................................................ 56 4 Bezpieczne programowanie. Aplikacje hakeroodporne 3.4. Wspóáczesne algorytmy szyfrowania ................................................................... 56 3.4.1. Rozwój algorytmów szyfrowania ................................................................... 56 3.4.2. Algorytmy symetryczne. Algorytm RC4 ........................................................ 57 3.4.3. Szyfrowanie symetryczne, algorytm DES ...................................................... 61 3.4.4. Szyfrowanie symetryczne, algorytm AES ...................................................... 61 3.4.5. Szyfrowanie asymetryczne, algorytm RSA .................................................... 61 3.4.6. Podpis cyfrowy ............................................................................................... 63 3.4.7. Szyfr z kluczem jednorazowym ...................................................................... 63 3.5. Algorytmy wyznaczające sygnatury (skróty) danych .............................................. 64 3.5.1. Algorytm wyznaczania CRC .......................................................................... 64 3.5.2. Algorytm MD5 ............................................................................................... 65 3.5.3. Algorytm SHA-1 ............................................................................................ 65 3.6. Generatory liczb pseudolosowych ........................................................................... 69 3.7. Do czego moĪe sáuĪyü szyfrowanie w zabezpieczaniu programów? ....................... 70 Zadania do samodzielnego wykonania ........................................................................... 71 Pytania kontrolne ............................................................................................................ 71 Rozdziaä 4. Zabezpieczanie programów sieciowych na przykäadzie jözyka PHP ... 73 4.1. WstĊp ....................................................................................................................... 73 4.2. Obsáuga danych z zewnątrz ..................................................................................... 74 4.3. Przekazywanie danych miĊdzy skryptami ............................................................... 75 4.4. Uwierzytelnianie w PHP .......................................................................................... 76 4.5. Niebezpieczne konstrukcje jĊzyka ........................................................................... 79 4.5.1. Konstrukcja include ($plik) ............................................................................ 80 4.5.2. eval($code), konstrukcja $$ ............................................................................ 81 4.5.3. fopen($url) ...................................................................................................... 82 4.6. Bezpieczna obsáuga báĊdów ..................................................................................... 83 4.7. BezpieczeĔstwo systemu plików ............................................................................. 84 4.8. Cross site scripting ................................................................................................... 85 4.9. Wstrzykiwanie kodu SQL ........................................................................................ 86 4.9.1. Wstrzykiwanie kodu SQL — przykáad 1. ....................................................... 87 4.9.2. Wstrzykiwanie kodu SQL — przykáad 2. ....................................................... 90 4.9.3. UĪycie PDO .................................................................................................... 91 4.9.4. Ataki wielofazowe .......................................................................................... 92 4.9.5. Sposoby ochrony ............................................................................................ 92 4.10. Wstrzykiwanie poleceĔ systemowych (shell injection) ......................................... 93 4.11. Wstrzykiwanie zawartoĞci e-mail (e-mail injection) .............................................. 94 4.12. Cross site request forgery ...................................................................................... 95 4.13. PrzejĊcie kontroli nad sesją (session fixation) ....................................................... 97 4.14. Session poisoning ................................................................................................ 101 4.14.1. Przechowywanie stanu aplikacji w niezabezpieczonych miejscach ........... 101 4.14.2. Przypisanie wartoĞci do zmiennej sesyjnej o nazwie stworzonej na podstawie danych od uĪytkownika ................... 104 4.14.3. Podmiana sekwencji wywoáaĔ przez wáamywacza. Problem wyĞcigu ....... 105 4.14.4. UĪywanie tych samych zmiennych sesyjnych do róĪnych celów ............... 106 4.14.5. Zmienne sesyjne nie są gwarancją bezpieczeĔstwa .................................... 108 4.15. Ataki typu DOS i DDOS ..................................................................................... 110 4.16. Dyrektywa register_globals ................................................................................. 112 4.17. NarzĊdzie zaciemniające kod Ĩródáowy jĊzyka PHP ........................................... 114 ZakoĔczenie .................................................................................................................. 116 Zadania do samodzielnego wykonania ......................................................................... 116 Pytania kontrolne .......................................................................................................... 116 Spis treĈci 5 Rozdziaä 5. Zaawansowane metody zabezpieczania programów ....................... 121 5.1. WstĊp ..................................................................................................................... 121 5.2. Klucze rejestracyjne przypisane do uĪytkownika .................................................. 122 5.2.1. Idea kluczy rejestracyjnych przypisanych do uĪytkownika .......................... 122 5.2.2. Typowe techniki ........................................................................................... 124 5.2.3. Tworzenie kluczy rejestracyjnych w aplikacjach sieciowych ....................... 125 5.3. Samotestujący siĊ program .................................................................................... 126 5.3.1. Testowanie integralnoĞci programu gwarancją jego oryginalnoĞci .............. 126 5.3.2. Przykáad — weryfikacja integralnoĞci pliku wykonywalnego ..................... 127 5.3.3. Przykáad — weryfikacja integralnoĞci kodu programu ................................ 132 5.4. Sprawdzanie integralnoĞci danych ......................................................................... 135 5.4.1. Ukryj moje dane ........................................................................................... 136 5.4.2. Testowanie integralnoĞci danych ulegających zmianom .............................. 137 5.4.3. Wersje czasowe oprogramowania — káopoty z shareware ........................... 138 5.4.4. Bezpieczne przechowywanie danych — przykáad ........................................ 140 5.5. Samomodyfikujący siĊ program ............................................................................ 144 5.5.1. Samomodyfikujący siĊ program. Brzydka sztuczka czy eleganckie zabezpieczenie? ................................. 144 5.5.2. SabotaĪ, czyli jak ukaraü krakera? ................................................................ 146 5.5.3. „Za 5 sekund ten program ulegnie samozniszczeniu” — automatyczna deinstalacja programu ................................................. 147 5.5.4. „Kod o ograniczonej przydatnoĞci do wykonania” ............................................ 148 5.6. Klucz programowy ................................................................................................ 150 5.6.1. Klucz programowy — przykáad ................................................................... 151 5.6.2. Deszyfrowanie fragmentów programu w trakcie jego dziaáania ................... 156 5.6.3. Przykáad programu deszyfrującego siĊ w trakcie dziaáania .......................... 158 5.7. Zaciemnianie kodu i danych programu .................................................................. 161 5.7.1. Czy to wciąĪ open source? Zaciemnianie kodu jako metoda obronna .......... 161 5.8. Zabezpieczenia. Jak to w praktyce wprowadziü w Īycie .................................... 163 5.8.1. Zabezpieczenia a etapy produkcji ................................................................. 163 5.8.2. Generator zabezpieczeĔ ................................................................................ 164 Zadania do samodzielnego wykonania ......................................................................... 165 Pytania kontrolne .......................................................................................................... 166 Rozdziaä 6. Zabezpieczenie programów przed debugerami ............................... 167 6.1. WstĊp ..................................................................................................................... 167 6.2. Wykrywanie debugerów ........................................................................................ 168 6.3. Utrudnianie debugowania ...................................................................................... 169 6.3.1. Wstawki kodu utrudniające debugowanie .................................................... 169 6.3.2. Generator wstawek kodu utrudniających debugowanie ................................ 172 Zadania do samodzielnego wykonania ......................................................................... 175 Pytania kontrolne .......................................................................................................... 175 Rozdziaä 7. Wykorzystanie internetu do zabezpieczania programów .................. 177 7.1. WstĊp ..................................................................................................................... 177 7.2. Rejestracja programu przez internet ...................................................................... 178 7.3. Aktywacja numeru seryjnego przez internet .......................................................... 179 7.4. Kontrola uĪytkowania aplikacji z czĊĞciowym dostĊpem do internetu .................. 180 7.5. Weryfikacja prawidáowej pracy aplikacji przez sieü .............................................. 181 7.6. Przechowywanie poufnych danych uĪytkownika .................................................. 182 7.7. Deszyfrowanie programu w trakcie dziaáania a internet ........................................ 183 7.8. Fragmentaryczne dane pobierane z internetu ......................................................... 185 7.9. Przesyáanie informacji o programie do centralnego serwera .................................... 186 oraz technik biometrycznych ......................................................... 197 8.1. WstĊp ..................................................................................................................... 197 8.2. Zabezpieczenie aplikacji za pomocą kluczy sprzĊtowych ..................................... 198 8.2.1. Karty magnetyczne i elektroniczne .............................................................. 198 8.2.2. Podpis cyfrowy na trwaáym noĞniku ............................................................ 199 8.2.3. Klucze sprzĊtowe w zabezpieczaniu oprogramowania ................................. 200 8.3. Technologie GPS i RFID, geolokalizacja .............................................................. 201 8.3.1. Technologie GPS i RFID .............................................................................. 201 8.3.2. Problemy etyczne i moralne postĊpu technicznego związanego z lokalizacją i kontrolą uĪytkowników ................................... 202 8.4. Weryfikacja toĪsamoĞci za pomocą technik biometrycznych ................................... 203 8.4.1. Techniki biometryczne ................................................................................. 203 8.4.2. Indywidualne oprogramowanie .................................................................... 204 8.5. Szpiegostwo elektroniczne .................................................................................... 204 8.5.1. Wáamania do sieci bezprzewodowych .......................................................... 204 8.5.2. Przechwytywanie fal elektromagnetycznych ................................................ 205 Pytania kontrolne .......................................................................................................... 206 Rozdziaä 9. Tworzenie bezpiecznych aplikacji w Ĉrodowisku .NET ..................... 207 9.1. WstĊp ..................................................................................................................... 207 9.2. Autoryzacja oparta na uprawnieniach i rolach (Role-Based Authorization) .......... 208 9.2.1. Uprawnienia, interfejs IPermission, klasa Principal ..................................... 209 9.2.2. Autoryzacja nakazowa oparta na rolach (Imperative Role-Based Security) ........ 210 9.2.3. Autoryzacja deklaracyjna oparta na rolach (Declarative Role-Based Security) ............................................................................................................... 213 9.3. Zabezpieczenie dostĊpu kodu do zasobów (Code Access Security) ......................... 215 6 Bezpieczne programowanie. Aplikacje hakeroodporne 7.9.1. Totalna inwigilacja? Rejestrowanie informacji o zachowaniu programu i uĪytkownika ..................................................... 186 7.9.2. Zdalne sprawdzanie toĪsamoĞci uĪytkownika .............................................. 188 7.9.3. Zdalne i lokalne blokowanie dziaáania programu sterowanego danymi z centralnego serwera ............................................... 191 7.10. Wirtualne wybory ................................................................................................ 192 Zadania do samodzielnego wykonania ......................................................................... 196 Pytania kontrolne .......................................................................................................... 196 Rozdziaä 8. Zabezpieczanie programów przy uĔyciu kluczy sprzötowych 9.3.1. Nakazowe zabezpieczenie dostĊpu kodu do zasobów (Imperative Code Access Security) ............................................................... 215 9.3.2. Deklaracyjne zabezpieczenie dostĊpu kodu do zasobów (Declarative Code Access Security) .............................................................. 219 9.3.3. Poziomy reguá bezpieczeĔstwa (Security Policy Level) ............................... 220 9.3.4. NarzĊdzie The Code Access Security Policy Utility — caspol.exe .............. 221 9.4. BezpieczeĔstwo ASP.NET .................................................................................... 222 9.4.1. Metody uwierzytelniania w ASP.NET ......................................................... 222 9.4.2. DostĊp anonimowy ....................................................................................... 223 9.4.3. Uwierzytelnianie systemu Windows ............................................................ 223 9.4.4. Uwierzytelnianie przy uĪyciu formularza ..................................................... 226 9.4.5. Uwierzytelnianie za pomocą .NET Passport ................................................ 228 9.4.6. Bezpieczna komunikacja za pomocą SSL .................................................... 228 9.5. Tworzenie silnych nazw podzespoáom .................................................................. 230 Zadania do samodzielnego wykonania ......................................................................... 231 Pytania kontrolne .......................................................................................................... 232 Spis treĈci 7 Rozdziaä 10. Bezpieczny Program ..................................................................... 235 10.1. WstĊp ................................................................................................................... 235 10.2. Opis programu ..................................................................................................... 236 10.3. Przegląd kodu Ĩródáowego ................................................................................... 238 10.3.1. BezpiecznyProgram.exe ............................................................................. 238 10.3.2. ZabezpieczBP.exe ...................................................................................... 245 10.3.3. StwórzKluczBP.exe .................................................................................... 246 10.4. Wnioski ............................................................................................................... 247 Zadania do samodzielnego wykonania ......................................................................... 249 Rozdziaä 11. Psychologiczna strona bezpieczeþstwa ......................................... 251 11.1. WstĊp ................................................................................................................... 251 11.2. Wpáyw architektury programu na jego bezpieczeĔstwo ...................................... 251 11.3. „Tylne wejĞcia” i kod tymczasowy ......................................................................... 253 11.4. UĪycie gotowego kodu ........................................................................................ 254 11.5. Open source ......................................................................................................... 256 11.6. TaĔczące Ğwinki kontra bezpieczeĔstwo ............................................................. 257 11.7. Security by obscurity — zabezpieczanie przez zaciemnianie .............................. 258 11.8. Karanie wáamywacza ........................................................................................... 260 11.9. Brzytwa Ockhama ............................................................................................... 261 11.10. UĪycie socjotechniki .......................................................................................... 261 11.11. Nie poprawiaj wáamywacza ............................................................................... 262 11.12. Walka ze script kiddies ...................................................................................... 263 11.13. Ochrona przed automatami ................................................................................ 264 11.14. Ataki z wewnątrz ............................................................................................... 267 11.15. àaĔcuch a sieü zabezpieczeĔ ............................................................................. 267 11.16. CaáoĞciowe spojrzenie na problem bezpieczeĔstwa ........................................... 268 Pytania kontrolne .......................................................................................................... 270 Podsumowanie ............................................................................. 273 Odpowiedzi do pytaþ kontrolnych .................................................. 281 Säowniczek pojöè ......................................................................... 293 Skorowidz .................................................................................... 301 Rozdziaä 6. Zabezpieczenie programów przed debugerami 6.1. Wstöp Wykrywanie aktywnych debugerów oraz programów zrzucających fragment pamiĊci typu ProcDump to czynnoĞü, która moĪe byü opáacalna, jednak nie jest tak prosta, jak siĊ wydaje. Istnieje wiele wyrafinowanych sztuczek wykrywających te programy, jednak zdecydowana wiĊkszoĞü z nich wykrywa dokáadnie okreĞlone programy, jak na przykáad SoftIce czy OllyDbg, i w dodatku czĊsto tylko okreĞlone ich wersje. Najgorszą infor- macją jest jednak to, Īe istnieje mnóstwo áatek i rozszerzeĔ popularnych debugerów, które zabezpieczają siĊ przed wykryciem. Programy te po modyfikacjach (wykona- nych czĊsto przez samych krakerów dla siebie) ukrywają siĊ i stosują techniki mylące. Dlatego wykrywanie debugerów jest zadaniem czĊsto skazanym na poraĪkĊ. Zwykle jest siĊ póá kroku do tyáu, a nawet jeĞli uda nam siĊ poprzez zaimplementowanie wielu technik jednoczeĞnie wykryü skutecznie wszystkie istniejące debugery, to i tak jest to tylko chwilowe zwyciĊstwo, bo za chwilĊ powstaną takie, których nie wykry- jemy. Jest to wiĊc typowe leczenie objawów, a nie przyczyn choroby. Nie oznacza to, Īe nie naleĪy w ogóle przejmowaü siĊ problemem i nie stosowaü Īadnych zabezpieczeĔ. Jednak jeĞli Czytelnik nie jest geniuszem assemblera, powinien zostawiü to zadanie innym i uĪyü do tego celu programu pobranego z internetu. Jest ich wiele, zarówno darmowych, jak i páatnych. Do tych drugich naleĪą m.in. opisane w rozdziale drugim TheMida czy AsProtect. DziĊki temu zaoszczĊdzimy sobie czasu na próby, których wyniki mogą byü wątpliwe, a co wiĊcej, których rezultat ciĊĪko bĊdzie nam zweryfikowaü, poniewaĪ nie bĊdziemy dysponowaü odpowiednią iloĞcią wersji debuge- rów. Procedury kontrolujące dziaáanie takich programów nie muszą byü niestandar- dowe i dlatego warto pozostawiü je fachowcom. 168 Bezpieczne programowanie. Aplikacje hakeroodporne Z tych wáaĞnie powodów w rozdziale tym nie znajdziecie wielu wyrafinowanych sztuczek blokujących debugery. OpiszĊ jedynie kilka najprostszych, aby kaĪdy mógá sobie wy- robiü opiniĊ na ten temat i w razie potrzeby poszukaü bardziej zaawansowanych in- formacji w innych Ĩródáach. Zamiast tego skupiĊ siĊ na ogólnych metodach utrudniania debugowania, które mogą byü uĪyteczne niezaleĪnie od stosowania funkcji wykry- wających debugery lub komercyjnych systemów zabezpieczeĔ, które równieĪ takowe funkcje posiadają. 6.2. Wykrywanie debugerów Najprostszym sposobem wykrywania debugerów jest wstawienie do kodu po prostu: if(IsDebuggerPresent()) // wykonaj jakiĞ kod, np. zamknij program; MoĪna to áatwo przetestowaü, wpisując w miejsce komentarza na przykáad polecenie wyĞwietlenie jakiegoĞ komunikatu i uruchamiając aplikacjĊ krok po kroku w Visual Studio. Debuger VS zostanie wykryty i program wyĞwietli komunikat. Uruchamiając program z pliku wykonywalnego, nie zobaczymy komunikatu. Tego typu zabezpieczenie bĊdzie jednak caákowicie nieskuteczne w przypadku za- awansowanych debugerów uĪywanych przez krakerów, takich jak SoftIce czy OllyDbg. Wáamywacze uĪywają zmodyfikowanych wersji tych programów, które są zabezpie- czone nie tylko przed opisaną powyĪej weryfikacją, ale takĪe przed wieloma bardziej zaawansowanymi metodami. Twój program musiaáby mieü naprawdĊ szeroką gamĊ testów, aby moĪna byáo mieü pewnoĞü wykrycia wiĊkszoĞci mutacji tych debugerów. Dlatego wáaĞnie lepiej jest uĪyü gotowego narzĊdzia wykonanego przez specjalistów, a samemu skupiü siĊ na innych zabezpieczeniach. Jako ciekawostkĊ podam jeszcze przykáady dwóch rozwiązaĔ tego typu: mov ah,43h int 68h cmp eax,0F386h jz mamy_debugger W tym teĞcie próbujemy zbadaü, czy uruchomiony zostaá program SoftIce poprzez wykrywanie sterownika debugera systemowego. Kolejny przykáad opiera siĊ na wy- krywaniu int 41h uĪywanego przez debugery: xor ax,ax mov es,ax mov bx, cs lea dx, int41handler xchg dx, es:[41h*4] xchg bx, es:[41h*4+2] in al, 40h xor cx,cx int 41h xchg dx, es:[41h*4] xchg bx, es:[41h*4+2] Rozdziaä 6. i Zabezpieczenie programów przed debugerami 169 cmp cl,al jnz si_jest int41handler PROC mov cl,al iret int41handler ENDP Obydwa powyĪsze przykáady wykrywania debugera SoftIce pochodzą ze strony: http://4programmers.net/Assembler/FAQ/Wykrywanie_debuggera_(SoftICE)1. 6.3. Utrudnianie debugowania 6.3.1. Wstawki kodu utrudniajñce debugowanie Utrudnienie debugowania moĪna wykonaü, wklejając w wiele miejsc kodu Ĩródáowego programu relatywnie nieskomplikowane wstawki. JeĞli uĪywamy jĊzyka C/C++, sprawa jest prosta, moĪemy bowiem wykorzystaü makra preprocesora, co w poáączeniu z twór- czym uĪyciem instrukcji skoku bezwarunkowego (tak oczerniane przez wszystkich goto), wstawek assemblerowych czy konstrukcji takich jak setjmp czy longjmp, moĪe solidnie skomplikowaü Ğledzenie programu w debugerze. WaĪne jest, aby tego typu wstawki pozostawaáy neutralne dla kodu. Oto przykáad: jmp_buf env; #define AD(kod, numer) if( setjmp(env) == 0 ) { goto skok_ad_##numer; } else { kod; } goto koniec_ad_##numer; skok_ad_##numer: longjmp(env, 1); koniec_ad_##numer: ; PowyĪsze makro wstawia kod wyglądający mniej wiĊcej tak: if( setjmp(env) == 0 ) { goto skok_ad_1; } else 1 TreĞü udostĊpniona na zasadach licencji Creative Commons Attribution: http://creativecommons.org/licenses/by/2.0/pl/legalcode. 170 Bezpieczne programowanie. Aplikacje hakeroodporne { // WàAĝCIWY FRAGMENT KODU } goto koniec_ad_1; skok_ad_1: longjmp(env, 1); koniec_ad_1: W trakcie wykonania instrukcja setjmp(env) == 0 wywoáana po raz pierwszy ustawi punkt powrotu dla skoku longjmp na miejsce swojego wywoáania oraz zwróci wartoĞü TRUE. W związku z tym kolejną wykonywaną instrukcją bĊdzie goto skok_ad_1. NastĊpnie wykona siĊ longjmp(env,1), które spowoduje przesuniĊcie wykonania z powrotem do pierwszej linii kodu. Tym razem jednak warunek nie bĊdzie juĪ speániony i wykonany zostanie ciąg instrukcji oznaczony jako WĐAĦCIWY FRAGMENT KODU. Na koniec instrukcja goto koniec_ad_1 zapewni prawidáowe opuszczenie tego bloku kodu. Caáa konstrukcja ma wpleĞü w kod kilka dziwnych i zaciemniających sens skoków wydáuĪających i utrudniających Ğledzenie wykonania w debugerze. OczywiĞcie powinna byü uĪyta w programie wiele razy, aby byü naprawdĊ skuteczną. UĪycie makra jest nastĊpujące. Kod, który zaciemniamy, otacza siĊ wywoáaniem makra: AD(kod, x). Pewną wadą tego makra jest to, Īe trzeba go wywoáywaü z dodatkowym parametrem, który za kaĪdym razem musi byü inny. To, co przed zaciemnieniem wy- gląda tak: for( int i = 0; i 10; i++) for( int j = 0; j i; j++) if( x[i] x[j]) { int tmp = x[i]; x[i] = x[j]; x[j] = tmp; } po — bĊdzie wyglądaü tak: AD( for( int i = 0; i 10; i++) for( int j = 0; j i; j++) AD(if( x[i] x[j]) { int tmp = x[i]; AD(x[i] = x[j] ,2); AD(x[j] = tmp ,3); } , 1) , 0) Inne makra mogą korzystaü wprost ze wstawek assemblerowych: #define WSTAWKA_START_ASM __asm PUSH EAX __asm PUSH EBX __asm PUSH ECX __asm PUSHF #define WSTAWKA_STOP_ASM __asm POPF __asm POP ECX __asm POP EBX __asm POP EAX #define WSTAWKA_PUSTA_1 WSTAWKA_START_ASM __asm MOV EAX, ECX __asm MOV EAX, 0 __asm ´ADD EAX, 0xD007 _asm MOV EBX, EAX WSTAWKA_STOP_ASM Rozdziaä 6. i Zabezpieczenie programów przed debugerami 171 #define WSTAWKA_PUSTA_2 WSTAWKA_START_ASM MAKE_DUMMY_1 __asm TEST EAX, EAX __asm ´PUSHF __asm POP EAX __asm MOV EAC, EAX MAKE_STOP_ASM #define WSTAWKA_PUSTA_3 WSTAWKA_START_ASM __asm MOV EAX, EBX __asm ADD EAX, 0x01ac __asm PUSH EAX __asm MOV EAX, EBX __asm POP EBX WSTAWKA_STOP_ASM PowyĪsze kody nie mają Īadnego sensu, natomiast nie zmieniają stanu rejestrów ani flag (dziĊki uĪyciu makr WSTAWKA_START_ASM i WSTAWKA_STOP_ASM). UĪycie jest proste: wywoáanie makra wstawia siĊ po prostu do kodu. for( int i = 0; i 10; i++) for( int j = 0; j i; j++) if( x[i] x[j]) { WSTAWKA_PUSTA_3 int tmp = x[i]; WSTAWKA_PUSTA_3 WSTAWKA_PUSTA_2 x[i] = x[j]; WSTAWKA_PUSTA_3 WSTAWKA_PUSTA_1 WSTAWKA_PUSTA_3 x[j] = tmp; WSTAWKA_PUSTA_2 } Prawda, Īe proste? Polecam obejrzenie kodu assemblerowego wygenerowanego przez kompilator dla kaĪdej z trzech powyĪszych wersji kodu. PoĞwiĊciwszy 3 – 4 godziny, moĪna wyprodukowaü kilkanaĞcie czy nawet kilkadziesiąt podobnych fragmentów kodu i uĪyü ich w setkach miejsc, wykonując po prostu pracĊ typu kopiuj/wklej. Nie powstrzyma to samo w sobie Īadnego krakera, ale utrudni mu nieco pracĊ. Oczywi- Ğcie takie wstawki wydáuĪają kod oraz nieznacznie spowalniają jego wykonanie. JeĞli jednak bĊdziemy uĪywaü ich wyáącznie w najbardziej krytycznych fragmentach pro- gramu, dotyczących zabezpieczeĔ, to jest to opáacalne. Zwáaszcza Īe przy dzisiej- szych prĊdkoĞciach procesorów tych kilkadziesiąt instrukcji maszynowych nie bĊdzie duĪym obciąĪeniem. PowyĪsze makra są banalne i mają wyáącznie posáuĪyü jako przykáad tego, co moĪna robiü. W prawdziwym systemie warto posiedzieü nieco dáuĪej i dodaü nastĊpujące elementy:  Wstawki assemblerowe z duĪą iloĞcią skoków wymieszanych bez áadu, na przykáad: WSTAWKA_START_ASM __asm JMP skok_1x; skok_1x: __asm TEST EAX,EBX; __asm JMP skok_3x; skok_5x: __asm MOV EAX, EBX; __asm JMP skok_4x; skok_2x: __asm MOV EAX, ECX; __asm JMP skok_5x; skok_4x: __asm POPF; __asm JMP skok_6x; skok_3x: __asm MOV EAX, 0; __asm PUSH EAX; __asm MOV EAX, EBX; 172 Bezpieczne programowanie. Aplikacje hakeroodporne __asm TEST EAX, EAX; __asm JNZ skok_4x; __asm JMP skok_2x; skok_6x: __asm MOV EAX,EBX; WSTAWKA_STOP_ASM  UĪycie nie tylko skoków bezwzglĊdnych, ale takĪe duĪej iloĞci zagnieĪdĪonych funkcji oraz skoków warunkowych (jak w powyĪszym przykáadzie skok JNZ).  Wstawianie instrukcji, które nie bĊdą nigdy wykonane, w pobliĪe wáaĞciwego kodu. MoĪna tego dokonaü poprzez skoki. Ciekawą instrukcją, którą moĪna w takie miejsce wstawiü, jest __asm int 3, czyli instrukcja przerwania programowego.  MoĪna nawet pokusiü siĊ o sterowanie przepáywem wykonania za pomocą wyjątków. Przez caáy czas powinniĞmy mieü jednak na uwadze to, Īe jest to tylko dodatek, i uwaĪaü, aby nie zaciemniü sobie kodu nadmiernie. 6.3.2. Generator wstawek kodu utrudniajñcych debugowanie Makra, o których pisaáem powyĪej, to interesująca technika, ale mają one kilka wad:  Nie kaĪdy jĊzyk posiada makra preprocesora. MoĪna jeszcze ratowaü siĊ uĪyciem funkcji rozwijanych w miejscu wywoáania (inline), ale nie zawsze i nie wszystko uda siĊ nimi zastąpiü.  Makra pisane rĊcznie są zazwyczaj schematyczne. CiĊĪko je sparametryzowaü czy zmieniaü im dynamicznie treĞü.  Nawet najwygodniejsze w uĪyciu widnieją w kodzie Ĩródáowym, zmniejszając jego czytelnoĞü oraz utrudniając testowanie (i debugowanie, ale w koĔcu po to zostaáy napisane). Lepszym rozwiązaniem bĊdzie wiĊc zostawienie wersji deweloperskiej kodu w stanie czystym i wstawianie kodu antydebugowego przez automat dopiero w procesie pro- dukcji oprogramowania. DziĊki uĪyciu zautomatyzowanych systemów produkcji oprogramowania takich jak na przykáad CruiseControl .NET, systemów kontroli wer- sji takich jak CVS czy SVN oraz narzĊdzi skryptowych takich jak NANT, Python czy Ruby proces ten nie powinien byü skomplikowany. Wygląda on nastĊpująco:  Prace deweloperskie wykonywane są przez programistów. Programista, koĔcząc prace, wysyáa kod Ĩródáowy do repozytorium systemu kontroli wersji.  Automat pobiera zmodyfikowane Ĩródáa do swojej lokalnej kopii.  Prekompilacja — wygenerowanie przez automat wstawek antydebugowych i wstawienie ich do kodu.  Kompilacja zmodyfikowanego kodu.  Wykonanie testów automatycznych. Rozdziaä 6. i Zabezpieczenie programów przed debugerami 173 Automat taki moĪe generowaü wstawki losowo spoĞród zbioru elementów w miejsca oznaczone w kodzie w specyficzny sposób. DziĊki temu jedyne, co musi zrobiü pro- gramista, to wstawiü takie oznaczenia wszĊdzie, gdzie chce. MoĪe to byü na przykáad specyficzny komentarz: // ZABEZPIECZ for( int i = 0; i 10; i++) for( int j = 0; j i; j++) if( x[i] x[j]) { // ZABEZPIECZ // ZABEZPIECZ // ZABEZPIECZ // ZABEZPIECZ } // ZABEZPIECZ int tmp = x[i]; x[i] = x[j]; x[j] = tmp; Na páycie CD znajduje siĊ kod Ĩródáowy programu GenerujZabezpieczenia napisanego w jĊzyku C#. Jest to program uruchamiany z linii poleceĔ, którego jedynym parametrem jest ĞcieĪka do pliku Ĩródáowego (w jĊzyku C++), w którym wstawki // ZABEZPIECZ mają zostaü zmienione na wstawki antydebugowe. Czytelnik moĪe rozbudowaü i zmody- fikowaü go wedáug wáasnych potrzeb. MoĪna zmieniü go w nastĊpujący sposób:  Dodanie wiĊkszej iloĞci elementów sáuĪących do generowania wstawek.  Dodanie generacji wstawek dla róĪnych jĊzyków programowania.  Dodanie generacji kilku rodzajów wstawek, w tym parametryzowanych.  Stworzenie bardziej skomplikowanych wstawek.  Stworzenie mniej schematycznych wstawek. NaleĪy przy tym pamiĊtaü o tym, Īe program po prostu wstawia wstawkĊ tam, gdzie zobaczy stosowny tekst. MoĪe wiĊc siĊ zdarzyü, Īe kod Ĩródáowy po modyfikacji nie bĊdzie siĊ kompilowaü lub w ogóle nie bĊdzie dziaáaü. ZaleĪy to od sposobu uĪycia oznakowania wstawek. JeĞli ich treĞü pojawi siĊ w nietypowym miejscu, na przykáad w ciągu znaków do wyĞwietlenia na konsoli itp., to dziaáanie programu moĪe zmieniü siĊ na nieprawidáowe. Kod programu jest doĞü prosty. Podstawową funkcją jest ModyfikujPlik, która odczytuje plik, wyszukuje frazy // ZABEZPIECZ i podmienia je na losowo wygenerowane wstawki assemblerowe. Generowane są dwa typy wstawek:  Statyczna — od 1 do 9 rozkazów assemblera wylosowanych z tablicy statyczneWstawki.  Faászywe skoki — trzy przeplatające siĊ fragmenty kodu (wylosowane jak wstawka statyczna). 174 Bezpieczne programowanie. Aplikacje hakeroodporne Oto gáówna funkcja: static void ModyfikujPlik(string aĦcieľka) { // odczyt pliku TextReader reader = new StreamReader(aĦcieľka, ´System.Text.Encoding.Default); string zawartoħè = reader.ReadToEnd(); reader.Close(); // modyfikacja zawartoĞci int ile = 0; while (zawartoħè.IndexOf(oznaczenieWstawki) != -1) { int indeksWstawki = zawartoħè.IndexOf(oznaczenieWstawki); string wstawka = UtwórzWstawkú(); zawartoħè = zawartoħè.Substring(0, indeksWstawki) + wstawka + ´zawartoħè.Substring(indeksWstawki + oznaczenieWstawki.Length); ile++; } // zapis pliku TextWriter writer = new StreamWriter(aĦcieľka, false, ´System.Text.Encoding.Default); writer.Write(zawartoħè); writer.Close(); Console.WriteLine(aĦcieľka + zostađ zmodyfikowany ´+ ile.ToString() + razy ); } Pojedynczą wstawkĊ tworzy funkcja UtwórzWstawkú(): static string UtwórzWstawkú() { string ciægPodmiany = poczætekWstawki; int ile = rd.Next(1, 3); for (int i = 0; i ile; i++) { if(rd.Next(0,2) == 0) ciægPodmiany += UtwórzSztuczneSkoki(); else ciægPodmiany += UtwórzStatycznæWstawkú(); } return ciægPodmiany + koniecWstawki; } TĊ funkcjĊ zmodyfikuj, jeĞli chcesz mieü wiĊcej typów wstawek. Po prostu nie losuj liczb z zakresu 0; 2), lecz wiĊkszego, i zastąp warunek instrukcją switch. Funkcje UtwórzSztuczneSkoki i UtwórzStatycznæWstawkú wyglądają nastĊpująco: static string UtwórzStatycznæWstawkú() { int ile = rd.Next(1, 10); string retWart = ; for (int i = 0; i ile; i++) { Rozdziaä 6. i Zabezpieczenie programów przed debugerami 175 retWart += statyczneWstawki[rd.Next(0, statyczneWstawki.Length)] + ´ ; } return retWart; } static string UtwórzSztuczneSkoki() { string retWart = ; string etykieta1 = UtwórzEtykietú(); string etykieta2 = UtwórzEtykietú(); string etykieta3 = UtwórzEtykietú(); retWart += __asm JMP + etykieta1 + ; ; retWart += etykieta2 + : + UtwórzStatycznæWstawkú(); retWart += __asm JMP + etykieta3 + ; ; retWart += etykieta1 + : + UtwórzStatycznæWstawkú(); retWart += __asm JMP + etykieta2 + ; ; retWart += etykieta3 + : + UtwórzStatycznæWstawkú(); return retWart; } Druga z nich tworzy skoki ukáadające siĊ w ciąg: 1. IdĨ do 3 2. IdĨ do 4 3. IdĨ do 2 4. Koniec PomiĊdzy nimi znajdują siĊ statyczne wstawki wygenerowane przez UtwórzStatycznæ- Wstawkú (), której z kolei kod jest tak prosty, Īe raczej nie trzeba go objaĞniaü. Warto jeszcze dodaü, Īe kaĪda wstawka zaczyna siĊ odáoĪeniem stanu rejestrów i flag na stos, a koĔczy pobraniem ich stamtąd. DziĊki temu stan programu nie zmienia siĊ. Zadania do samodzielnego wykonania 1. RozwiĔ program GenerujZabezpieczenia zgodnie z sugestiami w treĞci rozdziaáu. Pytania kontrolne P 6.1. Jakie sñ wady makr antydebugowych wstawianych röcznie do kodu? a) Są caákowicie nieskuteczne i nie przeszkadzają krakerom. b) W niektórych jĊzykach programowania ich implementacja moĪe byü trudna. 176 Bezpieczne programowanie. Aplikacje hakeroodporne c) Nie jest áatwo napisaü takie makra nieschematycznie, zwykle są podobne do siebie. d) Znajdują siĊ w kodzie Ĩródáowym, co zaciemnia go i utrudnia testowanie.
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Bezpieczne programowanie. Aplikacje hakeroodporne
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ą: