Bezpieczne programowanie.

Aplikacje hakeroodporne
Autor: Jacek Ross
ISBN: 978-83-246-2405-8
Format: 158235, stron: 312

Wyobra sobie sytuacj, w ktrej powicasz mnstwo czasu na stworzenie nowego,

ciekawego rozwizania w wiecie informatyki. Kosztuje Ci to wiele dni i nocy ogromnego
wysiku. Dokadnie w momencie opuszczenia Twojego bezpiecznego komputera,
udostpniony wiatu, Twj pomys zostaje wystawiony na cik prb w sieci
dziaaj krakerzy, ktrzy za wszelk cen bd prbowali zama 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 wanie
w tej ksice! Podczas lektury poznasz zagroenia, na jakie naraony jest programista,
oraz proste sposoby utrudniania krakerom zadania. Dodatkowo zdobdziesz wiedz na
temat metod szyfrowania danych i wyznaczania sygnatur. Jednak, co najwaniejsze,
zobaczysz, jak wykorzysta t wiedz w praktyce! W publikacji Bezpieczne programowanie.
Aplikacje hakeroodporne znajdziesz rwnie sporo ciekawych informacji na temat
zabezpieczania aplikacji sieciowych oraz zaawansowane metody, gwarantujce
podniesienie bezpieczestwa Twojego produktu do wysokiego poziomu. To jeszcze
nie wszystko! W kolejnych rozdziaach autor prezentuje sposoby ochrony przed
debugerami, patenty na bezpieczne tworzenie kodu na platformie .NET oraz
psychologiczne aspekty tworzenia hakeroodpornych aplikacji!
Przegld zagroe, rodzaje oszustw i narusze bezpieczestwa
Zabezpieczenie programu przy uyciu numeru seryjnego
Dostpne na rynku systemy zabezpieczania aplikacji
Algorytmy szyfrujce
Tworzenie skrtw wiadomoci
Wykorzystanie szyfrowania przy zabezpieczaniu oprogramowania
Zabezpieczenia aplikacji wykorzystujcych PHP i .NET
Ochrona przed atakami typu: wstrzykiwanie SQL, XSS, DOS i DDOS
Uywanie zaawansowanych metod ochrony oprogramowania
Sposoby zaciemniania programu
Ochrona kodu przed debugerami
Zastosowanie kluczy sprztowych i technik biometrycznych
Psychologiczne aspekty ochrony oprogramowania
Dowiedz si, jak tworzy aplikacje odporne na ataki!

Spis treci
Wstp .............................................................................................. 9
Rozdzia 1. Zagroenia czyhajce na programistw ........................................... 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 sabe punkty ........................................................ 16
1.4. A jak to robi w Diablo... czyli co o bezpieczestwie aplikacji sieciowych .......... 19
1.5. Rodzaje oszustw i narusze bezpieczestwa ........................................................... 21
1.5.1. Nieuprawnione uycie bd 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 take mam myle o zabezpieczeniach? ....................................................... 25
1.8. Czym si rni kraker od zodzieja samochodw? .................................................. 27
Zadania do samodzielnego wykonania ........................................................................... 30
Pytania kontrolne ............................................................................................................ 31

Rozdzia 2. Proste metody zabezpieczenia programw ......................................... 33

2.1. Wstp ....................................................................................................................... 33
2.2. Numer seryjny ......................................................................................................... 33
2.3. CrackMe przykady saboci prostych zabezpiecze
przed nieuprawnionym uytkowaniem programu ................................................. 35
2.3.1. CrackMe1 ....................................................................................................... 35
2.3.2. CrackMe2 ....................................................................................................... 42
2.4. Gotowe systemy zabezpieczania aplikacji przed nieuprawnionym uyciem ........... 44
Przegld systemw zabezpieczajcych dostpnych na rynku ................................... 47
2.5. Zakoczenie ............................................................................................................. 50
Zadania do samodzielnego wykonania ........................................................................... 51
Pytania kontrolne ............................................................................................................ 51

