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!
• Przegl¹d zagro¿eñ, rodzaje oszustw i naruszeñ bezpieczeñstwa
• Zabezpieczenie programu przy u¿yciu numeru seryjnego
• Dostêpne na rynku systemy zabezpieczania aplikacji
• Algorytmy szyfruj¹ce
• Tworzenie skrótów wiadomoœci
• Wykorzystanie szyfrowania przy zabezpieczaniu oprogramowania
• Zabezpieczenia aplikacji wykorzystuj¹cych PHP i .NET
• Ochrona przed atakami typu: wstrzykiwanie SQL, XSS, DOS i DDOS
• U¿ywanie zaawansowanych metod ochrony oprogramowania
• Sposoby zaciemniania programu
• Ochrona kodu przed debugerami
• Zastosowanie kluczy sprzêtowych i technik biometrycznych
• 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
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
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
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. Ya%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. Wst3p
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. 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
{
// WAABCIWY 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
WLAMCIWY 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. 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. 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
int tmp = x[i];
// ZABEZPIECZ
x[i] = x[j];
// ZABEZPIECZ
x[j] = tmp;
// ZABEZPIECZ
}
// ZABEZPIECZ
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).
Czytaj dalej...
174
Bezpieczne programowanie. Aplikacje hakeroodporne
Oto g$ówna funkcja:
static void ModyfikujPlik(string aMcie`ka)
{
// odczyt pliku
TextReader reader = new StreamReader(aMcie`ka,
System.Text.Encoding.Default);
string zawartocf = reader.ReadToEnd();
reader.Close();
// modyfikacja zawarto'ci
int ile = 0;
while (zawartocf.IndexOf(oznaczenieWstawki) != -1)
{
int indeksWstawki = zawartocf.IndexOf(oznaczenieWstawki);
string wstawka = UtwórzWstawkp();
zawartocf = zawartocf.Substring(0, indeksWstawki) + wstawka +
zawartocf.Substring(indeksWstawki + oznaczenieWstawki.Length);
ile++;
}
// zapis pliku
TextWriter writer = new StreamWriter(aMcie`ka, false,
System.Text.Encoding.Default);
writer.Write(zawartocf);
writer.Close();
Console.WriteLine(aMcie`ka + " zostav zmodyfikowany "
+ ile.ToString() + " razy");
}
Pojedyncz# wstawk* tworzy funkcja
UtwórzWstawkp()
:
static string UtwórzWstawkp()
{
string cizgPodmiany = poczztekWstawki;
int ile = rd.Next(1, 3);
for (int i = 0; i < ile; i++)
{
if(rd.Next(0,2) == 0)
cizgPodmiany += UtwórzSztuczneSkoki();
else
cizgPodmiany += UtwórzStatycznzWstawkp();
}
return cizgPodmiany + 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órzStatycznzWstawkp
wygl#daj# nast*puj#co:
static string UtwórzStatycznzWstawkp()
{
int ile = rd.Next(1, 10);
string retWart = "";
for (int i = 0; i < ile; i++)
{