Rozdzia 3. Teoria szyfrowania. Algorytmy szyfrujce w praktyce ....................... 53

3.1. Wstp ....................................................................................................................... 53
3.2. Szyfrowanie i kodowanie informacji ....................................................................... 53
3.3. Historyczne algorytmy szyfrowania i kodowania .................................................... 54
3.3.1. Pocztki .......................................................................................................... 54
3.3.2. Szyfry przestawieniowe i podstawieniowe, szyfr Cezara ............................... 55
3.3.3. Szyfry polialfabetyczne .................................................................................. 55
3.3.4. Zasada Kerckhoffsa ........................................................................................ 56

Bezpieczne programowanie. Aplikacje hakeroodporne

3.4. Wspczesne algorytmy szyfrowania ................................................................... 56
3.4.1. Rozwj algorytmw 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 wyznaczajce sygnatury (skrty) 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 moe suy szyfrowanie w zabezpieczaniu programw? ....................... 70
Zadania do samodzielnego wykonania ........................................................................... 71
Pytania kontrolne ............................................................................................................ 71

Rozdzia 4. Zabezpieczanie programw sieciowych na przykadzie jzyka PHP ... 73

4.1. Wstp ....................................................................................................................... 73
4.2. Obsuga danych z zewntrz ..................................................................................... 74
4.3. Przekazywanie danych midzy skryptami ............................................................... 75
4.4. Uwierzytelnianie w PHP .......................................................................................... 76
4.5. Niebezpieczne konstrukcje jzyka ........................................................................... 79
4.5.1. Konstrukcja include ($plik) ............................................................................ 80
4.5.2. eval($code), konstrukcja $$ ............................................................................ 81
4.5.3. fopen($url) ...................................................................................................... 82
4.6. Bezpieczna obsuga bdw ..................................................................................... 83
4.7. Bezpieczestwo systemu plikw ............................................................................. 84
4.8. Cross site scripting ................................................................................................... 85
4.9. Wstrzykiwanie kodu SQL ........................................................................................ 86
4.9.1. Wstrzykiwanie kodu SQL przykad 1. ....................................................... 87
4.9.2. Wstrzykiwanie kodu SQL przykad 2. ....................................................... 90
4.9.3. Uycie 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 zawartoci e-mail (e-mail injection) .............................................. 94
4.12. Cross site request forgery ...................................................................................... 95
4.13. Przejcie 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 wartoci do zmiennej sesyjnej
o nazwie stworzonej na podstawie danych od uytkownika ................... 104
4.14.3. Podmiana sekwencji wywoa przez wamywacza. Problem wycigu ....... 105
4.14.4. Uywanie tych samych zmiennych sesyjnych do rnych celw ............... 106
4.14.5. Zmienne sesyjne nie s gwarancj bezpieczestwa .................................... 108
4.15. Ataki typu DOS i DDOS ..................................................................................... 110
4.16. Dyrektywa register_globals ................................................................................. 112
4.17. Narzdzie zaciemniajce kod rdowy jzyka PHP ........................................... 114
Zakoczenie .................................................................................................................. 116
Zadania do samodzielnego wykonania ......................................................................... 116
Pytania kontrolne .......................................................................................................... 116

Spis treci

Rozdzia 5. Zaawansowane metody zabezpieczania programw ....................... 121

5.1. Wstp ..................................................................................................................... 121
5.2. Klucze rejestracyjne przypisane do uytkownika .................................................. 122
5.2.1. Idea kluczy rejestracyjnych przypisanych do uytkownika .......................... 122
5.2.2. Typowe techniki ........................................................................................... 124
5.2.3. Tworzenie kluczy rejestracyjnych w aplikacjach sieciowych ....................... 125
5.3. Samotestujcy si program .................................................................................... 126
5.3.1. Testowanie integralnoci programu gwarancj jego oryginalnoci .............. 126
5.3.2. Przykad weryfikacja integralnoci pliku wykonywalnego ..................... 127
5.3.3. Przykad weryfikacja integralnoci kodu programu ................................ 132
5.4. Sprawdzanie integralnoci danych ......................................................................... 135
5.4.1. Ukryj moje dane ........................................................................................... 136
5.4.2. Testowanie integralnoci danych ulegajcych zmianom .............................. 137
5.4.3. Wersje czasowe oprogramowania kopoty z shareware ........................... 138
5.4.4. Bezpieczne przechowywanie danych przykad ........................................ 140
5.5. Samomodyfikujcy si program ............................................................................ 144
5.5.1. Samomodyfikujcy 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 przydatnoci do wykonania ............................................ 148
5.6. Klucz programowy ................................................................................................ 150
5.6.1. Klucz programowy przykad ................................................................... 151
5.6.2. Deszyfrowanie fragmentw programu w trakcie jego dziaania ................... 156
5.6.3. Przykad programu deszyfrujcego si w trakcie dziaania .......................... 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 programw przed debugerami ............................... 167

6.1. Wstp ..................................................................................................................... 167
6.2. Wykrywanie debugerw ........................................................................................ 168
6.3. Utrudnianie debugowania ...................................................................................... 169
6.3.1. Wstawki kodu utrudniajce debugowanie .................................................... 169
6.3.2. Generator wstawek kodu utrudniajcych debugowanie ................................ 172
Zadania do samodzielnego wykonania ......................................................................... 175
Pytania kontrolne .......................................................................................................... 175

Rozdzia 7. Wykorzystanie internetu do zabezpieczania programw .................. 177

7.1. Wstp ..................................................................................................................... 177
7.2. Rejestracja programu przez internet ...................................................................... 178
7.3. Aktywacja numeru seryjnego przez internet .......................................................... 179
7.4. Kontrola uytkowania aplikacji z czciowym dostpem do internetu .................. 180
7.5. Weryfikacja prawidowej pracy aplikacji przez sie .............................................. 181
7.6. Przechowywanie poufnych danych uytkownika .................................................. 182
7.7. Deszyfrowanie programu w trakcie dziaania a internet ........................................ 183
7.8. Fragmentaryczne dane pobierane z internetu ......................................................... 185
7.9. Przesyanie informacji o programie do centralnego serwera .................................... 186

Bezpieczne programowanie. Aplikacje hakeroodporne

7.9.1. Totalna inwigilacja? Rejestrowanie informacji
o zachowaniu programu i uytkownika ..................................................... 186
7.9.2. Zdalne sprawdzanie tosamoci uytkownika .............................................. 188
7.9.3. Zdalne i lokalne blokowanie dziaania programu
sterowanego danymi z centralnego serwera ............................................... 191
7.10. Wirtualne wybory ................................................................................................ 192
Zadania do samodzielnego wykonania ......................................................................... 196
Pytania kontrolne .......................................................................................................... 196

Rozdzia 8. Zabezpieczanie programw przy uyciu kluczy sprztowych

oraz technik biometrycznych ......................................................... 197
8.1. Wstp ..................................................................................................................... 197
8.2. Zabezpieczenie aplikacji za pomoc kluczy sprztowych ..................................... 198
8.2.1. Karty magnetyczne i elektroniczne .............................................................. 198
8.2.2. Podpis cyfrowy na trwaym noniku ............................................................ 199
8.2.3. Klucze sprztowe 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 postpu technicznego
zwizanego z lokalizacj i kontrol uytkownikw ................................... 202
8.4. Weryfikacja tosamoci 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. Wamania 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. Wstp ..................................................................................................................... 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 dostpu kodu do zasobw (Code Access Security) ......................... 215
9.3.1. Nakazowe zabezpieczenie dostpu kodu do zasobw
(Imperative Code Access Security) ............................................................... 215
9.3.2. Deklaracyjne zabezpieczenie dostpu kodu do zasobw
(Declarative Code Access Security) .............................................................. 219
9.3.3. Poziomy regu bezpieczestwa (Security Policy Level) ............................... 220
9.3.4. Narzdzie The Code Access Security Policy Utility caspol.exe .............. 221
9.4. Bezpieczestwo ASP.NET .................................................................................... 222
9.4.1. Metody uwierzytelniania w ASP.NET ......................................................... 222
9.4.2. Dostp anonimowy ....................................................................................... 223
9.4.3. Uwierzytelnianie systemu Windows ............................................................ 223
9.4.4. Uwierzytelnianie przy uyciu 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 podzespoom .................................................................. 230
Zadania do samodzielnego wykonania ......................................................................... 231
Pytania kontrolne .......................................................................................................... 232

Spis treci

Rozdzia 10. Bezpieczny Program ..................................................................... 235

10.1. Wstp ................................................................................................................... 235
10.2. Opis programu ..................................................................................................... 236
10.3. Przegld kodu rdowego ................................................................................... 238
10.3.1. BezpiecznyProgram.exe ............................................................................. 238
10.3.2. ZabezpieczBP.exe ...................................................................................... 245
10.3.3. StwrzKluczBP.exe .................................................................................... 246
10.4. Wnioski ............................................................................................................... 247
Zadania do samodzielnego wykonania ......................................................................... 249

Rozdzia 11. Psychologiczna strona bezpieczestwa ......................................... 251

11.1. Wstp ................................................................................................................... 251
11.2. Wpyw architektury programu na jego bezpieczestwo ...................................... 251
11.3. Tylne wejcia i kod tymczasowy ......................................................................... 253
11.4. Uycie gotowego kodu ........................................................................................ 254
11.5. Open source ......................................................................................................... 256
11.6. Taczce winki kontra bezpieczestwo ............................................................. 257
11.7. Security by obscurity zabezpieczanie przez zaciemnianie .............................. 258
11.8. Karanie wamywacza ........................................................................................... 260
11.9. Brzytwa Ockhama ............................................................................................... 261
11.10. Uycie socjotechniki .......................................................................................... 261
11.11. Nie poprawiaj wamywacza ............................................................................... 262
11.12. Walka ze script kiddies ...................................................................................... 263
11.13. Ochrona przed automatami ................................................................................ 264
11.14. Ataki z wewntrz ............................................................................................... 267
11.15.
acuch a sie zabezpiecze ............................................................................. 267
11.16. Caociowe spojrzenie na problem bezpieczestwa ........................................... 268
Pytania kontrolne .......................................................................................................... 270

Podsumowanie ............................................................................. 273

Odpowiedzi do pyta kontrolnych .................................................. 281
Sowniczek poj ......................................................................... 293
Skorowidz .................................................................................... 301

Rozdzia 6.

Zabezpieczenie programw
przed debugerami
6.1. Wstp
Wykrywanie aktywnych debugerw oraz programw zrzucajcych fragment pamici
typu ProcDump to czynno , ktra moe by opacalna, jednak nie jest tak prosta, jak
si wydaje. Istnieje wiele wyrafinowanych sztuczek wykrywajcych te programy, jednak
zdecydowana wikszo z nich wykrywa dokadnie okrelone programy, jak na przykad
SoftIce czy OllyDbg, i w dodatku czsto tylko okrelone ich wersje. Najgorsz informacj jest jednak to, e istnieje mnstwo atek i rozszerze popularnych debugerw,
ktre zabezpieczaj si przed wykryciem. Programy te po modyfikacjach (wykonanych czsto przez samych krakerw dla siebie) ukrywaj si i stosuj techniki mylce.
Dlatego wykrywanie debugerw jest zadaniem czsto skazanym na porak. Zwykle
jest si p kroku do tyu, a nawet jeli uda nam si poprzez zaimplementowanie
wielu technik jednoczenie wykry skutecznie wszystkie istniejce debugery, to i tak
jest to tylko chwilowe zwycistwo, bo za chwil powstan takie, ktrych nie wykryjemy. Jest to wic typowe leczenie objaww, a nie przyczyn choroby.
Nie oznacza to, e nie naley w ogle przejmowa si problemem i nie stosowa adnych
zabezpiecze. Jednak jeli Czytelnik nie jest geniuszem assemblera, powinien zostawi
to zadanie innym i uy do tego celu programu pobranego z internetu. Jest ich wiele,
zarwno darmowych, jak i patnych. Do tych drugich nale m.in. opisane w rozdziale
drugim TheMida czy AsProtect. Dziki temu zaoszczdzimy sobie czasu na prby,
ktrych wyniki mog by wtpliwe, a co wicej, ktrych rezultat ciko bdzie nam
zweryfikowa , poniewa nie bdziemy dysponowa odpowiedni iloci wersji debugerw. Procedury kontrolujce dziaanie takich programw nie musz by niestandardowe i dlatego warto pozostawi je fachowcom.

168

Bezpieczne programowanie. Aplikacje hakeroodporne

Z tych wanie powodw w rozdziale tym nie znajdziecie wielu wyrafinowanych sztuczek
blokujcych debugery. Opisz jedynie kilka najprostszych, aby kady mg sobie wyrobi opini na ten temat i w razie potrzeby poszuka bardziej zaawansowanych informacji w innych rdach. Zamiast tego skupi si na oglnych metodach utrudniania
debugowania, ktre mog by uyteczne niezalenie od stosowania funkcji wykrywajcych debugery lub komercyjnych systemw zabezpiecze, ktre rwnie takowe
funkcje posiadaj.

6.2. Wykrywanie debugerw

Najprostszym sposobem wykrywania debugerw jest wstawienie do kodu po prostu:
if(IsDebuggerPresent())
// wykonaj jaki kod, np. zamknij program;

Mona to atwo przetestowa , wpisujc w miejsce komentarza na przykad polecenie

wywietlenie jakiego komunikatu i uruchamiajc aplikacj krok po kroku w Visual
Studio. Debuger VS zostanie wykryty i program wywietli komunikat. Uruchamiajc
program z pliku wykonywalnego, nie zobaczymy komunikatu.
Tego typu zabezpieczenie bdzie jednak cakowicie nieskuteczne w przypadku zaawansowanych debugerw uywanych przez krakerw, takich jak SoftIce czy OllyDbg.
Wamywacze uywaj zmodyfikowanych wersji tych programw, ktre s zabezpieczone nie tylko przed opisan powyej weryfikacj, ale take przed wieloma bardziej
zaawansowanymi metodami. Twj program musiaby mie naprawd szerok gam
testw, aby mona byo mie pewno wykrycia wikszoci mutacji tych debugerw.
Dlatego wanie lepiej jest uy gotowego narzdzia wykonanego przez specjalistw,
a samemu skupi si na innych zabezpieczeniach. Jako ciekawostk podam jeszcze
przykady dwch rozwiza tego typu:
mov ah,43h
int 68h
cmp eax,0F386h
jz mamy_debugger

W tym tecie prbujemy zbada , czy uruchomiony zosta program SoftIce poprzez
wykrywanie sterownika debugera systemowego. Kolejny przykad opiera si na wykrywaniu int 41h uywanego 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 programw przed debugerami

169

cmp cl,al
jnz si_jest
int41handler PROC
mov cl,al
iret
int41handler ENDP

Obydwa powysze przykady wykrywania debugera SoftIce pochodz ze strony:

http://4programmers.net/Assembler/FAQ/Wykrywanie_debuggera_(SoftICE)1.

6.3. Utrudnianie debugowania

6.3.1. Wstawki kodu utrudniajce debugowanie
Utrudnienie debugowania mona wykona , wklejajc w wiele miejsc kodu rdowego
programu relatywnie nieskomplikowane wstawki. Jeli uywamy jzyka C/C++, sprawa
jest prosta, moemy bowiem wykorzysta makra preprocesora, co w poczeniu z twrczym uyciem instrukcji skoku bezwarunkowego (tak oczerniane przez wszystkich
goto), wstawek assemblerowych czy konstrukcji takich jak setjmp czy longjmp, moe
solidnie skomplikowa ledzenie programu w debugerze. Wane jest, aby tego typu
wstawki pozostaway neutralne dla kodu.
Oto przykad:
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:
;

Powysze makro wstawia kod wygldajcy mniej wicej tak:

if( setjmp(env) == 0 )
{
goto skok_ad_1;
}
else
1

Tre udostpniona na zasadach licencji Creative Commons Attribution:

http://creativecommons.org/licenses/by/2.0/pl/legalcode.

\
\
\
\
\
\
\
\
\
\
\

170

Bezpieczne programowanie. Aplikacje hakeroodporne

{
// W
ACIWY FRAGMENT KODU
}
goto koniec_ad_1;
skok_ad_1:
longjmp(env, 1);
koniec_ad_1:

W trakcie wykonania instrukcja setjmp(env) == 0 wywoana po raz pierwszy ustawi

punkt powrotu dla skoku longjmp na miejsce swojego wywoania oraz zwrci warto
TRUE. W zwizku z tym kolejn wykonywan instrukcj bdzie goto skok_ad_1. Nastpnie
wykona si longjmp(env,1), ktre spowoduje przesunicie wykonania z powrotem do
pierwszej linii kodu. Tym razem jednak warunek nie bdzie ju speniony i wykonany
zostanie cig instrukcji oznaczony jako WACIWY FRAGMENT KODU. Na koniec instrukcja
goto koniec_ad_1 zapewni prawidowe opuszczenie tego bloku kodu. Caa konstrukcja
ma wple w kod kilka dziwnych i zaciemniajcych sens skokw wyduajcych
i utrudniajcych ledzenie wykonania w debugerze. Oczywicie powinna by uyta
w programie wiele razy, aby by naprawd skuteczn.
Uycie makra jest nastpujce. Kod, ktry zaciemniamy, otacza si wywoaniem makra:
AD(kod, x). Pewn wad tego makra jest to, e trzeba go wywoywa z dodatkowym

parametrem, ktry za kadym razem musi by inny. To, co przed zaciemnieniem wyglda 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 bdzie wyglda 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 programw 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

Powysze kody nie maj adnego sensu, natomiast nie zmieniaj stanu rejestrw ani
flag (dziki uyciu makr WSTAWKA_START_ASM i WSTAWKA_STOP_ASM). Uycie jest proste:
wywoanie 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 kadej z trzech powyszych wersji kodu. Powiciwszy 3 4 godziny,
mona wyprodukowa kilkanacie czy nawet kilkadziesit podobnych fragmentw
kodu i uy ich w setkach miejsc, wykonujc po prostu prac typu kopiuj/wklej. Nie
powstrzyma to samo w sobie adnego krakera, ale utrudni mu nieco prac. Oczywicie takie wstawki wyduaj kod oraz nieznacznie spowalniaj jego wykonanie. Jeli
jednak bdziemy uywa ich wycznie w najbardziej krytycznych fragmentach programu, dotyczcych zabezpiecze, to jest to opacalne. Zwaszcza e przy dzisiejszych prdkociach procesorw tych kilkadziesit instrukcji maszynowych nie bdzie
duym obcieniem.
Powysze makra s banalne i maj wycznie posuy jako przykad tego, co mona
robi . W prawdziwym systemie warto posiedzie nieco duej i doda nastpujce
elementy:
Wstawki assemblerowe z du iloci skokw wymieszanych bez adu, na

przykad:
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

Uycie nie tylko skokw bezwzgldnych, ale take duej iloci zagniedonych
funkcji oraz skokw warunkowych (jak w powyszym przykadzie skok JNZ).
Wstawianie instrukcji, ktre nie bd nigdy wykonane, w poblie waciwego

kodu. Mona tego dokona poprzez skoki. Ciekaw instrukcj, ktr mona
w takie miejsce wstawi , jest __asm int 3, czyli instrukcja przerwania
programowego.
Mona nawet pokusi si o sterowanie przepywem wykonania za pomoc

wyjtkw.
Przez cay czas powinnimy mie jednak na uwadze to, e jest to tylko dodatek, i uwaa ,
aby nie zaciemni sobie kodu nadmiernie.

6.3.2. Generator wstawek kodu utrudniajcych

debugowanie
Makra, o ktrych pisaem powyej, to interesujca technika, ale maj one kilka wad:
Nie kady jzyk posiada makra preprocesora. Mona jeszcze ratowa si uyciem
funkcji rozwijanych w miejscu wywoania (inline), ale nie zawsze i nie

wszystko uda si nimi zastpi .

Makra pisane rcznie s zazwyczaj schematyczne. Ciko je sparametryzowa

czy zmienia im dynamicznie tre .

Nawet najwygodniejsze w uyciu widniej w kodzie rdowym, zmniejszajc

jego czytelno oraz utrudniajc testowanie (i debugowanie, ale w kocu po to

zostay napisane).
Lepszym rozwizaniem bdzie wic zostawienie wersji deweloperskiej kodu w stanie
czystym i wstawianie kodu antydebugowego przez automat dopiero w procesie produkcji oprogramowania. Dziki uyciu zautomatyzowanych systemw produkcji
oprogramowania takich jak na przykad CruiseControl .NET, systemw kontroli wersji takich jak CVS czy SVN oraz narzdzi skryptowych takich jak NANT, Python czy
Ruby proces ten nie powinien by skomplikowany. Wyglda on nastpujco:
Prace deweloperskie wykonywane s przez programistw. Programista,

koczc prace, wysya kod rdowy do repozytorium systemu kontroli wersji.

Automat pobiera zmodyfikowane rda do swojej lokalnej kopii.
Prekompilacja wygenerowanie przez automat wstawek antydebugowych

i wstawienie ich do kodu.

Kompilacja zmodyfikowanego kodu.
Wykonanie testw automatycznych.

Rozdzia 6. i Zabezpieczenie programw przed debugerami

173

Automat taki moe generowa wstawki losowo spord zbioru elementw w miejsca
oznaczone w kodzie w specyficzny sposb. Dziki temu jedyne, co musi zrobi programista, to wstawi takie oznaczenia wszdzie, gdzie chce. Moe to by na przykad
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 pycie CD znajduje si kod rdowy programu GenerujZabezpieczenia napisanego

w jzyku C#. Jest to program uruchamiany z linii polece, ktrego jedynym parametrem
jest cieka do pliku rdowego (w jzyku C++), w ktrym wstawki // ZABEZPIECZ
maj zosta zmienione na wstawki antydebugowe. Czytelnik moe rozbudowa i zmodyfikowa go wedug wasnych potrzeb. Mona zmieni go w nastpujcy sposb:
Dodanie wikszej iloci elementw sucych do generowania wstawek.
Dodanie generacji wstawek dla rnych jzykw programowania.
Dodanie generacji kilku rodzajw wstawek, w tym parametryzowanych.
Stworzenie bardziej skomplikowanych wstawek.
Stworzenie mniej schematycznych wstawek.

Naley przy tym pamita o tym, e program po prostu wstawia wstawk tam, gdzie
zobaczy stosowny tekst. Moe wic si zdarzy , e kod rdowy po modyfikacji nie
bdzie si kompilowa lub w ogle nie bdzie dziaa . Zaley to od sposobu uycia
oznakowania wstawek. Jeli ich tre pojawi si w nietypowym miejscu, na przykad
w cigu znakw do wywietlenia na konsoli itp., to dziaanie programu moe zmieni
si na nieprawidowe.
Kod programu jest do prosty. Podstawow funkcj jest ModyfikujPlik, ktra odczytuje
plik, wyszukuje frazy // ZABEZPIECZ i podmienia je na losowo wygenerowane wstawki
assemblerowe. Generowane s dwa typy wstawek:
Statyczna od 1 do 9 rozkazw assemblera wylosowanych z tablicy
statyczneWstawki.
Faszywe skoki trzy przeplatajce si fragmenty kodu (wylosowane jak wstawka

statyczna).

174

Bezpieczne programowanie. Aplikacje hakeroodporne

Oto gwna funkcja:

static void ModyfikujPlik(string acieka)
{
// odczyt pliku
TextReader reader = new StreamReader(acieka,
System.Text.Encoding.Default);
string zawarto = reader.ReadToEnd();
reader.Close();
// modyfikacja zawartoci
int ile = 0;
while (zawarto.IndexOf(oznaczenieWstawki) != -1)
{
int indeksWstawki = zawarto.IndexOf(oznaczenieWstawki);
string wstawka = UtwrzWstawk();
zawarto = zawarto.Substring(0, indeksWstawki) + wstawka +
zawarto.Substring(indeksWstawki + oznaczenieWstawki.Length);
ile++;
}
// zapis pliku
TextWriter writer = new StreamWriter(acieka, false,
System.Text.Encoding.Default);
writer.Write(zawarto);
writer.Close();
Console.WriteLine(acieka + " zosta zmodyfikowany "
+ ile.ToString() + " razy");
}

Pojedyncz wstawk tworzy funkcja UtwrzWstawk():

static string UtwrzWstawk()
{
string cigPodmiany = pocztekWstawki;
int ile = rd.Next(1, 3);
for (int i = 0; i < ile; i++)
{
if(rd.Next(0,2) == 0)
cigPodmiany += UtwrzSztuczneSkoki();
else
cigPodmiany += UtwrzStatycznWstawk();
}
return cigPodmiany + koniecWstawki;
}

T funkcj zmodyfikuj, jeli chcesz mie wicej typw wstawek. Po prostu nie losuj
liczb z zakresu <0; 2), lecz wikszego, i zastp warunek instrukcj switch. Funkcje
UtwrzSztuczneSkoki i UtwrzStatycznWstawk wygldaj nastpujco:
static string UtwrzStatycznWstawk()
{
int ile = rd.Next(1, 10);
string retWart = "";
for (int i = 0; i < ile; i++)
{

Rozdzia 6. i Zabezpieczenie programw przed debugerami

175

retWart += statyczneWstawki[rd.Next(0, statyczneWstawki.Length)] +

"\r\n";
}
return retWart;
}
static string UtwrzSztuczneSkoki()
{
string retWart = "";
string etykieta1 = UtwrzEtykiet();
string etykieta2 = UtwrzEtykiet();
string etykieta3 = UtwrzEtykiet();
retWart += "__asm JMP " + etykieta1 + ";\r\n";
retWart += etykieta2 + ":" + UtwrzStatycznWstawk();
retWart += "__asm JMP " + etykieta3 + ";\r\n";
retWart += etykieta1 + ":" + UtwrzStatycznWstawk();
retWart += "__asm JMP " + etykieta2 + ";\r\n";
retWart += etykieta3 + ":" + UtwrzStatycznWstawk();
return retWart;
}

Druga z nich tworzy skoki ukadajce si w cig:

1. Id do 3
2. Id do 4
3. Id do 2
4. Koniec

Pomidzy nimi znajduj si statyczne wstawki wygenerowane przez UtwrzStatycznWstawk (), ktrej z kolei kod jest tak prosty, e raczej nie trzeba go objania . Warto
jeszcze doda , e kada wstawka zaczyna si odoeniem stanu rejestrw i flag na
stos, a koczy pobraniem ich stamtd. Dziki temu stan programu nie zmienia si.

Zadania do samodzielnego wykonania

1. Rozwi program GenerujZabezpieczenia zgodnie z sugestiami w treci rozdziau.

Pytania kontrolne
P 6.1. Jakie s wady makr antydebugowych
wstawianych rcznie do kodu?
a) S cakowicie nieskuteczne i nie przeszkadzaj krakerom.
b) W niektrych jzykach programowania ich implementacja moe 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 rdowym, co zaciemnia go i utrudnia testowanie.